OSDN Git Service

Remove the types float and complex.
authorian <ian@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 21 Jan 2011 18:19:03 +0000 (18:19 +0000)
committerian <ian@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 21 Jan 2011 18:19:03 +0000 (18:19 +0000)
Update to current version of Go library.

Update testsuite for removed types.

* go-lang.c (go_langhook_init): Omit float_type_size when calling
go_create_gogo.
* go-c.h: Update declaration of go_create_gogo.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@169098 138bc75d-0d04-0410-961f-82ee72b054a4

388 files changed:
gcc/go/ChangeLog
gcc/go/go-c.h
gcc/go/go-lang.c
gcc/go/gofrontend/export.cc
gcc/go/gofrontend/export.h
gcc/go/gofrontend/expressions.cc
gcc/go/gofrontend/go.cc
gcc/go/gofrontend/gogo.cc
gcc/go/gofrontend/gogo.h
gcc/go/gofrontend/import.cc
gcc/go/gofrontend/types.cc
gcc/go/gofrontend/types.h
gcc/testsuite/go.test/test/blank.go
gcc/testsuite/go.test/test/cmplx.go
gcc/testsuite/go.test/test/cmplxdivide1.go
gcc/testsuite/go.test/test/complit.go
gcc/testsuite/go.test/test/const1.go
gcc/testsuite/go.test/test/convlit.go
gcc/testsuite/go.test/test/decl.go
gcc/testsuite/go.test/test/declbad.go
gcc/testsuite/go.test/test/fixedbugs/bug006.go
gcc/testsuite/go.test/test/fixedbugs/bug007.go
gcc/testsuite/go.test/test/fixedbugs/bug010.go
gcc/testsuite/go.test/test/fixedbugs/bug011.go
gcc/testsuite/go.test/test/fixedbugs/bug035.go
gcc/testsuite/go.test/test/fixedbugs/bug047.go
gcc/testsuite/go.test/test/fixedbugs/bug080.go
gcc/testsuite/go.test/test/fixedbugs/bug109.go
gcc/testsuite/go.test/test/fixedbugs/bug167.go
gcc/testsuite/go.test/test/fixedbugs/bug193.go
gcc/testsuite/go.test/test/fixedbugs/bug206.go
gcc/testsuite/go.test/test/fixedbugs/bug220.go
gcc/testsuite/go.test/test/fixedbugs/bug230.go
gcc/testsuite/go.test/test/fixedbugs/bug238.go
gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug2.go
gcc/testsuite/go.test/test/fixedbugs/bug248.dir/bug3.go
gcc/testsuite/go.test/test/fixedbugs/bug299.go
gcc/testsuite/go.test/test/func.go
gcc/testsuite/go.test/test/func1.go
gcc/testsuite/go.test/test/interface/explicit.go
gcc/testsuite/go.test/test/iota.go
gcc/testsuite/go.test/test/ken/cplx0.go
gcc/testsuite/go.test/test/ken/cplx1.go
gcc/testsuite/go.test/test/ken/cplx3.go
gcc/testsuite/go.test/test/ken/cplx4.go
gcc/testsuite/go.test/test/ken/cplx5.go
gcc/testsuite/go.test/test/ken/robfunc.go
gcc/testsuite/go.test/test/ken/simpconv.go
gcc/testsuite/go.test/test/ken/slicearray.go
gcc/testsuite/go.test/test/ken/sliceslice.go
gcc/testsuite/go.test/test/literal.go
gcc/testsuite/go.test/test/map.go
gcc/testsuite/go.test/test/method1.go
gcc/testsuite/go.test/test/named.go
gcc/testsuite/go.test/test/nil.go
gcc/testsuite/go.test/test/recover2.go
gcc/testsuite/go.test/test/test0.go
gcc/testsuite/go.test/test/typeswitch.go
gcc/testsuite/go.test/test/zerodivide.go
libgo/MERGE
libgo/Makefile.am
libgo/Makefile.in
libgo/go/archive/tar/reader_test.go
libgo/go/archive/tar/writer_test.go
libgo/go/archive/zip/reader_test.go
libgo/go/asn1/asn1.go
libgo/go/big/int_test.go
libgo/go/big/rat.go
libgo/go/big/rat_test.go
libgo/go/bufio/bufio.go
libgo/go/bufio/bufio_test.go
libgo/go/bytes/buffer.go
libgo/go/bytes/buffer_test.go
libgo/go/bytes/bytes.go
libgo/go/bytes/bytes_test.go
libgo/go/cmath/asin.go
libgo/go/cmath/cmath_test.go
libgo/go/cmath/conj.go
libgo/go/cmath/exp.go
libgo/go/cmath/isinf.go
libgo/go/cmath/isnan.go
libgo/go/cmath/log.go
libgo/go/cmath/pow.go
libgo/go/cmath/rect.go
libgo/go/cmath/sin.go
libgo/go/cmath/sqrt.go
libgo/go/cmath/tan.go
libgo/go/compress/flate/deflate.go
libgo/go/compress/flate/deflate_test.go
libgo/go/compress/flate/inflate.go
libgo/go/container/vector/intvector_test.go
libgo/go/container/vector/numbers_test.go
libgo/go/container/vector/stringvector_test.go
libgo/go/container/vector/vector_test.go
libgo/go/crypto/block/cipher.go
libgo/go/crypto/cipher/cbc.go [new file with mode: 0644]
libgo/go/crypto/cipher/cbc_aes_test.go [moved from libgo/go/crypto/block/cbc_aes_test.go with 76% similarity]
libgo/go/crypto/cipher/cfb.go [new file with mode: 0644]
libgo/go/crypto/cipher/cfb_test.go [new file with mode: 0644]
libgo/go/crypto/cipher/cipher.go [new file with mode: 0644]
libgo/go/crypto/cipher/common_test.go [new file with mode: 0644]
libgo/go/crypto/cipher/ctr.go [new file with mode: 0644]
libgo/go/crypto/cipher/ctr_aes_test.go [moved from libgo/go/crypto/block/ctr_aes_test.go with 74% similarity]
libgo/go/crypto/cipher/io.go [new file with mode: 0644]
libgo/go/crypto/cipher/ocfb.go [new file with mode: 0644]
libgo/go/crypto/cipher/ocfb_test.go [new file with mode: 0644]
libgo/go/crypto/cipher/ofb.go [new file with mode: 0644]
libgo/go/crypto/cipher/ofb_test.go [new file with mode: 0644]
libgo/go/crypto/elliptic/elliptic.go [new file with mode: 0644]
libgo/go/crypto/elliptic/elliptic_test.go [new file with mode: 0644]
libgo/go/crypto/hmac/hmac.go
libgo/go/crypto/hmac/hmac_test.go
libgo/go/crypto/openpgp/armor/armor.go [new file with mode: 0644]
libgo/go/crypto/openpgp/armor/armor_test.go [new file with mode: 0644]
libgo/go/crypto/openpgp/armor/encode.go [new file with mode: 0644]
libgo/go/crypto/openpgp/error/error.go [new file with mode: 0644]
libgo/go/crypto/openpgp/s2k/s2k.go [new file with mode: 0644]
libgo/go/crypto/openpgp/s2k/s2k_test.go [new file with mode: 0644]
libgo/go/crypto/rc4/rc4.go
libgo/go/crypto/rc4/rc4_test.go
libgo/go/crypto/rsa/pkcs1v15.go
libgo/go/crypto/tls/ca_set.go
libgo/go/crypto/tls/cipher_suites.go [new file with mode: 0644]
libgo/go/crypto/tls/common.go
libgo/go/crypto/tls/conn.go
libgo/go/crypto/tls/conn_test.go [new file with mode: 0644]
libgo/go/crypto/tls/generate_cert.go
libgo/go/crypto/tls/handshake_client.go
libgo/go/crypto/tls/handshake_client_test.go [new file with mode: 0644]
libgo/go/crypto/tls/handshake_messages.go
libgo/go/crypto/tls/handshake_messages_test.go
libgo/go/crypto/tls/handshake_server.go
libgo/go/crypto/tls/handshake_server_test.go
libgo/go/crypto/tls/key_agreement.go [new file with mode: 0644]
libgo/go/crypto/tls/prf.go
libgo/go/crypto/tls/prf_test.go
libgo/go/crypto/tls/tls.go
libgo/go/crypto/twofish/twofish.go [new file with mode: 0644]
libgo/go/crypto/twofish/twofish_test.go [new file with mode: 0644]
libgo/go/crypto/x509/x509.go
libgo/go/crypto/x509/x509_test.go
libgo/go/debug/dwarf/testdata/typedef.c
libgo/go/debug/dwarf/testdata/typedef.elf
libgo/go/debug/dwarf/testdata/typedef.macho
libgo/go/debug/dwarf/type_test.go
libgo/go/debug/elf/elf.go
libgo/go/debug/elf/file.go
libgo/go/debug/macho/file.go
libgo/go/debug/macho/macho.go
libgo/go/debug/pe/file.go
libgo/go/debug/pe/file_test.go
libgo/go/debug/proc/proc_nacl.go [deleted file]
libgo/go/debug/proc/regs_nacl_386.go [deleted file]
libgo/go/ebnf/ebnf.go
libgo/go/ebnf/ebnf_test.go
libgo/go/ebnf/parser.go
libgo/go/encoding/base32/base32.go [new file with mode: 0644]
libgo/go/encoding/base32/base32_test.go [new file with mode: 0644]
libgo/go/encoding/binary/binary.go
libgo/go/encoding/binary/binary_test.go
libgo/go/encoding/line/line.go [new file with mode: 0644]
libgo/go/encoding/line/line_test.go [new file with mode: 0644]
libgo/go/exec/exec_test.go
libgo/go/exec/lp_unix.go
libgo/go/exec/lp_windows.go
libgo/go/exp/4s/4s.go [deleted file]
libgo/go/exp/4s/5s.go [deleted file]
libgo/go/exp/4s/data.go [deleted file]
libgo/go/exp/4s/xs.go [deleted file]
libgo/go/exp/datafmt/datafmt.go
libgo/go/exp/datafmt/datafmt_test.go
libgo/go/exp/datafmt/parser.go
libgo/go/exp/draw/draw.go
libgo/go/exp/eval/bridge.go
libgo/go/exp/eval/compiler.go
libgo/go/exp/eval/eval_test.go
libgo/go/exp/eval/expr.go
libgo/go/exp/eval/expr1.go
libgo/go/exp/eval/scope.go
libgo/go/exp/eval/stmt.go
libgo/go/exp/eval/type.go
libgo/go/exp/eval/typec.go
libgo/go/exp/eval/value.go
libgo/go/exp/eval/world.go
libgo/go/exp/nacl/av/av.go [deleted file]
libgo/go/exp/nacl/av/event.go [deleted file]
libgo/go/exp/nacl/av/image.go [deleted file]
libgo/go/exp/nacl/srpc/client.go [deleted file]
libgo/go/exp/nacl/srpc/msg.go [deleted file]
libgo/go/exp/nacl/srpc/server.go [deleted file]
libgo/go/exp/ogle/cmd.go
libgo/go/exp/ogle/rtype.go
libgo/go/exp/spacewar/code.go [deleted file]
libgo/go/exp/spacewar/pdp1.go [deleted file]
libgo/go/exp/spacewar/spacewar.go [deleted file]
libgo/go/expvar/expvar.go
libgo/go/expvar/expvar_test.go
libgo/go/flag/export_test.go [new file with mode: 0644]
libgo/go/flag/flag.go
libgo/go/flag/flag_test.go
libgo/go/fmt/doc.go
libgo/go/fmt/fmt_test.go
libgo/go/fmt/format.go
libgo/go/fmt/print.go
libgo/go/fmt/scan.go
libgo/go/fmt/scan_test.go
libgo/go/fmt/stringer_test.go
libgo/go/go/ast/ast.go
libgo/go/go/ast/filter.go
libgo/go/go/ast/walk.go
libgo/go/go/doc/doc.go
libgo/go/go/parser/interface.go
libgo/go/go/parser/parser.go
libgo/go/go/parser/parser_test.go
libgo/go/go/printer/nodes.go
libgo/go/go/printer/printer.go
libgo/go/go/printer/printer_test.go
libgo/go/go/printer/testdata/comments.golden
libgo/go/go/printer/testdata/comments.input
libgo/go/go/printer/testdata/declarations.golden
libgo/go/go/printer/testdata/declarations.input
libgo/go/go/scanner/scanner.go
libgo/go/go/scanner/scanner_test.go
libgo/go/go/token/position.go [new file with mode: 0644]
libgo/go/go/token/position_test.go [new file with mode: 0644]
libgo/go/go/token/token.go
libgo/go/go/typechecker/scope.go
libgo/go/go/typechecker/typechecker.go
libgo/go/go/typechecker/typechecker_test.go
libgo/go/gob/codec_test.go
libgo/go/gob/decode.go
libgo/go/gob/decoder.go
libgo/go/gob/doc.go
libgo/go/gob/encode.go
libgo/go/gob/encoder.go
libgo/go/gob/encoder_test.go
libgo/go/gob/type.go
libgo/go/gob/type_test.go
libgo/go/hash/crc64/crc64.go
libgo/go/html/doc.go
libgo/go/html/entity.go
libgo/go/html/entity_test.go [new file with mode: 0644]
libgo/go/html/escape.go
libgo/go/html/parse.go [new file with mode: 0644]
libgo/go/html/parse_test.go [new file with mode: 0644]
libgo/go/html/token.go
libgo/go/html/token_test.go
libgo/go/http/client.go
libgo/go/http/fs.go
libgo/go/http/fs_test.go [new file with mode: 0644]
libgo/go/http/readrequest_test.go
libgo/go/http/request.go
libgo/go/http/response.go
libgo/go/http/response_test.go
libgo/go/http/serve_test.go [new file with mode: 0644]
libgo/go/http/server.go
libgo/go/http/testdata/file [new file with mode: 0644]
libgo/go/http/transfer.go
libgo/go/http/url.go
libgo/go/http/url_test.go
libgo/go/index/suffixarray/qsufsort.go [new file with mode: 0644]
libgo/go/index/suffixarray/suffixarray.go
libgo/go/index/suffixarray/suffixarray_test.go
libgo/go/io/io.go
libgo/go/io/io_test.go
libgo/go/json/decode.go
libgo/go/json/decode_test.go
libgo/go/json/encode.go
libgo/go/json/scanner_test.go
libgo/go/json/stream.go
libgo/go/json/stream_test.go
libgo/go/log/log.go
libgo/go/math/all_test.go
libgo/go/math/bits.go
libgo/go/math/const.go
libgo/go/math/exp.go
libgo/go/math/exp2.go
libgo/go/math/exp_port.go [new file with mode: 0644]
libgo/go/math/exp_test.go [new file with mode: 0644]
libgo/go/math/frexp.go
libgo/go/math/gamma.go
libgo/go/math/jn.go
libgo/go/math/ldexp.go
libgo/go/math/lgamma.go
libgo/go/math/logb.go
libgo/go/math/modf.go
libgo/go/math/pow.go
libgo/go/math/sqrt_port.go
libgo/go/net/dial.go
libgo/go/net/dnsclient.go
libgo/go/net/dnsname_test.go
libgo/go/net/fd.go
libgo/go/net/fd_windows.go
libgo/go/net/hosts.go
libgo/go/net/ipsock.go
libgo/go/net/net_test.go
libgo/go/net/port.go
libgo/go/net/resolv_windows.go
libgo/go/net/server_test.go
libgo/go/net/sock.go
libgo/go/net/tcpsock.go
libgo/go/net/textproto/reader.go
libgo/go/net/timeout_test.go
libgo/go/net/unixsock.go
libgo/go/netchan/common.go
libgo/go/netchan/export.go
libgo/go/netchan/import.go
libgo/go/netchan/netchan_test.go
libgo/go/os/env_windows.go
libgo/go/os/exec.go
libgo/go/os/file.go
libgo/go/os/inotify/inotify_linux.go [new file with mode: 0644]
libgo/go/os/inotify/inotify_linux_test.go [new file with mode: 0644]
libgo/go/os/os_test.go
libgo/go/os/path.go
libgo/go/os/path_test.go
libgo/go/path/match.go
libgo/go/path/path.go
libgo/go/path/path_test.go
libgo/go/path/path_unix.go [new file with mode: 0644]
libgo/go/path/path_windows.go [new file with mode: 0644]
libgo/go/rand/rand.go
libgo/go/rand/rand_test.go
libgo/go/rand/zipf.go
libgo/go/reflect/all_test.go
libgo/go/reflect/type.go
libgo/go/reflect/value.go
libgo/go/regexp/all_test.go
libgo/go/regexp/find_test.go
libgo/go/regexp/regexp.go
libgo/go/rpc/debug.go
libgo/go/rpc/server.go
libgo/go/runtime/chan_defs.go [new file with mode: 0644]
libgo/go/runtime/debug.go
libgo/go/runtime/debug/stack.go [new file with mode: 0644]
libgo/go/runtime/debug/stack_test.go [new file with mode: 0644]
libgo/go/runtime/extern.go
libgo/go/runtime/hashmap_defs.go [new file with mode: 0644]
libgo/go/runtime/iface_defs.go [new file with mode: 0644]
libgo/go/runtime/malloc_defs.go [new file with mode: 0644]
libgo/go/runtime/mheapmap32_defs.go [new file with mode: 0644]
libgo/go/runtime/mheapmap64_defs.go [new file with mode: 0644]
libgo/go/runtime/runtime_defs.go [new file with mode: 0644]
libgo/go/runtime/type.go
libgo/go/smtp/smtp.go
libgo/go/sort/search.go [new file with mode: 0644]
libgo/go/sort/search_test.go [new file with mode: 0644]
libgo/go/sort/sort.go
libgo/go/sort/sort_test.go
libgo/go/strconv/atob_test.go
libgo/go/strconv/atof.go
libgo/go/strconv/atof_test.go
libgo/go/strconv/ftoa.go
libgo/go/strconv/ftoa_test.go
libgo/go/strings/strings.go
libgo/go/strings/strings_test.go
libgo/go/syslog/syslog_test.go
libgo/go/template/format.go
libgo/go/template/template.go
libgo/go/template/template_test.go
libgo/go/testing/benchmark.go
libgo/go/testing/quick/quick.go
libgo/go/testing/quick/quick_test.go
libgo/go/testing/testing.go
libgo/go/time/format.go
libgo/go/time/sleep.go
libgo/go/time/sleep_test.go
libgo/go/time/tick.go
libgo/go/time/tick_test.go
libgo/go/utf8/string_test.go
libgo/go/utf8/utf8.go
libgo/go/utf8/utf8_test.go
libgo/go/websocket/client.go
libgo/go/websocket/websocket_test.go
libgo/go/xml/read.go
libgo/go/xml/read_test.go
libgo/go/xml/xml.go
libgo/go/xml/xml_test.go
libgo/mksysinfo.sh
libgo/runtime/go-reflect-call.c
libgo/runtime/go-reflect.c
libgo/runtime/go-type.h
libgo/runtime/malloc.goc
libgo/runtime/malloc.h
libgo/runtime/mgc0.c
libgo/runtime/mheap.c
libgo/syscalls/socket.go
libgo/syscalls/sysfile_posix.go

index 6354ce5..7c1f272 100644 (file)
@@ -1,3 +1,9 @@
+2011-01-21  Ian Lance Taylor  <iant@google.com>
+
+       * go-lang.c (go_langhook_init): Omit float_type_size when calling
+       go_create_gogo.
+       * go-c.h: Update declaration of go_create_gogo.
+
 2011-01-13  Ian Lance Taylor  <iant@google.com>
 
        * go-backend.c: Include "rtl.h" and "target.h".
index a451517..1c7a3b1 100644 (file)
@@ -41,8 +41,7 @@ extern void go_set_prefix (const char*);
 
 extern void go_add_search_path (const char*);
 
-extern void go_create_gogo (int int_type_size, int float_type_size,
-                           int pointer_size);
+extern void go_create_gogo (int int_type_size, int pointer_size);
 
 extern void go_parse_input_files (const char**, unsigned int,
                                  bool only_check_syntax,
index 323f8c5..ef019d3 100644 (file)
@@ -1,5 +1,5 @@
 /* go-lang.c -- Go frontend gcc interface.
-   Copyright (C) 2009, 2010 Free Software Foundation, Inc.
+   Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -103,7 +103,7 @@ go_langhook_init (void)
      to, e.g., unsigned_char_type_node) but before calling
      build_common_builtin_nodes (because it calls, indirectly,
      go_type_for_size).  */
-  go_create_gogo (INT_TYPE_SIZE, FLOAT_TYPE_SIZE, POINTER_SIZE);
+  go_create_gogo (INT_TYPE_SIZE, POINTER_SIZE);
 
   build_common_builtin_nodes ();
 
index 6b42d0c..cbf24b8 100644 (file)
@@ -345,8 +345,6 @@ Export::register_builtin_types(Gogo* gogo)
   this->register_builtin_type(gogo, "int", BUILTIN_INT);
   this->register_builtin_type(gogo, "uint", BUILTIN_UINT);
   this->register_builtin_type(gogo, "uintptr", BUILTIN_UINTPTR);
-  this->register_builtin_type(gogo, "float", BUILTIN_FLOAT);
-  this->register_builtin_type(gogo, "complex", BUILTIN_COMPLEX);
   this->register_builtin_type(gogo, "bool", BUILTIN_BOOL);
   this->register_builtin_type(gogo, "string", BUILTIN_STRING);
 }
index 90c2465..4a1fd2b 100644 (file)
@@ -33,14 +33,12 @@ enum Builtin_code
   BUILTIN_INT = -11,
   BUILTIN_UINT = -12,
   BUILTIN_UINTPTR = -13,
-  BUILTIN_FLOAT = -14,
   BUILTIN_BOOL = -15,
   BUILTIN_STRING = -16,
   BUILTIN_COMPLEX64 = -17,
   BUILTIN_COMPLEX128 = -18,
-  BUILTIN_COMPLEX = -19,
 
-  SMALLEST_BUILTIN_CODE = -19
+  SMALLEST_BUILTIN_CODE = -18
 };
 
 // This class manages exporting Go declarations.  It handles the main
index 6fa1b99..8eefaee 100644 (file)
@@ -1932,7 +1932,7 @@ Float_expression::do_determine_type(const Type_context* context)
               || context->type->complex_type() != NULL))
     this->type_ = context->type;
   else if (!context->may_be_abstract)
-    this->type_ = Type::lookup_float_type("float");
+    this->type_ = Type::lookup_float_type("float64");
 }
 
 // Return true if the floating point value VAL fits in the range of
@@ -2185,7 +2185,7 @@ Complex_expression::do_determine_type(const Type_context* context)
           && context->type->complex_type() != NULL)
     this->type_ = context->type;
   else if (!context->may_be_abstract)
-    this->type_ = Type::lookup_complex_type("complex");
+    this->type_ = Type::lookup_complex_type("complex128");
 }
 
 // Return true if the complex value REAL/IMAG fits in the range of the
@@ -6473,7 +6473,7 @@ class Builtin_call_expression : public Call_expression
       BUILTIN_CAP,
       BUILTIN_CLOSE,
       BUILTIN_CLOSED,
-      BUILTIN_CMPLX,
+      BUILTIN_COMPLEX,
       BUILTIN_COPY,
       BUILTIN_IMAG,
       BUILTIN_LEN,
@@ -6501,7 +6501,7 @@ class Builtin_call_expression : public Call_expression
   real_imag_type(Type*);
 
   static Type*
-  cmplx_type(Type*);
+  complex_type(Type*);
 
   // A pointer back to the general IR structure.  This avoids a global
   // variable, or passing it around everywhere.
@@ -6532,8 +6532,8 @@ Builtin_call_expression::Builtin_call_expression(Gogo* gogo,
     this->code_ = BUILTIN_CLOSE;
   else if (name == "closed")
     this->code_ = BUILTIN_CLOSED;
-  else if (name == "cmplx")
-    this->code_ = BUILTIN_CMPLX;
+  else if (name == "complex")
+    this->code_ = BUILTIN_COMPLEX;
   else if (name == "copy")
     this->code_ = BUILTIN_COPY;
   else if (name == "imag")
@@ -6774,9 +6774,7 @@ Builtin_call_expression::real_imag_type(Type* arg_type)
     return NULL;
   while (nt->real_type()->named_type() != NULL)
     nt = nt->real_type()->named_type();
-  if (nt->name() == "complex")
-    return Type::lookup_float_type("float");
-  else if (nt->name() == "complex64")
+  if (nt->name() == "complex64")
     return Type::lookup_float_type("float32");
   else if (nt->name() == "complex128")
     return Type::lookup_float_type("float64");
@@ -6784,11 +6782,11 @@ Builtin_call_expression::real_imag_type(Type* arg_type)
     return NULL;
 }
 
-// Return the type of the cmplx function, given the type of one of the
+// Return the type of the complex function, given the type of one of the
 // argments.  Like real_imag_type, we have to map by name.
 
 Type*
-Builtin_call_expression::cmplx_type(Type* arg_type)
+Builtin_call_expression::complex_type(Type* arg_type)
 {
   if (arg_type == NULL || arg_type->is_abstract())
     return NULL;
@@ -6797,9 +6795,7 @@ Builtin_call_expression::cmplx_type(Type* arg_type)
     return NULL;
   while (nt->real_type()->named_type() != NULL)
     nt = nt->real_type()->named_type();
-  if (nt->name() == "float")
-    return Type::lookup_complex_type("complex");
-  else if (nt->name() == "float32")
+  if (nt->name() == "float32")
     return Type::lookup_complex_type("complex64");
   else if (nt->name() == "float64")
     return Type::lookup_complex_type("complex128");
@@ -6868,7 +6864,7 @@ Builtin_call_expression::do_is_constant() const
        return arg->field_reference_expression() != NULL;
       }
 
-    case BUILTIN_CMPLX:
+    case BUILTIN_COMPLEX:
       {
        const Expression_list* args = this->args();
        if (args != NULL && args->size() == 2)
@@ -7053,7 +7049,7 @@ bool
 Builtin_call_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
                                                   Type** ptype) const
 {
-  if (this->code_ == BUILTIN_CMPLX)
+  if (this->code_ == BUILTIN_COMPLEX)
     {
       const Expression_list* args = this->args();
       if (args == NULL || args->size() != 2)
@@ -7078,7 +7074,7 @@ Builtin_call_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
        {
          mpfr_set(real, r, GMP_RNDN);
          mpfr_set(imag, i, GMP_RNDN);
-         *ptype = Builtin_call_expression::cmplx_type(rtype);
+         *ptype = Builtin_call_expression::complex_type(rtype);
          ret = true;
        }
 
@@ -7154,7 +7150,7 @@ Builtin_call_expression::do_type()
        return t;
       }
 
-    case BUILTIN_CMPLX:
+    case BUILTIN_COMPLEX:
       {
        const Expression_list* args = this->args();
        if (args == NULL || args->size() != 2)
@@ -7166,7 +7162,7 @@ Builtin_call_expression::do_type()
            if (t->is_abstract())
              t = t->make_non_abstract_type();
          }
-       t = Builtin_call_expression::cmplx_type(t);
+       t = Builtin_call_expression::complex_type(t);
        if (t == NULL)
          t = Type::make_error_type();
        return t;
@@ -7195,13 +7191,13 @@ Builtin_call_expression::do_determine_type(const Type_context* context)
 
     case BUILTIN_REAL:
     case BUILTIN_IMAG:
-      arg_type = Builtin_call_expression::cmplx_type(context->type);
+      arg_type = Builtin_call_expression::complex_type(context->type);
       is_print = false;
       break;
 
-    case BUILTIN_CMPLX:
+    case BUILTIN_COMPLEX:
       {
-       // For the cmplx function the type of one operand can
+       // For the complex function the type of one operand can
        // determine the type of the other, as in a binary expression.
        arg_type = Builtin_call_expression::real_imag_type(context->type);
        if (args != NULL && args->size() == 2)
@@ -7498,7 +7494,7 @@ Builtin_call_expression::do_check_types(Gogo*)
        }
       break;
 
-    case BUILTIN_CMPLX:
+    case BUILTIN_COMPLEX:
       {
        const Expression_list* args = this->args();
        if (args == NULL || args->size() < 2)
@@ -7512,9 +7508,9 @@ Builtin_call_expression::do_check_types(Gogo*)
          this->set_is_error();
        else if (!Type::are_identical(args->front()->type(),
                                      args->back()->type(), true, NULL))
-         this->report_error(_("cmplx arguments must have identical types"));
+         this->report_error(_("complex arguments must have identical types"));
        else if (args->front()->type()->float_type() == NULL)
-         this->report_error(_("cmplx arguments must have "
+         this->report_error(_("complex arguments must have "
                               "floating-point type"));
       }
       break;
@@ -8077,7 +8073,7 @@ Builtin_call_expression::do_get_tree(Translate_context* context)
                                 arg_tree);
       }
 
-    case BUILTIN_CMPLX:
+    case BUILTIN_COMPLEX:
       {
        const Expression_list* args = this->args();
        gcc_assert(args != NULL && args->size() == 2);
index c756084..2f30fd8 100644 (file)
@@ -24,10 +24,10 @@ static Gogo* gogo;
 
 GO_EXTERN_C
 void
-go_create_gogo(int int_type_size, int float_type_size, int pointer_size)
+go_create_gogo(int int_type_size, int pointer_size)
 {
   gcc_assert(::gogo == NULL);
-  ::gogo = new Gogo(int_type_size, float_type_size, pointer_size);
+  ::gogo = new Gogo(int_type_size, pointer_size);
   if (!unique_prefix.empty())
     ::gogo->set_unique_prefix(unique_prefix);
 }
index 8e67074..794dd74 100644 (file)
@@ -19,7 +19,7 @@
 
 // Class Gogo.
 
-Gogo::Gogo(int int_type_size, int float_type_size, int pointer_size)
+Gogo::Gogo(int int_type_size, int pointer_size)
   : package_(NULL),
     functions_(),
     globals_(new Bindings(NULL)),
@@ -86,12 +86,6 @@ Gogo::Gogo(int int_type_size, int float_type_size, int pointer_size)
                                               pointer_size,
                                               RUNTIME_TYPE_KIND_UINTPTR));
 
-  this->add_named_type(Type::make_float_type("float", float_type_size,
-                                            RUNTIME_TYPE_KIND_FLOAT));
-
-  this->add_named_type(Type::make_complex_type("complex", float_type_size * 2,
-                                              RUNTIME_TYPE_KIND_COMPLEX));
-
   this->add_named_type(Type::make_named_bool_type());
 
   this->add_named_type(Type::make_named_string_type());
@@ -199,10 +193,10 @@ Gogo::Gogo(int int_type_size, int float_type_size, int pointer_size)
   append_type->set_is_builtin();
   this->globals_->add_function_declaration("append", NULL, append_type, loc);
 
-  Function_type* cmplx_type = Type::make_function_type(NULL, NULL, NULL, loc);
-  cmplx_type->set_is_varargs();
-  cmplx_type->set_is_builtin();
-  this->globals_->add_function_declaration("cmplx", NULL, cmplx_type, loc);
+  Function_type* complex_type = Type::make_function_type(NULL, NULL, NULL, loc);
+  complex_type->set_is_varargs();
+  complex_type->set_is_builtin();
+  this->globals_->add_function_declaration("complex", NULL, complex_type, loc);
 
   Function_type* real_type = Type::make_function_type(NULL, NULL, NULL, loc);
   real_type->set_is_varargs();
@@ -212,7 +206,7 @@ Gogo::Gogo(int int_type_size, int float_type_size, int pointer_size)
   Function_type* imag_type = Type::make_function_type(NULL, NULL, NULL, loc);
   imag_type->set_is_varargs();
   imag_type->set_is_builtin();
-  this->globals_->add_function_declaration("imag", NULL, cmplx_type, loc);
+  this->globals_->add_function_declaration("imag", NULL, imag_type, loc);
 
   this->define_builtin_function_trees();
 
index 0a822c5..cb3fe67 100644 (file)
@@ -100,9 +100,9 @@ operator<(const Import_init& i1, const Import_init& i2)
 class Gogo
 {
  public:
-  // Create the IR, passing in the sizes of the types "int", "float",
-  // and "uintptr" in bits.
-  Gogo(int int_type_size, int float_type_size, int pointer_size);
+  // Create the IR, passing in the sizes of the types "int" and
+  // "uintptr" in bits.
+  Gogo(int int_type_size, int pointer_size);
 
   // Get the package name.
   const std::string&
index ec27aba..d926edf 100644 (file)
@@ -704,8 +704,6 @@ Import::register_builtin_types(Gogo* gogo)
   this->register_builtin_type(gogo, "int", BUILTIN_INT);
   this->register_builtin_type(gogo, "uint", BUILTIN_UINT);
   this->register_builtin_type(gogo, "uintptr", BUILTIN_UINTPTR);
-  this->register_builtin_type(gogo, "float", BUILTIN_FLOAT);
-  this->register_builtin_type(gogo, "complex", BUILTIN_COMPLEX);
   this->register_builtin_type(gogo, "bool", BUILTIN_BOOL);
   this->register_builtin_type(gogo, "string", BUILTIN_STRING);
 }
index 418e8a8..a70f5e9 100644 (file)
@@ -194,9 +194,9 @@ Type::make_non_abstract_type()
     case TYPE_INTEGER:
       return Type::lookup_integer_type("int");
     case TYPE_FLOAT:
-      return Type::lookup_float_type("float");
+      return Type::lookup_float_type("float64");
     case TYPE_COMPLEX:
-      return Type::lookup_complex_type("complex");
+      return Type::lookup_complex_type("complex128");
     case TYPE_STRING:
       return Type::lookup_string_type();
     case TYPE_BOOLEAN:
@@ -1872,8 +1872,7 @@ Float_type::create_abstract_float_type()
 {
   static Float_type* abstract_type;
   if (abstract_type == NULL)
-    abstract_type = new Float_type(true, FLOAT_TYPE_SIZE,
-                                  RUNTIME_TYPE_KIND_FLOAT);
+    abstract_type = new Float_type(true, 64, RUNTIME_TYPE_KIND_FLOAT64);
   return abstract_type;
 }
 
@@ -2029,8 +2028,7 @@ Complex_type::create_abstract_complex_type()
 {
   static Complex_type* abstract_type;
   if (abstract_type == NULL)
-    abstract_type = new Complex_type(true, FLOAT_TYPE_SIZE * 2,
-                                    RUNTIME_TYPE_KIND_FLOAT);
+    abstract_type = new Complex_type(true, 128, RUNTIME_TYPE_KIND_COMPLEX128);
   return abstract_type;
 }
 
index a8d8a0b..b9e8caf 100644 (file)
@@ -60,22 +60,20 @@ static const int RUNTIME_TYPE_KIND_UINT16 = 9;
 static const int RUNTIME_TYPE_KIND_UINT32 = 10;
 static const int RUNTIME_TYPE_KIND_UINT64 = 11;
 static const int RUNTIME_TYPE_KIND_UINTPTR = 12;
-static const int RUNTIME_TYPE_KIND_FLOAT = 13;
-static const int RUNTIME_TYPE_KIND_FLOAT32 = 14;
-static const int RUNTIME_TYPE_KIND_FLOAT64 = 15;
-static const int RUNTIME_TYPE_KIND_COMPLEX = 16;
-static const int RUNTIME_TYPE_KIND_COMPLEX64 = 17;
-static const int RUNTIME_TYPE_KIND_COMPLEX128 = 18;
-static const int RUNTIME_TYPE_KIND_ARRAY = 19;
-static const int RUNTIME_TYPE_KIND_CHAN = 20;
-static const int RUNTIME_TYPE_KIND_FUNC = 21;
-static const int RUNTIME_TYPE_KIND_INTERFACE = 22;
-static const int RUNTIME_TYPE_KIND_MAP = 23;
-static const int RUNTIME_TYPE_KIND_PTR = 24;
-static const int RUNTIME_TYPE_KIND_SLICE = 25;
-static const int RUNTIME_TYPE_KIND_STRING = 26;
-static const int RUNTIME_TYPE_KIND_STRUCT = 27;
-static const int RUNTIME_TYPE_KIND_UNSAFE_POINTER = 28;
+static const int RUNTIME_TYPE_KIND_FLOAT32 = 13;
+static const int RUNTIME_TYPE_KIND_FLOAT64 = 14;
+static const int RUNTIME_TYPE_KIND_COMPLEX64 = 15;
+static const int RUNTIME_TYPE_KIND_COMPLEX128 = 16;
+static const int RUNTIME_TYPE_KIND_ARRAY = 17;
+static const int RUNTIME_TYPE_KIND_CHAN = 18;
+static const int RUNTIME_TYPE_KIND_FUNC = 19;
+static const int RUNTIME_TYPE_KIND_INTERFACE = 20;
+static const int RUNTIME_TYPE_KIND_MAP = 21;
+static const int RUNTIME_TYPE_KIND_PTR = 22;
+static const int RUNTIME_TYPE_KIND_SLICE = 23;
+static const int RUNTIME_TYPE_KIND_STRING = 24;
+static const int RUNTIME_TYPE_KIND_STRUCT = 25;
+static const int RUNTIME_TYPE_KIND_UNSAFE_POINTER = 26;
 
 // To build the complete list of methods for a named type we need to
 // gather all methods from anonymous fields.  Those methods may
index b9d3a32..681a5e7 100644 (file)
@@ -28,7 +28,7 @@ const (
        c4
 )
 
-var ints = []string {
+var ints = []string{
        "1",
        "2",
        "3",
@@ -36,15 +36,15 @@ var ints = []string {
 
 func f() (int, int) {
        call += "f"
-       return 1,2
+       return 1, 2
 }
 
-func g() (float, float) {
+func g() (float64, float64) {
        call += "g"
-       return 3,4
+       return 3, 4
 }
 
-func h(_ int, _ float) {
+func h(_ int, _ float64) {
 }
 
 func i() int {
@@ -55,43 +55,64 @@ func i() int {
 var _ = i()
 
 func main() {
-       if call != "i" {panic("init did not run")}
+       if call != "i" {
+               panic("init did not run")
+       }
        call = ""
        _, _ = f()
        a, _ := f()
-       if a != 1 {panic(a)}
+       if a != 1 {
+               panic(a)
+       }
        b, _ := g()
-       if b != 3 {panic(b)}
+       if b != 3 {
+               panic(b)
+       }
        _, a = f()
-       if a != 2 {panic(a)}
+       if a != 2 {
+               panic(a)
+       }
        _, b = g()
-       if b != 4 {panic(b)}
+       if b != 4 {
+               panic(b)
+       }
        _ = i()
-       if call != "ffgfgi" {panic(call)}
-       if c4 != 4 {panic(c4)}
+       if call != "ffgfgi" {
+               panic(call)
+       }
+       if c4 != 4 {
+               panic(c4)
+       }
 
        out := ""
        for _, s := range ints {
                out += s
        }
-       if out != "123" {panic(out)}
+       if out != "123" {
+               panic(out)
+       }
 
        sum := 0
-       for s, _ := range ints {
+       for s := range ints {
                sum += s
        }
-       if sum != 3 {panic(sum)}
+       if sum != 3 {
+               panic(sum)
+       }
 
-       h(a,b)
+       h(a, b)
 }
 
 // useless but legal
 var _ int = 1
 var _ = 2
 var _, _ = 3, 4
+
 const _ = 3
 const _, _ = 4, 5
+
 type _ int
+
 func _() {
        panic("oops")
 }
index 6262c68..d5a77d6 100644 (file)
@@ -7,25 +7,19 @@
 package main
 
 var (
-       f float
        f32 float32
        f64 float64
 
-       c complex
-       c64 complex64
+       c64  complex64
        c128 complex128
 )
-       
+
 func main() {
        // ok
-       c = cmplx(f, f)
-       c64 = cmplx(f32, f32)
-       c128 = cmplx(f64, f64)
+       c64 = complex(f32, f32)
+       c128 = complex(f64, f64)
 
-       _ = cmplx(f, f32)       // ERROR "cmplx"
-       _ = cmplx(f, f64)       // ERROR "cmplx"
-       _ = cmplx(f32, f)       // ERROR "cmplx"
-       _ = cmplx(f32, f64)     // ERROR "cmplx"
-       _ = cmplx(f64, f)       // ERROR "cmplx"
-       _ = cmplx(f64, f32)     // ERROR "cmplx"
+       _ = complex128(0)     // ok
+       _ = complex(f32, f64) // ERROR "complex"
+       _ = complex(f64, f32) // ERROR "complex"
 }
index 96ea704..6a1dee9 100644 (file)
 // # generated by cmplxdivide.c
 
 package main
-
 var tests = []Test{
-       Test{cmplx(0, 0), cmplx(0, 0), cmplx(nan, nan)},
-       Test{cmplx(0, 0), cmplx(0, 1), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(0, -1), cmplx(negzero, 0)},
-       Test{cmplx(0, 0), cmplx(0, 2), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 0), cmplx(0, inf), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(0, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 0), cmplx(1, 0), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(1, 1), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(1, -1), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(1, 2), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 0), cmplx(1, inf), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 0), cmplx(-1, 0), cmplx(negzero, negzero)},
-       Test{cmplx(0, 0), cmplx(-1, 1), cmplx(negzero, negzero)},
-       Test{cmplx(0, 0), cmplx(-1, -1), cmplx(negzero, negzero)},
-       Test{cmplx(0, 0), cmplx(-1, 2), cmplx(0, negzero)},
-       Test{cmplx(0, 0), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 0), cmplx(-1, inf), cmplx(0, negzero)},
-       Test{cmplx(0, 0), cmplx(-1, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(0, 0), cmplx(2, 0), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(2, 1), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(2, -1), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(2, 2), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 0), cmplx(2, inf), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(2, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 0), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(0, 0), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(0, 0), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(0, 0), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(0, 0), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 0), cmplx(nan, inf), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(nan, -inf), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(inf, 0), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(inf, 1), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(inf, -1), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(inf, 2), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(inf, nan), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(inf, inf), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(inf, -inf), cmplx(0, 0)},
-       Test{cmplx(0, 0), cmplx(-inf, 0), cmplx(negzero, negzero)},
-       Test{cmplx(0, 0), cmplx(-inf, 1), cmplx(negzero, negzero)},
-       Test{cmplx(0, 0), cmplx(-inf, -1), cmplx(negzero, negzero)},
-       Test{cmplx(0, 0), cmplx(-inf, 2), cmplx(negzero, negzero)},
-       Test{cmplx(0, 0), cmplx(-inf, nan), cmplx(0, negzero)},
-       Test{cmplx(0, 0), cmplx(-inf, inf), cmplx(0, negzero)},
-       Test{cmplx(0, 0), cmplx(-inf, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 1), cmplx(0, 0), cmplx(nan, inf)},
-       Test{cmplx(0, 1), cmplx(0, 1), cmplx(1, 0)},
-       Test{cmplx(0, 1), cmplx(0, -1), cmplx(-1, 0)},
-       Test{cmplx(0, 1), cmplx(0, 2), cmplx(0.5, 0)},
-       Test{cmplx(0, 1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 1), cmplx(0, inf), cmplx(0, 0)},
-       Test{cmplx(0, 1), cmplx(0, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 1), cmplx(1, 0), cmplx(0, 1)},
-       Test{cmplx(0, 1), cmplx(1, 1), cmplx(0.5, 0.5)},
-       Test{cmplx(0, 1), cmplx(1, -1), cmplx(-0.5, 0.5)},
-       Test{cmplx(0, 1), cmplx(1, 2), cmplx(0.4, 0.2)},
-       Test{cmplx(0, 1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 1), cmplx(1, inf), cmplx(0, 0)},
-       Test{cmplx(0, 1), cmplx(1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 1), cmplx(-1, 0), cmplx(negzero, -1)},
-       Test{cmplx(0, 1), cmplx(-1, 1), cmplx(0.5, -0.5)},
-       Test{cmplx(0, 1), cmplx(-1, -1), cmplx(-0.5, -0.5)},
-       Test{cmplx(0, 1), cmplx(-1, 2), cmplx(0.4, -0.2)},
-       Test{cmplx(0, 1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 1), cmplx(-1, inf), cmplx(0, negzero)},
-       Test{cmplx(0, 1), cmplx(-1, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(0, 1), cmplx(2, 0), cmplx(0, 0.5)},
-       Test{cmplx(0, 1), cmplx(2, 1), cmplx(0.2, 0.4)},
-       Test{cmplx(0, 1), cmplx(2, -1), cmplx(-0.2, 0.4)},
-       Test{cmplx(0, 1), cmplx(2, 2), cmplx(0.25, 0.25)},
-       Test{cmplx(0, 1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 1), cmplx(2, inf), cmplx(0, 0)},
-       Test{cmplx(0, 1), cmplx(2, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(0, 1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(0, 1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(0, 1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(0, 1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 1), cmplx(nan, inf), cmplx(0, 0)},
-       Test{cmplx(0, 1), cmplx(nan, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 1), cmplx(inf, 0), cmplx(0, 0)},
-       Test{cmplx(0, 1), cmplx(inf, 1), cmplx(0, 0)},
-       Test{cmplx(0, 1), cmplx(inf, -1), cmplx(0, 0)},
-       Test{cmplx(0, 1), cmplx(inf, 2), cmplx(0, 0)},
-       Test{cmplx(0, 1), cmplx(inf, nan), cmplx(0, 0)},
-       Test{cmplx(0, 1), cmplx(inf, inf), cmplx(0, 0)},
-       Test{cmplx(0, 1), cmplx(inf, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 1), cmplx(-inf, 0), cmplx(negzero, negzero)},
-       Test{cmplx(0, 1), cmplx(-inf, 1), cmplx(negzero, negzero)},
-       Test{cmplx(0, 1), cmplx(-inf, -1), cmplx(negzero, negzero)},
-       Test{cmplx(0, 1), cmplx(-inf, 2), cmplx(negzero, negzero)},
-       Test{cmplx(0, 1), cmplx(-inf, nan), cmplx(0, negzero)},
-       Test{cmplx(0, 1), cmplx(-inf, inf), cmplx(0, negzero)},
-       Test{cmplx(0, 1), cmplx(-inf, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(0, -1), cmplx(0, 0), cmplx(nan, -inf)},
-       Test{cmplx(0, -1), cmplx(0, 1), cmplx(-1, negzero)},
-       Test{cmplx(0, -1), cmplx(0, -1), cmplx(1, negzero)},
-       Test{cmplx(0, -1), cmplx(0, 2), cmplx(-0.5, negzero)},
-       Test{cmplx(0, -1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(0, -1), cmplx(0, inf), cmplx(negzero, negzero)},
-       Test{cmplx(0, -1), cmplx(0, -inf), cmplx(0, negzero)},
-       Test{cmplx(0, -1), cmplx(1, 0), cmplx(0, -1)},
-       Test{cmplx(0, -1), cmplx(1, 1), cmplx(-0.5, -0.5)},
-       Test{cmplx(0, -1), cmplx(1, -1), cmplx(0.5, -0.5)},
-       Test{cmplx(0, -1), cmplx(1, 2), cmplx(-0.4, -0.2)},
-       Test{cmplx(0, -1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, -1), cmplx(1, inf), cmplx(negzero, negzero)},
-       Test{cmplx(0, -1), cmplx(1, -inf), cmplx(0, negzero)},
-       Test{cmplx(0, -1), cmplx(-1, 0), cmplx(negzero, 1)},
-       Test{cmplx(0, -1), cmplx(-1, 1), cmplx(-0.5, 0.5)},
-       Test{cmplx(0, -1), cmplx(-1, -1), cmplx(0.5, 0.5)},
-       Test{cmplx(0, -1), cmplx(-1, 2), cmplx(-0.4, 0.2)},
-       Test{cmplx(0, -1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, -1), cmplx(-1, inf), cmplx(negzero, 0)},
-       Test{cmplx(0, -1), cmplx(-1, -inf), cmplx(0, 0)},
-       Test{cmplx(0, -1), cmplx(2, 0), cmplx(0, -0.5)},
-       Test{cmplx(0, -1), cmplx(2, 1), cmplx(-0.2, -0.4)},
-       Test{cmplx(0, -1), cmplx(2, -1), cmplx(0.2, -0.4)},
-       Test{cmplx(0, -1), cmplx(2, 2), cmplx(-0.25, -0.25)},
-       Test{cmplx(0, -1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(0, -1), cmplx(2, inf), cmplx(negzero, negzero)},
-       Test{cmplx(0, -1), cmplx(2, -inf), cmplx(0, negzero)},
-       Test{cmplx(0, -1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(0, -1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(0, -1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(0, -1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(0, -1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(0, -1), cmplx(nan, inf), cmplx(negzero, negzero)},
-       Test{cmplx(0, -1), cmplx(nan, -inf), cmplx(0, 0)},
-       Test{cmplx(0, -1), cmplx(inf, 0), cmplx(0, negzero)},
-       Test{cmplx(0, -1), cmplx(inf, 1), cmplx(0, negzero)},
-       Test{cmplx(0, -1), cmplx(inf, -1), cmplx(0, negzero)},
-       Test{cmplx(0, -1), cmplx(inf, 2), cmplx(0, negzero)},
-       Test{cmplx(0, -1), cmplx(inf, nan), cmplx(0, negzero)},
-       Test{cmplx(0, -1), cmplx(inf, inf), cmplx(negzero, negzero)},
-       Test{cmplx(0, -1), cmplx(inf, -inf), cmplx(0, negzero)},
-       Test{cmplx(0, -1), cmplx(-inf, 0), cmplx(negzero, 0)},
-       Test{cmplx(0, -1), cmplx(-inf, 1), cmplx(negzero, 0)},
-       Test{cmplx(0, -1), cmplx(-inf, -1), cmplx(negzero, 0)},
-       Test{cmplx(0, -1), cmplx(-inf, 2), cmplx(negzero, 0)},
-       Test{cmplx(0, -1), cmplx(-inf, nan), cmplx(negzero, 0)},
-       Test{cmplx(0, -1), cmplx(-inf, inf), cmplx(negzero, 0)},
-       Test{cmplx(0, -1), cmplx(-inf, -inf), cmplx(0, 0)},
-       Test{cmplx(0, 2), cmplx(0, 0), cmplx(nan, inf)},
-       Test{cmplx(0, 2), cmplx(0, 1), cmplx(2, 0)},
-       Test{cmplx(0, 2), cmplx(0, -1), cmplx(-2, 0)},
-       Test{cmplx(0, 2), cmplx(0, 2), cmplx(1, 0)},
-       Test{cmplx(0, 2), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 2), cmplx(0, inf), cmplx(0, 0)},
-       Test{cmplx(0, 2), cmplx(0, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 2), cmplx(1, 0), cmplx(0, 2)},
-       Test{cmplx(0, 2), cmplx(1, 1), cmplx(1, 1)},
-       Test{cmplx(0, 2), cmplx(1, -1), cmplx(-1, 1)},
-       Test{cmplx(0, 2), cmplx(1, 2), cmplx(0.8, 0.4)},
-       Test{cmplx(0, 2), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 2), cmplx(1, inf), cmplx(0, 0)},
-       Test{cmplx(0, 2), cmplx(1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 2), cmplx(-1, 0), cmplx(negzero, -2)},
-       Test{cmplx(0, 2), cmplx(-1, 1), cmplx(1, -1)},
-       Test{cmplx(0, 2), cmplx(-1, -1), cmplx(-1, -1)},
-       Test{cmplx(0, 2), cmplx(-1, 2), cmplx(0.8, -0.4)},
-       Test{cmplx(0, 2), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 2), cmplx(-1, inf), cmplx(0, negzero)},
-       Test{cmplx(0, 2), cmplx(-1, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(0, 2), cmplx(2, 0), cmplx(0, 1)},
-       Test{cmplx(0, 2), cmplx(2, 1), cmplx(0.4, 0.8)},
-       Test{cmplx(0, 2), cmplx(2, -1), cmplx(-0.4, 0.8)},
-       Test{cmplx(0, 2), cmplx(2, 2), cmplx(0.5, 0.5)},
-       Test{cmplx(0, 2), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 2), cmplx(2, inf), cmplx(0, 0)},
-       Test{cmplx(0, 2), cmplx(2, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 2), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(0, 2), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(0, 2), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(0, 2), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(0, 2), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(0, 2), cmplx(nan, inf), cmplx(0, 0)},
-       Test{cmplx(0, 2), cmplx(nan, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 2), cmplx(inf, 0), cmplx(0, 0)},
-       Test{cmplx(0, 2), cmplx(inf, 1), cmplx(0, 0)},
-       Test{cmplx(0, 2), cmplx(inf, -1), cmplx(0, 0)},
-       Test{cmplx(0, 2), cmplx(inf, 2), cmplx(0, 0)},
-       Test{cmplx(0, 2), cmplx(inf, nan), cmplx(0, 0)},
-       Test{cmplx(0, 2), cmplx(inf, inf), cmplx(0, 0)},
-       Test{cmplx(0, 2), cmplx(inf, -inf), cmplx(negzero, 0)},
-       Test{cmplx(0, 2), cmplx(-inf, 0), cmplx(negzero, negzero)},
-       Test{cmplx(0, 2), cmplx(-inf, 1), cmplx(negzero, negzero)},
-       Test{cmplx(0, 2), cmplx(-inf, -1), cmplx(negzero, negzero)},
-       Test{cmplx(0, 2), cmplx(-inf, 2), cmplx(negzero, negzero)},
-       Test{cmplx(0, 2), cmplx(-inf, nan), cmplx(0, negzero)},
-       Test{cmplx(0, 2), cmplx(-inf, inf), cmplx(0, negzero)},
-       Test{cmplx(0, 2), cmplx(-inf, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(0, nan), cmplx(0, 0), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(0, 1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(0, -1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(0, 2), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(1, 0), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(1, 1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(1, -1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(1, 2), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-1, 0), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-1, 1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-1, -1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-1, 2), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(2, 0), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(2, 1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(2, -1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(2, 2), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(0, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(0, 0), cmplx(nan, inf)},
-       Test{cmplx(0, inf), cmplx(0, 1), cmplx(inf, nan)},
-       Test{cmplx(0, inf), cmplx(0, -1), cmplx(-inf, nan)},
-       Test{cmplx(0, inf), cmplx(0, 2), cmplx(inf, nan)},
-       Test{cmplx(0, inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(1, 0), cmplx(nan, inf)},
-       Test{cmplx(0, inf), cmplx(1, 1), cmplx(inf, inf)},
-       Test{cmplx(0, inf), cmplx(1, -1), cmplx(-inf, inf)},
-       Test{cmplx(0, inf), cmplx(1, 2), cmplx(inf, inf)},
-       Test{cmplx(0, inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(-1, 0), cmplx(nan, -inf)},
-       Test{cmplx(0, inf), cmplx(-1, 1), cmplx(inf, -inf)},
-       Test{cmplx(0, inf), cmplx(-1, -1), cmplx(-inf, -inf)},
-       Test{cmplx(0, inf), cmplx(-1, 2), cmplx(inf, -inf)},
-       Test{cmplx(0, inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(2, 0), cmplx(nan, inf)},
-       Test{cmplx(0, inf), cmplx(2, 1), cmplx(inf, inf)},
-       Test{cmplx(0, inf), cmplx(2, -1), cmplx(-inf, inf)},
-       Test{cmplx(0, inf), cmplx(2, 2), cmplx(inf, inf)},
-       Test{cmplx(0, inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(0, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(0, 0), cmplx(nan, -inf)},
-       Test{cmplx(0, -inf), cmplx(0, 1), cmplx(-inf, nan)},
-       Test{cmplx(0, -inf), cmplx(0, -1), cmplx(inf, nan)},
-       Test{cmplx(0, -inf), cmplx(0, 2), cmplx(-inf, nan)},
-       Test{cmplx(0, -inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(1, 0), cmplx(nan, -inf)},
-       Test{cmplx(0, -inf), cmplx(1, 1), cmplx(-inf, -inf)},
-       Test{cmplx(0, -inf), cmplx(1, -1), cmplx(inf, -inf)},
-       Test{cmplx(0, -inf), cmplx(1, 2), cmplx(-inf, -inf)},
-       Test{cmplx(0, -inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(-1, 0), cmplx(nan, inf)},
-       Test{cmplx(0, -inf), cmplx(-1, 1), cmplx(-inf, inf)},
-       Test{cmplx(0, -inf), cmplx(-1, -1), cmplx(inf, inf)},
-       Test{cmplx(0, -inf), cmplx(-1, 2), cmplx(-inf, inf)},
-       Test{cmplx(0, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(2, 0), cmplx(nan, -inf)},
-       Test{cmplx(0, -inf), cmplx(2, 1), cmplx(-inf, -inf)},
-       Test{cmplx(0, -inf), cmplx(2, -1), cmplx(inf, -inf)},
-       Test{cmplx(0, -inf), cmplx(2, 2), cmplx(-inf, -inf)},
-       Test{cmplx(0, -inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(0, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, 0), cmplx(0, 0), cmplx(inf, nan)},
-       Test{cmplx(1, 0), cmplx(0, 1), cmplx(0, -1)},
-       Test{cmplx(1, 0), cmplx(0, -1), cmplx(negzero, 1)},
-       Test{cmplx(1, 0), cmplx(0, 2), cmplx(0, -0.5)},
-       Test{cmplx(1, 0), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 0), cmplx(0, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 0), cmplx(0, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 0), cmplx(1, 0), cmplx(1, 0)},
-       Test{cmplx(1, 0), cmplx(1, 1), cmplx(0.5, -0.5)},
-       Test{cmplx(1, 0), cmplx(1, -1), cmplx(0.5, 0.5)},
-       Test{cmplx(1, 0), cmplx(1, 2), cmplx(0.2, -0.4)},
-       Test{cmplx(1, 0), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 0), cmplx(1, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 0), cmplx(1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 0), cmplx(-1, 0), cmplx(-1, negzero)},
-       Test{cmplx(1, 0), cmplx(-1, 1), cmplx(-0.5, -0.5)},
-       Test{cmplx(1, 0), cmplx(-1, -1), cmplx(-0.5, 0.5)},
-       Test{cmplx(1, 0), cmplx(-1, 2), cmplx(-0.2, -0.4)},
-       Test{cmplx(1, 0), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 0), cmplx(-1, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 0), cmplx(-1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 0), cmplx(2, 0), cmplx(0.5, 0)},
-       Test{cmplx(1, 0), cmplx(2, 1), cmplx(0.4, -0.2)},
-       Test{cmplx(1, 0), cmplx(2, -1), cmplx(0.4, 0.2)},
-       Test{cmplx(1, 0), cmplx(2, 2), cmplx(0.25, -0.25)},
-       Test{cmplx(1, 0), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 0), cmplx(2, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 0), cmplx(2, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 0), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(1, 0), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(1, 0), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(1, 0), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(1, 0), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 0), cmplx(nan, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 0), cmplx(nan, -inf), cmplx(0, 0)},
-       Test{cmplx(1, 0), cmplx(inf, 0), cmplx(0, 0)},
-       Test{cmplx(1, 0), cmplx(inf, 1), cmplx(0, 0)},
-       Test{cmplx(1, 0), cmplx(inf, -1), cmplx(0, 0)},
-       Test{cmplx(1, 0), cmplx(inf, 2), cmplx(0, 0)},
-       Test{cmplx(1, 0), cmplx(inf, nan), cmplx(0, 0)},
-       Test{cmplx(1, 0), cmplx(inf, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 0), cmplx(inf, -inf), cmplx(0, 0)},
-       Test{cmplx(1, 0), cmplx(-inf, 0), cmplx(negzero, negzero)},
-       Test{cmplx(1, 0), cmplx(-inf, 1), cmplx(negzero, negzero)},
-       Test{cmplx(1, 0), cmplx(-inf, -1), cmplx(negzero, negzero)},
-       Test{cmplx(1, 0), cmplx(-inf, 2), cmplx(negzero, negzero)},
-       Test{cmplx(1, 0), cmplx(-inf, nan), cmplx(negzero, negzero)},
-       Test{cmplx(1, 0), cmplx(-inf, inf), cmplx(negzero, negzero)},
-       Test{cmplx(1, 0), cmplx(-inf, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 1), cmplx(0, 0), cmplx(inf, inf)},
-       Test{cmplx(1, 1), cmplx(0, 1), cmplx(1, -1)},
-       Test{cmplx(1, 1), cmplx(0, -1), cmplx(-1, 1)},
-       Test{cmplx(1, 1), cmplx(0, 2), cmplx(0.5, -0.5)},
-       Test{cmplx(1, 1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 1), cmplx(0, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 1), cmplx(0, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 1), cmplx(1, 0), cmplx(1, 1)},
-       Test{cmplx(1, 1), cmplx(1, 1), cmplx(1, 0)},
-       Test{cmplx(1, 1), cmplx(1, -1), cmplx(0, 1)},
-       Test{cmplx(1, 1), cmplx(1, 2), cmplx(0.6, -0.2)},
-       Test{cmplx(1, 1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 1), cmplx(1, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 1), cmplx(1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 1), cmplx(-1, 0), cmplx(-1, -1)},
-       Test{cmplx(1, 1), cmplx(-1, 1), cmplx(negzero, -1)},
-       Test{cmplx(1, 1), cmplx(-1, -1), cmplx(-1, negzero)},
-       Test{cmplx(1, 1), cmplx(-1, 2), cmplx(0.2, -0.6)},
-       Test{cmplx(1, 1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 1), cmplx(-1, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 1), cmplx(-1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 1), cmplx(2, 0), cmplx(0.5, 0.5)},
-       Test{cmplx(1, 1), cmplx(2, 1), cmplx(0.6, 0.2)},
-       Test{cmplx(1, 1), cmplx(2, -1), cmplx(0.2, 0.6)},
-       Test{cmplx(1, 1), cmplx(2, 2), cmplx(0.5, 0)},
-       Test{cmplx(1, 1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 1), cmplx(2, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 1), cmplx(2, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(1, 1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(1, 1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(1, 1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(1, 1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 1), cmplx(nan, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 1), cmplx(nan, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 1), cmplx(inf, 0), cmplx(0, 0)},
-       Test{cmplx(1, 1), cmplx(inf, 1), cmplx(0, 0)},
-       Test{cmplx(1, 1), cmplx(inf, -1), cmplx(0, 0)},
-       Test{cmplx(1, 1), cmplx(inf, 2), cmplx(0, 0)},
-       Test{cmplx(1, 1), cmplx(inf, nan), cmplx(0, 0)},
-       Test{cmplx(1, 1), cmplx(inf, inf), cmplx(0, 0)},
-       Test{cmplx(1, 1), cmplx(inf, -inf), cmplx(0, 0)},
-       Test{cmplx(1, 1), cmplx(-inf, 0), cmplx(negzero, negzero)},
-       Test{cmplx(1, 1), cmplx(-inf, 1), cmplx(negzero, negzero)},
-       Test{cmplx(1, 1), cmplx(-inf, -1), cmplx(negzero, negzero)},
-       Test{cmplx(1, 1), cmplx(-inf, 2), cmplx(negzero, negzero)},
-       Test{cmplx(1, 1), cmplx(-inf, nan), cmplx(negzero, negzero)},
-       Test{cmplx(1, 1), cmplx(-inf, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 1), cmplx(-inf, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, -1), cmplx(0, 0), cmplx(inf, -inf)},
-       Test{cmplx(1, -1), cmplx(0, 1), cmplx(-1, -1)},
-       Test{cmplx(1, -1), cmplx(0, -1), cmplx(1, 1)},
-       Test{cmplx(1, -1), cmplx(0, 2), cmplx(-0.5, -0.5)},
-       Test{cmplx(1, -1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(1, -1), cmplx(0, inf), cmplx(negzero, negzero)},
-       Test{cmplx(1, -1), cmplx(0, -inf), cmplx(0, 0)},
-       Test{cmplx(1, -1), cmplx(1, 0), cmplx(1, -1)},
-       Test{cmplx(1, -1), cmplx(1, 1), cmplx(0, -1)},
-       Test{cmplx(1, -1), cmplx(1, -1), cmplx(1, 0)},
-       Test{cmplx(1, -1), cmplx(1, 2), cmplx(-0.2, -0.6)},
-       Test{cmplx(1, -1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, -1), cmplx(1, inf), cmplx(negzero, negzero)},
-       Test{cmplx(1, -1), cmplx(1, -inf), cmplx(0, 0)},
-       Test{cmplx(1, -1), cmplx(-1, 0), cmplx(-1, 1)},
-       Test{cmplx(1, -1), cmplx(-1, 1), cmplx(-1, negzero)},
-       Test{cmplx(1, -1), cmplx(-1, -1), cmplx(negzero, 1)},
-       Test{cmplx(1, -1), cmplx(-1, 2), cmplx(-0.6, -0.2)},
-       Test{cmplx(1, -1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, -1), cmplx(-1, inf), cmplx(negzero, negzero)},
-       Test{cmplx(1, -1), cmplx(-1, -inf), cmplx(0, 0)},
-       Test{cmplx(1, -1), cmplx(2, 0), cmplx(0.5, -0.5)},
-       Test{cmplx(1, -1), cmplx(2, 1), cmplx(0.2, -0.6)},
-       Test{cmplx(1, -1), cmplx(2, -1), cmplx(0.6, -0.2)},
-       Test{cmplx(1, -1), cmplx(2, 2), cmplx(0, -0.5)},
-       Test{cmplx(1, -1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(1, -1), cmplx(2, inf), cmplx(negzero, negzero)},
-       Test{cmplx(1, -1), cmplx(2, -inf), cmplx(0, 0)},
-       Test{cmplx(1, -1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(1, -1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(1, -1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(1, -1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(1, -1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(1, -1), cmplx(nan, inf), cmplx(negzero, negzero)},
-       Test{cmplx(1, -1), cmplx(nan, -inf), cmplx(0, 0)},
-       Test{cmplx(1, -1), cmplx(inf, 0), cmplx(0, negzero)},
-       Test{cmplx(1, -1), cmplx(inf, 1), cmplx(0, negzero)},
-       Test{cmplx(1, -1), cmplx(inf, -1), cmplx(0, negzero)},
-       Test{cmplx(1, -1), cmplx(inf, 2), cmplx(0, negzero)},
-       Test{cmplx(1, -1), cmplx(inf, nan), cmplx(0, negzero)},
-       Test{cmplx(1, -1), cmplx(inf, inf), cmplx(0, negzero)},
-       Test{cmplx(1, -1), cmplx(inf, -inf), cmplx(0, 0)},
-       Test{cmplx(1, -1), cmplx(-inf, 0), cmplx(negzero, 0)},
-       Test{cmplx(1, -1), cmplx(-inf, 1), cmplx(negzero, 0)},
-       Test{cmplx(1, -1), cmplx(-inf, -1), cmplx(negzero, 0)},
-       Test{cmplx(1, -1), cmplx(-inf, 2), cmplx(negzero, 0)},
-       Test{cmplx(1, -1), cmplx(-inf, nan), cmplx(negzero, 0)},
-       Test{cmplx(1, -1), cmplx(-inf, inf), cmplx(negzero, 0)},
-       Test{cmplx(1, -1), cmplx(-inf, -inf), cmplx(0, 0)},
-       Test{cmplx(1, 2), cmplx(0, 0), cmplx(inf, inf)},
-       Test{cmplx(1, 2), cmplx(0, 1), cmplx(2, -1)},
-       Test{cmplx(1, 2), cmplx(0, -1), cmplx(-2, 1)},
-       Test{cmplx(1, 2), cmplx(0, 2), cmplx(1, -0.5)},
-       Test{cmplx(1, 2), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 2), cmplx(0, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 2), cmplx(0, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 2), cmplx(1, 0), cmplx(1, 2)},
-       Test{cmplx(1, 2), cmplx(1, 1), cmplx(1.5, 0.5)},
-       Test{cmplx(1, 2), cmplx(1, -1), cmplx(-0.5, 1.5)},
-       Test{cmplx(1, 2), cmplx(1, 2), cmplx(1, 0)},
-       Test{cmplx(1, 2), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 2), cmplx(1, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 2), cmplx(1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 2), cmplx(-1, 0), cmplx(-1, -2)},
-       Test{cmplx(1, 2), cmplx(-1, 1), cmplx(0.5, -1.5)},
-       Test{cmplx(1, 2), cmplx(-1, -1), cmplx(-1.5, -0.5)},
-       Test{cmplx(1, 2), cmplx(-1, 2), cmplx(0.6, -0.8)},
-       Test{cmplx(1, 2), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 2), cmplx(-1, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 2), cmplx(-1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 2), cmplx(2, 0), cmplx(0.5, 1)},
-       Test{cmplx(1, 2), cmplx(2, 1), cmplx(0.8, 0.6)},
-       Test{cmplx(1, 2), cmplx(2, -1), cmplx(0, 1)},
-       Test{cmplx(1, 2), cmplx(2, 2), cmplx(0.75, 0.25)},
-       Test{cmplx(1, 2), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 2), cmplx(2, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 2), cmplx(2, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 2), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(1, 2), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(1, 2), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(1, 2), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(1, 2), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(1, 2), cmplx(nan, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 2), cmplx(nan, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 2), cmplx(inf, 0), cmplx(0, 0)},
-       Test{cmplx(1, 2), cmplx(inf, 1), cmplx(0, 0)},
-       Test{cmplx(1, 2), cmplx(inf, -1), cmplx(0, 0)},
-       Test{cmplx(1, 2), cmplx(inf, 2), cmplx(0, 0)},
-       Test{cmplx(1, 2), cmplx(inf, nan), cmplx(0, 0)},
-       Test{cmplx(1, 2), cmplx(inf, inf), cmplx(0, 0)},
-       Test{cmplx(1, 2), cmplx(inf, -inf), cmplx(negzero, 0)},
-       Test{cmplx(1, 2), cmplx(-inf, 0), cmplx(negzero, negzero)},
-       Test{cmplx(1, 2), cmplx(-inf, 1), cmplx(negzero, negzero)},
-       Test{cmplx(1, 2), cmplx(-inf, -1), cmplx(negzero, negzero)},
-       Test{cmplx(1, 2), cmplx(-inf, 2), cmplx(negzero, negzero)},
-       Test{cmplx(1, 2), cmplx(-inf, nan), cmplx(negzero, negzero)},
-       Test{cmplx(1, 2), cmplx(-inf, inf), cmplx(0, negzero)},
-       Test{cmplx(1, 2), cmplx(-inf, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(1, nan), cmplx(0, 0), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(0, 1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(0, -1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(0, 2), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(1, 0), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(1, 1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(1, -1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(1, 2), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-1, 0), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-1, 1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-1, -1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-1, 2), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(2, 0), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(2, 1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(2, -1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(2, 2), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(1, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(0, 0), cmplx(inf, inf)},
-       Test{cmplx(1, inf), cmplx(0, 1), cmplx(inf, nan)},
-       Test{cmplx(1, inf), cmplx(0, -1), cmplx(-inf, nan)},
-       Test{cmplx(1, inf), cmplx(0, 2), cmplx(inf, nan)},
-       Test{cmplx(1, inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(1, 0), cmplx(nan, inf)},
-       Test{cmplx(1, inf), cmplx(1, 1), cmplx(inf, inf)},
-       Test{cmplx(1, inf), cmplx(1, -1), cmplx(-inf, inf)},
-       Test{cmplx(1, inf), cmplx(1, 2), cmplx(inf, inf)},
-       Test{cmplx(1, inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(-1, 0), cmplx(nan, -inf)},
-       Test{cmplx(1, inf), cmplx(-1, 1), cmplx(inf, -inf)},
-       Test{cmplx(1, inf), cmplx(-1, -1), cmplx(-inf, -inf)},
-       Test{cmplx(1, inf), cmplx(-1, 2), cmplx(inf, -inf)},
-       Test{cmplx(1, inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(2, 0), cmplx(nan, inf)},
-       Test{cmplx(1, inf), cmplx(2, 1), cmplx(inf, inf)},
-       Test{cmplx(1, inf), cmplx(2, -1), cmplx(-inf, inf)},
-       Test{cmplx(1, inf), cmplx(2, 2), cmplx(inf, inf)},
-       Test{cmplx(1, inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(1, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(0, 0), cmplx(inf, -inf)},
-       Test{cmplx(1, -inf), cmplx(0, 1), cmplx(-inf, nan)},
-       Test{cmplx(1, -inf), cmplx(0, -1), cmplx(inf, nan)},
-       Test{cmplx(1, -inf), cmplx(0, 2), cmplx(-inf, nan)},
-       Test{cmplx(1, -inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(1, 0), cmplx(nan, -inf)},
-       Test{cmplx(1, -inf), cmplx(1, 1), cmplx(-inf, -inf)},
-       Test{cmplx(1, -inf), cmplx(1, -1), cmplx(inf, -inf)},
-       Test{cmplx(1, -inf), cmplx(1, 2), cmplx(-inf, -inf)},
-       Test{cmplx(1, -inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(-1, 0), cmplx(nan, inf)},
-       Test{cmplx(1, -inf), cmplx(-1, 1), cmplx(-inf, inf)},
-       Test{cmplx(1, -inf), cmplx(-1, -1), cmplx(inf, inf)},
-       Test{cmplx(1, -inf), cmplx(-1, 2), cmplx(-inf, inf)},
-       Test{cmplx(1, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(2, 0), cmplx(nan, -inf)},
-       Test{cmplx(1, -inf), cmplx(2, 1), cmplx(-inf, -inf)},
-       Test{cmplx(1, -inf), cmplx(2, -1), cmplx(inf, -inf)},
-       Test{cmplx(1, -inf), cmplx(2, 2), cmplx(-inf, -inf)},
-       Test{cmplx(1, -inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(1, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, 0), cmplx(0, 0), cmplx(-inf, nan)},
-       Test{cmplx(-1, 0), cmplx(0, 1), cmplx(0, 1)},
-       Test{cmplx(-1, 0), cmplx(0, -1), cmplx(negzero, -1)},
-       Test{cmplx(-1, 0), cmplx(0, 2), cmplx(0, 0.5)},
-       Test{cmplx(-1, 0), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 0), cmplx(0, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 0), cmplx(0, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 0), cmplx(1, 0), cmplx(-1, 0)},
-       Test{cmplx(-1, 0), cmplx(1, 1), cmplx(-0.5, 0.5)},
-       Test{cmplx(-1, 0), cmplx(1, -1), cmplx(-0.5, -0.5)},
-       Test{cmplx(-1, 0), cmplx(1, 2), cmplx(-0.2, 0.4)},
-       Test{cmplx(-1, 0), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 0), cmplx(1, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 0), cmplx(1, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 0), cmplx(-1, 0), cmplx(1, negzero)},
-       Test{cmplx(-1, 0), cmplx(-1, 1), cmplx(0.5, 0.5)},
-       Test{cmplx(-1, 0), cmplx(-1, -1), cmplx(0.5, -0.5)},
-       Test{cmplx(-1, 0), cmplx(-1, 2), cmplx(0.2, 0.4)},
-       Test{cmplx(-1, 0), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 0), cmplx(-1, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 0), cmplx(-1, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 0), cmplx(2, 0), cmplx(-0.5, 0)},
-       Test{cmplx(-1, 0), cmplx(2, 1), cmplx(-0.4, 0.2)},
-       Test{cmplx(-1, 0), cmplx(2, -1), cmplx(-0.4, -0.2)},
-       Test{cmplx(-1, 0), cmplx(2, 2), cmplx(-0.25, 0.25)},
-       Test{cmplx(-1, 0), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 0), cmplx(2, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 0), cmplx(2, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 0), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, 0), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, 0), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, 0), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, 0), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 0), cmplx(nan, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 0), cmplx(nan, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 0), cmplx(inf, 0), cmplx(negzero, 0)},
-       Test{cmplx(-1, 0), cmplx(inf, 1), cmplx(negzero, 0)},
-       Test{cmplx(-1, 0), cmplx(inf, -1), cmplx(negzero, 0)},
-       Test{cmplx(-1, 0), cmplx(inf, 2), cmplx(negzero, 0)},
-       Test{cmplx(-1, 0), cmplx(inf, nan), cmplx(negzero, 0)},
-       Test{cmplx(-1, 0), cmplx(inf, inf), cmplx(negzero, 0)},
-       Test{cmplx(-1, 0), cmplx(inf, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 0), cmplx(-inf, 0), cmplx(0, negzero)},
-       Test{cmplx(-1, 0), cmplx(-inf, 1), cmplx(0, negzero)},
-       Test{cmplx(-1, 0), cmplx(-inf, -1), cmplx(0, negzero)},
-       Test{cmplx(-1, 0), cmplx(-inf, 2), cmplx(0, negzero)},
-       Test{cmplx(-1, 0), cmplx(-inf, nan), cmplx(0, 0)},
-       Test{cmplx(-1, 0), cmplx(-inf, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 0), cmplx(-inf, -inf), cmplx(0, negzero)},
-       Test{cmplx(-1, 1), cmplx(0, 0), cmplx(-inf, inf)},
-       Test{cmplx(-1, 1), cmplx(0, 1), cmplx(1, 1)},
-       Test{cmplx(-1, 1), cmplx(0, -1), cmplx(-1, -1)},
-       Test{cmplx(-1, 1), cmplx(0, 2), cmplx(0.5, 0.5)},
-       Test{cmplx(-1, 1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 1), cmplx(0, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 1), cmplx(0, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 1), cmplx(1, 0), cmplx(-1, 1)},
-       Test{cmplx(-1, 1), cmplx(1, 1), cmplx(0, 1)},
-       Test{cmplx(-1, 1), cmplx(1, -1), cmplx(-1, 0)},
-       Test{cmplx(-1, 1), cmplx(1, 2), cmplx(0.2, 0.6)},
-       Test{cmplx(-1, 1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 1), cmplx(1, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 1), cmplx(1, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 1), cmplx(-1, 0), cmplx(1, -1)},
-       Test{cmplx(-1, 1), cmplx(-1, 1), cmplx(1, negzero)},
-       Test{cmplx(-1, 1), cmplx(-1, -1), cmplx(negzero, -1)},
-       Test{cmplx(-1, 1), cmplx(-1, 2), cmplx(0.6, 0.2)},
-       Test{cmplx(-1, 1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 1), cmplx(-1, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 1), cmplx(-1, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 1), cmplx(2, 0), cmplx(-0.5, 0.5)},
-       Test{cmplx(-1, 1), cmplx(2, 1), cmplx(-0.2, 0.6)},
-       Test{cmplx(-1, 1), cmplx(2, -1), cmplx(-0.6, 0.2)},
-       Test{cmplx(-1, 1), cmplx(2, 2), cmplx(0, 0.5)},
-       Test{cmplx(-1, 1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 1), cmplx(2, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 1), cmplx(2, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, 1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, 1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, 1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, 1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 1), cmplx(nan, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 1), cmplx(nan, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 1), cmplx(inf, 0), cmplx(negzero, 0)},
-       Test{cmplx(-1, 1), cmplx(inf, 1), cmplx(negzero, 0)},
-       Test{cmplx(-1, 1), cmplx(inf, -1), cmplx(negzero, 0)},
-       Test{cmplx(-1, 1), cmplx(inf, 2), cmplx(negzero, 0)},
-       Test{cmplx(-1, 1), cmplx(inf, nan), cmplx(negzero, 0)},
-       Test{cmplx(-1, 1), cmplx(inf, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 1), cmplx(inf, -inf), cmplx(negzero, 0)},
-       Test{cmplx(-1, 1), cmplx(-inf, 0), cmplx(0, negzero)},
-       Test{cmplx(-1, 1), cmplx(-inf, 1), cmplx(0, negzero)},
-       Test{cmplx(-1, 1), cmplx(-inf, -1), cmplx(0, negzero)},
-       Test{cmplx(-1, 1), cmplx(-inf, 2), cmplx(0, negzero)},
-       Test{cmplx(-1, 1), cmplx(-inf, nan), cmplx(0, negzero)},
-       Test{cmplx(-1, 1), cmplx(-inf, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 1), cmplx(-inf, -inf), cmplx(0, negzero)},
-       Test{cmplx(-1, -1), cmplx(0, 0), cmplx(-inf, -inf)},
-       Test{cmplx(-1, -1), cmplx(0, 1), cmplx(-1, 1)},
-       Test{cmplx(-1, -1), cmplx(0, -1), cmplx(1, -1)},
-       Test{cmplx(-1, -1), cmplx(0, 2), cmplx(-0.5, 0.5)},
-       Test{cmplx(-1, -1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, -1), cmplx(0, inf), cmplx(negzero, 0)},
-       Test{cmplx(-1, -1), cmplx(0, -inf), cmplx(0, negzero)},
-       Test{cmplx(-1, -1), cmplx(1, 0), cmplx(-1, -1)},
-       Test{cmplx(-1, -1), cmplx(1, 1), cmplx(-1, 0)},
-       Test{cmplx(-1, -1), cmplx(1, -1), cmplx(0, -1)},
-       Test{cmplx(-1, -1), cmplx(1, 2), cmplx(-0.6, 0.2)},
-       Test{cmplx(-1, -1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, -1), cmplx(1, inf), cmplx(negzero, 0)},
-       Test{cmplx(-1, -1), cmplx(1, -inf), cmplx(0, negzero)},
-       Test{cmplx(-1, -1), cmplx(-1, 0), cmplx(1, 1)},
-       Test{cmplx(-1, -1), cmplx(-1, 1), cmplx(negzero, 1)},
-       Test{cmplx(-1, -1), cmplx(-1, -1), cmplx(1, negzero)},
-       Test{cmplx(-1, -1), cmplx(-1, 2), cmplx(-0.2, 0.6)},
-       Test{cmplx(-1, -1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, -1), cmplx(-1, inf), cmplx(negzero, 0)},
-       Test{cmplx(-1, -1), cmplx(-1, -inf), cmplx(0, negzero)},
-       Test{cmplx(-1, -1), cmplx(2, 0), cmplx(-0.5, -0.5)},
-       Test{cmplx(-1, -1), cmplx(2, 1), cmplx(-0.6, -0.2)},
-       Test{cmplx(-1, -1), cmplx(2, -1), cmplx(-0.2, -0.6)},
-       Test{cmplx(-1, -1), cmplx(2, 2), cmplx(-0.5, 0)},
-       Test{cmplx(-1, -1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, -1), cmplx(2, inf), cmplx(negzero, 0)},
-       Test{cmplx(-1, -1), cmplx(2, -inf), cmplx(0, negzero)},
-       Test{cmplx(-1, -1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, -1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, -1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, -1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, -1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, -1), cmplx(nan, inf), cmplx(negzero, 0)},
-       Test{cmplx(-1, -1), cmplx(nan, -inf), cmplx(0, negzero)},
-       Test{cmplx(-1, -1), cmplx(inf, 0), cmplx(negzero, negzero)},
-       Test{cmplx(-1, -1), cmplx(inf, 1), cmplx(negzero, negzero)},
-       Test{cmplx(-1, -1), cmplx(inf, -1), cmplx(negzero, negzero)},
-       Test{cmplx(-1, -1), cmplx(inf, 2), cmplx(negzero, negzero)},
-       Test{cmplx(-1, -1), cmplx(inf, nan), cmplx(negzero, negzero)},
-       Test{cmplx(-1, -1), cmplx(inf, inf), cmplx(negzero, 0)},
-       Test{cmplx(-1, -1), cmplx(inf, -inf), cmplx(0, negzero)},
-       Test{cmplx(-1, -1), cmplx(-inf, 0), cmplx(0, 0)},
-       Test{cmplx(-1, -1), cmplx(-inf, 1), cmplx(0, 0)},
-       Test{cmplx(-1, -1), cmplx(-inf, -1), cmplx(0, 0)},
-       Test{cmplx(-1, -1), cmplx(-inf, 2), cmplx(0, 0)},
-       Test{cmplx(-1, -1), cmplx(-inf, nan), cmplx(0, 0)},
-       Test{cmplx(-1, -1), cmplx(-inf, inf), cmplx(0, 0)},
-       Test{cmplx(-1, -1), cmplx(-inf, -inf), cmplx(0, 0)},
-       Test{cmplx(-1, 2), cmplx(0, 0), cmplx(-inf, inf)},
-       Test{cmplx(-1, 2), cmplx(0, 1), cmplx(2, 1)},
-       Test{cmplx(-1, 2), cmplx(0, -1), cmplx(-2, -1)},
-       Test{cmplx(-1, 2), cmplx(0, 2), cmplx(1, 0.5)},
-       Test{cmplx(-1, 2), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 2), cmplx(0, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 2), cmplx(0, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 2), cmplx(1, 0), cmplx(-1, 2)},
-       Test{cmplx(-1, 2), cmplx(1, 1), cmplx(0.5, 1.5)},
-       Test{cmplx(-1, 2), cmplx(1, -1), cmplx(-1.5, 0.5)},
-       Test{cmplx(-1, 2), cmplx(1, 2), cmplx(0.6, 0.8)},
-       Test{cmplx(-1, 2), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 2), cmplx(1, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 2), cmplx(1, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 2), cmplx(-1, 0), cmplx(1, -2)},
-       Test{cmplx(-1, 2), cmplx(-1, 1), cmplx(1.5, -0.5)},
-       Test{cmplx(-1, 2), cmplx(-1, -1), cmplx(-0.5, -1.5)},
-       Test{cmplx(-1, 2), cmplx(-1, 2), cmplx(1, 0)},
-       Test{cmplx(-1, 2), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 2), cmplx(-1, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 2), cmplx(-1, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 2), cmplx(2, 0), cmplx(-0.5, 1)},
-       Test{cmplx(-1, 2), cmplx(2, 1), cmplx(0, 1)},
-       Test{cmplx(-1, 2), cmplx(2, -1), cmplx(-0.8, 0.6)},
-       Test{cmplx(-1, 2), cmplx(2, 2), cmplx(0.25, 0.75)},
-       Test{cmplx(-1, 2), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 2), cmplx(2, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 2), cmplx(2, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 2), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, 2), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, 2), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, 2), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, 2), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, 2), cmplx(nan, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 2), cmplx(nan, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, 2), cmplx(inf, 0), cmplx(negzero, 0)},
-       Test{cmplx(-1, 2), cmplx(inf, 1), cmplx(negzero, 0)},
-       Test{cmplx(-1, 2), cmplx(inf, -1), cmplx(negzero, 0)},
-       Test{cmplx(-1, 2), cmplx(inf, 2), cmplx(negzero, 0)},
-       Test{cmplx(-1, 2), cmplx(inf, nan), cmplx(negzero, 0)},
-       Test{cmplx(-1, 2), cmplx(inf, inf), cmplx(0, 0)},
-       Test{cmplx(-1, 2), cmplx(inf, -inf), cmplx(negzero, 0)},
-       Test{cmplx(-1, 2), cmplx(-inf, 0), cmplx(0, negzero)},
-       Test{cmplx(-1, 2), cmplx(-inf, 1), cmplx(0, negzero)},
-       Test{cmplx(-1, 2), cmplx(-inf, -1), cmplx(0, negzero)},
-       Test{cmplx(-1, 2), cmplx(-inf, 2), cmplx(0, negzero)},
-       Test{cmplx(-1, 2), cmplx(-inf, nan), cmplx(0, negzero)},
-       Test{cmplx(-1, 2), cmplx(-inf, inf), cmplx(0, negzero)},
-       Test{cmplx(-1, 2), cmplx(-inf, -inf), cmplx(negzero, negzero)},
-       Test{cmplx(-1, nan), cmplx(0, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(0, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(0, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(0, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(1, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(1, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(1, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(1, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-1, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-1, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-1, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-1, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(2, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(2, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(2, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(2, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(0, 0), cmplx(-inf, inf)},
-       Test{cmplx(-1, inf), cmplx(0, 1), cmplx(inf, nan)},
-       Test{cmplx(-1, inf), cmplx(0, -1), cmplx(-inf, nan)},
-       Test{cmplx(-1, inf), cmplx(0, 2), cmplx(inf, nan)},
-       Test{cmplx(-1, inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(1, 0), cmplx(nan, inf)},
-       Test{cmplx(-1, inf), cmplx(1, 1), cmplx(inf, inf)},
-       Test{cmplx(-1, inf), cmplx(1, -1), cmplx(-inf, inf)},
-       Test{cmplx(-1, inf), cmplx(1, 2), cmplx(inf, inf)},
-       Test{cmplx(-1, inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(-1, 0), cmplx(nan, -inf)},
-       Test{cmplx(-1, inf), cmplx(-1, 1), cmplx(inf, -inf)},
-       Test{cmplx(-1, inf), cmplx(-1, -1), cmplx(-inf, -inf)},
-       Test{cmplx(-1, inf), cmplx(-1, 2), cmplx(inf, -inf)},
-       Test{cmplx(-1, inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(2, 0), cmplx(nan, inf)},
-       Test{cmplx(-1, inf), cmplx(2, 1), cmplx(inf, inf)},
-       Test{cmplx(-1, inf), cmplx(2, -1), cmplx(-inf, inf)},
-       Test{cmplx(-1, inf), cmplx(2, 2), cmplx(inf, inf)},
-       Test{cmplx(-1, inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(0, 0), cmplx(-inf, -inf)},
-       Test{cmplx(-1, -inf), cmplx(0, 1), cmplx(-inf, nan)},
-       Test{cmplx(-1, -inf), cmplx(0, -1), cmplx(inf, nan)},
-       Test{cmplx(-1, -inf), cmplx(0, 2), cmplx(-inf, nan)},
-       Test{cmplx(-1, -inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(1, 0), cmplx(nan, -inf)},
-       Test{cmplx(-1, -inf), cmplx(1, 1), cmplx(-inf, -inf)},
-       Test{cmplx(-1, -inf), cmplx(1, -1), cmplx(inf, -inf)},
-       Test{cmplx(-1, -inf), cmplx(1, 2), cmplx(-inf, -inf)},
-       Test{cmplx(-1, -inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(-1, 0), cmplx(nan, inf)},
-       Test{cmplx(-1, -inf), cmplx(-1, 1), cmplx(-inf, inf)},
-       Test{cmplx(-1, -inf), cmplx(-1, -1), cmplx(inf, inf)},
-       Test{cmplx(-1, -inf), cmplx(-1, 2), cmplx(-inf, inf)},
-       Test{cmplx(-1, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(2, 0), cmplx(nan, -inf)},
-       Test{cmplx(-1, -inf), cmplx(2, 1), cmplx(-inf, -inf)},
-       Test{cmplx(-1, -inf), cmplx(2, -1), cmplx(inf, -inf)},
-       Test{cmplx(-1, -inf), cmplx(2, 2), cmplx(-inf, -inf)},
-       Test{cmplx(-1, -inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-1, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, 0), cmplx(0, 0), cmplx(inf, nan)},
-       Test{cmplx(2, 0), cmplx(0, 1), cmplx(0, -2)},
-       Test{cmplx(2, 0), cmplx(0, -1), cmplx(negzero, 2)},
-       Test{cmplx(2, 0), cmplx(0, 2), cmplx(0, -1)},
-       Test{cmplx(2, 0), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 0), cmplx(0, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 0), cmplx(0, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 0), cmplx(1, 0), cmplx(2, 0)},
-       Test{cmplx(2, 0), cmplx(1, 1), cmplx(1, -1)},
-       Test{cmplx(2, 0), cmplx(1, -1), cmplx(1, 1)},
-       Test{cmplx(2, 0), cmplx(1, 2), cmplx(0.4, -0.8)},
-       Test{cmplx(2, 0), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 0), cmplx(1, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 0), cmplx(1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 0), cmplx(-1, 0), cmplx(-2, negzero)},
-       Test{cmplx(2, 0), cmplx(-1, 1), cmplx(-1, -1)},
-       Test{cmplx(2, 0), cmplx(-1, -1), cmplx(-1, 1)},
-       Test{cmplx(2, 0), cmplx(-1, 2), cmplx(-0.4, -0.8)},
-       Test{cmplx(2, 0), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 0), cmplx(-1, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 0), cmplx(-1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 0), cmplx(2, 0), cmplx(1, 0)},
-       Test{cmplx(2, 0), cmplx(2, 1), cmplx(0.8, -0.4)},
-       Test{cmplx(2, 0), cmplx(2, -1), cmplx(0.8, 0.4)},
-       Test{cmplx(2, 0), cmplx(2, 2), cmplx(0.5, -0.5)},
-       Test{cmplx(2, 0), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 0), cmplx(2, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 0), cmplx(2, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 0), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(2, 0), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(2, 0), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(2, 0), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(2, 0), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 0), cmplx(nan, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 0), cmplx(nan, -inf), cmplx(0, 0)},
-       Test{cmplx(2, 0), cmplx(inf, 0), cmplx(0, 0)},
-       Test{cmplx(2, 0), cmplx(inf, 1), cmplx(0, 0)},
-       Test{cmplx(2, 0), cmplx(inf, -1), cmplx(0, 0)},
-       Test{cmplx(2, 0), cmplx(inf, 2), cmplx(0, 0)},
-       Test{cmplx(2, 0), cmplx(inf, nan), cmplx(0, 0)},
-       Test{cmplx(2, 0), cmplx(inf, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 0), cmplx(inf, -inf), cmplx(0, 0)},
-       Test{cmplx(2, 0), cmplx(-inf, 0), cmplx(negzero, negzero)},
-       Test{cmplx(2, 0), cmplx(-inf, 1), cmplx(negzero, negzero)},
-       Test{cmplx(2, 0), cmplx(-inf, -1), cmplx(negzero, negzero)},
-       Test{cmplx(2, 0), cmplx(-inf, 2), cmplx(negzero, negzero)},
-       Test{cmplx(2, 0), cmplx(-inf, nan), cmplx(negzero, negzero)},
-       Test{cmplx(2, 0), cmplx(-inf, inf), cmplx(negzero, negzero)},
-       Test{cmplx(2, 0), cmplx(-inf, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 1), cmplx(0, 0), cmplx(inf, inf)},
-       Test{cmplx(2, 1), cmplx(0, 1), cmplx(1, -2)},
-       Test{cmplx(2, 1), cmplx(0, -1), cmplx(-1, 2)},
-       Test{cmplx(2, 1), cmplx(0, 2), cmplx(0.5, -1)},
-       Test{cmplx(2, 1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 1), cmplx(0, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 1), cmplx(0, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 1), cmplx(1, 0), cmplx(2, 1)},
-       Test{cmplx(2, 1), cmplx(1, 1), cmplx(1.5, -0.5)},
-       Test{cmplx(2, 1), cmplx(1, -1), cmplx(0.5, 1.5)},
-       Test{cmplx(2, 1), cmplx(1, 2), cmplx(0.8, -0.6)},
-       Test{cmplx(2, 1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 1), cmplx(1, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 1), cmplx(1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 1), cmplx(-1, 0), cmplx(-2, -1)},
-       Test{cmplx(2, 1), cmplx(-1, 1), cmplx(-0.5, -1.5)},
-       Test{cmplx(2, 1), cmplx(-1, -1), cmplx(-1.5, 0.5)},
-       Test{cmplx(2, 1), cmplx(-1, 2), cmplx(0, -1)},
-       Test{cmplx(2, 1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 1), cmplx(-1, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 1), cmplx(-1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 1), cmplx(2, 0), cmplx(1, 0.5)},
-       Test{cmplx(2, 1), cmplx(2, 1), cmplx(1, 0)},
-       Test{cmplx(2, 1), cmplx(2, -1), cmplx(0.6, 0.8)},
-       Test{cmplx(2, 1), cmplx(2, 2), cmplx(0.75, -0.25)},
-       Test{cmplx(2, 1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 1), cmplx(2, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 1), cmplx(2, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(2, 1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(2, 1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(2, 1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(2, 1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 1), cmplx(nan, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 1), cmplx(nan, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 1), cmplx(inf, 0), cmplx(0, 0)},
-       Test{cmplx(2, 1), cmplx(inf, 1), cmplx(0, 0)},
-       Test{cmplx(2, 1), cmplx(inf, -1), cmplx(0, 0)},
-       Test{cmplx(2, 1), cmplx(inf, 2), cmplx(0, 0)},
-       Test{cmplx(2, 1), cmplx(inf, nan), cmplx(0, 0)},
-       Test{cmplx(2, 1), cmplx(inf, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 1), cmplx(inf, -inf), cmplx(0, 0)},
-       Test{cmplx(2, 1), cmplx(-inf, 0), cmplx(negzero, negzero)},
-       Test{cmplx(2, 1), cmplx(-inf, 1), cmplx(negzero, negzero)},
-       Test{cmplx(2, 1), cmplx(-inf, -1), cmplx(negzero, negzero)},
-       Test{cmplx(2, 1), cmplx(-inf, 2), cmplx(negzero, negzero)},
-       Test{cmplx(2, 1), cmplx(-inf, nan), cmplx(negzero, negzero)},
-       Test{cmplx(2, 1), cmplx(-inf, inf), cmplx(negzero, negzero)},
-       Test{cmplx(2, 1), cmplx(-inf, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, -1), cmplx(0, 0), cmplx(inf, -inf)},
-       Test{cmplx(2, -1), cmplx(0, 1), cmplx(-1, -2)},
-       Test{cmplx(2, -1), cmplx(0, -1), cmplx(1, 2)},
-       Test{cmplx(2, -1), cmplx(0, 2), cmplx(-0.5, -1)},
-       Test{cmplx(2, -1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(2, -1), cmplx(0, inf), cmplx(negzero, negzero)},
-       Test{cmplx(2, -1), cmplx(0, -inf), cmplx(0, 0)},
-       Test{cmplx(2, -1), cmplx(1, 0), cmplx(2, -1)},
-       Test{cmplx(2, -1), cmplx(1, 1), cmplx(0.5, -1.5)},
-       Test{cmplx(2, -1), cmplx(1, -1), cmplx(1.5, 0.5)},
-       Test{cmplx(2, -1), cmplx(1, 2), cmplx(0, -1)},
-       Test{cmplx(2, -1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, -1), cmplx(1, inf), cmplx(negzero, negzero)},
-       Test{cmplx(2, -1), cmplx(1, -inf), cmplx(0, 0)},
-       Test{cmplx(2, -1), cmplx(-1, 0), cmplx(-2, 1)},
-       Test{cmplx(2, -1), cmplx(-1, 1), cmplx(-1.5, -0.5)},
-       Test{cmplx(2, -1), cmplx(-1, -1), cmplx(-0.5, 1.5)},
-       Test{cmplx(2, -1), cmplx(-1, 2), cmplx(-0.8, -0.6)},
-       Test{cmplx(2, -1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, -1), cmplx(-1, inf), cmplx(negzero, negzero)},
-       Test{cmplx(2, -1), cmplx(-1, -inf), cmplx(0, 0)},
-       Test{cmplx(2, -1), cmplx(2, 0), cmplx(1, -0.5)},
-       Test{cmplx(2, -1), cmplx(2, 1), cmplx(0.6, -0.8)},
-       Test{cmplx(2, -1), cmplx(2, -1), cmplx(1, 0)},
-       Test{cmplx(2, -1), cmplx(2, 2), cmplx(0.25, -0.75)},
-       Test{cmplx(2, -1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(2, -1), cmplx(2, inf), cmplx(negzero, negzero)},
-       Test{cmplx(2, -1), cmplx(2, -inf), cmplx(0, 0)},
-       Test{cmplx(2, -1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(2, -1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(2, -1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(2, -1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(2, -1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(2, -1), cmplx(nan, inf), cmplx(negzero, negzero)},
-       Test{cmplx(2, -1), cmplx(nan, -inf), cmplx(0, 0)},
-       Test{cmplx(2, -1), cmplx(inf, 0), cmplx(0, negzero)},
-       Test{cmplx(2, -1), cmplx(inf, 1), cmplx(0, negzero)},
-       Test{cmplx(2, -1), cmplx(inf, -1), cmplx(0, negzero)},
-       Test{cmplx(2, -1), cmplx(inf, 2), cmplx(0, negzero)},
-       Test{cmplx(2, -1), cmplx(inf, nan), cmplx(0, negzero)},
-       Test{cmplx(2, -1), cmplx(inf, inf), cmplx(0, negzero)},
-       Test{cmplx(2, -1), cmplx(inf, -inf), cmplx(0, 0)},
-       Test{cmplx(2, -1), cmplx(-inf, 0), cmplx(negzero, 0)},
-       Test{cmplx(2, -1), cmplx(-inf, 1), cmplx(negzero, 0)},
-       Test{cmplx(2, -1), cmplx(-inf, -1), cmplx(negzero, 0)},
-       Test{cmplx(2, -1), cmplx(-inf, 2), cmplx(negzero, 0)},
-       Test{cmplx(2, -1), cmplx(-inf, nan), cmplx(negzero, 0)},
-       Test{cmplx(2, -1), cmplx(-inf, inf), cmplx(negzero, negzero)},
-       Test{cmplx(2, -1), cmplx(-inf, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 2), cmplx(0, 0), cmplx(inf, inf)},
-       Test{cmplx(2, 2), cmplx(0, 1), cmplx(2, -2)},
-       Test{cmplx(2, 2), cmplx(0, -1), cmplx(-2, 2)},
-       Test{cmplx(2, 2), cmplx(0, 2), cmplx(1, -1)},
-       Test{cmplx(2, 2), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 2), cmplx(0, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 2), cmplx(0, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 2), cmplx(1, 0), cmplx(2, 2)},
-       Test{cmplx(2, 2), cmplx(1, 1), cmplx(2, 0)},
-       Test{cmplx(2, 2), cmplx(1, -1), cmplx(0, 2)},
-       Test{cmplx(2, 2), cmplx(1, 2), cmplx(1.2, -0.4)},
-       Test{cmplx(2, 2), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 2), cmplx(1, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 2), cmplx(1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 2), cmplx(-1, 0), cmplx(-2, -2)},
-       Test{cmplx(2, 2), cmplx(-1, 1), cmplx(negzero, -2)},
-       Test{cmplx(2, 2), cmplx(-1, -1), cmplx(-2, negzero)},
-       Test{cmplx(2, 2), cmplx(-1, 2), cmplx(0.4, -1.2)},
-       Test{cmplx(2, 2), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 2), cmplx(-1, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 2), cmplx(-1, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 2), cmplx(2, 0), cmplx(1, 1)},
-       Test{cmplx(2, 2), cmplx(2, 1), cmplx(1.2, 0.4)},
-       Test{cmplx(2, 2), cmplx(2, -1), cmplx(0.4, 1.2)},
-       Test{cmplx(2, 2), cmplx(2, 2), cmplx(1, 0)},
-       Test{cmplx(2, 2), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 2), cmplx(2, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 2), cmplx(2, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 2), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(2, 2), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(2, 2), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(2, 2), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(2, 2), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(2, 2), cmplx(nan, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 2), cmplx(nan, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, 2), cmplx(inf, 0), cmplx(0, 0)},
-       Test{cmplx(2, 2), cmplx(inf, 1), cmplx(0, 0)},
-       Test{cmplx(2, 2), cmplx(inf, -1), cmplx(0, 0)},
-       Test{cmplx(2, 2), cmplx(inf, 2), cmplx(0, 0)},
-       Test{cmplx(2, 2), cmplx(inf, nan), cmplx(0, 0)},
-       Test{cmplx(2, 2), cmplx(inf, inf), cmplx(0, 0)},
-       Test{cmplx(2, 2), cmplx(inf, -inf), cmplx(0, 0)},
-       Test{cmplx(2, 2), cmplx(-inf, 0), cmplx(negzero, negzero)},
-       Test{cmplx(2, 2), cmplx(-inf, 1), cmplx(negzero, negzero)},
-       Test{cmplx(2, 2), cmplx(-inf, -1), cmplx(negzero, negzero)},
-       Test{cmplx(2, 2), cmplx(-inf, 2), cmplx(negzero, negzero)},
-       Test{cmplx(2, 2), cmplx(-inf, nan), cmplx(negzero, negzero)},
-       Test{cmplx(2, 2), cmplx(-inf, inf), cmplx(0, negzero)},
-       Test{cmplx(2, 2), cmplx(-inf, -inf), cmplx(negzero, 0)},
-       Test{cmplx(2, nan), cmplx(0, 0), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(0, 1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(0, -1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(0, 2), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(1, 0), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(1, 1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(1, -1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(1, 2), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-1, 0), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-1, 1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-1, -1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-1, 2), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(2, 0), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(2, 1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(2, -1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(2, 2), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(2, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(0, 0), cmplx(inf, inf)},
-       Test{cmplx(2, inf), cmplx(0, 1), cmplx(inf, nan)},
-       Test{cmplx(2, inf), cmplx(0, -1), cmplx(-inf, nan)},
-       Test{cmplx(2, inf), cmplx(0, 2), cmplx(inf, nan)},
-       Test{cmplx(2, inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(1, 0), cmplx(nan, inf)},
-       Test{cmplx(2, inf), cmplx(1, 1), cmplx(inf, inf)},
-       Test{cmplx(2, inf), cmplx(1, -1), cmplx(-inf, inf)},
-       Test{cmplx(2, inf), cmplx(1, 2), cmplx(inf, inf)},
-       Test{cmplx(2, inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(-1, 0), cmplx(nan, -inf)},
-       Test{cmplx(2, inf), cmplx(-1, 1), cmplx(inf, -inf)},
-       Test{cmplx(2, inf), cmplx(-1, -1), cmplx(-inf, -inf)},
-       Test{cmplx(2, inf), cmplx(-1, 2), cmplx(inf, -inf)},
-       Test{cmplx(2, inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(2, 0), cmplx(nan, inf)},
-       Test{cmplx(2, inf), cmplx(2, 1), cmplx(inf, inf)},
-       Test{cmplx(2, inf), cmplx(2, -1), cmplx(-inf, inf)},
-       Test{cmplx(2, inf), cmplx(2, 2), cmplx(inf, inf)},
-       Test{cmplx(2, inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(2, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(0, 0), cmplx(inf, -inf)},
-       Test{cmplx(2, -inf), cmplx(0, 1), cmplx(-inf, nan)},
-       Test{cmplx(2, -inf), cmplx(0, -1), cmplx(inf, nan)},
-       Test{cmplx(2, -inf), cmplx(0, 2), cmplx(-inf, nan)},
-       Test{cmplx(2, -inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(1, 0), cmplx(nan, -inf)},
-       Test{cmplx(2, -inf), cmplx(1, 1), cmplx(-inf, -inf)},
-       Test{cmplx(2, -inf), cmplx(1, -1), cmplx(inf, -inf)},
-       Test{cmplx(2, -inf), cmplx(1, 2), cmplx(-inf, -inf)},
-       Test{cmplx(2, -inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(-1, 0), cmplx(nan, inf)},
-       Test{cmplx(2, -inf), cmplx(-1, 1), cmplx(-inf, inf)},
-       Test{cmplx(2, -inf), cmplx(-1, -1), cmplx(inf, inf)},
-       Test{cmplx(2, -inf), cmplx(-1, 2), cmplx(-inf, inf)},
-       Test{cmplx(2, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(2, 0), cmplx(nan, -inf)},
-       Test{cmplx(2, -inf), cmplx(2, 1), cmplx(-inf, -inf)},
-       Test{cmplx(2, -inf), cmplx(2, -1), cmplx(inf, -inf)},
-       Test{cmplx(2, -inf), cmplx(2, 2), cmplx(-inf, -inf)},
-       Test{cmplx(2, -inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(2, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(0, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(0, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(0, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(0, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(1, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(1, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(1, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(1, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-1, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-1, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-1, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-1, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(2, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(2, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(2, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(2, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 0), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(0, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(0, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(0, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(0, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(1, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(1, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(1, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(1, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-1, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-1, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-1, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-1, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(2, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(2, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(2, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(2, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 1), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(0, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(0, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(0, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(0, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(1, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(1, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(1, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(1, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-1, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-1, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-1, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-1, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(2, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(2, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(2, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(2, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -1), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(0, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(0, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(0, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(0, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(1, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(1, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(1, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(1, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-1, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-1, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-1, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-1, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(2, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(2, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(2, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(2, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, 2), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(0, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(0, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(0, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(0, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(1, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(1, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(1, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(1, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-1, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-1, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-1, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-1, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(2, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(2, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(2, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(2, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(0, 0), cmplx(nan, inf)},
-       Test{cmplx(nan, inf), cmplx(0, 1), cmplx(inf, nan)},
-       Test{cmplx(nan, inf), cmplx(0, -1), cmplx(-inf, nan)},
-       Test{cmplx(nan, inf), cmplx(0, 2), cmplx(inf, nan)},
-       Test{cmplx(nan, inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(1, 0), cmplx(nan, inf)},
-       Test{cmplx(nan, inf), cmplx(1, 1), cmplx(inf, inf)},
-       Test{cmplx(nan, inf), cmplx(1, -1), cmplx(-inf, inf)},
-       Test{cmplx(nan, inf), cmplx(1, 2), cmplx(inf, inf)},
-       Test{cmplx(nan, inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(-1, 0), cmplx(nan, -inf)},
-       Test{cmplx(nan, inf), cmplx(-1, 1), cmplx(inf, -inf)},
-       Test{cmplx(nan, inf), cmplx(-1, -1), cmplx(-inf, -inf)},
-       Test{cmplx(nan, inf), cmplx(-1, 2), cmplx(inf, -inf)},
-       Test{cmplx(nan, inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(2, 0), cmplx(nan, inf)},
-       Test{cmplx(nan, inf), cmplx(2, 1), cmplx(inf, inf)},
-       Test{cmplx(nan, inf), cmplx(2, -1), cmplx(-inf, inf)},
-       Test{cmplx(nan, inf), cmplx(2, 2), cmplx(inf, inf)},
-       Test{cmplx(nan, inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(0, 0), cmplx(nan, -inf)},
-       Test{cmplx(nan, -inf), cmplx(0, 1), cmplx(-inf, nan)},
-       Test{cmplx(nan, -inf), cmplx(0, -1), cmplx(inf, nan)},
-       Test{cmplx(nan, -inf), cmplx(0, 2), cmplx(-inf, nan)},
-       Test{cmplx(nan, -inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(1, 0), cmplx(nan, -inf)},
-       Test{cmplx(nan, -inf), cmplx(1, 1), cmplx(-inf, -inf)},
-       Test{cmplx(nan, -inf), cmplx(1, -1), cmplx(inf, -inf)},
-       Test{cmplx(nan, -inf), cmplx(1, 2), cmplx(-inf, -inf)},
-       Test{cmplx(nan, -inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(-1, 0), cmplx(nan, inf)},
-       Test{cmplx(nan, -inf), cmplx(-1, 1), cmplx(-inf, inf)},
-       Test{cmplx(nan, -inf), cmplx(-1, -1), cmplx(inf, inf)},
-       Test{cmplx(nan, -inf), cmplx(-1, 2), cmplx(-inf, inf)},
-       Test{cmplx(nan, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(2, 0), cmplx(nan, -inf)},
-       Test{cmplx(nan, -inf), cmplx(2, 1), cmplx(-inf, -inf)},
-       Test{cmplx(nan, -inf), cmplx(2, -1), cmplx(inf, -inf)},
-       Test{cmplx(nan, -inf), cmplx(2, 2), cmplx(-inf, -inf)},
-       Test{cmplx(nan, -inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(nan, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(0, 0), cmplx(inf, nan)},
-       Test{cmplx(inf, 0), cmplx(0, 1), cmplx(nan, -inf)},
-       Test{cmplx(inf, 0), cmplx(0, -1), cmplx(nan, inf)},
-       Test{cmplx(inf, 0), cmplx(0, 2), cmplx(nan, -inf)},
-       Test{cmplx(inf, 0), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(1, 0), cmplx(inf, nan)},
-       Test{cmplx(inf, 0), cmplx(1, 1), cmplx(inf, -inf)},
-       Test{cmplx(inf, 0), cmplx(1, -1), cmplx(inf, inf)},
-       Test{cmplx(inf, 0), cmplx(1, 2), cmplx(inf, -inf)},
-       Test{cmplx(inf, 0), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(-1, 0), cmplx(-inf, nan)},
-       Test{cmplx(inf, 0), cmplx(-1, 1), cmplx(-inf, -inf)},
-       Test{cmplx(inf, 0), cmplx(-1, -1), cmplx(-inf, inf)},
-       Test{cmplx(inf, 0), cmplx(-1, 2), cmplx(-inf, -inf)},
-       Test{cmplx(inf, 0), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(2, 0), cmplx(inf, nan)},
-       Test{cmplx(inf, 0), cmplx(2, 1), cmplx(inf, -inf)},
-       Test{cmplx(inf, 0), cmplx(2, -1), cmplx(inf, inf)},
-       Test{cmplx(inf, 0), cmplx(2, 2), cmplx(inf, -inf)},
-       Test{cmplx(inf, 0), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 0), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(0, 0), cmplx(inf, inf)},
-       Test{cmplx(inf, 1), cmplx(0, 1), cmplx(nan, -inf)},
-       Test{cmplx(inf, 1), cmplx(0, -1), cmplx(nan, inf)},
-       Test{cmplx(inf, 1), cmplx(0, 2), cmplx(nan, -inf)},
-       Test{cmplx(inf, 1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(1, 0), cmplx(inf, nan)},
-       Test{cmplx(inf, 1), cmplx(1, 1), cmplx(inf, -inf)},
-       Test{cmplx(inf, 1), cmplx(1, -1), cmplx(inf, inf)},
-       Test{cmplx(inf, 1), cmplx(1, 2), cmplx(inf, -inf)},
-       Test{cmplx(inf, 1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(-1, 0), cmplx(-inf, nan)},
-       Test{cmplx(inf, 1), cmplx(-1, 1), cmplx(-inf, -inf)},
-       Test{cmplx(inf, 1), cmplx(-1, -1), cmplx(-inf, inf)},
-       Test{cmplx(inf, 1), cmplx(-1, 2), cmplx(-inf, -inf)},
-       Test{cmplx(inf, 1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(2, 0), cmplx(inf, nan)},
-       Test{cmplx(inf, 1), cmplx(2, 1), cmplx(inf, -inf)},
-       Test{cmplx(inf, 1), cmplx(2, -1), cmplx(inf, inf)},
-       Test{cmplx(inf, 1), cmplx(2, 2), cmplx(inf, -inf)},
-       Test{cmplx(inf, 1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 1), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(0, 0), cmplx(inf, -inf)},
-       Test{cmplx(inf, -1), cmplx(0, 1), cmplx(nan, -inf)},
-       Test{cmplx(inf, -1), cmplx(0, -1), cmplx(nan, inf)},
-       Test{cmplx(inf, -1), cmplx(0, 2), cmplx(nan, -inf)},
-       Test{cmplx(inf, -1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(1, 0), cmplx(inf, nan)},
-       Test{cmplx(inf, -1), cmplx(1, 1), cmplx(inf, -inf)},
-       Test{cmplx(inf, -1), cmplx(1, -1), cmplx(inf, inf)},
-       Test{cmplx(inf, -1), cmplx(1, 2), cmplx(inf, -inf)},
-       Test{cmplx(inf, -1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(-1, 0), cmplx(-inf, nan)},
-       Test{cmplx(inf, -1), cmplx(-1, 1), cmplx(-inf, -inf)},
-       Test{cmplx(inf, -1), cmplx(-1, -1), cmplx(-inf, inf)},
-       Test{cmplx(inf, -1), cmplx(-1, 2), cmplx(-inf, -inf)},
-       Test{cmplx(inf, -1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(2, 0), cmplx(inf, nan)},
-       Test{cmplx(inf, -1), cmplx(2, 1), cmplx(inf, -inf)},
-       Test{cmplx(inf, -1), cmplx(2, -1), cmplx(inf, inf)},
-       Test{cmplx(inf, -1), cmplx(2, 2), cmplx(inf, -inf)},
-       Test{cmplx(inf, -1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -1), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(0, 0), cmplx(inf, inf)},
-       Test{cmplx(inf, 2), cmplx(0, 1), cmplx(nan, -inf)},
-       Test{cmplx(inf, 2), cmplx(0, -1), cmplx(nan, inf)},
-       Test{cmplx(inf, 2), cmplx(0, 2), cmplx(nan, -inf)},
-       Test{cmplx(inf, 2), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(1, 0), cmplx(inf, nan)},
-       Test{cmplx(inf, 2), cmplx(1, 1), cmplx(inf, -inf)},
-       Test{cmplx(inf, 2), cmplx(1, -1), cmplx(inf, inf)},
-       Test{cmplx(inf, 2), cmplx(1, 2), cmplx(inf, -inf)},
-       Test{cmplx(inf, 2), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(-1, 0), cmplx(-inf, nan)},
-       Test{cmplx(inf, 2), cmplx(-1, 1), cmplx(-inf, -inf)},
-       Test{cmplx(inf, 2), cmplx(-1, -1), cmplx(-inf, inf)},
-       Test{cmplx(inf, 2), cmplx(-1, 2), cmplx(-inf, -inf)},
-       Test{cmplx(inf, 2), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(2, 0), cmplx(inf, nan)},
-       Test{cmplx(inf, 2), cmplx(2, 1), cmplx(inf, -inf)},
-       Test{cmplx(inf, 2), cmplx(2, -1), cmplx(inf, inf)},
-       Test{cmplx(inf, 2), cmplx(2, 2), cmplx(inf, -inf)},
-       Test{cmplx(inf, 2), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, 2), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(0, 0), cmplx(inf, nan)},
-       Test{cmplx(inf, nan), cmplx(0, 1), cmplx(nan, -inf)},
-       Test{cmplx(inf, nan), cmplx(0, -1), cmplx(nan, inf)},
-       Test{cmplx(inf, nan), cmplx(0, 2), cmplx(nan, -inf)},
-       Test{cmplx(inf, nan), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(1, 0), cmplx(inf, nan)},
-       Test{cmplx(inf, nan), cmplx(1, 1), cmplx(inf, -inf)},
-       Test{cmplx(inf, nan), cmplx(1, -1), cmplx(inf, inf)},
-       Test{cmplx(inf, nan), cmplx(1, 2), cmplx(inf, -inf)},
-       Test{cmplx(inf, nan), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(-1, 0), cmplx(-inf, nan)},
-       Test{cmplx(inf, nan), cmplx(-1, 1), cmplx(-inf, -inf)},
-       Test{cmplx(inf, nan), cmplx(-1, -1), cmplx(-inf, inf)},
-       Test{cmplx(inf, nan), cmplx(-1, 2), cmplx(-inf, -inf)},
-       Test{cmplx(inf, nan), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(2, 0), cmplx(inf, nan)},
-       Test{cmplx(inf, nan), cmplx(2, 1), cmplx(inf, -inf)},
-       Test{cmplx(inf, nan), cmplx(2, -1), cmplx(inf, inf)},
-       Test{cmplx(inf, nan), cmplx(2, 2), cmplx(inf, -inf)},
-       Test{cmplx(inf, nan), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(0, 0), cmplx(inf, inf)},
-       Test{cmplx(inf, inf), cmplx(0, 1), cmplx(inf, -inf)},
-       Test{cmplx(inf, inf), cmplx(0, -1), cmplx(-inf, inf)},
-       Test{cmplx(inf, inf), cmplx(0, 2), cmplx(inf, -inf)},
-       Test{cmplx(inf, inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(1, 0), cmplx(inf, inf)},
-       Test{cmplx(inf, inf), cmplx(1, 1), cmplx(inf, nan)},
-       Test{cmplx(inf, inf), cmplx(1, -1), cmplx(nan, inf)},
-       Test{cmplx(inf, inf), cmplx(1, 2), cmplx(inf, nan)},
-       Test{cmplx(inf, inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(-1, 0), cmplx(-inf, -inf)},
-       Test{cmplx(inf, inf), cmplx(-1, 1), cmplx(nan, -inf)},
-       Test{cmplx(inf, inf), cmplx(-1, -1), cmplx(-inf, nan)},
-       Test{cmplx(inf, inf), cmplx(-1, 2), cmplx(nan, -inf)},
-       Test{cmplx(inf, inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(2, 0), cmplx(inf, inf)},
-       Test{cmplx(inf, inf), cmplx(2, 1), cmplx(inf, nan)},
-       Test{cmplx(inf, inf), cmplx(2, -1), cmplx(nan, inf)},
-       Test{cmplx(inf, inf), cmplx(2, 2), cmplx(inf, nan)},
-       Test{cmplx(inf, inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(0, 0), cmplx(inf, -inf)},
-       Test{cmplx(inf, -inf), cmplx(0, 1), cmplx(-inf, -inf)},
-       Test{cmplx(inf, -inf), cmplx(0, -1), cmplx(inf, inf)},
-       Test{cmplx(inf, -inf), cmplx(0, 2), cmplx(-inf, -inf)},
-       Test{cmplx(inf, -inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(1, 0), cmplx(inf, -inf)},
-       Test{cmplx(inf, -inf), cmplx(1, 1), cmplx(nan, -inf)},
-       Test{cmplx(inf, -inf), cmplx(1, -1), cmplx(inf, nan)},
-       Test{cmplx(inf, -inf), cmplx(1, 2), cmplx(nan, -inf)},
-       Test{cmplx(inf, -inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(-1, 0), cmplx(-inf, inf)},
-       Test{cmplx(inf, -inf), cmplx(-1, 1), cmplx(-inf, nan)},
-       Test{cmplx(inf, -inf), cmplx(-1, -1), cmplx(nan, inf)},
-       Test{cmplx(inf, -inf), cmplx(-1, 2), cmplx(-inf, nan)},
-       Test{cmplx(inf, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(2, 0), cmplx(inf, -inf)},
-       Test{cmplx(inf, -inf), cmplx(2, 1), cmplx(nan, -inf)},
-       Test{cmplx(inf, -inf), cmplx(2, -1), cmplx(inf, nan)},
-       Test{cmplx(inf, -inf), cmplx(2, 2), cmplx(nan, -inf)},
-       Test{cmplx(inf, -inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(inf, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(0, 0), cmplx(-inf, nan)},
-       Test{cmplx(-inf, 0), cmplx(0, 1), cmplx(nan, inf)},
-       Test{cmplx(-inf, 0), cmplx(0, -1), cmplx(nan, -inf)},
-       Test{cmplx(-inf, 0), cmplx(0, 2), cmplx(nan, inf)},
-       Test{cmplx(-inf, 0), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(1, 0), cmplx(-inf, nan)},
-       Test{cmplx(-inf, 0), cmplx(1, 1), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 0), cmplx(1, -1), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, 0), cmplx(1, 2), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 0), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(-1, 0), cmplx(inf, nan)},
-       Test{cmplx(-inf, 0), cmplx(-1, 1), cmplx(inf, inf)},
-       Test{cmplx(-inf, 0), cmplx(-1, -1), cmplx(inf, -inf)},
-       Test{cmplx(-inf, 0), cmplx(-1, 2), cmplx(inf, inf)},
-       Test{cmplx(-inf, 0), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(2, 0), cmplx(-inf, nan)},
-       Test{cmplx(-inf, 0), cmplx(2, 1), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 0), cmplx(2, -1), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, 0), cmplx(2, 2), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 0), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 0), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(0, 0), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 1), cmplx(0, 1), cmplx(nan, inf)},
-       Test{cmplx(-inf, 1), cmplx(0, -1), cmplx(nan, -inf)},
-       Test{cmplx(-inf, 1), cmplx(0, 2), cmplx(nan, inf)},
-       Test{cmplx(-inf, 1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(1, 0), cmplx(-inf, nan)},
-       Test{cmplx(-inf, 1), cmplx(1, 1), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 1), cmplx(1, -1), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, 1), cmplx(1, 2), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(-1, 0), cmplx(inf, nan)},
-       Test{cmplx(-inf, 1), cmplx(-1, 1), cmplx(inf, inf)},
-       Test{cmplx(-inf, 1), cmplx(-1, -1), cmplx(inf, -inf)},
-       Test{cmplx(-inf, 1), cmplx(-1, 2), cmplx(inf, inf)},
-       Test{cmplx(-inf, 1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(2, 0), cmplx(-inf, nan)},
-       Test{cmplx(-inf, 1), cmplx(2, 1), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 1), cmplx(2, -1), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, 1), cmplx(2, 2), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 1), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(0, 0), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, -1), cmplx(0, 1), cmplx(nan, inf)},
-       Test{cmplx(-inf, -1), cmplx(0, -1), cmplx(nan, -inf)},
-       Test{cmplx(-inf, -1), cmplx(0, 2), cmplx(nan, inf)},
-       Test{cmplx(-inf, -1), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(1, 0), cmplx(-inf, nan)},
-       Test{cmplx(-inf, -1), cmplx(1, 1), cmplx(-inf, inf)},
-       Test{cmplx(-inf, -1), cmplx(1, -1), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, -1), cmplx(1, 2), cmplx(-inf, inf)},
-       Test{cmplx(-inf, -1), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(-1, 0), cmplx(inf, nan)},
-       Test{cmplx(-inf, -1), cmplx(-1, 1), cmplx(inf, inf)},
-       Test{cmplx(-inf, -1), cmplx(-1, -1), cmplx(inf, -inf)},
-       Test{cmplx(-inf, -1), cmplx(-1, 2), cmplx(inf, inf)},
-       Test{cmplx(-inf, -1), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(2, 0), cmplx(-inf, nan)},
-       Test{cmplx(-inf, -1), cmplx(2, 1), cmplx(-inf, inf)},
-       Test{cmplx(-inf, -1), cmplx(2, -1), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, -1), cmplx(2, 2), cmplx(-inf, inf)},
-       Test{cmplx(-inf, -1), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -1), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(0, 0), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 2), cmplx(0, 1), cmplx(nan, inf)},
-       Test{cmplx(-inf, 2), cmplx(0, -1), cmplx(nan, -inf)},
-       Test{cmplx(-inf, 2), cmplx(0, 2), cmplx(nan, inf)},
-       Test{cmplx(-inf, 2), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(1, 0), cmplx(-inf, nan)},
-       Test{cmplx(-inf, 2), cmplx(1, 1), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 2), cmplx(1, -1), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, 2), cmplx(1, 2), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 2), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(-1, 0), cmplx(inf, nan)},
-       Test{cmplx(-inf, 2), cmplx(-1, 1), cmplx(inf, inf)},
-       Test{cmplx(-inf, 2), cmplx(-1, -1), cmplx(inf, -inf)},
-       Test{cmplx(-inf, 2), cmplx(-1, 2), cmplx(inf, inf)},
-       Test{cmplx(-inf, 2), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(2, 0), cmplx(-inf, nan)},
-       Test{cmplx(-inf, 2), cmplx(2, 1), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 2), cmplx(2, -1), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, 2), cmplx(2, 2), cmplx(-inf, inf)},
-       Test{cmplx(-inf, 2), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, 2), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(0, 0), cmplx(-inf, nan)},
-       Test{cmplx(-inf, nan), cmplx(0, 1), cmplx(nan, inf)},
-       Test{cmplx(-inf, nan), cmplx(0, -1), cmplx(nan, -inf)},
-       Test{cmplx(-inf, nan), cmplx(0, 2), cmplx(nan, inf)},
-       Test{cmplx(-inf, nan), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(1, 0), cmplx(-inf, nan)},
-       Test{cmplx(-inf, nan), cmplx(1, 1), cmplx(-inf, inf)},
-       Test{cmplx(-inf, nan), cmplx(1, -1), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, nan), cmplx(1, 2), cmplx(-inf, inf)},
-       Test{cmplx(-inf, nan), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(-1, 0), cmplx(inf, nan)},
-       Test{cmplx(-inf, nan), cmplx(-1, 1), cmplx(inf, inf)},
-       Test{cmplx(-inf, nan), cmplx(-1, -1), cmplx(inf, -inf)},
-       Test{cmplx(-inf, nan), cmplx(-1, 2), cmplx(inf, inf)},
-       Test{cmplx(-inf, nan), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(2, 0), cmplx(-inf, nan)},
-       Test{cmplx(-inf, nan), cmplx(2, 1), cmplx(-inf, inf)},
-       Test{cmplx(-inf, nan), cmplx(2, -1), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, nan), cmplx(2, 2), cmplx(-inf, inf)},
-       Test{cmplx(-inf, nan), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, nan), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(0, 0), cmplx(-inf, inf)},
-       Test{cmplx(-inf, inf), cmplx(0, 1), cmplx(inf, inf)},
-       Test{cmplx(-inf, inf), cmplx(0, -1), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, inf), cmplx(0, 2), cmplx(inf, inf)},
-       Test{cmplx(-inf, inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(1, 0), cmplx(-inf, inf)},
-       Test{cmplx(-inf, inf), cmplx(1, 1), cmplx(nan, inf)},
-       Test{cmplx(-inf, inf), cmplx(1, -1), cmplx(-inf, nan)},
-       Test{cmplx(-inf, inf), cmplx(1, 2), cmplx(nan, inf)},
-       Test{cmplx(-inf, inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(-1, 0), cmplx(inf, -inf)},
-       Test{cmplx(-inf, inf), cmplx(-1, 1), cmplx(inf, nan)},
-       Test{cmplx(-inf, inf), cmplx(-1, -1), cmplx(nan, -inf)},
-       Test{cmplx(-inf, inf), cmplx(-1, 2), cmplx(inf, nan)},
-       Test{cmplx(-inf, inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(2, 0), cmplx(-inf, inf)},
-       Test{cmplx(-inf, inf), cmplx(2, 1), cmplx(nan, inf)},
-       Test{cmplx(-inf, inf), cmplx(2, -1), cmplx(-inf, nan)},
-       Test{cmplx(-inf, inf), cmplx(2, 2), cmplx(nan, inf)},
-       Test{cmplx(-inf, inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, inf), cmplx(-inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(0, 0), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, -inf), cmplx(0, 1), cmplx(-inf, inf)},
-       Test{cmplx(-inf, -inf), cmplx(0, -1), cmplx(inf, -inf)},
-       Test{cmplx(-inf, -inf), cmplx(0, 2), cmplx(-inf, inf)},
-       Test{cmplx(-inf, -inf), cmplx(0, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(0, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(0, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(1, 0), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, -inf), cmplx(1, 1), cmplx(-inf, nan)},
-       Test{cmplx(-inf, -inf), cmplx(1, -1), cmplx(nan, -inf)},
-       Test{cmplx(-inf, -inf), cmplx(1, 2), cmplx(-inf, nan)},
-       Test{cmplx(-inf, -inf), cmplx(1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(-1, 0), cmplx(inf, inf)},
-       Test{cmplx(-inf, -inf), cmplx(-1, 1), cmplx(nan, inf)},
-       Test{cmplx(-inf, -inf), cmplx(-1, -1), cmplx(inf, nan)},
-       Test{cmplx(-inf, -inf), cmplx(-1, 2), cmplx(nan, inf)},
-       Test{cmplx(-inf, -inf), cmplx(-1, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(-1, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(-1, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(2, 0), cmplx(-inf, -inf)},
-       Test{cmplx(-inf, -inf), cmplx(2, 1), cmplx(-inf, nan)},
-       Test{cmplx(-inf, -inf), cmplx(2, -1), cmplx(nan, -inf)},
-       Test{cmplx(-inf, -inf), cmplx(2, 2), cmplx(-inf, nan)},
-       Test{cmplx(-inf, -inf), cmplx(2, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(2, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(2, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(nan, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(nan, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(nan, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(nan, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(nan, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(nan, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(nan, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(inf, -inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(-inf, 0), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(-inf, 1), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(-inf, -1), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(-inf, 2), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(-inf, nan), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(-inf, inf), cmplx(nan, nan)},
-       Test{cmplx(-inf, -inf), cmplx(-inf, -inf), cmplx(nan, nan)},
+       Test{complex(0, 0), complex(0, 0), complex(-nan, -nan)},
+       Test{complex(0, 0), complex(0, 1), complex(0, 0)},
+       Test{complex(0, 0), complex(0, -1), complex(negzero, 0)},
+       Test{complex(0, 0), complex(0, 2), complex(0, 0)},
+       Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 0), complex(1, 0), complex(0, 0)},
+       Test{complex(0, 0), complex(1, 1), complex(0, 0)},
+       Test{complex(0, 0), complex(1, -1), complex(0, 0)},
+       Test{complex(0, 0), complex(1, 2), complex(0, 0)},
+       Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 0), complex(-1, 0), complex(negzero, negzero)},
+       Test{complex(0, 0), complex(-1, 1), complex(negzero, negzero)},
+       Test{complex(0, 0), complex(-1, -1), complex(negzero, negzero)},
+       Test{complex(0, 0), complex(-1, 2), complex(0, negzero)},
+       Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 0), complex(2, 0), complex(0, 0)},
+       Test{complex(0, 0), complex(2, 1), complex(0, 0)},
+       Test{complex(0, 0), complex(2, -1), complex(0, 0)},
+       Test{complex(0, 0), complex(2, 2), complex(0, 0)},
+       Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 0), complex(nan, 0), complex(nan, nan)},
+       Test{complex(0, 0), complex(nan, 1), complex(nan, nan)},
+       Test{complex(0, 0), complex(nan, -1), complex(nan, nan)},
+       Test{complex(0, 0), complex(nan, 2), complex(nan, nan)},
+       Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 0), complex(inf, 0), complex(0, 0)},
+       Test{complex(0, 0), complex(inf, 1), complex(0, 0)},
+       Test{complex(0, 0), complex(inf, -1), complex(0, 0)},
+       Test{complex(0, 0), complex(inf, 2), complex(0, 0)},
+       Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 0), complex(-inf, 0), complex(negzero, negzero)},
+       Test{complex(0, 0), complex(-inf, 1), complex(negzero, negzero)},
+       Test{complex(0, 0), complex(-inf, -1), complex(negzero, negzero)},
+       Test{complex(0, 0), complex(-inf, 2), complex(negzero, negzero)},
+       Test{complex(0, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 1), complex(0, 0), complex(-nan, inf)},
+       Test{complex(0, 1), complex(0, 1), complex(1, 0)},
+       Test{complex(0, 1), complex(0, -1), complex(-1, 0)},
+       Test{complex(0, 1), complex(0, 2), complex(0.5, 0)},
+       Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 1), complex(1, 0), complex(0, 1)},
+       Test{complex(0, 1), complex(1, 1), complex(0.5, 0.5)},
+       Test{complex(0, 1), complex(1, -1), complex(-0.5, 0.5)},
+       Test{complex(0, 1), complex(1, 2), complex(0.4, 0.2)},
+       Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 1), complex(-1, 0), complex(negzero, -1)},
+       Test{complex(0, 1), complex(-1, 1), complex(0.5, -0.5)},
+       Test{complex(0, 1), complex(-1, -1), complex(-0.5, -0.5)},
+       Test{complex(0, 1), complex(-1, 2), complex(0.4, -0.2)},
+       Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 1), complex(2, 0), complex(0, 0.5)},
+       Test{complex(0, 1), complex(2, 1), complex(0.2, 0.4)},
+       Test{complex(0, 1), complex(2, -1), complex(-0.2, 0.4)},
+       Test{complex(0, 1), complex(2, 2), complex(0.25, 0.25)},
+       Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 1), complex(nan, 0), complex(nan, nan)},
+       Test{complex(0, 1), complex(nan, 1), complex(nan, nan)},
+       Test{complex(0, 1), complex(nan, -1), complex(nan, nan)},
+       Test{complex(0, 1), complex(nan, 2), complex(nan, nan)},
+       Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 1), complex(inf, 0), complex(0, 0)},
+       Test{complex(0, 1), complex(inf, 1), complex(0, 0)},
+       Test{complex(0, 1), complex(inf, -1), complex(0, 0)},
+       Test{complex(0, 1), complex(inf, 2), complex(0, 0)},
+       Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 1), complex(-inf, 0), complex(negzero, negzero)},
+       Test{complex(0, 1), complex(-inf, 1), complex(negzero, negzero)},
+       Test{complex(0, 1), complex(-inf, -1), complex(negzero, negzero)},
+       Test{complex(0, 1), complex(-inf, 2), complex(negzero, negzero)},
+       Test{complex(0, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, -1), complex(0, 0), complex(-nan, -inf)},
+       Test{complex(0, -1), complex(0, 1), complex(-1, negzero)},
+       Test{complex(0, -1), complex(0, -1), complex(1, negzero)},
+       Test{complex(0, -1), complex(0, 2), complex(-0.5, negzero)},
+       Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(0, -1), complex(1, 0), complex(0, -1)},
+       Test{complex(0, -1), complex(1, 1), complex(-0.5, -0.5)},
+       Test{complex(0, -1), complex(1, -1), complex(0.5, -0.5)},
+       Test{complex(0, -1), complex(1, 2), complex(-0.4, -0.2)},
+       Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(0, -1), complex(-1, 0), complex(negzero, 1)},
+       Test{complex(0, -1), complex(-1, 1), complex(-0.5, 0.5)},
+       Test{complex(0, -1), complex(-1, -1), complex(0.5, 0.5)},
+       Test{complex(0, -1), complex(-1, 2), complex(-0.4, 0.2)},
+       Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(0, -1), complex(2, 0), complex(0, -0.5)},
+       Test{complex(0, -1), complex(2, 1), complex(-0.2, -0.4)},
+       Test{complex(0, -1), complex(2, -1), complex(0.2, -0.4)},
+       Test{complex(0, -1), complex(2, 2), complex(-0.25, -0.25)},
+       Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(0, -1), complex(nan, 0), complex(nan, nan)},
+       Test{complex(0, -1), complex(nan, 1), complex(nan, nan)},
+       Test{complex(0, -1), complex(nan, -1), complex(nan, nan)},
+       Test{complex(0, -1), complex(nan, 2), complex(nan, nan)},
+       Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(0, -1), complex(inf, 0), complex(0, negzero)},
+       Test{complex(0, -1), complex(inf, 1), complex(0, negzero)},
+       Test{complex(0, -1), complex(inf, -1), complex(0, negzero)},
+       Test{complex(0, -1), complex(inf, 2), complex(0, negzero)},
+       Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(0, -1), complex(-inf, 0), complex(negzero, 0)},
+       Test{complex(0, -1), complex(-inf, 1), complex(negzero, 0)},
+       Test{complex(0, -1), complex(-inf, -1), complex(negzero, 0)},
+       Test{complex(0, -1), complex(-inf, 2), complex(negzero, 0)},
+       Test{complex(0, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(0, 2), complex(0, 0), complex(-nan, inf)},
+       Test{complex(0, 2), complex(0, 1), complex(2, 0)},
+       Test{complex(0, 2), complex(0, -1), complex(-2, 0)},
+       Test{complex(0, 2), complex(0, 2), complex(1, 0)},
+       Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 2), complex(1, 0), complex(0, 2)},
+       Test{complex(0, 2), complex(1, 1), complex(1, 1)},
+       Test{complex(0, 2), complex(1, -1), complex(-1, 1)},
+       Test{complex(0, 2), complex(1, 2), complex(0.8, 0.4)},
+       Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 2), complex(-1, 0), complex(negzero, -2)},
+       Test{complex(0, 2), complex(-1, 1), complex(1, -1)},
+       Test{complex(0, 2), complex(-1, -1), complex(-1, -1)},
+       Test{complex(0, 2), complex(-1, 2), complex(0.8, -0.4)},
+       Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 2), complex(2, 0), complex(0, 1)},
+       Test{complex(0, 2), complex(2, 1), complex(0.4, 0.8)},
+       Test{complex(0, 2), complex(2, -1), complex(-0.4, 0.8)},
+       Test{complex(0, 2), complex(2, 2), complex(0.5, 0.5)},
+       Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 2), complex(nan, 0), complex(nan, nan)},
+       Test{complex(0, 2), complex(nan, 1), complex(nan, nan)},
+       Test{complex(0, 2), complex(nan, -1), complex(nan, nan)},
+       Test{complex(0, 2), complex(nan, 2), complex(nan, nan)},
+       Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 2), complex(inf, 0), complex(0, 0)},
+       Test{complex(0, 2), complex(inf, 1), complex(0, 0)},
+       Test{complex(0, 2), complex(inf, -1), complex(0, 0)},
+       Test{complex(0, 2), complex(inf, 2), complex(0, 0)},
+       Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(0, 2), complex(-inf, 0), complex(negzero, negzero)},
+       Test{complex(0, 2), complex(-inf, 1), complex(negzero, negzero)},
+       Test{complex(0, 2), complex(-inf, -1), complex(negzero, negzero)},
+       Test{complex(0, 2), complex(-inf, 2), complex(negzero, negzero)},
+       Test{complex(0, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(nan, nan), complex(0, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(0, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(0, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(0, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)},
+       Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)},
+       Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)},
+       Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)},
+       Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)},
+       Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)},
+       Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)},
+       Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)},
+       Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)},
+       Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)},
+       Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)},
+       Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)},
+       Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)},
+       Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)},
+       Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)},
+       Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)},
+       Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)},
+       Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)},
+       Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)},
+       Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)},
+       Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)},
+       Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)},
+       Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(1, 0), complex(0, 0), complex(inf, -nan)},
+       Test{complex(1, 0), complex(0, 1), complex(0, -1)},
+       Test{complex(1, 0), complex(0, -1), complex(negzero, 1)},
+       Test{complex(1, 0), complex(0, 2), complex(0, -0.5)},
+       Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 0), complex(1, 0), complex(1, 0)},
+       Test{complex(1, 0), complex(1, 1), complex(0.5, -0.5)},
+       Test{complex(1, 0), complex(1, -1), complex(0.5, 0.5)},
+       Test{complex(1, 0), complex(1, 2), complex(0.2, -0.4)},
+       Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 0), complex(-1, 0), complex(-1, negzero)},
+       Test{complex(1, 0), complex(-1, 1), complex(-0.5, -0.5)},
+       Test{complex(1, 0), complex(-1, -1), complex(-0.5, 0.5)},
+       Test{complex(1, 0), complex(-1, 2), complex(-0.2, -0.4)},
+       Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 0), complex(2, 0), complex(0.5, 0)},
+       Test{complex(1, 0), complex(2, 1), complex(0.4, -0.2)},
+       Test{complex(1, 0), complex(2, -1), complex(0.4, 0.2)},
+       Test{complex(1, 0), complex(2, 2), complex(0.25, -0.25)},
+       Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 0), complex(nan, 0), complex(nan, nan)},
+       Test{complex(1, 0), complex(nan, 1), complex(nan, nan)},
+       Test{complex(1, 0), complex(nan, -1), complex(nan, nan)},
+       Test{complex(1, 0), complex(nan, 2), complex(nan, nan)},
+       Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 0), complex(inf, 0), complex(0, 0)},
+       Test{complex(1, 0), complex(inf, 1), complex(0, 0)},
+       Test{complex(1, 0), complex(inf, -1), complex(0, 0)},
+       Test{complex(1, 0), complex(inf, 2), complex(0, 0)},
+       Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 0), complex(-inf, 0), complex(negzero, negzero)},
+       Test{complex(1, 0), complex(-inf, 1), complex(negzero, negzero)},
+       Test{complex(1, 0), complex(-inf, -1), complex(negzero, negzero)},
+       Test{complex(1, 0), complex(-inf, 2), complex(negzero, negzero)},
+       Test{complex(1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 1), complex(0, 0), complex(inf, inf)},
+       Test{complex(1, 1), complex(0, 1), complex(1, -1)},
+       Test{complex(1, 1), complex(0, -1), complex(-1, 1)},
+       Test{complex(1, 1), complex(0, 2), complex(0.5, -0.5)},
+       Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 1), complex(1, 0), complex(1, 1)},
+       Test{complex(1, 1), complex(1, 1), complex(1, 0)},
+       Test{complex(1, 1), complex(1, -1), complex(0, 1)},
+       Test{complex(1, 1), complex(1, 2), complex(0.6, -0.2)},
+       Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 1), complex(-1, 0), complex(-1, -1)},
+       Test{complex(1, 1), complex(-1, 1), complex(negzero, -1)},
+       Test{complex(1, 1), complex(-1, -1), complex(-1, negzero)},
+       Test{complex(1, 1), complex(-1, 2), complex(0.2, -0.6)},
+       Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 1), complex(2, 0), complex(0.5, 0.5)},
+       Test{complex(1, 1), complex(2, 1), complex(0.6, 0.2)},
+       Test{complex(1, 1), complex(2, -1), complex(0.2, 0.6)},
+       Test{complex(1, 1), complex(2, 2), complex(0.5, 0)},
+       Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 1), complex(nan, 0), complex(nan, nan)},
+       Test{complex(1, 1), complex(nan, 1), complex(nan, nan)},
+       Test{complex(1, 1), complex(nan, -1), complex(nan, nan)},
+       Test{complex(1, 1), complex(nan, 2), complex(nan, nan)},
+       Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 1), complex(inf, 0), complex(0, 0)},
+       Test{complex(1, 1), complex(inf, 1), complex(0, 0)},
+       Test{complex(1, 1), complex(inf, -1), complex(0, 0)},
+       Test{complex(1, 1), complex(inf, 2), complex(0, 0)},
+       Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 1), complex(-inf, 0), complex(negzero, negzero)},
+       Test{complex(1, 1), complex(-inf, 1), complex(negzero, negzero)},
+       Test{complex(1, 1), complex(-inf, -1), complex(negzero, negzero)},
+       Test{complex(1, 1), complex(-inf, 2), complex(negzero, negzero)},
+       Test{complex(1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, -1), complex(0, 0), complex(inf, -inf)},
+       Test{complex(1, -1), complex(0, 1), complex(-1, -1)},
+       Test{complex(1, -1), complex(0, -1), complex(1, 1)},
+       Test{complex(1, -1), complex(0, 2), complex(-0.5, -0.5)},
+       Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(1, -1), complex(1, 0), complex(1, -1)},
+       Test{complex(1, -1), complex(1, 1), complex(0, -1)},
+       Test{complex(1, -1), complex(1, -1), complex(1, 0)},
+       Test{complex(1, -1), complex(1, 2), complex(-0.2, -0.6)},
+       Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(1, -1), complex(-1, 0), complex(-1, 1)},
+       Test{complex(1, -1), complex(-1, 1), complex(-1, negzero)},
+       Test{complex(1, -1), complex(-1, -1), complex(negzero, 1)},
+       Test{complex(1, -1), complex(-1, 2), complex(-0.6, -0.2)},
+       Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(1, -1), complex(2, 0), complex(0.5, -0.5)},
+       Test{complex(1, -1), complex(2, 1), complex(0.2, -0.6)},
+       Test{complex(1, -1), complex(2, -1), complex(0.6, -0.2)},
+       Test{complex(1, -1), complex(2, 2), complex(0, -0.5)},
+       Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(1, -1), complex(nan, 0), complex(nan, nan)},
+       Test{complex(1, -1), complex(nan, 1), complex(nan, nan)},
+       Test{complex(1, -1), complex(nan, -1), complex(nan, nan)},
+       Test{complex(1, -1), complex(nan, 2), complex(nan, nan)},
+       Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(1, -1), complex(inf, 0), complex(0, negzero)},
+       Test{complex(1, -1), complex(inf, 1), complex(0, negzero)},
+       Test{complex(1, -1), complex(inf, -1), complex(0, negzero)},
+       Test{complex(1, -1), complex(inf, 2), complex(0, negzero)},
+       Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(1, -1), complex(-inf, 0), complex(negzero, 0)},
+       Test{complex(1, -1), complex(-inf, 1), complex(negzero, 0)},
+       Test{complex(1, -1), complex(-inf, -1), complex(negzero, 0)},
+       Test{complex(1, -1), complex(-inf, 2), complex(negzero, 0)},
+       Test{complex(1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(1, 2), complex(0, 0), complex(inf, inf)},
+       Test{complex(1, 2), complex(0, 1), complex(2, -1)},
+       Test{complex(1, 2), complex(0, -1), complex(-2, 1)},
+       Test{complex(1, 2), complex(0, 2), complex(1, -0.5)},
+       Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 2), complex(1, 0), complex(1, 2)},
+       Test{complex(1, 2), complex(1, 1), complex(1.5, 0.5)},
+       Test{complex(1, 2), complex(1, -1), complex(-0.5, 1.5)},
+       Test{complex(1, 2), complex(1, 2), complex(1, 0)},
+       Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 2), complex(-1, 0), complex(-1, -2)},
+       Test{complex(1, 2), complex(-1, 1), complex(0.5, -1.5)},
+       Test{complex(1, 2), complex(-1, -1), complex(-1.5, -0.5)},
+       Test{complex(1, 2), complex(-1, 2), complex(0.6, -0.8)},
+       Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 2), complex(2, 0), complex(0.5, 1)},
+       Test{complex(1, 2), complex(2, 1), complex(0.8, 0.6)},
+       Test{complex(1, 2), complex(2, -1), complex(0, 1)},
+       Test{complex(1, 2), complex(2, 2), complex(0.75, 0.25)},
+       Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 2), complex(nan, 0), complex(nan, nan)},
+       Test{complex(1, 2), complex(nan, 1), complex(nan, nan)},
+       Test{complex(1, 2), complex(nan, -1), complex(nan, nan)},
+       Test{complex(1, 2), complex(nan, 2), complex(nan, nan)},
+       Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 2), complex(inf, 0), complex(0, 0)},
+       Test{complex(1, 2), complex(inf, 1), complex(0, 0)},
+       Test{complex(1, 2), complex(inf, -1), complex(0, 0)},
+       Test{complex(1, 2), complex(inf, 2), complex(0, 0)},
+       Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(1, 2), complex(-inf, 0), complex(negzero, negzero)},
+       Test{complex(1, 2), complex(-inf, 1), complex(negzero, negzero)},
+       Test{complex(1, 2), complex(-inf, -1), complex(negzero, negzero)},
+       Test{complex(1, 2), complex(-inf, 2), complex(negzero, negzero)},
+       Test{complex(1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(nan, nan), complex(0, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(0, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(0, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(0, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)},
+       Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)},
+       Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)},
+       Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)},
+       Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)},
+       Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)},
+       Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)},
+       Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)},
+       Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)},
+       Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)},
+       Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)},
+       Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)},
+       Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)},
+       Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)},
+       Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)},
+       Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)},
+       Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)},
+       Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)},
+       Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)},
+       Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)},
+       Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)},
+       Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)},
+       Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-1, 0), complex(0, 0), complex(-inf, -nan)},
+       Test{complex(-1, 0), complex(0, 1), complex(0, 1)},
+       Test{complex(-1, 0), complex(0, -1), complex(negzero, -1)},
+       Test{complex(-1, 0), complex(0, 2), complex(0, 0.5)},
+       Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, 0), complex(1, 0), complex(-1, 0)},
+       Test{complex(-1, 0), complex(1, 1), complex(-0.5, 0.5)},
+       Test{complex(-1, 0), complex(1, -1), complex(-0.5, -0.5)},
+       Test{complex(-1, 0), complex(1, 2), complex(-0.2, 0.4)},
+       Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, 0), complex(-1, 0), complex(1, negzero)},
+       Test{complex(-1, 0), complex(-1, 1), complex(0.5, 0.5)},
+       Test{complex(-1, 0), complex(-1, -1), complex(0.5, -0.5)},
+       Test{complex(-1, 0), complex(-1, 2), complex(0.2, 0.4)},
+       Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, 0), complex(2, 0), complex(-0.5, 0)},
+       Test{complex(-1, 0), complex(2, 1), complex(-0.4, 0.2)},
+       Test{complex(-1, 0), complex(2, -1), complex(-0.4, -0.2)},
+       Test{complex(-1, 0), complex(2, 2), complex(-0.25, 0.25)},
+       Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, 0), complex(nan, 0), complex(nan, nan)},
+       Test{complex(-1, 0), complex(nan, 1), complex(nan, nan)},
+       Test{complex(-1, 0), complex(nan, -1), complex(nan, nan)},
+       Test{complex(-1, 0), complex(nan, 2), complex(nan, nan)},
+       Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, 0), complex(inf, 0), complex(negzero, 0)},
+       Test{complex(-1, 0), complex(inf, 1), complex(negzero, 0)},
+       Test{complex(-1, 0), complex(inf, -1), complex(negzero, 0)},
+       Test{complex(-1, 0), complex(inf, 2), complex(negzero, 0)},
+       Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, 0), complex(-inf, 0), complex(0, negzero)},
+       Test{complex(-1, 0), complex(-inf, 1), complex(0, negzero)},
+       Test{complex(-1, 0), complex(-inf, -1), complex(0, negzero)},
+       Test{complex(-1, 0), complex(-inf, 2), complex(0, negzero)},
+       Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, 1), complex(0, 0), complex(-inf, inf)},
+       Test{complex(-1, 1), complex(0, 1), complex(1, 1)},
+       Test{complex(-1, 1), complex(0, -1), complex(-1, -1)},
+       Test{complex(-1, 1), complex(0, 2), complex(0.5, 0.5)},
+       Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, 1), complex(1, 0), complex(-1, 1)},
+       Test{complex(-1, 1), complex(1, 1), complex(0, 1)},
+       Test{complex(-1, 1), complex(1, -1), complex(-1, 0)},
+       Test{complex(-1, 1), complex(1, 2), complex(0.2, 0.6)},
+       Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, 1), complex(-1, 0), complex(1, -1)},
+       Test{complex(-1, 1), complex(-1, 1), complex(1, negzero)},
+       Test{complex(-1, 1), complex(-1, -1), complex(negzero, -1)},
+       Test{complex(-1, 1), complex(-1, 2), complex(0.6, 0.2)},
+       Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, 1), complex(2, 0), complex(-0.5, 0.5)},
+       Test{complex(-1, 1), complex(2, 1), complex(-0.2, 0.6)},
+       Test{complex(-1, 1), complex(2, -1), complex(-0.6, 0.2)},
+       Test{complex(-1, 1), complex(2, 2), complex(0, 0.5)},
+       Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, 1), complex(nan, 0), complex(nan, nan)},
+       Test{complex(-1, 1), complex(nan, 1), complex(nan, nan)},
+       Test{complex(-1, 1), complex(nan, -1), complex(nan, nan)},
+       Test{complex(-1, 1), complex(nan, 2), complex(nan, nan)},
+       Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, 1), complex(inf, 0), complex(negzero, 0)},
+       Test{complex(-1, 1), complex(inf, 1), complex(negzero, 0)},
+       Test{complex(-1, 1), complex(inf, -1), complex(negzero, 0)},
+       Test{complex(-1, 1), complex(inf, 2), complex(negzero, 0)},
+       Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, 1), complex(-inf, 0), complex(0, negzero)},
+       Test{complex(-1, 1), complex(-inf, 1), complex(0, negzero)},
+       Test{complex(-1, 1), complex(-inf, -1), complex(0, negzero)},
+       Test{complex(-1, 1), complex(-inf, 2), complex(0, negzero)},
+       Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, -1), complex(0, 0), complex(-inf, -inf)},
+       Test{complex(-1, -1), complex(0, 1), complex(-1, 1)},
+       Test{complex(-1, -1), complex(0, -1), complex(1, -1)},
+       Test{complex(-1, -1), complex(0, 2), complex(-0.5, 0.5)},
+       Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, -1), complex(1, 0), complex(-1, -1)},
+       Test{complex(-1, -1), complex(1, 1), complex(-1, 0)},
+       Test{complex(-1, -1), complex(1, -1), complex(0, -1)},
+       Test{complex(-1, -1), complex(1, 2), complex(-0.6, 0.2)},
+       Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, -1), complex(-1, 0), complex(1, 1)},
+       Test{complex(-1, -1), complex(-1, 1), complex(negzero, 1)},
+       Test{complex(-1, -1), complex(-1, -1), complex(1, negzero)},
+       Test{complex(-1, -1), complex(-1, 2), complex(-0.2, 0.6)},
+       Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, -1), complex(2, 0), complex(-0.5, -0.5)},
+       Test{complex(-1, -1), complex(2, 1), complex(-0.6, -0.2)},
+       Test{complex(-1, -1), complex(2, -1), complex(-0.2, -0.6)},
+       Test{complex(-1, -1), complex(2, 2), complex(-0.5, 0)},
+       Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, -1), complex(nan, 0), complex(nan, nan)},
+       Test{complex(-1, -1), complex(nan, 1), complex(nan, nan)},
+       Test{complex(-1, -1), complex(nan, -1), complex(nan, nan)},
+       Test{complex(-1, -1), complex(nan, 2), complex(nan, nan)},
+       Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, -1), complex(inf, 0), complex(negzero, negzero)},
+       Test{complex(-1, -1), complex(inf, 1), complex(negzero, negzero)},
+       Test{complex(-1, -1), complex(inf, -1), complex(negzero, negzero)},
+       Test{complex(-1, -1), complex(inf, 2), complex(negzero, negzero)},
+       Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, -1), complex(-inf, 0), complex(0, 0)},
+       Test{complex(-1, -1), complex(-inf, 1), complex(0, 0)},
+       Test{complex(-1, -1), complex(-inf, -1), complex(0, 0)},
+       Test{complex(-1, -1), complex(-inf, 2), complex(0, 0)},
+       Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)},
+       Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)},
+       Test{complex(-1, 2), complex(0, 0), complex(-inf, inf)},
+       Test{complex(-1, 2), complex(0, 1), complex(2, 1)},
+       Test{complex(-1, 2), complex(0, -1), complex(-2, -1)},
+       Test{complex(-1, 2), complex(0, 2), complex(1, 0.5)},
+       Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, 2), complex(1, 0), complex(-1, 2)},
+       Test{complex(-1, 2), complex(1, 1), complex(0.5, 1.5)},
+       Test{complex(-1, 2), complex(1, -1), complex(-1.5, 0.5)},
+       Test{complex(-1, 2), complex(1, 2), complex(0.6, 0.8)},
+       Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, 2), complex(-1, 0), complex(1, -2)},
+       Test{complex(-1, 2), complex(-1, 1), complex(1.5, -0.5)},
+       Test{complex(-1, 2), complex(-1, -1), complex(-0.5, -1.5)},
+       Test{complex(-1, 2), complex(-1, 2), complex(1, 0)},
+       Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, 2), complex(2, 0), complex(-0.5, 1)},
+       Test{complex(-1, 2), complex(2, 1), complex(0, 1)},
+       Test{complex(-1, 2), complex(2, -1), complex(-0.8, 0.6)},
+       Test{complex(-1, 2), complex(2, 2), complex(0.25, 0.75)},
+       Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, 2), complex(nan, 0), complex(nan, nan)},
+       Test{complex(-1, 2), complex(nan, 1), complex(nan, nan)},
+       Test{complex(-1, 2), complex(nan, -1), complex(nan, nan)},
+       Test{complex(-1, 2), complex(nan, 2), complex(nan, nan)},
+       Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, 2), complex(inf, 0), complex(negzero, 0)},
+       Test{complex(-1, 2), complex(inf, 1), complex(negzero, 0)},
+       Test{complex(-1, 2), complex(inf, -1), complex(negzero, 0)},
+       Test{complex(-1, 2), complex(inf, 2), complex(negzero, 0)},
+       Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(-1, 2), complex(-inf, 0), complex(0, negzero)},
+       Test{complex(-1, 2), complex(-inf, 1), complex(0, negzero)},
+       Test{complex(-1, 2), complex(-inf, -1), complex(0, negzero)},
+       Test{complex(-1, 2), complex(-inf, 2), complex(0, negzero)},
+       Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)},
+       Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)},
+       Test{complex(nan, nan), complex(0, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(0, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(0, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(0, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)},
+       Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)},
+       Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)},
+       Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)},
+       Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)},
+       Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)},
+       Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)},
+       Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)},
+       Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)},
+       Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)},
+       Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)},
+       Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)},
+       Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)},
+       Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)},
+       Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)},
+       Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)},
+       Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)},
+       Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)},
+       Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)},
+       Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)},
+       Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)},
+       Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)},
+       Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(2, 0), complex(0, 0), complex(inf, -nan)},
+       Test{complex(2, 0), complex(0, 1), complex(0, -2)},
+       Test{complex(2, 0), complex(0, -1), complex(negzero, 2)},
+       Test{complex(2, 0), complex(0, 2), complex(0, -1)},
+       Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 0), complex(1, 0), complex(2, 0)},
+       Test{complex(2, 0), complex(1, 1), complex(1, -1)},
+       Test{complex(2, 0), complex(1, -1), complex(1, 1)},
+       Test{complex(2, 0), complex(1, 2), complex(0.4, -0.8)},
+       Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 0), complex(-1, 0), complex(-2, negzero)},
+       Test{complex(2, 0), complex(-1, 1), complex(-1, -1)},
+       Test{complex(2, 0), complex(-1, -1), complex(-1, 1)},
+       Test{complex(2, 0), complex(-1, 2), complex(-0.4, -0.8)},
+       Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 0), complex(2, 0), complex(1, 0)},
+       Test{complex(2, 0), complex(2, 1), complex(0.8, -0.4)},
+       Test{complex(2, 0), complex(2, -1), complex(0.8, 0.4)},
+       Test{complex(2, 0), complex(2, 2), complex(0.5, -0.5)},
+       Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 0), complex(nan, 0), complex(nan, nan)},
+       Test{complex(2, 0), complex(nan, 1), complex(nan, nan)},
+       Test{complex(2, 0), complex(nan, -1), complex(nan, nan)},
+       Test{complex(2, 0), complex(nan, 2), complex(nan, nan)},
+       Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 0), complex(inf, 0), complex(0, 0)},
+       Test{complex(2, 0), complex(inf, 1), complex(0, 0)},
+       Test{complex(2, 0), complex(inf, -1), complex(0, 0)},
+       Test{complex(2, 0), complex(inf, 2), complex(0, 0)},
+       Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 0), complex(-inf, 0), complex(negzero, negzero)},
+       Test{complex(2, 0), complex(-inf, 1), complex(negzero, negzero)},
+       Test{complex(2, 0), complex(-inf, -1), complex(negzero, negzero)},
+       Test{complex(2, 0), complex(-inf, 2), complex(negzero, negzero)},
+       Test{complex(2, 0), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 1), complex(0, 0), complex(inf, inf)},
+       Test{complex(2, 1), complex(0, 1), complex(1, -2)},
+       Test{complex(2, 1), complex(0, -1), complex(-1, 2)},
+       Test{complex(2, 1), complex(0, 2), complex(0.5, -1)},
+       Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 1), complex(1, 0), complex(2, 1)},
+       Test{complex(2, 1), complex(1, 1), complex(1.5, -0.5)},
+       Test{complex(2, 1), complex(1, -1), complex(0.5, 1.5)},
+       Test{complex(2, 1), complex(1, 2), complex(0.8, -0.6)},
+       Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 1), complex(-1, 0), complex(-2, -1)},
+       Test{complex(2, 1), complex(-1, 1), complex(-0.5, -1.5)},
+       Test{complex(2, 1), complex(-1, -1), complex(-1.5, 0.5)},
+       Test{complex(2, 1), complex(-1, 2), complex(0, -1)},
+       Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 1), complex(2, 0), complex(1, 0.5)},
+       Test{complex(2, 1), complex(2, 1), complex(1, 0)},
+       Test{complex(2, 1), complex(2, -1), complex(0.6, 0.8)},
+       Test{complex(2, 1), complex(2, 2), complex(0.75, -0.25)},
+       Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 1), complex(nan, 0), complex(nan, nan)},
+       Test{complex(2, 1), complex(nan, 1), complex(nan, nan)},
+       Test{complex(2, 1), complex(nan, -1), complex(nan, nan)},
+       Test{complex(2, 1), complex(nan, 2), complex(nan, nan)},
+       Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 1), complex(inf, 0), complex(0, 0)},
+       Test{complex(2, 1), complex(inf, 1), complex(0, 0)},
+       Test{complex(2, 1), complex(inf, -1), complex(0, 0)},
+       Test{complex(2, 1), complex(inf, 2), complex(0, 0)},
+       Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 1), complex(-inf, 0), complex(negzero, negzero)},
+       Test{complex(2, 1), complex(-inf, 1), complex(negzero, negzero)},
+       Test{complex(2, 1), complex(-inf, -1), complex(negzero, negzero)},
+       Test{complex(2, 1), complex(-inf, 2), complex(negzero, negzero)},
+       Test{complex(2, 1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, -1), complex(0, 0), complex(inf, -inf)},
+       Test{complex(2, -1), complex(0, 1), complex(-1, -2)},
+       Test{complex(2, -1), complex(0, -1), complex(1, 2)},
+       Test{complex(2, -1), complex(0, 2), complex(-0.5, -1)},
+       Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(2, -1), complex(1, 0), complex(2, -1)},
+       Test{complex(2, -1), complex(1, 1), complex(0.5, -1.5)},
+       Test{complex(2, -1), complex(1, -1), complex(1.5, 0.5)},
+       Test{complex(2, -1), complex(1, 2), complex(0, -1)},
+       Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(2, -1), complex(-1, 0), complex(-2, 1)},
+       Test{complex(2, -1), complex(-1, 1), complex(-1.5, -0.5)},
+       Test{complex(2, -1), complex(-1, -1), complex(-0.5, 1.5)},
+       Test{complex(2, -1), complex(-1, 2), complex(-0.8, -0.6)},
+       Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(2, -1), complex(2, 0), complex(1, -0.5)},
+       Test{complex(2, -1), complex(2, 1), complex(0.6, -0.8)},
+       Test{complex(2, -1), complex(2, -1), complex(1, 0)},
+       Test{complex(2, -1), complex(2, 2), complex(0.25, -0.75)},
+       Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(2, -1), complex(nan, 0), complex(nan, nan)},
+       Test{complex(2, -1), complex(nan, 1), complex(nan, nan)},
+       Test{complex(2, -1), complex(nan, -1), complex(nan, nan)},
+       Test{complex(2, -1), complex(nan, 2), complex(nan, nan)},
+       Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(2, -1), complex(inf, 0), complex(0, negzero)},
+       Test{complex(2, -1), complex(inf, 1), complex(0, negzero)},
+       Test{complex(2, -1), complex(inf, -1), complex(0, negzero)},
+       Test{complex(2, -1), complex(inf, 2), complex(0, negzero)},
+       Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(2, -1), complex(-inf, 0), complex(negzero, 0)},
+       Test{complex(2, -1), complex(-inf, 1), complex(negzero, 0)},
+       Test{complex(2, -1), complex(-inf, -1), complex(negzero, 0)},
+       Test{complex(2, -1), complex(-inf, 2), complex(negzero, 0)},
+       Test{complex(2, -1), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)},
+       Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)},
+       Test{complex(2, 2), complex(0, 0), complex(inf, inf)},
+       Test{complex(2, 2), complex(0, 1), complex(2, -2)},
+       Test{complex(2, 2), complex(0, -1), complex(-2, 2)},
+       Test{complex(2, 2), complex(0, 2), complex(1, -1)},
+       Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 2), complex(1, 0), complex(2, 2)},
+       Test{complex(2, 2), complex(1, 1), complex(2, 0)},
+       Test{complex(2, 2), complex(1, -1), complex(0, 2)},
+       Test{complex(2, 2), complex(1, 2), complex(1.2, -0.4)},
+       Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 2), complex(-1, 0), complex(-2, -2)},
+       Test{complex(2, 2), complex(-1, 1), complex(negzero, -2)},
+       Test{complex(2, 2), complex(-1, -1), complex(-2, negzero)},
+       Test{complex(2, 2), complex(-1, 2), complex(0.4, -1.2)},
+       Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 2), complex(2, 0), complex(1, 1)},
+       Test{complex(2, 2), complex(2, 1), complex(1.2, 0.4)},
+       Test{complex(2, 2), complex(2, -1), complex(0.4, 1.2)},
+       Test{complex(2, 2), complex(2, 2), complex(1, 0)},
+       Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 2), complex(nan, 0), complex(nan, nan)},
+       Test{complex(2, 2), complex(nan, 1), complex(nan, nan)},
+       Test{complex(2, 2), complex(nan, -1), complex(nan, nan)},
+       Test{complex(2, 2), complex(nan, 2), complex(nan, nan)},
+       Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 2), complex(inf, 0), complex(0, 0)},
+       Test{complex(2, 2), complex(inf, 1), complex(0, 0)},
+       Test{complex(2, 2), complex(inf, -1), complex(0, 0)},
+       Test{complex(2, 2), complex(inf, 2), complex(0, 0)},
+       Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(2, 2), complex(-inf, 0), complex(negzero, negzero)},
+       Test{complex(2, 2), complex(-inf, 1), complex(negzero, negzero)},
+       Test{complex(2, 2), complex(-inf, -1), complex(negzero, negzero)},
+       Test{complex(2, 2), complex(-inf, 2), complex(negzero, negzero)},
+       Test{complex(2, 2), complex(nan, nan), complex(nan, nan)},
+       Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)},
+       Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)},
+       Test{complex(nan, nan), complex(0, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(0, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(0, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(0, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(1, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(2, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)},
+       Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)},
+       Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)},
+       Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)},
+       Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)},
+       Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)},
+       Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)},
+       Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)},
+       Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)},
+       Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)},
+       Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)},
+       Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)},
+       Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)},
+       Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)},
+       Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)},
+       Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)},
+       Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)},
+&nb