LCOV - code coverage report
Current view: top level - gdk - gdk_calc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2485 7298 34.1 %
Date: 2021-09-14 19:48:19 Functions: 243 978 24.8 %

          Line data    Source code
       1             : /*
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       5             :  *
       6             :  * Copyright 1997 - July 2008 CWI, August 2008 - 2021 MonetDB B.V.
       7             :  */
       8             : 
       9             : #include "monetdb_config.h"
      10             : #include "gdk.h"
      11             : #include "gdk_private.h"
      12             : #include "gdk_calc_private.h"
      13             : 
      14             : /* Generally, the functions return a new BAT aligned with the input
      15             :  * BAT(s).  If there are multiple input BATs, they must be aligned.
      16             :  * If there is a candidate list, the calculations are only done for
      17             :  * the candidates, all other values are NIL (so that the output is
      18             :  * still aligned). */
      19             : 
      20             : /* format strings for the seven/eight basic types we deal with */
      21             : #define FMTbte  "%d"
      22             : #define FMTsht  "%d"
      23             : #define FMTint  "%d"
      24             : #define FMTlng  LLFMT
      25             : #ifdef HAVE_HGE
      26             : #define FMThge  "%.40g"
      27             : #endif
      28             : #define FMTflt  "%.9g"
      29             : #define FMTdbl  "%.17g"
      30             : #define FMToid  OIDFMT
      31             : 
      32             : /* casts; only required for type hge, since there is no genuine format
      33             :  * string for it (i.e., for __int128) (yet?) */
      34             : #define CSTbte
      35             : #define CSTsht
      36             : #define CSTint
      37             : #define CSTlng
      38             : #ifdef HAVE_HGE
      39             : #define CSThge  (dbl)
      40             : #endif
      41             : #define CSTflt
      42             : #define CSTdbl
      43             : #define CSToid
      44             : 
      45             : /* Most of the internal routines return a count of the number of NIL
      46             :  * values they produced.  They indicate an error by returning a value
      47             :  * >= BUN_NONE.  BUN_NONE means that the error was dealt with by
      48             :  * calling GDKerror (generally for overflow or conversion errors).
      49             :  * BUN_NONE+1 is returned by the DIV and MOD functions to indicate
      50             :  * division by zero.  */
      51             : 
      52             : /* replace BATconstant with a version that produces a void bat for
      53             :  * TYPE_oid/nil */
      54             : #define BATconstantV(HSEQ, TAILTYPE, VALUE, CNT, ROLE)                  \
      55             :         ((TAILTYPE) == TYPE_oid && ((CNT) == 0 || *(oid*)(VALUE) == oid_nil) \
      56             :          ? BATconstant(HSEQ, TYPE_void, VALUE, CNT, ROLE)               \
      57             :          : BATconstant(HSEQ, TAILTYPE, VALUE, CNT, ROLE))
      58             : 
      59             : static gdk_return
      60        2308 : checkbats(BAT *b1, BAT *b2, const char *func)
      61             : {
      62        2308 :         if (b1->batCount != b2->batCount) {
      63           0 :                 GDKerror("%s: inputs not the same size.\n", func);
      64           0 :                 return GDK_FAIL;
      65             :         }
      66             :         return GDK_SUCCEED;
      67             : }
      68             : 
      69             : #define ON_OVERFLOW1(TYPE, OP)                                  \
      70             :         do {                                                    \
      71             :                 GDKerror("22003!overflow in calculation "     \
      72             :                          OP "(" FMT##TYPE ").\n",           \
      73             :                          CST##TYPE src[x]);                     \
      74             :                 BBPreclaim(bn);                                 \
      75             :                 bat_iterator_end(&bi);                              \
      76             :                 return NULL;                                    \
      77             :         } while (0)
      78             : 
      79             : #define ON_OVERFLOW(TYPE1, TYPE2, OP)                                   \
      80             :         do {                                                            \
      81             :                 GDKerror("22003!overflow in calculation "             \
      82             :                          FMT##TYPE1 OP FMT##TYPE2 ".\n",              \
      83             :                          CST##TYPE1 ((TYPE1 *)lft)[i], CST##TYPE2 ((TYPE2 *)rgt)[j]); \
      84             :                 return BUN_NONE;                                        \
      85             :         } while (0)
      86             : 
      87             : #define UNARY_2TYPE_FUNC(TYPE1, TYPE2, FUNC)                            \
      88             :         do {                                                            \
      89             :                 const TYPE1 *restrict src = (const TYPE1 *) bi.base;    \
      90             :                 TYPE2 *restrict dst = (TYPE2 *) Tloc(bn, 0);            \
      91             :                 for (i = 0; i < ncand; i++) {                                \
      92             :                         x = canditer_next(&ci) - bhseqbase;         \
      93             :                         if (is_##TYPE1##_nil(src[x])) {                 \
      94             :                                 nils++;                                 \
      95             :                                 dst[i] = TYPE2##_nil;                   \
      96             :                         } else {                                        \
      97             :                                 dst[i] = FUNC(src[x]);                  \
      98             :                         }                                               \
      99             :                 }                                                       \
     100             :         } while (0)
     101             : 
     102             : #define UNARY_2TYPE_FUNC_nilcheck(TYPE1, TYPE2, FUNC, on_overflow)      \
     103             :         do {                                                            \
     104             :                 const TYPE1 *restrict src = (const TYPE1 *) bi.base;    \
     105             :                 TYPE2 *restrict dst = (TYPE2 *) Tloc(bn, 0);            \
     106             :                 for (i = 0; i < ncand; i++) {                                \
     107             :                         x = canditer_next(&ci) - bhseqbase;         \
     108             :                         if (is_##TYPE1##_nil(src[x])) {                 \
     109             :                                 nils++;                                 \
     110             :                                 dst[i] = TYPE2##_nil;                   \
     111             :                         } else {                                        \
     112             :                                 dst[i] = FUNC(src[x]);                  \
     113             :                                 if (is_##TYPE2##_nil(dst[i])) {         \
     114             :                                         on_overflow;                    \
     115             :                                 }                                       \
     116             :                         }                                               \
     117             :                 }                                                       \
     118             :         } while (0)
     119             : 
     120             : #define BINARY_3TYPE_FUNC(TYPE1, TYPE2, TYPE3, FUNC)                    \
     121             :         do {                                                            \
     122             :                 i = j = 0;                                              \
     123             :                 if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {   \
     124             :                         for (k = 0; k < ncand; k++) {                        \
     125             :                                 if (incr1)                              \
     126             :                                         i = canditer_next_dense(ci1) - candoff1; \
     127             :                                 if (incr2)                              \
     128             :                                         j = canditer_next_dense(ci2) - candoff2; \
     129             :                                 TYPE1 v1 = ((const TYPE1 *) lft)[i];    \
     130             :                                 TYPE2 v2 = ((const TYPE2 *) rgt)[j];    \
     131             :                                 if (is_##TYPE1##_nil(v1) || is_##TYPE2##_nil(v2)) { \
     132             :                                         nils++;                         \
     133             :                                         ((TYPE3 *) dst)[k] = TYPE3##_nil; \
     134             :                                 } else {                                \
     135             :                                         ((TYPE3 *) dst)[k] = FUNC(v1, v2); \
     136             :                                 }                                       \
     137             :                         }                                               \
     138             :                 } else {                                                \
     139             :                         for (k = 0; k < ncand; k++) {                        \
     140             :                                 if (incr1)                              \
     141             :                                         i = canditer_next(ci1) - candoff1; \
     142             :                                 if (incr2)                              \
     143             :                                         j = canditer_next(ci2) - candoff2; \
     144             :                                 TYPE1 v1 = ((const TYPE1 *) lft)[i];    \
     145             :                                 TYPE2 v2 = ((const TYPE2 *) rgt)[j];    \
     146             :                                 if (is_##TYPE1##_nil(v1) || is_##TYPE2##_nil(v2)) { \
     147             :                                         nils++;                         \
     148             :                                         ((TYPE3 *) dst)[k] = TYPE3##_nil; \
     149             :                                 } else {                                \
     150             :                                         ((TYPE3 *) dst)[k] = FUNC(v1, v2); \
     151             :                                 }                                       \
     152             :                         }                                               \
     153             :                 }                                                       \
     154             :         } while (0)
     155             : 
     156             : #define BINARY_3TYPE_FUNC_nilcheck(TYPE1, TYPE2, TYPE3, FUNC, on_overflow) \
     157             :         do {                                                            \
     158             :                 i = j = 0;                                              \
     159             :                 if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {   \
     160             :                         for (k = 0; k < ncand; k++) {                        \
     161             :                                 if (incr1)                              \
     162             :                                         i = canditer_next_dense(ci1) - candoff1; \
     163             :                                 if (incr2)                              \
     164             :                                         j = canditer_next_dense(ci2) - candoff2; \
     165             :                                 TYPE1 v1 = ((const TYPE1 *) lft)[i];    \
     166             :                                 TYPE2 v2 = ((const TYPE2 *) rgt)[j];    \
     167             :                                 if (is_##TYPE1##_nil(v1) || is_##TYPE2##_nil(v2)) { \
     168             :                                         nils++;                         \
     169             :                                         ((TYPE3 *) dst)[k] = TYPE3##_nil; \
     170             :                                 } else {                                \
     171             :                                         ((TYPE3 *) dst)[k] = FUNC(v1, v2); \
     172             :                                         if (is_##TYPE3##_nil(((TYPE3 *) dst)[k])) \
     173             :                                                 on_overflow;            \
     174             :                                 }                                       \
     175             :                         }                                               \
     176             :                 } else {                                                \
     177             :                         for (k = 0; k < ncand; k++) {                        \
     178             :                                 if (incr1)                              \
     179             :                                         i = canditer_next(ci1) - candoff1; \
     180             :                                 if (incr2)                              \
     181             :                                         j = canditer_next(ci2) - candoff2; \
     182             :                                 TYPE1 v1 = ((const TYPE1 *) lft)[i];    \
     183             :                                 TYPE2 v2 = ((const TYPE2 *) rgt)[j];    \
     184             :                                 if (is_##TYPE1##_nil(v1) || is_##TYPE2##_nil(v2)) { \
     185             :                                         nils++;                         \
     186             :                                         ((TYPE3 *) dst)[k] = TYPE3##_nil; \
     187             :                                 } else {                                \
     188             :                                         ((TYPE3 *) dst)[k] = FUNC(v1, v2); \
     189             :                                         if (is_##TYPE3##_nil(((TYPE3 *) dst)[k])) \
     190             :                                                 on_overflow;            \
     191             :                                 }                                       \
     192             :                         }                                               \
     193             :                 }                                                       \
     194             :         } while (0)
     195             : 
     196             : /* special case for EQ and NE where we have a nil_matches flag for
     197             :  * when it is set */
     198             : #define BINARY_3TYPE_FUNC_nilmatch(TYPE1, TYPE2, TYPE3, FUNC)           \
     199             :         do {                                                            \
     200             :                 i = j = 0;                                              \
     201             :                 if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {   \
     202             :                         for (k = 0; k < ncand; k++) {                        \
     203             :                                 if (incr1)                              \
     204             :                                         i = canditer_next_dense(ci1) - candoff1; \
     205             :                                 if (incr2)                              \
     206             :                                         j = canditer_next_dense(ci2) - candoff2; \
     207             :                                 TYPE1 v1 = ((const TYPE1 *) lft)[i];    \
     208             :                                 TYPE2 v2 = ((const TYPE2 *) rgt)[j];    \
     209             :                                 if (is_##TYPE1##_nil(v1) || is_##TYPE2##_nil(v2)) { \
     210             :                                         ((TYPE3 *) dst)[k] = FUNC(is_##TYPE1##_nil(v1), is_##TYPE2##_nil(v2)); \
     211             :                                 } else {                                \
     212             :                                         ((TYPE3 *) dst)[k] = FUNC(v1, v2); \
     213             :                                 }                                       \
     214             :                         }                                               \
     215             :                 } else {                                                \
     216             :                         for (k = 0; k < ncand; k++) {                        \
     217             :                                 if (incr1)                              \
     218             :                                         i = canditer_next(ci1) - candoff1; \
     219             :                                 if (incr2)                              \
     220             :                                         j = canditer_next(ci2) - candoff2; \
     221             :                                 TYPE1 v1 = ((const TYPE1 *) lft)[i];    \
     222             :                                 TYPE2 v2 = ((const TYPE2 *) rgt)[j];    \
     223             :                                 if (is_##TYPE1##_nil(v1) || is_##TYPE2##_nil(v2)) { \
     224             :                                         ((TYPE3 *) dst)[k] = FUNC(is_##TYPE1##_nil(v1), is_##TYPE2##_nil(v2)); \
     225             :                                 } else {                                \
     226             :                                         ((TYPE3 *) dst)[k] = FUNC(v1, v2); \
     227             :                                 }                                       \
     228             :                         }                                               \
     229             :                 }                                                       \
     230             :         } while (0)
     231             : 
     232             : #define BINARY_3TYPE_FUNC_nonil(TYPE1, TYPE2, TYPE3, FUNC)              \
     233             :         do {                                                            \
     234             :                 i = j = 0;                                              \
     235             :                 if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {   \
     236             :                         for (k = 0; k < ncand; k++) {                        \
     237             :                                 if (incr1)                              \
     238             :                                         i = canditer_next_dense(ci1) - candoff1; \
     239             :                                 if (incr2)                              \
     240             :                                         j = canditer_next_dense(ci2) - candoff2; \
     241             :                                 TYPE1 v1 = ((const TYPE1 *) lft)[i];    \
     242             :                                 TYPE2 v2 = ((const TYPE2 *) rgt)[j];    \
     243             :                                 ((TYPE3 *) dst)[k] = FUNC(v1, v2);      \
     244             :                         }                                               \
     245             :                 } else {                                                \
     246             :                         for (k = 0; k < ncand; k++) {                        \
     247             :                                 if (incr1)                              \
     248             :                                         i = canditer_next(ci1) - candoff1; \
     249             :                                 if (incr2)                              \
     250             :                                         j = canditer_next(ci2) - candoff2; \
     251             :                                 TYPE1 v1 = ((const TYPE1 *) lft)[i];    \
     252             :                                 TYPE2 v2 = ((const TYPE2 *) rgt)[j];    \
     253             :                                 ((TYPE3 *) dst)[k] = FUNC(v1, v2);      \
     254             :                         }                                               \
     255             :                 }                                                       \
     256             :         } while (0)
     257             : 
     258             : #define BINARY_3TYPE_FUNC_nonil_nilcheck(TYPE1, TYPE2, TYPE3, FUNC, on_overflow) \
     259             :         do {                                                            \
     260             :                 i = j = 0;                                              \
     261             :                 if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {   \
     262             :                         for (k = 0; k < ncand; k++) {                        \
     263             :                                 if (incr1)                              \
     264             :                                         i = canditer_next_dense(ci1) - candoff1; \
     265             :                                 if (incr2)                              \
     266             :                                         j = canditer_next_dense(ci2) - candoff2; \
     267             :                                 TYPE1 v1 = ((const TYPE1 *) lft)[i];    \
     268             :                                 TYPE2 v2 = ((const TYPE2 *) rgt)[j];    \
     269             :                                 ((TYPE3 *) dst)[k] = FUNC(v1, v2);      \
     270             :                                 if (is_##TYPE3##_nil(((TYPE3 *) dst)[k])) \
     271             :                                         on_overflow;                    \
     272             :                         }                                               \
     273             :                 } else {                                                \
     274             :                         for (k = 0; k < ncand; k++) {                        \
     275             :                                 if (incr1)                              \
     276             :                                         i = canditer_next(ci1) - candoff1; \
     277             :                                 if (incr2)                              \
     278             :                                         j = canditer_next(ci2) - candoff2; \
     279             :                                 TYPE1 v1 = ((const TYPE1 *) lft)[i];    \
     280             :                                 TYPE2 v2 = ((const TYPE2 *) rgt)[j];    \
     281             :                                 ((TYPE3 *) dst)[k] = FUNC(v1, v2);      \
     282             :                                 if (is_##TYPE3##_nil(((TYPE3 *) dst)[k])) \
     283             :                                         on_overflow;                    \
     284             :                         }                                               \
     285             :                 }                                                       \
     286             :         } while (0)
     287             : 
     288             : #define BINARY_3TYPE_FUNC_CHECK(TYPE1, TYPE2, TYPE3, FUNC, CHECK)       \
     289             :         do {                                                            \
     290             :                 i = j = 0;                                              \
     291             :                 if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {   \
     292             :                         for (k = 0; k < ncand; k++) {                        \
     293             :                                 if (incr1)                              \
     294             :                                         i = canditer_next_dense(ci1) - candoff1; \
     295             :                                 if (incr2)                              \
     296             :                                         j = canditer_next_dense(ci2) - candoff2; \
     297             :                                 TYPE1 v1 = ((const TYPE1 *) lft)[i];    \
     298             :                                 TYPE2 v2 = ((const TYPE2 *) rgt)[j];    \
     299             :                                 if (is_##TYPE1##_nil(v1) || is_##TYPE2##_nil(v2)) { \
     300             :                                         nils++;                         \
     301             :                                         ((TYPE3 *) dst)[k] = TYPE3##_nil; \
     302             :                                 } else if (CHECK(v1, v2)) {             \
     303             :                                         if (abort_on_error) {           \
     304             :                                                 GDKerror("%s: shift operand too large in " \
     305             :                                                          #FUNC"("FMT##TYPE1","FMT##TYPE2").\n", \
     306             :                                                          func,          \
     307             :                                                          CST##TYPE1 v1, \
     308             :                                                          CST##TYPE2 v2); \
     309             :                                                 goto checkfail;         \
     310             :                                         }                               \
     311             :                                         ((TYPE3 *)dst)[k] = TYPE3##_nil; \
     312             :                                         nils++;                         \
     313             :                                 } else {                                \
     314             :                                         ((TYPE3 *) dst)[k] = FUNC(v1, v2); \
     315             :                                 }                                       \
     316             :                         }                                               \
     317             :                 } else {                                                \
     318             :                         for (k = 0; k < ncand; k++) {                        \
     319             :                                 if (incr1)                              \
     320             :                                         i = canditer_next(ci1) - candoff1; \
     321             :                                 if (incr2)                              \
     322             :                                         j = canditer_next(ci2) - candoff2; \
     323             :                                 TYPE1 v1 = ((const TYPE1 *) lft)[i];    \
     324             :                                 TYPE2 v2 = ((const TYPE2 *) rgt)[j];    \
     325             :                                 if (is_##TYPE1##_nil(v1) || is_##TYPE2##_nil(v2)) { \
     326             :                                         nils++;                         \
     327             :                                         ((TYPE3 *) dst)[k] = TYPE3##_nil; \
     328             :                                 } else if (CHECK(v1, v2)) {             \
     329             :                                         if (abort_on_error) {           \
     330             :                                                 GDKerror("%s: shift operand too large in " \
     331             :                                                          #FUNC"("FMT##TYPE1","FMT##TYPE2").\n", \
     332             :                                                          func,          \
     333             :                                                          CST##TYPE1 v1, \
     334             :                                                          CST##TYPE2 v2); \
     335             :                                                 goto checkfail;         \
     336             :                                         }                               \
     337             :                                         ((TYPE3 *)dst)[k] = TYPE3##_nil; \
     338             :                                         nils++;                         \
     339             :                                 } else {                                \
     340             :                                         ((TYPE3 *) dst)[k] = FUNC(v1, v2); \
     341             :                                 }                                       \
     342             :                         }                                               \
     343             :                 }                                                       \
     344             :         } while (0)
     345             : 
     346             : /* ---------------------------------------------------------------------- */
     347             : /* logical (for type bit) or bitwise (for integral types) NOT */
     348             : 
     349             : #define NOT(x)          (~(x))
     350             : #define NOTBIT(x)       (!(x))
     351             : 
     352             : BAT *
     353        1374 : BATcalcnot(BAT *b, BAT *s)
     354             : {
     355             :         lng t0 = 0;
     356             :         BAT *bn;
     357             :         BUN nils = 0;
     358             :         BUN i, ncand;
     359             :         oid x, bhseqbase;
     360             :         struct canditer ci;
     361             : 
     362        1374 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
     363             : 
     364        1374 :         BATcheck(b, NULL);
     365             : 
     366        1374 :         bhseqbase = b->hseqbase;
     367        1374 :         ncand = canditer_init(&ci, b, s);
     368        1374 :         if (ncand == 0)
     369         774 :                 return BATconstant(ci.hseq, b->ttype,
     370         774 :                                    ATOMnilptr(b->ttype), ncand, TRANSIENT);
     371             : 
     372         600 :         bn = COLnew(ci.hseq, b->ttype, ncand, TRANSIENT);
     373         600 :         if (bn == NULL)
     374             :                 return NULL;
     375             : 
     376         600 :         BATiter bi = bat_iterator(b);
     377         600 :         switch (ATOMbasetype(b->ttype)) {
     378           0 :         case TYPE_msk:
     379           0 :                 if (ci.tpe == cand_dense) {
     380           0 :                         const uint32_t *restrict src = (const uint32_t *) bi.base + (ci.seq - b->hseqbase) / 32;
     381           0 :                         uint32_t *restrict dst = Tloc(bn, 0);
     382           0 :                         int bits = (ci.seq - b->hseqbase) % 32;
     383           0 :                         ncand = (ncand + 31) / 32;
     384           0 :                         if (bits == 0) {
     385           0 :                                 for (i = 0; i < ncand; i++)
     386           0 :                                         dst[i] = ~src[i];
     387             :                         } else {
     388           0 :                                 for (i = 0; i < ncand; i++)
     389           0 :                                         dst[i] = (~src[i] >> bits) | ~(src[i + 1] >> (32 - bits));
     390             :                         }
     391           0 :                         if (ci.ncand % 32 != 0)
     392           0 :                                 dst[ci.ncand / 32] &= (1U << (ci.ncand % 32)) - 1;
     393             :                 } else {
     394           0 :                         for (i = 0; i < ncand; i++) {
     395           0 :                                 x = canditer_next(&ci) - bhseqbase;
     396           0 :                                 mskSetVal(bn, i, !Tmskval(&bi, x));
     397             :                         }
     398             :                 }
     399             :                 break;
     400         600 :         case TYPE_bte:
     401         600 :                 if (b->ttype == TYPE_bit) {
     402       10855 :                         UNARY_2TYPE_FUNC(bit, bit, NOTBIT);
     403             :                 } else {
     404           0 :                         UNARY_2TYPE_FUNC_nilcheck(bte, bte, NOT, ON_OVERFLOW1(bte, "NOT"));
     405             :                 }
     406             :                 break;
     407           0 :         case TYPE_sht:
     408           0 :                 UNARY_2TYPE_FUNC_nilcheck(sht, sht, NOT, ON_OVERFLOW1(sht, "NOT"));
     409             :                 break;
     410           0 :         case TYPE_int:
     411           0 :                 UNARY_2TYPE_FUNC_nilcheck(int, int, NOT, ON_OVERFLOW1(int, "NOT"));
     412             :                 break;
     413           0 :         case TYPE_lng:
     414           0 :                 UNARY_2TYPE_FUNC_nilcheck(lng, lng, NOT, ON_OVERFLOW1(lng, "NOT"));
     415             :                 break;
     416             : #ifdef HAVE_HGE
     417           0 :         case TYPE_hge:
     418           0 :                 UNARY_2TYPE_FUNC_nilcheck(hge, hge, NOT, ON_OVERFLOW1(hge, "NOT"));
     419             :                 break;
     420             : #endif
     421           0 :         default:
     422           0 :                 bat_iterator_end(&bi);
     423           0 :                 BBPunfix(bn->batCacheid);
     424           0 :                 GDKerror("type %s not supported.\n", ATOMname(b->ttype));
     425           0 :                 return NULL;
     426             :         }
     427         600 :         bat_iterator_end(&bi);
     428             : 
     429         600 :         BATsetcount(bn, ci.ncand);
     430             : 
     431             :         /* NOT reverses the order, but NILs mess it up */
     432         600 :         bn->tsorted = nils == 0 && b->trevsorted;
     433         600 :         bn->trevsorted = nils == 0 && b->tsorted;
     434         600 :         bn->tnil = nils != 0;
     435         600 :         bn->tnonil = nils == 0;
     436         600 :         bn->tkey = b->tkey && nils <= 1;
     437             : 
     438         600 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
     439             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
     440             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
     441             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
     442             : 
     443             :         return bn;
     444             : }
     445             : 
     446             : gdk_return
     447      431907 : VARcalcnot(ValPtr ret, const ValRecord *v)
     448             : {
     449      431907 :         ret->vtype = v->vtype;
     450      431910 :         switch (ATOMbasetype(v->vtype)) {
     451           0 :         case TYPE_msk:
     452           0 :                 ret->val.mval = !v->val.mval;
     453           0 :                 break;
     454      431907 :         case TYPE_bte:
     455      431907 :                 if (is_bit_nil(v->val.btval))
     456        2234 :                         ret->val.btval = bit_nil;
     457      429673 :                 else if (v->vtype == TYPE_bit)
     458      429670 :                         ret->val.btval = !v->val.btval;
     459             :                 else {
     460           3 :                         ret->val.btval = ~v->val.btval;
     461           3 :                         if (is_bte_nil(ret->val.btval)) {
     462           0 :                                 GDKerror("22003!overflow in calculation "
     463             :                                          "NOT(" FMTbte ").\n", v->val.btval);
     464           0 :                                 return GDK_FAIL;
     465             :                         }
     466             :                 }
     467             :                 break;
     468           0 :         case TYPE_sht:
     469           0 :                 if (is_sht_nil(v->val.shval))
     470           0 :                         ret->val.shval = sht_nil;
     471             :                 else {
     472           0 :                         ret->val.shval = ~v->val.shval;
     473           0 :                         if (is_sht_nil(ret->val.shval)) {
     474           0 :                                 GDKerror("22003!overflow in calculation "
     475             :                                          "NOT(" FMTsht ").\n", v->val.shval);
     476           0 :                                 return GDK_FAIL;
     477             :                         }
     478             :                 }
     479             :                 break;
     480           0 :         case TYPE_int:
     481           0 :                 if (is_int_nil(v->val.ival))
     482           0 :                         ret->val.ival = int_nil;
     483             :                 else {
     484           0 :                         ret->val.ival = ~v->val.ival;
     485           0 :                         if (is_int_nil(ret->val.ival)) {
     486           0 :                                 GDKerror("22003!overflow in calculation "
     487             :                                          "NOT(" FMTint ").\n", v->val.ival);
     488           0 :                                 return GDK_FAIL;
     489             :                         }
     490             :                 }
     491             :                 break;
     492           0 :         case TYPE_lng:
     493           0 :                 if (is_lng_nil(v->val.lval))
     494           0 :                         ret->val.lval = lng_nil;
     495             :                 else {
     496           0 :                         ret->val.lval = ~v->val.lval;
     497           0 :                         if (is_lng_nil(ret->val.lval)) {
     498           0 :                                 GDKerror("22003!overflow in calculation "
     499             :                                          "NOT(" FMTlng ").\n", v->val.lval);
     500           0 :                                 return GDK_FAIL;
     501             :                         }
     502             :                 }
     503             :                 break;
     504             : #ifdef HAVE_HGE
     505           0 :         case TYPE_hge:
     506           0 :                 if (is_hge_nil(v->val.hval))
     507           0 :                         ret->val.hval = hge_nil;
     508             :                 else {
     509           0 :                         ret->val.hval = ~v->val.hval;
     510           0 :                         if (is_hge_nil(ret->val.hval)) {
     511           0 :                                 GDKerror("22003!overflow in calculation "
     512             :                                          "NOT(" FMThge ").\n",
     513             :                                          CSThge v->val.hval);
     514           0 :                                 return GDK_FAIL;
     515             :                         }
     516             :                 }
     517             :                 break;
     518             : #endif
     519           0 :         default:
     520           0 :                 GDKerror("bad input type %s.\n", ATOMname(v->vtype));
     521           0 :                 return GDK_FAIL;
     522             :         }
     523             :         return GDK_SUCCEED;
     524             : }
     525             : 
     526             : /* ---------------------------------------------------------------------- */
     527             : /* negate value (any numeric type) */
     528             : 
     529             : #define NEGATE(x)       (-(x))
     530             : 
     531             : BAT *
     532         225 : BATcalcnegate(BAT *b, BAT *s)
     533             : {
     534             :         lng t0 = 0;
     535             :         BAT *bn;
     536             :         BUN nils = 0;
     537             :         BUN i, ncand;
     538             :         oid x, bhseqbase;
     539             :         struct canditer ci;
     540             : 
     541         225 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
     542             : 
     543         225 :         BATcheck(b, NULL);
     544             : 
     545         225 :         bhseqbase = b->hseqbase;
     546         225 :         ncand = canditer_init(&ci, b, s);
     547         223 :         if (ncand == 0)
     548          30 :                 return BATconstant(ci.hseq, b->ttype,
     549          30 :                                    ATOMnilptr(b->ttype), ncand, TRANSIENT);
     550             : 
     551         193 :         bn = COLnew(ci.hseq, b->ttype, ncand, TRANSIENT);
     552         198 :         if (bn == NULL)
     553             :                 return NULL;
     554             : 
     555         198 :         BATiter bi = bat_iterator(b);
     556         394 :         switch (ATOMbasetype(b->ttype)) {
     557           5 :         case TYPE_bte:
     558          73 :                 UNARY_2TYPE_FUNC(bte, bte, NEGATE);
     559             :                 break;
     560           1 :         case TYPE_sht:
     561           3 :                 UNARY_2TYPE_FUNC(sht, sht, NEGATE);
     562             :                 break;
     563         119 :         case TYPE_int:
     564         537 :                 UNARY_2TYPE_FUNC(int, int, NEGATE);
     565             :                 break;
     566          23 :         case TYPE_lng:
     567         276 :                 UNARY_2TYPE_FUNC(lng, lng, NEGATE);
     568             :                 break;
     569             : #ifdef HAVE_HGE
     570          21 :         case TYPE_hge:
     571         288 :                 UNARY_2TYPE_FUNC(hge, hge, NEGATE);
     572             :                 break;
     573             : #endif
     574           0 :         case TYPE_flt:
     575           0 :                 UNARY_2TYPE_FUNC(flt, flt, NEGATE);
     576             :                 break;
     577          28 :         case TYPE_dbl:
     578         108 :                 UNARY_2TYPE_FUNC(dbl, dbl, NEGATE);
     579             :                 break;
     580           0 :         default:
     581           0 :                 bat_iterator_end(&bi);
     582           0 :                 BBPunfix(bn->batCacheid);
     583           0 :                 GDKerror("type %s not supported.\n", ATOMname(b->ttype));
     584           0 :                 return NULL;
     585             :         }
     586         197 :         bat_iterator_end(&bi);
     587             : 
     588         199 :         BATsetcount(bn, ncand);
     589             : 
     590             :         /* unary - reverses the order, but NILs mess it up */
     591         196 :         bn->tsorted = nils == 0 && b->trevsorted;
     592         196 :         bn->trevsorted = nils == 0 && b->tsorted;
     593         196 :         bn->tnil = nils != 0;
     594         196 :         bn->tnonil = nils == 0;
     595         196 :         bn->tkey = b->tkey && nils <= 1;
     596             : 
     597         196 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
     598             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
     599             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
     600             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
     601             : 
     602             :         return bn;
     603             : }
     604             : 
     605             : gdk_return
     606        1675 : VARcalcnegate(ValPtr ret, const ValRecord *v)
     607             : {
     608        1675 :         ret->vtype = v->vtype;
     609        3350 :         switch (ATOMbasetype(v->vtype)) {
     610         991 :         case TYPE_bte:
     611         991 :                 if (is_bte_nil(v->val.btval))
     612           4 :                         ret->val.btval = bte_nil;
     613             :                 else
     614         987 :                         ret->val.btval = -v->val.btval;
     615             :                 break;
     616         123 :         case TYPE_sht:
     617         123 :                 if (is_sht_nil(v->val.shval))
     618           1 :                         ret->val.shval = sht_nil;
     619             :                 else
     620         122 :                         ret->val.shval = -v->val.shval;
     621             :                 break;
     622         316 :         case TYPE_int:
     623         316 :                 if (is_int_nil(v->val.ival))
     624          16 :                         ret->val.ival = int_nil;
     625             :                 else
     626         300 :                         ret->val.ival = -v->val.ival;
     627             :                 break;
     628         158 :         case TYPE_lng:
     629         158 :                 if (is_lng_nil(v->val.lval))
     630           5 :                         ret->val.lval = lng_nil;
     631             :                 else
     632         153 :                         ret->val.lval = -v->val.lval;
     633             :                 break;
     634             : #ifdef HAVE_HGE
     635          45 :         case TYPE_hge:
     636          45 :                 if (is_hge_nil(v->val.hval))
     637           4 :                         ret->val.hval = hge_nil;
     638             :                 else
     639          41 :                         ret->val.hval = -v->val.hval;
     640             :                 break;
     641             : #endif
     642           8 :         case TYPE_flt:
     643           8 :                 if (is_flt_nil(v->val.fval))
     644           8 :                         ret->val.fval = flt_nil;
     645             :                 else
     646           0 :                         ret->val.fval = -v->val.fval;
     647             :                 break;
     648          34 :         case TYPE_dbl:
     649          34 :                 if (is_dbl_nil(v->val.dval))
     650           2 :                         ret->val.dval = dbl_nil;
     651             :                 else
     652          32 :                         ret->val.dval = -v->val.dval;
     653             :                 break;
     654           0 :         default:
     655           0 :                 GDKerror("bad input type %s.\n", ATOMname(v->vtype));
     656           0 :                 return GDK_FAIL;
     657             :         }
     658             :         return GDK_SUCCEED;
     659             : }
     660             : 
     661             : /* ---------------------------------------------------------------------- */
     662             : /* absolute value (any numeric type) */
     663             : 
     664             : BAT *
     665        7837 : BATcalcabsolute(BAT *b, BAT *s)
     666             : {
     667             :         lng t0 = 0;
     668             :         BAT *bn;
     669             :         BUN nils = 0;
     670             :         BUN i, ncand;
     671             :         oid x, bhseqbase;
     672             :         struct canditer ci;
     673             : 
     674        7837 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
     675             : 
     676        7837 :         BATcheck(b, NULL);
     677             : 
     678        7837 :         bhseqbase = b->hseqbase;
     679        7837 :         ncand = canditer_init(&ci, b, s);
     680        7836 :         if (ncand == 0)
     681        2339 :                 return BATconstant(ci.hseq, b->ttype,
     682        2339 :                                    ATOMnilptr(b->ttype), ncand, TRANSIENT);
     683             : 
     684        5497 :         bn = COLnew(ci.hseq, b->ttype, ncand, TRANSIENT);
     685        5496 :         if (bn == NULL)
     686             :                 return NULL;
     687             : 
     688        5496 :         BATiter bi = bat_iterator(b);
     689       10990 :         switch (ATOMbasetype(b->ttype)) {
     690           5 :         case TYPE_bte:
     691          23 :                 UNARY_2TYPE_FUNC(bte, bte, (bte) abs);
     692             :                 break;
     693           4 :         case TYPE_sht:
     694           8 :                 UNARY_2TYPE_FUNC(sht, sht, (sht) abs);
     695             :                 break;
     696        2569 :         case TYPE_int:
     697       18774 :                 UNARY_2TYPE_FUNC(int, int, abs);
     698             :                 break;
     699        2901 :         case TYPE_lng:
     700       19983 :                 UNARY_2TYPE_FUNC(lng, lng, llabs);
     701             :                 break;
     702             : #ifdef HAVE_HGE
     703           5 :         case TYPE_hge:
     704       85504 :                 UNARY_2TYPE_FUNC(hge, hge, ABSOLUTE);
     705             :                 break;
     706             : #endif
     707           1 :         case TYPE_flt:
     708           8 :                 UNARY_2TYPE_FUNC(flt, flt, fabsf);
     709             :                 break;
     710          10 :         case TYPE_dbl:
     711          43 :                 UNARY_2TYPE_FUNC(dbl, dbl, fabs);
     712             :                 break;
     713           0 :         default:
     714           0 :                 bat_iterator_end(&bi);
     715           0 :                 BBPunfix(bn->batCacheid);
     716           0 :                 GDKerror("bad input type %s.\n", ATOMname(b->ttype));
     717           0 :                 return NULL;
     718             :         }
     719        5497 :         bat_iterator_end(&bi);
     720             : 
     721        5499 :         BATsetcount(bn, ncand);
     722             : 
     723             :         /* ABSOLUTE messes up order (unless all values were negative
     724             :          * or all values were positive, but we don't know anything
     725             :          * about that) */
     726        5498 :         bn->tsorted = ncand <= 1 || nils == ncand;
     727        5498 :         bn->trevsorted = ncand <= 1 || nils == ncand;
     728        5498 :         bn->tkey = ncand <= 1;
     729        5498 :         bn->tnil = nils != 0;
     730        5498 :         bn->tnonil = nils == 0;
     731             : 
     732        5498 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
     733             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
     734             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
     735             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
     736             : 
     737             :         return bn;
     738             : }
     739             : 
     740             : gdk_return
     741          40 : VARcalcabsolute(ValPtr ret, const ValRecord *v)
     742             : {
     743          40 :         ret->vtype = v->vtype;
     744          80 :         switch (ATOMbasetype(v->vtype)) {
     745          15 :         case TYPE_bte:
     746          15 :                 if (is_bte_nil(v->val.btval))
     747           0 :                         ret->val.btval = bte_nil;
     748             :                 else
     749          15 :                         ret->val.btval = (bte) abs(v->val.btval);
     750             :                 break;
     751           5 :         case TYPE_sht:
     752           5 :                 if (is_sht_nil(v->val.shval))
     753           0 :                         ret->val.shval = sht_nil;
     754             :                 else
     755           5 :                         ret->val.shval = (sht) abs(v->val.shval);
     756             :                 break;
     757          14 :         case TYPE_int:
     758          14 :                 if (is_int_nil(v->val.ival))
     759           0 :                         ret->val.ival = int_nil;
     760             :                 else
     761          14 :                         ret->val.ival = abs(v->val.ival);
     762             :                 break;
     763           5 :         case TYPE_lng:
     764           5 :                 if (is_lng_nil(v->val.lval))
     765           0 :                         ret->val.lval = lng_nil;
     766             :                 else
     767           5 :                         ret->val.lval = llabs(v->val.lval);
     768             :                 break;
     769             : #ifdef HAVE_HGE
     770           0 :         case TYPE_hge:
     771           0 :                 if (is_hge_nil(v->val.hval))
     772           0 :                         ret->val.hval = hge_nil;
     773             :                 else
     774           0 :                         ret->val.hval = ABSOLUTE(v->val.hval);
     775             :                 break;
     776             : #endif
     777           0 :         case TYPE_flt:
     778           0 :                 if (is_flt_nil(v->val.fval))
     779           0 :                         ret->val.fval = flt_nil;
     780             :                 else
     781           0 :                         ret->val.fval = fabsf(v->val.fval);
     782             :                 break;
     783           1 :         case TYPE_dbl:
     784           1 :                 if (is_dbl_nil(v->val.dval))
     785           0 :                         ret->val.dval = dbl_nil;
     786             :                 else
     787           1 :                         ret->val.dval = fabs(v->val.dval);
     788             :                 break;
     789           0 :         default:
     790           0 :                 GDKerror("bad input type %s.\n", ATOMname(v->vtype));
     791           0 :                 return GDK_FAIL;
     792             :         }
     793             :         return GDK_SUCCEED;
     794             : }
     795             : 
     796             : /* ---------------------------------------------------------------------- */
     797             : /* is the value equal to zero (any numeric type) */
     798             : 
     799             : #define ISZERO(x)               ((bit) ((x) == 0))
     800             : 
     801             : BAT *
     802           0 : BATcalciszero(BAT *b, BAT *s)
     803             : {
     804             :         lng t0 = 0;
     805             :         BAT *bn;
     806             :         BUN nils = 0;
     807             :         BUN i, ncand;
     808             :         oid x, bhseqbase;
     809             :         struct canditer ci;
     810             : 
     811           0 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
     812             : 
     813           0 :         BATcheck(b, NULL);
     814             : 
     815           0 :         bhseqbase = b->hseqbase;
     816           0 :         ncand = canditer_init(&ci, b, s);
     817           0 :         if (ncand == 0)
     818           0 :                 return BATconstant(ci.hseq, TYPE_bit,
     819             :                                    ATOMnilptr(TYPE_bit), ncand, TRANSIENT);
     820             : 
     821           0 :         bn = COLnew(ci.hseq, TYPE_bit, ncand, TRANSIENT);
     822           0 :         if (bn == NULL)
     823             :                 return NULL;
     824             : 
     825           0 :         BATiter bi = bat_iterator(b);
     826           0 :         switch (ATOMbasetype(b->ttype)) {
     827           0 :         case TYPE_bte:
     828           0 :                 UNARY_2TYPE_FUNC(bte, bit, ISZERO);
     829             :                 break;
     830           0 :         case TYPE_sht:
     831           0 :                 UNARY_2TYPE_FUNC(sht, bit, ISZERO);
     832             :                 break;
     833           0 :         case TYPE_int:
     834           0 :                 UNARY_2TYPE_FUNC(int, bit, ISZERO);
     835             :                 break;
     836           0 :         case TYPE_lng:
     837           0 :                 UNARY_2TYPE_FUNC(lng, bit, ISZERO);
     838             :                 break;
     839             : #ifdef HAVE_HGE
     840           0 :         case TYPE_hge:
     841           0 :                 UNARY_2TYPE_FUNC(hge, bit, ISZERO);
     842             :                 break;
     843             : #endif
     844           0 :         case TYPE_flt:
     845           0 :                 UNARY_2TYPE_FUNC(flt, bit, ISZERO);
     846             :                 break;
     847           0 :         case TYPE_dbl:
     848           0 :                 UNARY_2TYPE_FUNC(dbl, bit, ISZERO);
     849             :                 break;
     850           0 :         default:
     851           0 :                 bat_iterator_end(&bi);
     852           0 :                 BBPunfix(bn->batCacheid);
     853           0 :                 GDKerror("bad input type %s.\n", ATOMname(b->ttype));
     854           0 :                 return NULL;
     855             :         }
     856           0 :         bat_iterator_end(&bi);
     857             : 
     858           0 :         BATsetcount(bn, ncand);
     859             : 
     860           0 :         bn->tsorted = ncand <= 1 || nils == ncand;
     861           0 :         bn->trevsorted = ncand <= 1 || nils == ncand;
     862           0 :         bn->tkey = ncand <= 1;
     863           0 :         bn->tnil = nils != 0;
     864           0 :         bn->tnonil = nils == 0;
     865             : 
     866           0 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
     867             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
     868             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
     869             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
     870             : 
     871             :         return bn;
     872             : }
     873             : 
     874             : gdk_return
     875           0 : VARcalciszero(ValPtr ret, const ValRecord *v)
     876             : {
     877           0 :         ret->vtype = TYPE_bit;
     878           0 :         switch (ATOMbasetype(v->vtype)) {
     879           0 :         case TYPE_bte:
     880           0 :                 if (is_bte_nil(v->val.btval))
     881           0 :                         ret->val.btval = bit_nil;
     882             :                 else
     883           0 :                         ret->val.btval = ISZERO(v->val.btval);
     884             :                 break;
     885           0 :         case TYPE_sht:
     886           0 :                 if (is_sht_nil(v->val.shval))
     887           0 :                         ret->val.btval = bit_nil;
     888             :                 else
     889           0 :                         ret->val.btval = ISZERO(v->val.shval);
     890             :                 break;
     891           0 :         case TYPE_int:
     892           0 :                 if (is_int_nil(v->val.ival))
     893           0 :                         ret->val.btval = bit_nil;
     894             :                 else
     895           0 :                         ret->val.btval = ISZERO(v->val.ival);
     896             :                 break;
     897           0 :         case TYPE_lng:
     898           0 :                 if (is_lng_nil(v->val.lval))
     899           0 :                         ret->val.btval = bit_nil;
     900             :                 else
     901           0 :                         ret->val.btval = ISZERO(v->val.lval);
     902             :                 break;
     903             : #ifdef HAVE_HGE
     904           0 :         case TYPE_hge:
     905           0 :                 if (is_hge_nil(v->val.hval))
     906           0 :                         ret->val.btval = bit_nil;
     907             :                 else
     908           0 :                         ret->val.btval = ISZERO(v->val.hval);
     909             :                 break;
     910             : #endif
     911           0 :         case TYPE_flt:
     912           0 :                 if (is_flt_nil(v->val.fval))
     913           0 :                         ret->val.btval = bit_nil;
     914             :                 else
     915           0 :                         ret->val.btval = ISZERO(v->val.fval);
     916             :                 break;
     917           0 :         case TYPE_dbl:
     918           0 :                 if (is_dbl_nil(v->val.dval))
     919           0 :                         ret->val.btval = bit_nil;
     920             :                 else
     921           0 :                         ret->val.btval = ISZERO(v->val.dval);
     922             :                 break;
     923           0 :         default:
     924           0 :                 GDKerror("bad input type %s.\n", ATOMname(v->vtype));
     925           0 :                 return GDK_FAIL;
     926             :         }
     927             :         return GDK_SUCCEED;
     928             : }
     929             : 
     930             : /* ---------------------------------------------------------------------- */
     931             : /* sign of value (-1 for negative, 0 for 0, +1 for positive; any
     932             :  * numeric type) */
     933             : 
     934             : #define SIGN(x)         ((bte) ((x) < 0 ? -1 : (x) > 0))
     935             : 
     936             : BAT *
     937           9 : BATcalcsign(BAT *b, BAT *s)
     938             : {
     939             :         lng t0 = 0;
     940             :         BAT *bn;
     941             :         BUN nils = 0;
     942             :         BUN i, ncand;
     943             :         oid x, bhseqbase;
     944             :         struct canditer ci;
     945             : 
     946           9 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
     947             : 
     948           9 :         BATcheck(b, NULL);
     949             : 
     950           9 :         bhseqbase = b->hseqbase;
     951           9 :         ncand = canditer_init(&ci, b, s);
     952           9 :         if (ncand == 0)
     953           0 :                 return BATconstant(ci.hseq, TYPE_bte,
     954             :                                    ATOMnilptr(TYPE_bte), ncand, TRANSIENT);
     955             : 
     956           9 :         bn = COLnew(ci.hseq, TYPE_bte, ncand, TRANSIENT);
     957           9 :         if (bn == NULL)
     958             :                 return NULL;
     959             : 
     960           9 :         BATiter bi = bat_iterator(b);
     961          18 :         switch (ATOMbasetype(b->ttype)) {
     962           1 :         case TYPE_bte:
     963           7 :                 UNARY_2TYPE_FUNC(bte, bte, SIGN);
     964             :                 break;
     965           1 :         case TYPE_sht:
     966           7 :                 UNARY_2TYPE_FUNC(sht, bte, SIGN);
     967             :                 break;
     968           1 :         case TYPE_int:
     969           7 :                 UNARY_2TYPE_FUNC(int, bte, SIGN);
     970             :                 break;
     971           2 :         case TYPE_lng:
     972          14 :                 UNARY_2TYPE_FUNC(lng, bte, SIGN);
     973             :                 break;
     974             : #ifdef HAVE_HGE
     975           0 :         case TYPE_hge:
     976           0 :                 UNARY_2TYPE_FUNC(hge, bte, SIGN);
     977             :                 break;
     978             : #endif
     979           1 :         case TYPE_flt:
     980           8 :                 UNARY_2TYPE_FUNC(flt, bte, SIGN);
     981             :                 break;
     982           3 :         case TYPE_dbl:
     983          11 :                 UNARY_2TYPE_FUNC(dbl, bte, SIGN);
     984             :                 break;
     985           0 :         default:
     986           0 :                 bat_iterator_end(&bi);
     987           0 :                 BBPunfix(bn->batCacheid);
     988           0 :                 GDKerror("bad input type %s.\n", ATOMname(b->ttype));
     989           0 :                 return NULL;
     990             :         }
     991           9 :         bat_iterator_end(&bi);
     992             : 
     993           9 :         BATsetcount(bn, ncand);
     994             : 
     995             :         /* SIGN is ordered if the input is ordered (negative comes
     996             :          * first, positive comes after) and NILs stay in the same
     997             :          * position */
     998           9 :         bn->tsorted = b->tsorted || ncand <= 1 || nils == ncand;
     999           9 :         bn->trevsorted = b->trevsorted || ncand <= 1 || nils == ncand;
    1000           9 :         bn->tkey = ncand <= 1;
    1001           9 :         bn->tnil = nils != 0;
    1002           9 :         bn->tnonil = nils == 0;
    1003             : 
    1004           9 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
    1005             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    1006             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
    1007             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    1008             : 
    1009             :         return bn;
    1010             : }
    1011             : 
    1012             : gdk_return
    1013       27746 : VARcalcsign(ValPtr ret, const ValRecord *v)
    1014             : {
    1015       27746 :         ret->vtype = TYPE_bte;
    1016       55492 :         switch (ATOMbasetype(v->vtype)) {
    1017       25442 :         case TYPE_bte:
    1018       25442 :                 if (is_bte_nil(v->val.btval))
    1019           0 :                         ret->val.btval = bte_nil;
    1020             :                 else
    1021       25442 :                         ret->val.btval = SIGN(v->val.btval);
    1022             :                 break;
    1023        1053 :         case TYPE_sht:
    1024        1053 :                 if (is_sht_nil(v->val.shval))
    1025           0 :                         ret->val.btval = bte_nil;
    1026             :                 else
    1027        1053 :                         ret->val.btval = SIGN(v->val.shval);
    1028             :                 break;
    1029          99 :         case TYPE_int:
    1030          99 :                 if (is_int_nil(v->val.ival))
    1031           7 :                         ret->val.btval = bte_nil;
    1032             :                 else
    1033          92 :                         ret->val.btval = SIGN(v->val.ival);
    1034             :                 break;
    1035        1015 :         case TYPE_lng:
    1036        1015 :                 if (is_lng_nil(v->val.lval))
    1037           0 :                         ret->val.btval = bte_nil;
    1038             :                 else
    1039        1015 :                         ret->val.btval = SIGN(v->val.lval);
    1040             :                 break;
    1041             : #ifdef HAVE_HGE
    1042          31 :         case TYPE_hge:
    1043          31 :                 if (is_hge_nil(v->val.hval))
    1044           0 :                         ret->val.btval = bte_nil;
    1045             :                 else
    1046          31 :                         ret->val.btval = SIGN(v->val.hval);
    1047             :                 break;
    1048             : #endif
    1049          13 :         case TYPE_flt:
    1050          13 :                 if (is_flt_nil(v->val.fval))
    1051           3 :                         ret->val.btval = bte_nil;
    1052             :                 else
    1053          10 :                         ret->val.btval = SIGN(v->val.fval);
    1054             :                 break;
    1055          93 :         case TYPE_dbl:
    1056          93 :                 if (is_dbl_nil(v->val.dval))
    1057           0 :                         ret->val.btval = bte_nil;
    1058             :                 else
    1059          93 :                         ret->val.btval = SIGN(v->val.dval);
    1060             :                 break;
    1061           0 :         default:
    1062           0 :                 GDKerror("bad input type %s.\n",
    1063             :                          ATOMname(v->vtype));
    1064           0 :                 return GDK_FAIL;
    1065             :         }
    1066             :         return GDK_SUCCEED;
    1067             : }
    1068             : 
    1069             : /* ---------------------------------------------------------------------- */
    1070             : /* is the value nil (any type) */
    1071             : 
    1072             : #define ISNIL_TYPE(TYPE, NOTNIL)                                        \
    1073             :         do {                                                            \
    1074             :                 const TYPE *restrict src = (const TYPE *) bi.base;      \
    1075             :                 for (i = 0; i < ncand; i++) {                                \
    1076             :                         x = canditer_next(&ci) - bhseqbase;         \
    1077             :                         dst[i] = (bit) (is_##TYPE##_nil(src[x]) ^ NOTNIL); \
    1078             :                 }                                                       \
    1079             :         } while (0)
    1080             : 
    1081             : static BAT *
    1082        6703 : BATcalcisnil_implementation(BAT *b, BAT *s, bool notnil)
    1083             : {
    1084             :         lng t0 = 0;
    1085             :         BAT *bn;
    1086             :         BUN i, ncand;
    1087             :         oid x;
    1088             :         struct canditer ci;
    1089             :         bit *restrict dst;
    1090             :         BUN nils = 0;
    1091             :         oid bhseqbase;
    1092             : 
    1093        6703 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    1094             : 
    1095        6703 :         BATcheck(b, NULL);
    1096             : 
    1097        6703 :         bhseqbase = b->hseqbase;
    1098        6703 :         ncand = canditer_init(&ci, b, s);
    1099             : 
    1100        6696 :         if (b->tnonil || BATtdense(b)) {
    1101        1579 :                 return BATconstant(ci.hseq, TYPE_bit, &(bit){notnil},
    1102             :                                    ncand, TRANSIENT);
    1103        5117 :         } else if (b->ttype == TYPE_void) {
    1104             :                 /* non-nil handled above */
    1105           0 :                 assert(is_oid_nil(b->tseqbase));
    1106           0 :                 return BATconstant(ci.hseq, TYPE_bit, &(bit){!notnil},
    1107             :                                    ncand, TRANSIENT);
    1108             :         }
    1109             : 
    1110        5117 :         bn = COLnew(ci.hseq, TYPE_bit, ncand, TRANSIENT);
    1111        5134 :         if (bn == NULL)
    1112             :                 return NULL;
    1113             : 
    1114        5134 :         dst = (bit *) Tloc(bn, 0);
    1115             : 
    1116        5134 :         BATiter bi = bat_iterator(b);
    1117       10175 :         switch (ATOMbasetype(b->ttype)) {
    1118          82 :         case TYPE_bte:
    1119     4000769 :                 ISNIL_TYPE(bte, notnil);
    1120             :                 break;
    1121          34 :         case TYPE_sht:
    1122     4000040 :                 ISNIL_TYPE(sht, notnil);
    1123             :                 break;
    1124        2966 :         case TYPE_int:
    1125     7306693 :                 ISNIL_TYPE(int, notnil);
    1126             :                 break;
    1127        1871 :         case TYPE_lng:
    1128    19533899 :                 ISNIL_TYPE(lng, notnil);
    1129             :                 break;
    1130             : #ifdef HAVE_HGE
    1131          25 :         case TYPE_hge:
    1132     2069017 :                 ISNIL_TYPE(hge, notnil);
    1133             :                 break;
    1134             : #endif
    1135           5 :         case TYPE_flt:
    1136          20 :                 ISNIL_TYPE(flt, notnil);
    1137             :                 break;
    1138          18 :         case TYPE_dbl:
    1139         268 :                 ISNIL_TYPE(dbl, notnil);
    1140             :                 break;
    1141           1 :         case TYPE_uuid:
    1142           4 :                 ISNIL_TYPE(uuid, notnil);
    1143             :                 break;
    1144         114 :         default:
    1145             :         {
    1146         114 :                 int (*atomcmp)(const void *, const void *) = ATOMcompare(b->ttype);
    1147         114 :                 const void *nil = ATOMnilptr(b->ttype);
    1148             : 
    1149       19861 :                 for (i = 0; i < ncand; i++) {
    1150       19744 :                         x = canditer_next(&ci) - bhseqbase;
    1151       19744 :                         dst[i] = (bit) (((*atomcmp)(BUNtail(bi, x), nil) == 0) ^ notnil);
    1152             :                 }
    1153             :                 break;
    1154             :         }
    1155             :         }
    1156        5133 :         bat_iterator_end(&bi);
    1157             : 
    1158        5138 :         BATsetcount(bn, ncand);
    1159             : 
    1160             :         /* If b sorted, all nils are at the start, i.e. bn starts with
    1161             :          * 1's and ends with 0's, hence bn is revsorted.  Similarly
    1162             :          * for revsorted. At the notnil case, these properties remain the same */
    1163        5140 :         if (notnil) {
    1164        3099 :                 bn->tsorted = b->tsorted;
    1165        3099 :                 bn->trevsorted = b->trevsorted;
    1166             :         } else {
    1167        2041 :                 bn->tsorted = b->trevsorted;
    1168        2041 :                 bn->trevsorted = b->tsorted;
    1169             :         }
    1170        5140 :         bn->tnil = nils != 0;
    1171        5140 :         bn->tnonil = nils == 0;
    1172        5140 :         bn->tkey = ncand <= 1;
    1173             : 
    1174        5140 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
    1175             :                   ",notnil=%s -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    1176             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
    1177             :                   notnil ? "true" : "false", ALGOOPTBATPAR(bn), GDKusec() - t0);
    1178             : 
    1179             :         return bn;
    1180             : }
    1181             : 
    1182             : BAT *
    1183        2636 : BATcalcisnil(BAT *b, BAT *s)
    1184             : {
    1185        2636 :         return BATcalcisnil_implementation(b, s, false);
    1186             : }
    1187             : 
    1188             : BAT *
    1189        4075 : BATcalcisnotnil(BAT *b, BAT *s)
    1190             : {
    1191        4075 :         return BATcalcisnil_implementation(b, s, true);
    1192             : }
    1193             : 
    1194             : gdk_return
    1195      446241 : VARcalcisnil(ValPtr ret, const ValRecord *v)
    1196             : {
    1197      446241 :         ret->vtype = TYPE_bit;
    1198      446241 :         ret->val.btval = (bit) VALisnil(v);
    1199      446241 :         return GDK_SUCCEED;
    1200             : }
    1201             : 
    1202             : gdk_return
    1203         272 : VARcalcisnotnil(ValPtr ret, const ValRecord *v)
    1204             : {
    1205         272 :         ret->vtype = TYPE_bit;
    1206         272 :         ret->val.btval = (bit) !VALisnil(v);
    1207         272 :         return GDK_SUCCEED;
    1208             : }
    1209             : 
    1210             : #define MINMAX_TYPE(TYPE, OP)                                           \
    1211             :         do {                                                            \
    1212             :                 TYPE *tb1 = b1i.base, *tb2 = b2i.base, *restrict tbn = Tloc(bn, 0); \
    1213             :                 if (ci1.tpe == cand_dense && ci2.tpe == cand_dense) {   \
    1214             :                         for (BUN i = 0; i < ncand; i++) {            \
    1215             :                                 oid x1 = canditer_next_dense(&ci1) - b1hseqbase; \
    1216             :                                 oid x2 = canditer_next_dense(&ci2) - b2hseqbase; \
    1217             :                                 TYPE p1 = tb1[x1], p2 = tb2[x2];        \
    1218             :                                 if (is_##TYPE##_nil(p1) || is_##TYPE##_nil(p2)) { \
    1219             :                                         nils = true;                    \
    1220             :                                         tbn[i] = TYPE##_nil;            \
    1221             :                                 } else {                                \
    1222             :                                         tbn[i] = p1 OP p2 ? p1 : p2;    \
    1223             :                                 }                                       \
    1224             :                         }                                               \
    1225             :                 } else {                                                \
    1226             :                         for (BUN i = 0; i < ncand; i++) {            \
    1227             :                                 oid x1 = canditer_next(&ci1) - b1hseqbase; \
    1228             :                                 oid x2 = canditer_next(&ci2) - b2hseqbase; \
    1229             :                                 TYPE p1 = tb1[x1], p2 = tb2[x2];        \
    1230             :                                 if (is_##TYPE##_nil(p1) || is_##TYPE##_nil(p2)) { \
    1231             :                                         nils = true;                    \
    1232             :                                         tbn[i] = TYPE##_nil;            \
    1233             :                                 } else {                                \
    1234             :                                         tbn[i] = p1 OP p2 ? p1 : p2;    \
    1235             :                                 }                                       \
    1236             :                         }                                               \
    1237             :                 }                                                       \
    1238             :         } while (0)
    1239             : 
    1240             : BAT *
    1241         404 : BATcalcmin(BAT *b1, BAT *b2, BAT *s1, BAT *s2)
    1242             : {
    1243             :         lng t0 = 0;
    1244             :         BAT *bn;
    1245             :         bool nils = false;
    1246             :         BUN ncand;
    1247             :         struct canditer ci1, ci2;
    1248             :         oid b1hseqbase, b2hseqbase;
    1249             : 
    1250         404 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    1251             : 
    1252         404 :         BATcheck(b1, NULL);
    1253         404 :         BATcheck(b2, NULL);
    1254             : 
    1255         404 :         b1hseqbase = b1->hseqbase;
    1256         404 :         b2hseqbase = b2->hseqbase;
    1257        1212 :         if (ATOMtype(b1->ttype) != ATOMtype(b2->ttype)) {
    1258           0 :                 GDKerror("inputs have incompatible types\n");
    1259           0 :                 return NULL;
    1260             :         }
    1261             : 
    1262         404 :         ncand = canditer_init(&ci1, b1, s1);
    1263         404 :         if (canditer_init(&ci2, b2, s2) != ncand || ci1.hseq != ci2.hseq) {
    1264           0 :                 GDKerror("inputs not the same size.\n");
    1265           0 :                 return NULL;
    1266             :         }
    1267             : 
    1268         808 :         bn = COLnew(ci1.hseq, ATOMtype(b1->ttype), ncand, TRANSIENT);
    1269         404 :         if (bn == NULL)
    1270             :                 return NULL;
    1271             : 
    1272         404 :         BATiter b1i = bat_iterator(b1);
    1273         404 :         BATiter b2i = bat_iterator(b2);
    1274         804 :         switch (ATOMbasetype(b1->ttype)) {
    1275           1 :         case TYPE_bte:
    1276           2 :                 MINMAX_TYPE(bte, <);
    1277             :                 break;
    1278           0 :         case TYPE_sht:
    1279           0 :                 MINMAX_TYPE(sht, <);
    1280             :                 break;
    1281          16 :         case TYPE_int:
    1282          44 :                 MINMAX_TYPE(int, <);
    1283             :                 break;
    1284         387 :         case TYPE_lng:
    1285       32191 :                 MINMAX_TYPE(lng, <);
    1286             :                 break;
    1287             : #ifdef HAVE_HGE
    1288           0 :         case TYPE_hge:
    1289           0 :                 MINMAX_TYPE(hge, <);
    1290             :                 break;
    1291             : #endif
    1292           0 :         case TYPE_flt:
    1293           0 :                 MINMAX_TYPE(flt, <);
    1294             :                 break;
    1295           0 :         case TYPE_dbl:
    1296           0 :                 MINMAX_TYPE(dbl, <);
    1297             :                 break;
    1298           0 :         default: {
    1299           0 :                 const void *restrict nil = ATOMnilptr(b1->ttype);
    1300           0 :                 int (*cmp)(const void *, const void *) = ATOMcompare(b1->ttype);
    1301             : 
    1302           0 :                 if (ATOMvarsized(b1->ttype)) {
    1303           0 :                         if (ci1.tpe == cand_dense && ci2.tpe == cand_dense) {
    1304           0 :                                 for (BUN i = 0; i < ncand; i++) {
    1305           0 :                                         oid x1 = canditer_next_dense(&ci1) - b1hseqbase;
    1306           0 :                                         oid x2 = canditer_next_dense(&ci2) - b2hseqbase;
    1307           0 :                                         const void *p1 = BUNtvar(b1i, x1);
    1308           0 :                                         const void *p2 = BUNtvar(b2i, x2);
    1309           0 :                                         if (cmp(p1, nil) == 0 || cmp(p2, nil) == 0) {
    1310             :                                                 nils = true;
    1311             :                                                 p1 = nil;
    1312             :                                         } else {
    1313           0 :                                                 p1 = cmp(p1, p2) < 0 ? p1 : p2;
    1314             :                                         }
    1315           0 :                                         if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    1316           0 :                                                 goto bunins_failed;
    1317             :                                         }
    1318             :                                 }
    1319             :                         } else {
    1320           0 :                                 for (BUN i = 0; i < ncand; i++) {
    1321           0 :                                         oid x1 = canditer_next(&ci1) - b1hseqbase;
    1322           0 :                                         oid x2 = canditer_next(&ci2) - b2hseqbase;
    1323           0 :                                         const void *p1 = BUNtvar(b1i, x1);
    1324           0 :                                         const void *p2 = BUNtvar(b2i, x2);
    1325           0 :                                         if (cmp(p1, nil) == 0 || cmp(p2, nil) == 0) {
    1326             :                                                 nils = true;
    1327             :                                                 p1 = nil;
    1328             :                                         } else {
    1329           0 :                                                 p1 = cmp(p1, p2) < 0 ? p1 : p2;
    1330             :                                         }
    1331           0 :                                         if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    1332           0 :                                                 goto bunins_failed;
    1333             :                                         }
    1334             :                                 }
    1335             :                         }
    1336             :                 } else {
    1337           0 :                         uint8_t *restrict bcast = (uint8_t *) Tloc(bn, 0);
    1338           0 :                         uint16_t width = bn->twidth;
    1339           0 :                         if (ci1.tpe == cand_dense && ci2.tpe == cand_dense) {
    1340           0 :                                 for (BUN i = 0; i < ncand; i++) {
    1341           0 :                                         oid x1 = canditer_next_dense(&ci1) - b1hseqbase;
    1342           0 :                                         oid x2 = canditer_next_dense(&ci2) - b2hseqbase;
    1343           0 :                                         const void *p1 = BUNtloc(b1i, x1);
    1344           0 :                                         const void *p2 = BUNtloc(b2i, x2);
    1345           0 :                                         if (cmp(p1, nil) == 0 || cmp(p2, nil) == 0) {
    1346             :                                                 nils = true;
    1347             :                                                 p1 = nil;
    1348             :                                         } else {
    1349           0 :                                                 p1 = cmp(p1, p2) < 0 ? p1 : p2;
    1350             :                                         }
    1351           0 :                                         memcpy(bcast, p1, width);
    1352           0 :                                         bcast += width;
    1353             :                                 }
    1354             :                         } else {
    1355           0 :                                 for (BUN i = 0; i < ncand; i++) {
    1356           0 :                                         oid x1 = canditer_next(&ci1) - b1hseqbase;
    1357           0 :                                         oid x2 = canditer_next(&ci2) - b2hseqbase;
    1358           0 :                                         const void *p1 = BUNtloc(b1i, x1);
    1359           0 :                                         const void *p2 = BUNtloc(b2i, x2);
    1360           0 :                                         if (cmp(p1, nil) == 0 || cmp(p2, nil) == 0) {
    1361             :                                                 nils = true;
    1362             :                                                 p1 = nil;
    1363             :                                         } else {
    1364           0 :                                                 p1 = cmp(p1, p2) < 0 ? p1 : p2;
    1365             :                                         }
    1366           0 :                                         memcpy(bcast, p1, width);
    1367           0 :                                         bcast += width;
    1368             :                                 }
    1369             :                         }
    1370             :                 }
    1371             :         }
    1372             :         }
    1373         404 :         bat_iterator_end(&b1i);
    1374         404 :         bat_iterator_end(&b2i);
    1375             : 
    1376         404 :         bn->tnil = nils;
    1377         404 :         bn->tnonil = !nils;
    1378         404 :         BATsetcount(bn, ncand);
    1379         404 :         if (ncand <= 1) {
    1380         315 :                 bn->tsorted = true;
    1381         315 :                 bn->trevsorted = true;
    1382         315 :                 bn->tkey = true;
    1383         315 :                 bn->tseqbase = ATOMtype(b1->ttype) == TYPE_oid ? ncand == 1 ? *(oid*)Tloc(bn,0) : 0 : oid_nil;
    1384             :         } else {
    1385          89 :                 bn->tsorted = false;
    1386          89 :                 bn->trevsorted = false;
    1387          89 :                 bn->tkey = false;
    1388          89 :                 bn->tseqbase = oid_nil;
    1389             :         }
    1390             : 
    1391         404 :         TRC_DEBUG(ALGO, "b1=" ALGOBATFMT ",b2=" ALGOBATFMT
    1392             :                   ",s1=" ALGOOPTBATFMT ",s2=" ALGOOPTBATFMT
    1393             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    1394             :                   ALGOBATPAR(b1), ALGOBATPAR(b2),
    1395             :                   ALGOOPTBATPAR(s1), ALGOOPTBATPAR(s2),
    1396             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    1397             : 
    1398             :         return bn;
    1399           0 :   bunins_failed:
    1400           0 :         bat_iterator_end(&b1i);
    1401           0 :         bat_iterator_end(&b2i);
    1402           0 :         BBPreclaim(bn);
    1403           0 :         return NULL;
    1404             : }
    1405             : 
    1406             : #define MINMAX_NONIL_TYPE(TYPE, OP)                                     \
    1407             :         do {                                                            \
    1408             :                 TYPE *tb1 = b1i.base, *tb2 = b2i.base, *restrict tbn = Tloc(bn, 0); \
    1409             :                 if (ci1.tpe == cand_dense && ci2.tpe == cand_dense) {   \
    1410             :                         for (BUN i = 0; i < ncand; i++) {            \
    1411             :                                 oid x1 = canditer_next_dense(&ci1) - b1hseqbase; \
    1412             :                                 oid x2 = canditer_next_dense(&ci2) - b2hseqbase; \
    1413             :                                 TYPE p1 = tb1[x1], p2 = tb2[x2];        \
    1414             :                                 if (is_##TYPE##_nil(p1)) {              \
    1415             :                                         if (is_##TYPE##_nil(p2)) {      \
    1416             :                                                 tbn[i] = TYPE##_nil;    \
    1417             :                                                 nils = true;            \
    1418             :                                         } else {                        \
    1419             :                                                 tbn[i] = p2;            \
    1420             :                                         }                               \
    1421             :                                 } else {                                \
    1422             :                                         tbn[i] = !is_##TYPE##_nil(p2) && p2 OP p1 ? p2 : p1; \
    1423             :                                 }                                       \
    1424             :                         }                                               \
    1425             :                 } else {                                                \
    1426             :                         for (BUN i = 0; i < ncand; i++) {            \
    1427             :                                 oid x1 = canditer_next(&ci1) - b1hseqbase; \
    1428             :                                 oid x2 = canditer_next(&ci2) - b2hseqbase; \
    1429             :                                 TYPE p1 = tb1[x1], p2 = tb2[x2];        \
    1430             :                                 if (is_##TYPE##_nil(p1)) {              \
    1431             :                                         if (is_##TYPE##_nil(p2)) {      \
    1432             :                                                 tbn[i] = TYPE##_nil;    \
    1433             :                                                 nils = true;            \
    1434             :                                         } else {                        \
    1435             :                                                 tbn[i] = p2;            \
    1436             :                                         }                               \
    1437             :                                 } else {                                \
    1438             :                                         tbn[i] = !is_##TYPE##_nil(p2) && p2 OP p1 ? p2 : p1; \
    1439             :                                 }                                       \
    1440             :                         }                                               \
    1441             :                 }                                                       \
    1442             :         } while (0)
    1443             : 
    1444             : BAT *
    1445          22 : BATcalcmin_no_nil(BAT *b1, BAT *b2, BAT *s1, BAT *s2)
    1446             : {
    1447             :         lng t0 = 0;
    1448             :         BAT *bn;
    1449             :         bool nils = false;
    1450             :         BUN ncand;
    1451             :         struct canditer ci1, ci2;
    1452             :         oid b1hseqbase, b2hseqbase;
    1453             : 
    1454          22 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    1455             : 
    1456          22 :         BATcheck(b1, NULL);
    1457          22 :         BATcheck(b2, NULL);
    1458             : 
    1459          22 :         b1hseqbase = b1->hseqbase;
    1460          22 :         b2hseqbase = b2->hseqbase;
    1461          66 :         if (ATOMtype(b1->ttype) != ATOMtype(b2->ttype)) {
    1462           0 :                 GDKerror("inputs have incompatible types\n");
    1463           0 :                 return NULL;
    1464             :         }
    1465             : 
    1466          22 :         ncand = canditer_init(&ci1, b1, s1);
    1467          22 :         if (canditer_init(&ci2, b2, s2) != ncand || ci1.hseq != ci2.hseq) {
    1468           0 :                 GDKerror("inputs not the same size.\n");
    1469           0 :                 return NULL;
    1470             :         }
    1471             : 
    1472          44 :         bn = COLnew(ci1.hseq, ATOMtype(b1->ttype), ncand, TRANSIENT);
    1473          22 :         if (bn == NULL)
    1474             :                 return NULL;
    1475             : 
    1476          22 :         BATiter b1i = bat_iterator(b1);
    1477          22 :         BATiter b2i = bat_iterator(b2);
    1478          36 :         switch (ATOMbasetype(b1->ttype)) {
    1479          12 :         case TYPE_bte:
    1480         757 :                 MINMAX_NONIL_TYPE(bte, <);
    1481             :                 break;
    1482           3 :         case TYPE_sht:
    1483         210 :                 MINMAX_NONIL_TYPE(sht, <);
    1484             :                 break;
    1485           0 :         case TYPE_int:
    1486           0 :                 MINMAX_NONIL_TYPE(int, <);
    1487             :                 break;
    1488           2 :         case TYPE_lng:
    1489         190 :                 MINMAX_NONIL_TYPE(lng, <);
    1490             :                 break;
    1491             : #ifdef HAVE_HGE
    1492           0 :         case TYPE_hge:
    1493           0 :                 MINMAX_NONIL_TYPE(hge, <);
    1494             :                 break;
    1495             : #endif
    1496           0 :         case TYPE_flt:
    1497           0 :                 MINMAX_NONIL_TYPE(flt, <);
    1498             :                 break;
    1499           0 :         case TYPE_dbl:
    1500           0 :                 MINMAX_NONIL_TYPE(dbl, <);
    1501             :                 break;
    1502           5 :         default: {
    1503           5 :                 const void *restrict nil = ATOMnilptr(b1->ttype);
    1504           5 :                 int (*cmp)(const void *, const void *) = ATOMcompare(b1->ttype);
    1505             : 
    1506           5 :                 if (ATOMvarsized(b1->ttype)) {
    1507           5 :                         if (ci1.tpe == cand_dense && ci2.tpe == cand_dense) {
    1508         227 :                                 for (BUN i = 0; i < ncand; i++) {
    1509         222 :                                         oid x1 = canditer_next_dense(&ci1) - b1hseqbase;
    1510         222 :                                         oid x2 = canditer_next_dense(&ci2) - b2hseqbase;
    1511         222 :                                         const void *p1 = BUNtvar(b1i, x1);
    1512         222 :                                         const void *p2 = BUNtvar(b2i, x2);
    1513         222 :                                         if (cmp(p1, nil) == 0) {
    1514          96 :                                                 if (cmp(p2, nil) == 0) {
    1515             :                                                         /* both values are nil */
    1516             :                                                         nils = true;
    1517             :                                                 } else {
    1518             :                                                         p1 = p2;
    1519             :                                                 }
    1520             :                                         } else {
    1521         126 :                                                 p1 = cmp(p2, nil) != 0 && cmp(p2, p1) < 0 ? p2 : p1;
    1522             :                                         }
    1523         222 :                                         if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    1524           0 :                                                 goto bunins_failed;
    1525             :                                         }
    1526             :                                 }
    1527             :                         } else {
    1528           0 :                                 for (BUN i = 0; i < ncand; i++) {
    1529           0 :                                         oid x1 = canditer_next(&ci1) - b1hseqbase;
    1530           0 :                                         oid x2 = canditer_next(&ci2) - b2hseqbase;
    1531           0 :                                         const void *p1 = BUNtvar(b1i, x1);
    1532           0 :                                         const void *p2 = BUNtvar(b2i, x2);
    1533           0 :                                         if (cmp(p1, nil) == 0) {
    1534           0 :                                                 if (cmp(p2, nil) == 0) {
    1535             :                                                         /* both values are nil */
    1536             :                                                         nils = true;
    1537             :                                                 } else {
    1538             :                                                         p1 = p2;
    1539             :                                                 }
    1540             :                                         } else {
    1541           0 :                                                 p1 = cmp(p2, nil) != 0 && cmp(p2, p1) < 0 ? p2 : p1;
    1542             :                                         }
    1543           0 :                                         if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    1544           0 :                                                 goto bunins_failed;
    1545             :                                         }
    1546             :                                 }
    1547             :                         }
    1548             :                 } else {
    1549           0 :                         uint8_t *restrict bcast = (uint8_t *) Tloc(bn, 0);
    1550           0 :                         uint16_t width = bn->twidth;
    1551           0 :                         if (ci1.tpe == cand_dense && ci2.tpe == cand_dense) {
    1552           0 :                                 for (BUN i = 0; i < ncand; i++) {
    1553           0 :                                         oid x1 = canditer_next_dense(&ci1) - b1hseqbase;
    1554           0 :                                         oid x2 = canditer_next_dense(&ci2) - b2hseqbase;
    1555           0 :                                         const void *p1 = BUNtloc(b1i, x1);
    1556           0 :                                         const void *p2 = BUNtloc(b2i, x2);
    1557           0 :                                         if (cmp(p1, nil) == 0) {
    1558           0 :                                                 if (cmp(p2, nil) == 0) {
    1559             :                                                         /* both values are nil */
    1560             :                                                         nils = true;
    1561             :                                                 } else {
    1562             :                                                         p1 = p2;
    1563             :                                                 }
    1564             :                                         } else {
    1565           0 :                                                 p1 = cmp(p2, nil) != 0 && cmp(p2, p1) < 0 ? p2 : p1;
    1566             :                                         }
    1567           0 :                                         memcpy(bcast, p1, width);
    1568           0 :                                         bcast += width;
    1569             :                                 }
    1570             :                         } else {
    1571           0 :                                 for (BUN i = 0; i < ncand; i++) {
    1572           0 :                                         oid x1 = canditer_next(&ci1) - b1hseqbase;
    1573           0 :                                         oid x2 = canditer_next(&ci2) - b2hseqbase;
    1574           0 :                                         const void *p1 = BUNtloc(b1i, x1);
    1575           0 :                                         const void *p2 = BUNtloc(b2i, x2);
    1576           0 :                                         if (cmp(p1, nil) == 0) {
    1577           0 :                                                 if (cmp(p2, nil) == 0) {
    1578             :                                                         /* both values are nil */
    1579             :                                                         nils = true;
    1580             :                                                 } else {
    1581             :                                                         p1 = p2;
    1582             :                                                 }
    1583             :                                         } else {
    1584           0 :                                                 p1 = cmp(p2, nil) != 0 && cmp(p2, p1) < 0 ? p2 : p1;
    1585             :                                         }
    1586           0 :                                         memcpy(bcast, p1, width);
    1587           0 :                                         bcast += width;
    1588             :                                 }
    1589             :                         }
    1590             :                 }
    1591             :         }
    1592             :         }
    1593          22 :         bat_iterator_end(&b1i);
    1594          22 :         bat_iterator_end(&b2i);
    1595             : 
    1596          22 :         bn->tnil = nils;
    1597          22 :         bn->tnonil = !nils;
    1598          22 :         BATsetcount(bn, ncand);
    1599          22 :         if (ncand <= 1) {
    1600           0 :                 bn->tsorted = true;
    1601           0 :                 bn->trevsorted = true;
    1602           0 :                 bn->tkey = true;
    1603           0 :                 bn->tseqbase = ATOMtype(b1->ttype) == TYPE_oid ? ncand == 1 ? *(oid*)Tloc(bn,0) : 0 : oid_nil;
    1604             :         } else {
    1605          22 :                 bn->tsorted = false;
    1606          22 :                 bn->trevsorted = false;
    1607          22 :                 bn->tkey = false;
    1608          22 :                 bn->tseqbase = oid_nil;
    1609             :         }
    1610             : 
    1611          22 :         TRC_DEBUG(ALGO, "b1=" ALGOBATFMT ",b2=" ALGOBATFMT
    1612             :                   ",s1=" ALGOOPTBATFMT ",s2=" ALGOOPTBATFMT
    1613             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    1614             :                   ALGOBATPAR(b1), ALGOBATPAR(b2),
    1615             :                   ALGOOPTBATPAR(s1), ALGOOPTBATPAR(s2),
    1616             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    1617             : 
    1618             :         return bn;
    1619           0 :   bunins_failed:
    1620           0 :         bat_iterator_end(&b1i);
    1621           0 :         bat_iterator_end(&b2i);
    1622           0 :         BBPreclaim(bn);
    1623           0 :         return NULL;
    1624             : }
    1625             : 
    1626             : #define MINMAX_CST_TYPE(TYPE, OP)                                       \
    1627             :         do {                                                            \
    1628             :                 TYPE *restrict tb = bi.base, *restrict tbn = Tloc(bn, 0), pp2 = *(TYPE*) p2; \
    1629             :                 for (BUN i = 0; i < ncand; i++) {                    \
    1630             :                         oid x = canditer_next(&ci) - bhseqbase;             \
    1631             :                         TYPE p1 = tb[x];                                \
    1632             :                         if (is_##TYPE##_nil(p1)) {                      \
    1633             :                                 nils = true;                            \
    1634             :                                 tbn[i] = TYPE##_nil;                    \
    1635             :                         } else {                                        \
    1636             :                                 tbn[i] = p1 OP pp2 ? p1 : pp2;          \
    1637             :                         }                                               \
    1638             :                 }                                                       \
    1639             :         } while (0)
    1640             : 
    1641             : BAT *
    1642           5 : BATcalcmincst(BAT *b, const ValRecord *v, BAT *s)
    1643             : {
    1644             :         lng t0 = 0;
    1645             :         BAT *bn;
    1646             :         bool nils = false;
    1647             :         BUN ncand;
    1648             :         struct canditer ci;
    1649             :         const void *p2;
    1650             :         const void *restrict nil;
    1651             :         int (*cmp)(const void *, const void *);
    1652             :         oid bhseqbase;
    1653             : 
    1654           5 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    1655             : 
    1656           5 :         BATcheck(b, NULL);
    1657             : 
    1658           5 :         nil = ATOMnilptr(b->ttype);
    1659           5 :         cmp = ATOMcompare(b->ttype);
    1660           5 :         bhseqbase = b->hseqbase;
    1661          10 :         if (ATOMtype(b->ttype) != v->vtype) {
    1662           0 :                 GDKerror("inputs have incompatible types\n");
    1663           0 :                 return NULL;
    1664             :         }
    1665             : 
    1666           5 :         ncand = canditer_init(&ci, b, s);
    1667           5 :         p2 = VALptr(v);
    1668           7 :         if (ncand == 0 ||
    1669           2 :                 cmp(p2, nil) == 0 ||
    1670           2 :                 (b->ttype == TYPE_void && is_oid_nil(b->tseqbase)))
    1671           3 :                 return BATconstantV(ci.hseq, b->ttype, nil, ncand, TRANSIENT);
    1672             : 
    1673           4 :         bn = COLnew(ci.hseq, ATOMtype(b->ttype), ncand, TRANSIENT);
    1674           2 :         if (bn == NULL)
    1675             :                 return NULL;
    1676             : 
    1677           2 :         BATiter bi = bat_iterator(b);
    1678           4 :         switch (ATOMbasetype(b->ttype)) {
    1679           0 :         case TYPE_bte:
    1680           0 :                 MINMAX_CST_TYPE(bte, <);
    1681             :                 break;
    1682           0 :         case TYPE_sht:
    1683           0 :                 MINMAX_CST_TYPE(sht, <);
    1684             :                 break;
    1685           0 :         case TYPE_int:
    1686           0 :                 MINMAX_CST_TYPE(int, <);
    1687             :                 break;
    1688           0 :         case TYPE_lng:
    1689           0 :                 MINMAX_CST_TYPE(lng, <);
    1690             :                 break;
    1691             : #ifdef HAVE_HGE
    1692           0 :         case TYPE_hge:
    1693           0 :                 MINMAX_CST_TYPE(hge, <);
    1694             :                 break;
    1695             : #endif
    1696           0 :         case TYPE_flt:
    1697           0 :                 MINMAX_CST_TYPE(flt, <);
    1698             :                 break;
    1699           0 :         case TYPE_dbl:
    1700           0 :                 MINMAX_CST_TYPE(dbl, <);
    1701             :                 break;
    1702           2 :         default:
    1703           2 :                 if (ATOMvarsized(b->ttype)) {
    1704           2 :                         for (BUN i = 0; i < ncand; i++) {
    1705           1 :                                 oid x = canditer_next(&ci) - bhseqbase;
    1706           1 :                                 const void *restrict p1 = BUNtvar(bi, x);
    1707           1 :                                 if (cmp(p1, nil) == 0) {
    1708             :                                         nils = true;
    1709             :                                         p1 = nil;
    1710             :                                 } else {
    1711           1 :                                         p1 = cmp(p1, p2) < 0 ? p1 : p2;
    1712             :                                 }
    1713           1 :                                 if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    1714           0 :                                         goto bunins_failed;
    1715             :                                 }
    1716             :                         }
    1717             :                 } else {
    1718           1 :                         uint8_t *restrict bcast = (uint8_t *) Tloc(bn, 0);
    1719           1 :                         uint16_t width = bn->twidth;
    1720           3 :                         for (BUN i = 0; i < ncand; i++) {
    1721           2 :                                 oid x = canditer_next(&ci) - bhseqbase;
    1722           2 :                                 const void *restrict p1 = BUNtloc(bi, x);
    1723           2 :                                 if (cmp(p1, nil) == 0) {
    1724             :                                         nils = true;
    1725             :                                         p1 = nil;
    1726             :                                 } else {
    1727           2 :                                         p1 = cmp(p1, p2) < 0 ? p1 : p2;
    1728             :                                 }
    1729           2 :                                 memcpy(bcast, p1, width);
    1730           2 :                                 bcast += width;
    1731             :                         }
    1732             :                 }
    1733             :         }
    1734           2 :         bat_iterator_end(&bi);
    1735             : 
    1736           2 :         bn->tnil = nils;
    1737           2 :         bn->tnonil = !nils;
    1738           2 :         BATsetcount(bn, ncand);
    1739           2 :         if (ncand <= 1) {
    1740           1 :                 bn->tsorted = true;
    1741           1 :                 bn->trevsorted = true;
    1742           1 :                 bn->tkey = true;
    1743           1 :                 bn->tseqbase = ATOMtype(bn->ttype) == TYPE_oid ? ncand == 1 ? *(oid*)Tloc(bn,0) : 0 : oid_nil;
    1744             :         } else {
    1745           1 :                 bn->tsorted = false;
    1746           1 :                 bn->trevsorted = false;
    1747           1 :                 bn->tkey = false;
    1748           1 :                 bn->tseqbase = oid_nil;
    1749             :         }
    1750             : 
    1751           2 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
    1752             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    1753             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
    1754             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    1755             : 
    1756             :         return bn;
    1757             :   bunins_failed:
    1758           0 :         bat_iterator_end(&bi);
    1759           0 :         BBPreclaim(bn);
    1760           0 :         return NULL;
    1761             : }
    1762             : 
    1763             : BAT *
    1764           3 : BATcalccstmin(const ValRecord *v, BAT *b, BAT *s)
    1765             : {
    1766           3 :         return BATcalcmincst(b, v, s);
    1767             : }
    1768             : 
    1769             : #define MINMAX_NONIL_CST_TYPE(TYPE, OP)                                 \
    1770             :         do {                                                            \
    1771             :                 TYPE *restrict tb = bi.base, *restrict tbn = Tloc(bn, 0), pp2 = *(TYPE*) p2; \
    1772             :                 if (is_##TYPE##_nil(pp2)) {                             \
    1773             :                         for (BUN i = 0; i < ncand; i++) {            \
    1774             :                                 oid x = canditer_next(&ci) - bhseqbase; \
    1775             :                                 TYPE p1 = tb[x];                        \
    1776             :                                 nils |= is_##TYPE##_nil(p1);            \
    1777             :                                 tbn[i] = p1;                            \
    1778             :                         }                                               \
    1779             :                 } else {                                                \
    1780             :                         for (BUN i = 0; i < ncand; i++) {            \
    1781             :                                 oid x = canditer_next(&ci) - bhseqbase; \
    1782             :                                 TYPE p1 = tb[x];                        \
    1783             :                                 if (is_##TYPE##_nil(p1)) {              \
    1784             :                                         tbn[i] = pp2;                   \
    1785             :                                 } else {                                \
    1786             :                                         tbn[i] = p1 OP pp2 ? p1 : pp2;  \
    1787             :                                 }                                       \
    1788             :                         }                                               \
    1789             :                 }                                                       \
    1790             :         } while (0)
    1791             : 
    1792             : BAT *
    1793          46 : BATcalcmincst_no_nil(BAT *b, const ValRecord *v, BAT *s)
    1794             : {
    1795             :         lng t0 = 0;
    1796             :         BAT *bn;
    1797             :         bool nils = false;
    1798             :         BUN ncand;
    1799             :         struct canditer ci;
    1800             :         const void *p2;
    1801             :         const void *restrict nil;
    1802             :         int (*cmp)(const void *, const void *);
    1803             :         oid bhseqbase;
    1804             : 
    1805          46 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    1806             : 
    1807          46 :         BATcheck(b, NULL);
    1808             : 
    1809          46 :         nil = ATOMnilptr(b->ttype);
    1810          46 :         cmp = ATOMcompare(b->ttype);
    1811          46 :         bhseqbase = b->hseqbase;
    1812          92 :         if (ATOMtype(b->ttype) != v->vtype) {
    1813           0 :                 GDKerror("inputs have incompatible types\n");
    1814           0 :                 return NULL;
    1815             :         }
    1816             : 
    1817          46 :         ncand = canditer_init(&ci, b, s);
    1818          46 :         if (ncand == 0)
    1819          10 :                 return BATconstantV(ci.hseq, b->ttype, nil, ncand, TRANSIENT);
    1820             : 
    1821          36 :         p2 = VALptr(v);
    1822          36 :         if (b->ttype == TYPE_void &&
    1823           0 :                 is_oid_nil(b->tseqbase) &&
    1824           0 :                 is_oid_nil(* (const oid *) p2))
    1825           0 :                 return BATconstant(ci.hseq, TYPE_void, &oid_nil, ncand, TRANSIENT);
    1826             : 
    1827          72 :         bn = COLnew(ci.hseq, ATOMtype(b->ttype), ncand, TRANSIENT);
    1828          36 :         if (bn == NULL)
    1829             :                 return NULL;
    1830             : 
    1831          36 :         BATiter bi = bat_iterator(b);
    1832          67 :         switch (ATOMbasetype(b->ttype)) {
    1833           5 :         case TYPE_bte:
    1834          39 :                 MINMAX_NONIL_CST_TYPE(bte, <);
    1835             :                 break;
    1836           0 :         case TYPE_sht:
    1837           0 :                 MINMAX_NONIL_CST_TYPE(sht, <);
    1838             :                 break;
    1839           9 :         case TYPE_int:
    1840         459 :                 MINMAX_NONIL_CST_TYPE(int, <);
    1841             :                 break;
    1842           2 :         case TYPE_lng:
    1843          38 :                 MINMAX_NONIL_CST_TYPE(lng, <);
    1844             :                 break;
    1845             : #ifdef HAVE_HGE
    1846           8 :         case TYPE_hge:
    1847          16 :                 MINMAX_NONIL_CST_TYPE(hge, <);
    1848             :                 break;
    1849             : #endif
    1850           0 :         case TYPE_flt:
    1851           0 :                 MINMAX_NONIL_CST_TYPE(flt, <);
    1852             :                 break;
    1853          11 :         case TYPE_dbl:
    1854          47 :                 MINMAX_NONIL_CST_TYPE(dbl, <);
    1855             :                 break;
    1856           1 :         default:
    1857           1 :                 if (ATOMvarsized(b->ttype)) {
    1858           1 :                         if (cmp(p2, nil) == 0) {
    1859           0 :                                 for (BUN i = 0; i < ncand; i++) {
    1860           0 :                                         oid x = canditer_next(&ci) - bhseqbase;
    1861           0 :                                         const void *restrict p1 = BUNtvar(bi, x);
    1862           0 :                                         nils |= cmp(p1, nil) == 0;
    1863           0 :                                         if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    1864           0 :                                                 goto bunins_failed;
    1865             :                                         }
    1866             :                                 }
    1867             :                         } else {
    1868          55 :                                 for (BUN i = 0; i < ncand; i++) {
    1869          54 :                                         oid x = canditer_next(&ci) - bhseqbase;
    1870          54 :                                         const void *restrict p1 = BUNtvar(bi, x);
    1871          54 :                                         p1 = cmp(p1, nil) == 0 || cmp(p2, p1) < 0 ? p2 : p1;
    1872          54 :                                         if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    1873           0 :                                                 goto bunins_failed;
    1874             :                                         }
    1875             :                                 }
    1876             :                         }
    1877             :                 } else {
    1878           0 :                         uint8_t *restrict bcast = (uint8_t *) Tloc(bn, 0);
    1879           0 :                         uint16_t width = bn->twidth;
    1880           0 :                         if (cmp(p2, nil) == 0) {
    1881           0 :                                 for (BUN i = 0; i < ncand; i++) {
    1882           0 :                                         oid x = canditer_next(&ci) - bhseqbase;
    1883           0 :                                         const void *restrict p1 = BUNtloc(bi, x);
    1884           0 :                                         nils |= cmp(p1, nil) == 0;
    1885           0 :                                         memcpy(bcast, p1, width);
    1886           0 :                                         bcast += width;
    1887             :                                 }
    1888             :                         } else {
    1889           0 :                                 for (BUN i = 0; i < ncand; i++) {
    1890           0 :                                         oid x = canditer_next(&ci) - bhseqbase;
    1891           0 :                                         const void *restrict p1 = BUNtloc(bi, x);
    1892           0 :                                         p1 = cmp(p1, nil) == 0 || cmp(p2, p1) < 0 ? p2 : p1;
    1893           0 :                                         memcpy(bcast, p1, width);
    1894           0 :                                         bcast += width;
    1895             :                                 }
    1896             :                         }
    1897             :                 }
    1898             :         }
    1899          36 :         bat_iterator_end(&bi);
    1900             : 
    1901          36 :         bn->tnil = nils;
    1902          36 :         bn->tnonil = !nils;
    1903          36 :         BATsetcount(bn, ncand);
    1904          36 :         if (ncand <= 1) {
    1905          16 :                 bn->tsorted = true;
    1906          16 :                 bn->trevsorted = true;
    1907          16 :                 bn->tkey = true;
    1908          16 :                 bn->tseqbase = ATOMtype(bn->ttype) == TYPE_oid ? ncand == 1 ? *(oid*)Tloc(bn,0) : 0 : oid_nil;
    1909             :         } else {
    1910          20 :                 bn->tsorted = false;
    1911          20 :                 bn->trevsorted = false;
    1912          20 :                 bn->tkey = false;
    1913          20 :                 bn->tseqbase = oid_nil;
    1914             :         }
    1915             : 
    1916          36 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
    1917             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    1918             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
    1919             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    1920             : 
    1921             :         return bn;
    1922           0 :   bunins_failed:
    1923           0 :         bat_iterator_end(&bi);
    1924           0 :         BBPreclaim(bn);
    1925           0 :         return NULL;
    1926             : }
    1927             : 
    1928             : BAT *
    1929          26 : BATcalccstmin_no_nil(const ValRecord *v, BAT *b, BAT *s)
    1930             : {
    1931          26 :         return BATcalcmincst_no_nil(b, v, s);
    1932             : }
    1933             : 
    1934             : BAT *
    1935           3 : BATcalcmax(BAT *b1, BAT *b2, BAT *s1, BAT *s2)
    1936             : {
    1937             :         lng t0 = 0;
    1938             :         BAT *bn;
    1939             :         bool nils = false;
    1940             :         BUN ncand;
    1941             :         struct canditer ci1, ci2;
    1942             :         oid b1hseqbase, b2hseqbase;
    1943             : 
    1944           3 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    1945             : 
    1946           3 :         BATcheck(b1, NULL);
    1947           3 :         BATcheck(b2, NULL);
    1948             : 
    1949           3 :         b1hseqbase = b1->hseqbase;
    1950           3 :         b2hseqbase = b2->hseqbase;
    1951           9 :         if (ATOMtype(b1->ttype) != ATOMtype(b2->ttype)) {
    1952           0 :                 GDKerror("inputs have incompatible types\n");
    1953           0 :                 return NULL;
    1954             :         }
    1955             : 
    1956           3 :         ncand = canditer_init(&ci1, b1, s1);
    1957           3 :         if (canditer_init(&ci2, b2, s2) != ncand || ci1.hseq != ci2.hseq) {
    1958           0 :                 GDKerror("inputs not the same size.\n");
    1959           0 :                 return NULL;
    1960             :         }
    1961             : 
    1962           6 :         bn = COLnew(ci1.hseq, ATOMtype(b1->ttype), ncand, TRANSIENT);
    1963           3 :         if (bn == NULL)
    1964             :                 return NULL;
    1965             : 
    1966           3 :         BATiter b1i = bat_iterator(b1);
    1967           3 :         BATiter b2i = bat_iterator(b2);
    1968           6 :         switch (ATOMbasetype(b1->ttype)) {
    1969           0 :         case TYPE_bte:
    1970           0 :                 MINMAX_TYPE(bte, >);
    1971             :                 break;
    1972           0 :         case TYPE_sht:
    1973           0 :                 MINMAX_TYPE(sht, >);
    1974             :                 break;
    1975           1 :         case TYPE_int:
    1976           8 :                 MINMAX_TYPE(int, >);
    1977             :                 break;
    1978           0 :         case TYPE_lng:
    1979           0 :                 MINMAX_TYPE(lng, >);
    1980             :                 break;
    1981             : #ifdef HAVE_HGE
    1982           0 :         case TYPE_hge:
    1983           0 :                 MINMAX_TYPE(hge, >);
    1984             :                 break;
    1985             : #endif
    1986           0 :         case TYPE_flt:
    1987           0 :                 MINMAX_TYPE(flt, >);
    1988             :                 break;
    1989           0 :         case TYPE_dbl:
    1990           0 :                 MINMAX_TYPE(dbl, >);
    1991             :                 break;
    1992           2 :         default: {
    1993           2 :                 const void *restrict nil = ATOMnilptr(b1->ttype);
    1994           2 :                 int (*cmp)(const void *, const void *) = ATOMcompare(b1->ttype);
    1995             : 
    1996           2 :                 if (ATOMvarsized(b1->ttype)) {
    1997           1 :                         if (ci1.tpe == cand_dense && ci2.tpe == cand_dense) {
    1998          64 :                                 for (BUN i = 0; i < ncand; i++) {
    1999          63 :                                         oid x1 = canditer_next_dense(&ci1) - b1hseqbase;
    2000          63 :                                         oid x2 = canditer_next_dense(&ci2) - b2hseqbase;
    2001          63 :                                         const void *p1 = BUNtvar(b1i, x1);
    2002          63 :                                         const void *p2 = BUNtvar(b2i, x2);
    2003          63 :                                         if (cmp(p1, nil) == 0 || cmp(p2, nil) == 0) {
    2004             :                                                 nils = true;
    2005             :                                                 p1 = nil;
    2006             :                                         } else {
    2007          21 :                                                 p1 = cmp(p1, p2) > 0 ? p1 : p2;
    2008             :                                         }
    2009          63 :                                         if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    2010           0 :                                                 goto bunins_failed;
    2011             :                                         }
    2012             :                                 }
    2013             :                         } else {
    2014           0 :                                 for (BUN i = 0; i < ncand; i++) {
    2015           0 :                                         oid x1 = canditer_next(&ci1) - b1hseqbase;
    2016           0 :                                         oid x2 = canditer_next(&ci2) - b2hseqbase;
    2017           0 :                                         const void *p1 = BUNtvar(b1i, x1);
    2018           0 :                                         const void *p2 = BUNtvar(b2i, x2);
    2019           0 :                                         if (cmp(p1, nil) == 0 || cmp(p2, nil) == 0) {
    2020             :                                                 nils = true;
    2021             :                                                 p1 = nil;
    2022             :                                         } else {
    2023           0 :                                                 p1 = cmp(p1, p2) > 0 ? p1 : p2;
    2024             :                                         }
    2025           0 :                                         if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    2026           0 :                                                 goto bunins_failed;
    2027             :                                         }
    2028             :                                 }
    2029             :                         }
    2030             :                 } else {
    2031           1 :                         uint8_t *restrict bcast = (uint8_t *) Tloc(bn, 0);
    2032           1 :                         uint16_t width = bn->twidth;
    2033           1 :                         if (ci1.tpe == cand_dense && ci2.tpe == cand_dense) {
    2034           3 :                                 for (BUN i = 0; i < ncand; i++) {
    2035           2 :                                         oid x1 = canditer_next_dense(&ci1) - b1hseqbase;
    2036           2 :                                         oid x2 = canditer_next_dense(&ci2) - b2hseqbase;
    2037           2 :                                         const void *p1 = BUNtloc(b1i, x1);
    2038           2 :                                         const void *p2 = BUNtloc(b2i, x2);
    2039           2 :                                         if (cmp(p1, nil) == 0 || cmp(p2, nil) == 0) {
    2040             :                                                 nils = true;
    2041             :                                                 p1 = nil;
    2042             :                                         } else {
    2043           2 :                                                 p1 = cmp(p1, p2) > 0 ? p1 : p2;
    2044             :                                         }
    2045           2 :                                         memcpy(bcast, p1, width);
    2046           2 :                                         bcast += width;
    2047             :                                 }
    2048             :                         } else {
    2049           0 :                                 for (BUN i = 0; i < ncand; i++) {
    2050           0 :                                         oid x1 = canditer_next(&ci1) - b1hseqbase;
    2051           0 :                                         oid x2 = canditer_next(&ci2) - b2hseqbase;
    2052           0 :                                         const void *p1 = BUNtloc(b1i, x1);
    2053           0 :                                         const void *p2 = BUNtloc(b2i, x2);
    2054           0 :                                         if (cmp(p1, nil) == 0 || cmp(p2, nil) == 0) {
    2055             :                                                 nils = true;
    2056             :                                                 p1 = nil;
    2057             :                                         } else {
    2058           0 :                                                 p1 = cmp(p1, p2) > 0 ? p1 : p2;
    2059             :                                         }
    2060           0 :                                         memcpy(bcast, p1, width);
    2061           0 :                                         bcast += width;
    2062             :                                 }
    2063             :                         }
    2064             :                 }
    2065             :         }
    2066             :         }
    2067           3 :         bat_iterator_end(&b1i);
    2068           3 :         bat_iterator_end(&b2i);
    2069             : 
    2070           3 :         bn->tnil = nils;
    2071           3 :         bn->tnonil = !nils;
    2072           3 :         BATsetcount(bn, ncand);
    2073           3 :         if (ncand <= 1) {
    2074           0 :                 bn->tsorted = true;
    2075           0 :                 bn->trevsorted = true;
    2076           0 :                 bn->tkey = true;
    2077           0 :                 bn->tseqbase = ATOMtype(b1->ttype) == TYPE_oid ? ncand == 1 ? *(oid*)Tloc(bn,0) : 0 : oid_nil;
    2078             :         } else {
    2079           3 :                 bn->tsorted = false;
    2080           3 :                 bn->trevsorted = false;
    2081           3 :                 bn->tkey = false;
    2082           3 :                 bn->tseqbase = oid_nil;
    2083             :         }
    2084             : 
    2085           3 :         TRC_DEBUG(ALGO, "b1=" ALGOBATFMT ",b2=" ALGOBATFMT
    2086             :                   ",s1=" ALGOOPTBATFMT ",s2=" ALGOOPTBATFMT
    2087             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    2088             :                   ALGOBATPAR(b1), ALGOBATPAR(b2),
    2089             :                   ALGOOPTBATPAR(s1), ALGOOPTBATPAR(s2),
    2090             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    2091             : 
    2092             :         return bn;
    2093           0 :   bunins_failed:
    2094           0 :         bat_iterator_end(&b1i);
    2095           0 :         bat_iterator_end(&b2i);
    2096           0 :         BBPreclaim(bn);
    2097           0 :         return NULL;
    2098             : }
    2099             : 
    2100             : BAT *
    2101          10 : BATcalcmax_no_nil(BAT *b1, BAT *b2, BAT *s1, BAT *s2)
    2102             : {
    2103             :         lng t0 = 0;
    2104             :         BAT *bn;
    2105             :         bool nils = false;
    2106             :         BUN ncand;
    2107             :         struct canditer ci1, ci2;
    2108             :         oid b1hseqbase, b2hseqbase;
    2109             : 
    2110          10 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    2111             : 
    2112          10 :         BATcheck(b1, NULL);
    2113          10 :         BATcheck(b2, NULL);
    2114             : 
    2115          10 :         b1hseqbase = b1->hseqbase;
    2116          10 :         b2hseqbase = b2->hseqbase;
    2117          30 :         if (ATOMtype(b1->ttype) != ATOMtype(b2->ttype)) {
    2118           0 :                 GDKerror("inputs have incompatible types\n");
    2119           0 :                 return NULL;
    2120             :         }
    2121             : 
    2122          10 :         ncand = canditer_init(&ci1, b1, s1);
    2123          10 :         if (canditer_init(&ci2, b2, s2) != ncand || ci1.hseq != ci2.hseq) {
    2124           0 :                 GDKerror("inputs not the same size.\n");
    2125           0 :                 return NULL;
    2126             :         }
    2127             : 
    2128          20 :         bn = COLnew(ci1.hseq, ATOMtype(b1->ttype), ncand, TRANSIENT);
    2129          10 :         if (bn == NULL)
    2130             :                 return NULL;
    2131             : 
    2132          10 :         BATiter b1i = bat_iterator(b1);
    2133          10 :         BATiter b2i = bat_iterator(b2);
    2134          20 :         switch (ATOMbasetype(b1->ttype)) {
    2135           0 :         case TYPE_bte:
    2136           0 :                 MINMAX_NONIL_TYPE(bte, >);
    2137             :                 break;
    2138           0 :         case TYPE_sht:
    2139           0 :                 MINMAX_NONIL_TYPE(sht, >);
    2140             :                 break;
    2141           3 :         case TYPE_int:
    2142           3 :                 MINMAX_NONIL_TYPE(int, >);
    2143             :                 break;
    2144           1 :         case TYPE_lng:
    2145           2 :                 MINMAX_NONIL_TYPE(lng, >);
    2146             :                 break;
    2147             : #ifdef HAVE_HGE
    2148           0 :         case TYPE_hge:
    2149           0 :                 MINMAX_NONIL_TYPE(hge, >);
    2150             :                 break;
    2151             : #endif
    2152           0 :         case TYPE_flt:
    2153           0 :                 MINMAX_NONIL_TYPE(flt, >);
    2154             :                 break;
    2155           2 :         case TYPE_dbl:
    2156        5122 :                 MINMAX_NONIL_TYPE(dbl, >);
    2157             :                 break;
    2158           4 :         default: {
    2159           4 :                 const void *restrict nil = ATOMnilptr(b1->ttype);
    2160           4 :                 int (*cmp)(const void *, const void *) = ATOMcompare(b1->ttype);
    2161             : 
    2162           4 :                 if (ATOMvarsized(b1->ttype)) {
    2163           4 :                         if (ci1.tpe == cand_dense && ci2.tpe == cand_dense) {
    2164          13 :                                 for (BUN i = 0; i < ncand; i++) {
    2165           9 :                                         oid x1 = canditer_next_dense(&ci1) - b1hseqbase;
    2166           9 :                                         oid x2 = canditer_next_dense(&ci2) - b2hseqbase;
    2167             :                                         const void *p1, *p2;
    2168           9 :                                         p1 = BUNtvar(b1i, x1);
    2169           9 :                                         p2 = BUNtvar(b2i, x2);
    2170           9 :                                         if (cmp(p1, nil) == 0) {
    2171           0 :                                                 if (cmp(p2, nil) == 0) {
    2172             :                                                         /* both values are nil */
    2173             :                                                         nils = true;
    2174             :                                                 } else {
    2175             :                                                         p1 = p2;
    2176             :                                                 }
    2177             :                                         } else {
    2178           9 :                                                 p1 = cmp(p2, nil) != 0 && cmp(p2, p1) > 0 ? p2 : p1;
    2179             :                                         }
    2180           9 :                                         if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    2181           0 :                                                 goto bunins_failed;
    2182             :                                         }
    2183             :                                 }
    2184             :                         } else {
    2185           0 :                                 for (BUN i = 0; i < ncand; i++) {
    2186           0 :                                         oid x1 = canditer_next(&ci1) - b1hseqbase;
    2187           0 :                                         oid x2 = canditer_next(&ci2) - b2hseqbase;
    2188             :                                         const void *p1, *p2;
    2189           0 :                                         p1 = BUNtvar(b1i, x1);
    2190           0 :                                         p2 = BUNtvar(b2i, x2);
    2191           0 :                                         if (cmp(p1, nil) == 0) {
    2192           0 :                                                 if (cmp(p2, nil) == 0) {
    2193             :                                                         /* both values are nil */
    2194             :                                                         nils = true;
    2195             :                                                 } else {
    2196             :                                                         p1 = p2;
    2197             :                                                 }
    2198             :                                         } else {
    2199           0 :                                                 p1 = cmp(p2, nil) != 0 && cmp(p2, p1) > 0 ? p2 : p1;
    2200             :                                         }
    2201           0 :                                         if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    2202           0 :                                                 goto bunins_failed;
    2203             :                                         }
    2204             :                                 }
    2205             :                         }
    2206             :                 } else {
    2207           0 :                         uint8_t *restrict bcast = (uint8_t *) Tloc(bn, 0);
    2208           0 :                         uint16_t width = bn->twidth;
    2209           0 :                         if (ci1.tpe == cand_dense && ci2.tpe == cand_dense) {
    2210           0 :                                 for (BUN i = 0; i < ncand; i++) {
    2211           0 :                                         oid x1 = canditer_next_dense(&ci1) - b1hseqbase;
    2212           0 :                                         oid x2 = canditer_next_dense(&ci2) - b2hseqbase;
    2213             :                                         const void *p1, *p2;
    2214           0 :                                         p1 = BUNtloc(b1i, x1);
    2215           0 :                                         p2 = BUNtloc(b2i, x2);
    2216           0 :                                         if (cmp(p1, nil) == 0) {
    2217           0 :                                                 if (cmp(p2, nil) == 0) {
    2218             :                                                         /* both values are nil */
    2219             :                                                         nils = true;
    2220             :                                                 } else {
    2221             :                                                         p1 = p2;
    2222             :                                                 }
    2223             :                                         } else {
    2224           0 :                                                 p1 = cmp(p2, nil) != 0 && cmp(p2, p1) > 0 ? p2 : p1;
    2225             :                                         }
    2226           0 :                                         memcpy(bcast, p1, width);
    2227           0 :                                         bcast += width;
    2228             :                                 }
    2229             :                         } else {
    2230           0 :                                 for (BUN i = 0; i < ncand; i++) {
    2231           0 :                                         oid x1 = canditer_next(&ci1) - b1hseqbase;
    2232           0 :                                         oid x2 = canditer_next(&ci2) - b2hseqbase;
    2233             :                                         const void *p1, *p2;
    2234           0 :                                         p1 = BUNtloc(b1i, x1);
    2235           0 :                                         p2 = BUNtloc(b2i, x2);
    2236           0 :                                         if (cmp(p1, nil) == 0) {
    2237           0 :                                                 if (cmp(p2, nil) == 0) {
    2238             :                                                         /* both values are nil */
    2239             :                                                         nils = true;
    2240             :                                                 } else {
    2241             :                                                         p1 = p2;
    2242             :                                                 }
    2243             :                                         } else {
    2244           0 :                                                 p1 = cmp(p2, nil) != 0 && cmp(p2, p1) > 0 ? p2 : p1;
    2245             :                                         }
    2246           0 :                                         memcpy(bcast, p1, width);
    2247           0 :                                         bcast += width;
    2248             :                                 }
    2249             :                         }
    2250             :                 }
    2251             :         }
    2252             :         }
    2253          10 :         bat_iterator_end(&b1i);
    2254          10 :         bat_iterator_end(&b2i);
    2255             : 
    2256          10 :         bn->tnil = nils;
    2257          10 :         bn->tnonil = !nils;
    2258          10 :         BATsetcount(bn, ncand);
    2259          10 :         if (ncand <= 1) {
    2260           5 :                 bn->tsorted = true;
    2261           5 :                 bn->trevsorted = true;
    2262           5 :                 bn->tkey = true;
    2263           5 :                 bn->tseqbase = ATOMtype(b1->ttype) == TYPE_oid ? ncand == 1 ? *(oid*)Tloc(bn,0) : 0 : oid_nil;
    2264             :         } else {
    2265           5 :                 bn->tsorted = false;
    2266           5 :                 bn->trevsorted = false;
    2267           5 :                 bn->tkey = false;
    2268           5 :                 bn->tseqbase = oid_nil;
    2269             :         }
    2270             : 
    2271          10 :         TRC_DEBUG(ALGO, "b1=" ALGOBATFMT ",b2=" ALGOBATFMT
    2272             :                   ",s1=" ALGOOPTBATFMT ",s2=" ALGOOPTBATFMT
    2273             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    2274             :                   ALGOBATPAR(b1), ALGOBATPAR(b2),
    2275             :                   ALGOOPTBATPAR(s1), ALGOOPTBATPAR(s2),
    2276             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    2277             : 
    2278             :         return bn;
    2279           0 :   bunins_failed:
    2280           0 :         bat_iterator_end(&b1i);
    2281           0 :         bat_iterator_end(&b2i);
    2282           0 :         BBPreclaim(bn);
    2283           0 :         return NULL;
    2284             : }
    2285             : 
    2286             : BAT *
    2287           1 : BATcalcmaxcst(BAT *b, const ValRecord *v, BAT *s)
    2288             : {
    2289             :         lng t0 = 0;
    2290             :         BAT *bn;
    2291             :         bool nils = false;
    2292             :         BUN ncand;
    2293             :         struct canditer ci;
    2294             :         const void *p2;
    2295             :         const void *restrict nil;
    2296             :         int (*cmp)(const void *, const void *);
    2297             :         oid bhseqbase;
    2298             : 
    2299           1 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    2300             : 
    2301           1 :         BATcheck(b, NULL);
    2302             : 
    2303           1 :         nil = ATOMnilptr(b->ttype);
    2304           1 :         cmp = ATOMcompare(b->ttype);
    2305           1 :         bhseqbase = b->hseqbase;
    2306           2 :         if (ATOMtype(b->ttype) != v->vtype) {
    2307           0 :                 GDKerror("inputs have incompatible types\n");
    2308           0 :                 return NULL;
    2309             :         }
    2310             : 
    2311           1 :         ncand = canditer_init(&ci, b, s);
    2312           1 :         p2 = VALptr(v);
    2313           2 :         if (ncand == 0 ||
    2314           1 :                 cmp(p2, nil) == 0 ||
    2315           1 :                 (b->ttype == TYPE_void && is_oid_nil(b->tseqbase)))
    2316           0 :                 return BATconstantV(ci.hseq, b->ttype, nil, ncand, TRANSIENT);
    2317             : 
    2318           2 :         bn = COLnew(ci.hseq, ATOMtype(b->ttype), ncand, TRANSIENT);
    2319           1 :         if (bn == NULL)
    2320             :                 return NULL;
    2321             : 
    2322           1 :         BATiter bi = bat_iterator(b);
    2323           1 :         switch (ATOMbasetype(b->ttype)) {
    2324           1 :         case TYPE_bte:
    2325           2 :                 MINMAX_CST_TYPE(bte, >);
    2326             :                 break;
    2327           0 :         case TYPE_sht:
    2328           0 :                 MINMAX_CST_TYPE(sht, >);
    2329             :                 break;
    2330           0 :         case TYPE_int:
    2331           0 :                 MINMAX_CST_TYPE(int, >);
    2332             :                 break;
    2333           0 :         case TYPE_lng:
    2334           0 :                 MINMAX_CST_TYPE(lng, >);
    2335             :                 break;
    2336             : #ifdef HAVE_HGE
    2337           0 :         case TYPE_hge:
    2338           0 :                 MINMAX_CST_TYPE(hge, >);
    2339             :                 break;
    2340             : #endif
    2341           0 :         case TYPE_flt:
    2342           0 :                 MINMAX_CST_TYPE(flt, >);
    2343             :                 break;
    2344           0 :         case TYPE_dbl:
    2345           0 :                 MINMAX_CST_TYPE(dbl, >);
    2346             :                 break;
    2347           0 :         default:
    2348           0 :                 if (ATOMvarsized(b->ttype)) {
    2349           0 :                         for (BUN i = 0; i < ncand; i++) {
    2350           0 :                                 oid x = canditer_next(&ci) - bhseqbase;
    2351           0 :                                 const void *restrict p1 = BUNtvar(bi, x);
    2352           0 :                                 if (cmp(p1, nil) == 0) {
    2353             :                                         nils = true;
    2354             :                                         p1 = nil;
    2355             :                                 } else {
    2356           0 :                                         p1 = cmp(p1, p2) > 0 ? p1 : p2;
    2357             :                                 }
    2358           0 :                                 if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    2359           0 :                                         goto bunins_failed;
    2360             :                                 }
    2361             :                         }
    2362             :                 } else {
    2363           0 :                         uint8_t *restrict bcast = (uint8_t *) Tloc(bn, 0);
    2364           0 :                         uint16_t width = bn->twidth;
    2365           0 :                         for (BUN i = 0; i < ncand; i++) {
    2366           0 :                                 oid x = canditer_next(&ci) - bhseqbase;
    2367           0 :                                 const void *restrict p1 = BUNtloc(bi, x);
    2368           0 :                                 if (cmp(p1, nil) == 0) {
    2369             :                                         nils = true;
    2370             :                                         p1 = nil;
    2371             :                                 } else {
    2372           0 :                                         p1 = cmp(p1, p2) > 0 ? p1 : p2;
    2373             :                                 }
    2374           0 :                                 memcpy(bcast, p1, width);
    2375           0 :                                 bcast += width;
    2376             :                         }
    2377             :                 }
    2378             :         }
    2379           1 :         bat_iterator_end(&bi);
    2380             : 
    2381           1 :         bn->tnil = nils;
    2382           1 :         bn->tnonil = !nils;
    2383           1 :         BATsetcount(bn, ncand);
    2384           1 :         if (ncand <= 1) {
    2385           1 :                 bn->tsorted = true;
    2386           1 :                 bn->trevsorted = true;
    2387           1 :                 bn->tkey = true;
    2388           1 :                 bn->tseqbase = ATOMtype(bn->ttype) == TYPE_oid ? ncand == 1 ? *(oid*)Tloc(bn,0) : 0 : oid_nil;
    2389             :         } else {
    2390           0 :                 bn->tsorted = false;
    2391           0 :                 bn->trevsorted = false;
    2392           0 :                 bn->tkey = false;
    2393           0 :                 bn->tseqbase = oid_nil;
    2394             :         }
    2395             : 
    2396           1 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
    2397             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    2398             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
    2399             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    2400             : 
    2401             :         return bn;
    2402             :   bunins_failed:
    2403           0 :         bat_iterator_end(&bi);
    2404           0 :         BBPreclaim(bn);
    2405           0 :         return NULL;
    2406             : }
    2407             : 
    2408             : BAT *
    2409           1 : BATcalccstmax(const ValRecord *v, BAT *b, BAT *s)
    2410             : {
    2411           1 :         return BATcalcmaxcst(b, v, s);
    2412             : }
    2413             : 
    2414             : BAT *
    2415           7 : BATcalcmaxcst_no_nil(BAT *b, const ValRecord *v, BAT *s)
    2416             : {
    2417             :         lng t0 = 0;
    2418             :         BAT *bn;
    2419             :         bool nils = false;
    2420             :         BUN ncand;
    2421             :         struct canditer ci;
    2422             :         const void *p2;
    2423             :         const void *restrict nil;
    2424             :         int (*cmp)(const void *, const void *);
    2425             :         oid bhseqbase;
    2426             : 
    2427           7 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    2428             : 
    2429           7 :         BATcheck(b, NULL);
    2430             : 
    2431           7 :         nil = ATOMnilptr(b->ttype);
    2432             :         cmp = ATOMcompare(b->ttype);
    2433           7 :         bhseqbase = b->hseqbase;
    2434          14 :         if (ATOMtype(b->ttype) != v->vtype) {
    2435           0 :                 GDKerror("inputs have incompatible types\n");
    2436           0 :                 return NULL;
    2437             :         }
    2438             : 
    2439           7 :         ncand = canditer_init(&ci, b, s);
    2440           7 :         if (ncand == 0)
    2441           0 :                 return BATconstantV(ci.hseq, b->ttype, nil, ncand, TRANSIENT);
    2442             : 
    2443           7 :         cmp = ATOMcompare(b->ttype);
    2444           7 :         p2 = VALptr(v);
    2445           7 :         if (b->ttype == TYPE_void &&
    2446           0 :                 is_oid_nil(b->tseqbase) &&
    2447           0 :                 is_oid_nil(* (const oid *) p2))
    2448           0 :                 return BATconstant(ci.hseq, TYPE_void, &oid_nil, ncand, TRANSIENT);
    2449             : 
    2450          14 :         bn = COLnew(ci.hseq, ATOMtype(b->ttype), ncand, TRANSIENT);
    2451           8 :         if (bn == NULL)
    2452             :                 return NULL;
    2453             : 
    2454           8 :         BATiter bi = bat_iterator(b);
    2455          10 :         switch (ATOMbasetype(b->ttype)) {
    2456           3 :         case TYPE_bte:
    2457           6 :                 MINMAX_NONIL_CST_TYPE(bte, >);
    2458             :                 break;
    2459           0 :         case TYPE_sht:
    2460           0 :                 MINMAX_NONIL_CST_TYPE(sht, >);
    2461             :                 break;
    2462           2 :         case TYPE_int:
    2463           6 :                 MINMAX_NONIL_CST_TYPE(int, >);
    2464             :                 break;
    2465           2 :         case TYPE_lng:
    2466          64 :                 MINMAX_NONIL_CST_TYPE(lng, >);
    2467             :                 break;
    2468             : #ifdef HAVE_HGE
    2469           0 :         case TYPE_hge:
    2470           0 :                 MINMAX_NONIL_CST_TYPE(hge, >);
    2471             :                 break;
    2472             : #endif
    2473           0 :         case TYPE_flt:
    2474           0 :                 MINMAX_NONIL_CST_TYPE(flt, >);
    2475             :                 break;
    2476           0 :         case TYPE_dbl:
    2477           0 :                 MINMAX_NONIL_CST_TYPE(dbl, >);
    2478             :                 break;
    2479           0 :         default:
    2480           0 :                 if (ATOMvarsized(b->ttype)) {
    2481           0 :                         if (cmp(p2, nil) == 0) {
    2482           0 :                                 for (BUN i = 0; i < ncand; i++) {
    2483           0 :                                         oid x = canditer_next(&ci) - bhseqbase;
    2484           0 :                                         const void *restrict p1 = BUNtvar(bi, x);
    2485           0 :                                         nils |= cmp(p1, nil) == 0;
    2486           0 :                                         if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    2487           0 :                                                 goto bunins_failed;
    2488             :                                         }
    2489             :                                 }
    2490             :                         } else {
    2491           0 :                                 for (BUN i = 0; i < ncand; i++) {
    2492           0 :                                         oid x = canditer_next(&ci) - bhseqbase;
    2493           0 :                                         const void *restrict p1 = BUNtvar(bi, x);
    2494           0 :                                         p1 = cmp(p1, nil) == 0 || cmp(p2, p1) > 0 ? p2 : p1;
    2495           0 :                                         if (tfastins_nocheckVAR(bn, i, p1) != GDK_SUCCEED) {
    2496           0 :                                                 goto bunins_failed;
    2497             :                                         }
    2498             :                                 }
    2499             :                         }
    2500             :                 } else {
    2501           0 :                         uint8_t *restrict bcast = (uint8_t *) Tloc(bn, 0);
    2502           0 :                         uint16_t width = bn->twidth;
    2503           0 :                         if (cmp(p2, nil) == 0) {
    2504           0 :                                 for (BUN i = 0; i < ncand; i++) {
    2505           0 :                                         oid x = canditer_next(&ci) - bhseqbase;
    2506           0 :                                         const void *restrict p1 = BUNtloc(bi, x);
    2507           0 :                                         nils |= cmp(p1, nil) == 0;
    2508           0 :                                         memcpy(bcast, p1, width);
    2509           0 :                                         bcast += width;
    2510             :                                 }
    2511             :                         } else {
    2512           0 :                                 for (BUN i = 0; i < ncand; i++) {
    2513           0 :                                         oid x = canditer_next(&ci) - bhseqbase;
    2514           0 :                                         const void *restrict p1 = BUNtloc(bi, x);
    2515           0 :                                         p1 = cmp(p1, nil) == 0 || cmp(p2, p1) > 0 ? p2 : p1;
    2516           0 :                                         memcpy(bcast, p1, width);
    2517           0 :                                         bcast += width;
    2518             :                                 }
    2519             :                         }
    2520             :                 }
    2521             :         }
    2522           7 :         bat_iterator_end(&bi);
    2523             : 
    2524           7 :         bn->tnil = nils;
    2525           7 :         bn->tnonil = !nils;
    2526           7 :         BATsetcount(bn, ncand);
    2527           8 :         if (ncand <= 1) {
    2528           4 :                 bn->tsorted = true;
    2529           4 :                 bn->trevsorted = true;
    2530           4 :                 bn->tkey = true;
    2531           4 :                 bn->tseqbase = ATOMtype(bn->ttype) == TYPE_oid ? ncand == 1 ? *(oid*)Tloc(bn,0) : 0 : oid_nil;
    2532             :         } else {
    2533           4 :                 bn->tsorted = false;
    2534           4 :                 bn->trevsorted = false;
    2535           4 :                 bn->tkey = false;
    2536           4 :                 bn->tseqbase = oid_nil;
    2537             :         }
    2538             : 
    2539           8 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
    2540             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    2541             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
    2542             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    2543             : 
    2544             :         return bn;
    2545           0 :   bunins_failed:
    2546           0 :         bat_iterator_end(&bi);
    2547           0 :         BBPreclaim(bn);
    2548           0 :         return NULL;
    2549             : }
    2550             : 
    2551             : BAT *
    2552           0 : BATcalccstmax_no_nil(const ValRecord *v, BAT *b, BAT *s)
    2553             : {
    2554           0 :         return BATcalcmaxcst_no_nil(b, v, s);
    2555             : }
    2556             : 
    2557             : /* ---------------------------------------------------------------------- */
    2558             : /* addition (any numeric type) */
    2559             : 
    2560             : #define ADD_3TYPE(TYPE1, TYPE2, TYPE3, IF)                              \
    2561             : static BUN                                                              \
    2562             : add_##TYPE1##_##TYPE2##_##TYPE3(const TYPE1 *lft, bool incr1,           \
    2563             :                                 const TYPE2 *rgt, bool incr2,           \
    2564             :                                 TYPE3 *restrict dst, TYPE3 max,         \
    2565             :                                 struct canditer *restrict ci1,          \
    2566             :                                 struct canditer *restrict ci2,          \
    2567             :                                 oid candoff1, oid candoff2,             \
    2568             :                                 bool abort_on_error)                    \
    2569             : {                                                                       \
    2570             :         BUN nils = 0;                                                   \
    2571             :         BUN i = 0, j = 0, ncand = ci1->ncand;                                \
    2572             :                                                                         \
    2573             :         if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {           \
    2574             :                 for (BUN k = 0; k < ncand; k++) {                    \
    2575             :                         if (incr1)                                      \
    2576             :                                 i = canditer_next_dense(ci1) - candoff1; \
    2577             :                         if (incr2)                                      \
    2578             :                                 j = canditer_next_dense(ci2) - candoff2; \
    2579             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    2580             :                                 dst[k] = TYPE3##_nil;                   \
    2581             :                                 nils++;                                 \
    2582             :                         } else {                                        \
    2583             :                                 ADD##IF##_WITH_CHECK(lft[i], rgt[j],    \
    2584             :                                                      TYPE3, dst[k],     \
    2585             :                                                      max,               \
    2586             :                                                      ON_OVERFLOW(TYPE1, TYPE2, "+")); \
    2587             :                         }                                               \
    2588             :                 }                                                       \
    2589             :         } else {                                                        \
    2590             :                 for (BUN k = 0; k < ncand; k++) {                    \
    2591             :                         if (incr1)                                      \
    2592             :                                 i = canditer_next(ci1) - candoff1;      \
    2593             :                         if (incr2)                                      \
    2594             :                                 j = canditer_next(ci2) - candoff2;      \
    2595             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    2596             :                                 dst[k] = TYPE3##_nil;                   \
    2597             :                                 nils++;                                 \
    2598             :                         } else {                                        \
    2599             :                                 ADD##IF##_WITH_CHECK(lft[i], rgt[j],    \
    2600             :                                                      TYPE3, dst[k],     \
    2601             :                                                      max,               \
    2602             :                                                      ON_OVERFLOW(TYPE1, TYPE2, "+")); \
    2603             :                         }                                               \
    2604             :                 }                                                       \
    2605             :         }                                                               \
    2606             :         return nils;                                                    \
    2607             : }
    2608             : 
    2609             : #define ADD_3TYPE_enlarge(TYPE1, TYPE2, TYPE3, IF)                      \
    2610             : static BUN                                                              \
    2611             : add_##TYPE1##_##TYPE2##_##TYPE3(const TYPE1 *lft, bool incr1,           \
    2612             :                                 const TYPE2 *rgt, bool incr2,           \
    2613             :                                 TYPE3 *restrict dst, TYPE3 max,         \
    2614             :                                 struct canditer *restrict ci1,          \
    2615             :                                 struct canditer *restrict ci2,          \
    2616             :                                 oid candoff1, oid candoff2,             \
    2617             :                                 bool abort_on_error)                    \
    2618             : {                                                                       \
    2619             :         BUN nils = 0;                                                   \
    2620             :         BUN i = 0, j = 0, ncand = ci1->ncand;                                \
    2621             :         const bool couldoverflow = (max < (TYPE3) GDK_##TYPE1##_max + (TYPE3) GDK_##TYPE2##_max); \
    2622             :                                                                         \
    2623             :         if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {           \
    2624             :                 for (BUN k = 0; k < ncand; k++) {                    \
    2625             :                         if (incr1)                                      \
    2626             :                                 i = canditer_next_dense(ci1) - candoff1; \
    2627             :                         if (incr2)                                      \
    2628             :                                 j = canditer_next_dense(ci2) - candoff2; \
    2629             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    2630             :                                 dst[k] = TYPE3##_nil;                   \
    2631             :                                 nils++;                                 \
    2632             :                         } else if (couldoverflow) {                     \
    2633             :                                 ADD##IF##_WITH_CHECK(lft[i], rgt[j],    \
    2634             :                                                      TYPE3, dst[k],     \
    2635             :                                                      max,               \
    2636             :                                                      ON_OVERFLOW(TYPE1, TYPE2, "+")); \
    2637             :                         } else {                                        \
    2638             :                                 dst[k] = (TYPE3) lft[i] + rgt[j];       \
    2639             :                         }                                               \
    2640             :                 }                                                       \
    2641             :         } else {                                                        \
    2642             :                 for (BUN k = 0; k < ncand; k++) {                    \
    2643             :                         if (incr1)                                      \
    2644             :                                 i = canditer_next(ci1) - candoff1;      \
    2645             :                         if (incr2)                                      \
    2646             :                                 j = canditer_next(ci2) - candoff2;      \
    2647             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    2648             :                                 dst[k] = TYPE3##_nil;                   \
    2649             :                                 nils++;                                 \
    2650             :                         } else if (couldoverflow) {                     \
    2651             :                                 ADD##IF##_WITH_CHECK(lft[i], rgt[j],    \
    2652             :                                                      TYPE3, dst[k],     \
    2653             :                                                      max,               \
    2654             :                                                      ON_OVERFLOW(TYPE1, TYPE2, "+")); \
    2655             :                         } else {                                        \
    2656             :                                 dst[k] = (TYPE3) lft[i] + rgt[j];       \
    2657             :                         }                                               \
    2658             :                 }                                                       \
    2659             :         }                                                               \
    2660             :         return nils;                                                    \
    2661             : }
    2662             : 
    2663         366 : ADD_3TYPE(bte, bte, bte, I)
    2664           0 : ADD_3TYPE_enlarge(bte, bte, sht, I)
    2665           0 : ADD_3TYPE_enlarge(bte, bte, int, I)
    2666           0 : ADD_3TYPE_enlarge(bte, bte, lng, I)
    2667             : #ifdef HAVE_HGE
    2668           0 : ADD_3TYPE_enlarge(bte, bte, hge, I)
    2669             : #endif
    2670           0 : ADD_3TYPE_enlarge(bte, bte, flt, F)
    2671           0 : ADD_3TYPE_enlarge(bte, bte, dbl, F)
    2672           0 : ADD_3TYPE(bte, sht, sht, I)
    2673           0 : ADD_3TYPE_enlarge(bte, sht, int, I)
    2674           0 : ADD_3TYPE_enlarge(bte, sht, lng, I)
    2675             : #ifdef HAVE_HGE
    2676           0 : ADD_3TYPE_enlarge(bte, sht, hge, I)
    2677             : #endif
    2678           0 : ADD_3TYPE_enlarge(bte, sht, flt, F)
    2679           0 : ADD_3TYPE_enlarge(bte, sht, dbl, F)
    2680           0 : ADD_3TYPE(bte, int, int, I)
    2681           0 : ADD_3TYPE_enlarge(bte, int, lng, I)
    2682             : #ifdef HAVE_HGE
    2683           0 : ADD_3TYPE_enlarge(bte, int, hge, I)
    2684             : #endif
    2685           0 : ADD_3TYPE_enlarge(bte, int, flt, F)
    2686           0 : ADD_3TYPE_enlarge(bte, int, dbl, F)
    2687           0 : ADD_3TYPE(bte, lng, lng, I)
    2688             : #ifdef HAVE_HGE
    2689           0 : ADD_3TYPE_enlarge(bte, lng, hge, I)
    2690             : #endif
    2691           0 : ADD_3TYPE_enlarge(bte, lng, flt, F)
    2692           0 : ADD_3TYPE_enlarge(bte, lng, dbl, F)
    2693             : #ifdef HAVE_HGE
    2694           0 : ADD_3TYPE(bte, hge, hge, I)
    2695           0 : ADD_3TYPE_enlarge(bte, hge, flt, F)
    2696           0 : ADD_3TYPE_enlarge(bte, hge, dbl, F)
    2697             : #endif
    2698           0 : ADD_3TYPE(bte, flt, flt, F)
    2699           0 : ADD_3TYPE_enlarge(bte, flt, dbl, F)
    2700           0 : ADD_3TYPE(bte, dbl, dbl, F)
    2701           0 : ADD_3TYPE(sht, bte, sht, I)
    2702           0 : ADD_3TYPE_enlarge(sht, bte, int, I)
    2703           0 : ADD_3TYPE_enlarge(sht, bte, lng, I)
    2704             : #ifdef HAVE_HGE
    2705           0 : ADD_3TYPE_enlarge(sht, bte, hge, I)
    2706             : #endif
    2707           0 : ADD_3TYPE_enlarge(sht, bte, flt, F)
    2708           0 : ADD_3TYPE_enlarge(sht, bte, dbl, F)
    2709         989 : ADD_3TYPE(sht, sht, sht, I)
    2710           0 : ADD_3TYPE_enlarge(sht, sht, int, I)
    2711           0 : ADD_3TYPE_enlarge(sht, sht, lng, I)
    2712             : #ifdef HAVE_HGE
    2713           0 : ADD_3TYPE_enlarge(sht, sht, hge, I)
    2714             : #endif
    2715           0 : ADD_3TYPE_enlarge(sht, sht, flt, F)
    2716           0 : ADD_3TYPE_enlarge(sht, sht, dbl, F)
    2717           0 : ADD_3TYPE(sht, int, int, I)
    2718           0 : ADD_3TYPE_enlarge(sht, int, lng, I)
    2719             : #ifdef HAVE_HGE
    2720           0 : ADD_3TYPE_enlarge(sht, int, hge, I)
    2721             : #endif
    2722           0 : ADD_3TYPE_enlarge(sht, int, flt, F)
    2723           0 : ADD_3TYPE_enlarge(sht, int, dbl, F)
    2724           0 : ADD_3TYPE(sht, lng, lng, I)
    2725             : #ifdef HAVE_HGE
    2726           0 : ADD_3TYPE_enlarge(sht, lng, hge, I)
    2727             : #endif
    2728           0 : ADD_3TYPE_enlarge(sht, lng, flt, F)
    2729           0 : ADD_3TYPE_enlarge(sht, lng, dbl, F)
    2730             : #ifdef HAVE_HGE
    2731           0 : ADD_3TYPE(sht, hge, hge, I)
    2732           0 : ADD_3TYPE_enlarge(sht, hge, flt, F)
    2733           0 : ADD_3TYPE_enlarge(sht, hge, dbl, F)
    2734             : #endif
    2735           0 : ADD_3TYPE(sht, flt, flt, F)
    2736           0 : ADD_3TYPE_enlarge(sht, flt, dbl, F)
    2737           0 : ADD_3TYPE(sht, dbl, dbl, F)
    2738           0 : ADD_3TYPE(int, bte, int, I)
    2739           0 : ADD_3TYPE_enlarge(int, bte, lng, I)
    2740             : #ifdef HAVE_HGE
    2741           0 : ADD_3TYPE_enlarge(int, bte, hge, I)
    2742             : #endif
    2743           0 : ADD_3TYPE_enlarge(int, bte, flt, F)
    2744           0 : ADD_3TYPE_enlarge(int, bte, dbl, F)
    2745           0 : ADD_3TYPE(int, sht, int, I)
    2746           0 : ADD_3TYPE_enlarge(int, sht, lng, I)
    2747             : #ifdef HAVE_HGE
    2748           0 : ADD_3TYPE_enlarge(int, sht, hge, I)
    2749             : #endif
    2750           0 : ADD_3TYPE_enlarge(int, sht, flt, F)
    2751           0 : ADD_3TYPE_enlarge(int, sht, dbl, F)
    2752     5668668 : ADD_3TYPE(int, int, int, I)
    2753           0 : ADD_3TYPE_enlarge(int, int, lng, I)
    2754             : #ifdef HAVE_HGE
    2755           0 : ADD_3TYPE_enlarge(int, int, hge, I)
    2756             : #endif
    2757           0 : ADD_3TYPE_enlarge(int, int, flt, F)
    2758           0 : ADD_3TYPE_enlarge(int, int, dbl, F)
    2759           0 : ADD_3TYPE(int, lng, lng, I)
    2760             : #ifdef HAVE_HGE
    2761           0 : ADD_3TYPE_enlarge(int, lng, hge, I)
    2762             : #endif
    2763           0 : ADD_3TYPE_enlarge(int, lng, flt, F)
    2764           0 : ADD_3TYPE_enlarge(int, lng, dbl, F)
    2765             : #ifdef HAVE_HGE
    2766           0 : ADD_3TYPE(int, hge, hge, I)
    2767           0 : ADD_3TYPE_enlarge(int, hge, flt, F)
    2768           0 : ADD_3TYPE_enlarge(int, hge, dbl, F)
    2769             : #endif
    2770           0 : ADD_3TYPE(int, flt, flt, F)
    2771           0 : ADD_3TYPE_enlarge(int, flt, dbl, F)
    2772           0 : ADD_3TYPE(int, dbl, dbl, F)
    2773           0 : ADD_3TYPE(lng, bte, lng, I)
    2774             : #ifdef HAVE_HGE
    2775           0 : ADD_3TYPE_enlarge(lng, bte, hge, I)
    2776             : #endif
    2777           0 : ADD_3TYPE_enlarge(lng, bte, flt, F)
    2778           0 : ADD_3TYPE_enlarge(lng, bte, dbl, F)
    2779           0 : ADD_3TYPE(lng, sht, lng, I)
    2780             : #ifdef HAVE_HGE
    2781           0 : ADD_3TYPE_enlarge(lng, sht, hge, I)
    2782             : #endif
    2783           0 : ADD_3TYPE_enlarge(lng, sht, flt, F)
    2784           0 : ADD_3TYPE_enlarge(lng, sht, dbl, F)
    2785          20 : ADD_3TYPE(lng, int, lng, I)
    2786             : #ifdef HAVE_HGE
    2787           0 : ADD_3TYPE_enlarge(lng, int, hge, I)
    2788             : #endif
    2789           0 : ADD_3TYPE_enlarge(lng, int, flt, F)
    2790           0 : ADD_3TYPE_enlarge(lng, int, dbl, F)
    2791    10971683 : ADD_3TYPE(lng, lng, lng, I)
    2792             : #ifdef HAVE_HGE
    2793           0 : ADD_3TYPE_enlarge(lng, lng, hge, I)
    2794             : #endif
    2795           0 : ADD_3TYPE_enlarge(lng, lng, flt, F)
    2796           0 : ADD_3TYPE_enlarge(lng, lng, dbl, F)
    2797             : #ifdef HAVE_HGE
    2798           0 : ADD_3TYPE(lng, hge, hge, I)
    2799           0 : ADD_3TYPE_enlarge(lng, hge, flt, F)
    2800           0 : ADD_3TYPE_enlarge(lng, hge, dbl, F)
    2801             : #endif
    2802           0 : ADD_3TYPE(lng, flt, flt, F)
    2803           0 : ADD_3TYPE_enlarge(lng, flt, dbl, F)
    2804           0 : ADD_3TYPE(lng, dbl, dbl, F)
    2805             : #ifdef HAVE_HGE
    2806           0 : ADD_3TYPE(hge, bte, hge, I)
    2807           0 : ADD_3TYPE_enlarge(hge, bte, flt, F)
    2808           0 : ADD_3TYPE_enlarge(hge, bte, dbl, F)
    2809           0 : ADD_3TYPE(hge, sht, hge, I)
    2810           0 : ADD_3TYPE_enlarge(hge, sht, flt, F)
    2811           0 : ADD_3TYPE_enlarge(hge, sht, dbl, F)
    2812           0 : ADD_3TYPE(hge, int, hge, I)
    2813           0 : ADD_3TYPE_enlarge(hge, int, flt, F)
    2814           0 : ADD_3TYPE_enlarge(hge, int, dbl, F)
    2815           0 : ADD_3TYPE(hge, lng, hge, I)
    2816           0 : ADD_3TYPE_enlarge(hge, lng, flt, F)
    2817           0 : ADD_3TYPE_enlarge(hge, lng, dbl, F)
    2818      355006 : ADD_3TYPE(hge, hge, hge, I)
    2819           0 : ADD_3TYPE_enlarge(hge, hge, flt, F)
    2820           0 : ADD_3TYPE_enlarge(hge, hge, dbl, F)
    2821           0 : ADD_3TYPE(hge, flt, flt, F)
    2822           0 : ADD_3TYPE_enlarge(hge, flt, dbl, F)
    2823           0 : ADD_3TYPE(hge, dbl, dbl, F)
    2824             : #endif
    2825           0 : ADD_3TYPE(flt, bte, flt, F)
    2826           0 : ADD_3TYPE_enlarge(flt, bte, dbl, F)
    2827           0 : ADD_3TYPE(flt, sht, flt, F)
    2828           0 : ADD_3TYPE_enlarge(flt, sht, dbl, F)
    2829           2 : ADD_3TYPE(flt, int, flt, F)
    2830           0 : ADD_3TYPE_enlarge(flt, int, dbl, F)
    2831           0 : ADD_3TYPE(flt, lng, flt, F)
    2832           0 : ADD_3TYPE_enlarge(flt, lng, dbl, F)
    2833             : #ifdef HAVE_HGE
    2834           0 : ADD_3TYPE(flt, hge, flt, F)
    2835           0 : ADD_3TYPE_enlarge(flt, hge, dbl, F)
    2836             : #endif
    2837     3500060 : ADD_3TYPE(flt, flt, flt, F)
    2838           0 : ADD_3TYPE_enlarge(flt, flt, dbl, F)
    2839           0 : ADD_3TYPE(flt, dbl, dbl, F)
    2840           0 : ADD_3TYPE(dbl, bte, dbl, F)
    2841           0 : ADD_3TYPE(dbl, sht, dbl, F)
    2842           0 : ADD_3TYPE(dbl, int, dbl, F)
    2843           0 : ADD_3TYPE(dbl, lng, dbl, F)
    2844             : #ifdef HAVE_HGE
    2845           0 : ADD_3TYPE(dbl, hge, dbl, F)
    2846             : #endif
    2847           0 : ADD_3TYPE(dbl, flt, dbl, F)
    2848        2404 : ADD_3TYPE(dbl, dbl, dbl, F)
    2849             : 
    2850             : static BUN
    2851      173268 : add_typeswitchloop(const void *lft, int tp1, bool incr1,
    2852             :                    const void *rgt, int tp2, bool incr2,
    2853             :                    void *restrict dst, int tp,
    2854             :                    struct canditer *restrict ci1, struct canditer *restrict ci2,
    2855             :                    oid candoff1, oid candoff2, bool abort_on_error,
    2856             :                    const char *func)
    2857             : {
    2858             :         BUN nils;
    2859             : 
    2860      173268 :         tp1 = ATOMbasetype(tp1);
    2861      173268 :         tp2 = ATOMbasetype(tp2);
    2862      173268 :         tp = ATOMbasetype(tp);
    2863      173268 :         switch (tp1) {
    2864         179 :         case TYPE_bte:
    2865             :                 switch (tp2) {
    2866         179 :                 case TYPE_bte:
    2867             :                         switch (tp) {
    2868         179 :                         case TYPE_bte:
    2869         179 :                                 nils = add_bte_bte_bte(lft, incr1, rgt, incr2,
    2870             :                                                        dst, GDK_bte_max,
    2871             :                                                        ci1, ci2, candoff1, candoff2,
    2872             :                                                        abort_on_error);
    2873         179 :                                 break;
    2874           0 :                         case TYPE_sht:
    2875           0 :                                 nils = add_bte_bte_sht(lft, incr1, rgt, incr2,
    2876             :                                                        dst, GDK_sht_max,
    2877             :                                                        ci1, ci2, candoff1, candoff2,
    2878             :                                                        abort_on_error);
    2879           0 :                                 break;
    2880           0 :                         case TYPE_int:
    2881           0 :                                 nils = add_bte_bte_int(lft, incr1, rgt, incr2,
    2882             :                                                        dst, GDK_int_max,
    2883             :                                                        ci1, ci2, candoff1, candoff2,
    2884             :                                                        abort_on_error);
    2885           0 :                                 break;
    2886           0 :                         case TYPE_lng:
    2887           0 :                                 nils = add_bte_bte_lng(lft, incr1, rgt, incr2,
    2888             :                                                        dst, GDK_lng_max,
    2889             :                                                        ci1, ci2, candoff1, candoff2,
    2890             :                                                        abort_on_error);
    2891           0 :                                 break;
    2892             : #ifdef HAVE_HGE
    2893           0 :                         case TYPE_hge:
    2894           0 :                                 nils = add_bte_bte_hge(lft, incr1, rgt, incr2,
    2895             :                                                        dst, GDK_hge_max,
    2896             :                                                        ci1, ci2, candoff1, candoff2,
    2897             :                                                        abort_on_error);
    2898           0 :                                 break;
    2899             : #endif
    2900           0 :                         case TYPE_flt:
    2901           0 :                                 nils = add_bte_bte_flt(lft, incr1, rgt, incr2,
    2902             :                                                        dst, GDK_flt_max,
    2903             :                                                        ci1, ci2, candoff1, candoff2,
    2904             :                                                        abort_on_error);
    2905           0 :                                 break;
    2906           0 :                         case TYPE_dbl:
    2907           0 :                                 nils = add_bte_bte_dbl(lft, incr1, rgt, incr2,
    2908             :                                                        dst, GDK_dbl_max,
    2909             :                                                        ci1, ci2, candoff1, candoff2,
    2910             :                                                        abort_on_error);
    2911           0 :                                 break;
    2912           0 :                         default:
    2913           0 :                                 goto unsupported;
    2914             :                         }
    2915             :                         break;
    2916           0 :                 case TYPE_sht:
    2917             :                         switch (tp) {
    2918           0 :                         case TYPE_sht:
    2919           0 :                                 nils = add_bte_sht_sht(lft, incr1, rgt, incr2,
    2920             :                                                        dst, GDK_sht_max,
    2921             :                                                        ci1, ci2, candoff1, candoff2,
    2922             :                                                        abort_on_error);
    2923           0 :                                 break;
    2924           0 :                         case TYPE_int:
    2925           0 :                                 nils = add_bte_sht_int(lft, incr1, rgt, incr2,
    2926             :                                                        dst, GDK_int_max,
    2927             :                                                        ci1, ci2, candoff1, candoff2,
    2928             :                                                        abort_on_error);
    2929           0 :                                 break;
    2930           0 :                         case TYPE_lng:
    2931           0 :                                 nils = add_bte_sht_lng(lft, incr1, rgt, incr2,
    2932             :                                                        dst, GDK_lng_max,
    2933             :                                                        ci1, ci2, candoff1, candoff2,
    2934             :                                                        abort_on_error);
    2935           0 :                                 break;
    2936             : #ifdef HAVE_HGE
    2937           0 :                         case TYPE_hge:
    2938           0 :                                 nils = add_bte_sht_hge(lft, incr1, rgt, incr2,
    2939             :                                                        dst, GDK_hge_max,
    2940             :                                                        ci1, ci2, candoff1, candoff2,
    2941             :                                                        abort_on_error);
    2942           0 :                                 break;
    2943             : #endif
    2944           0 :                         case TYPE_flt:
    2945           0 :                                 nils = add_bte_sht_flt(lft, incr1, rgt, incr2,
    2946             :                                                        dst, GDK_flt_max,
    2947             :                                                        ci1, ci2, candoff1, candoff2,
    2948             :                                                        abort_on_error);
    2949           0 :                                 break;
    2950           0 :                         case TYPE_dbl:
    2951           0 :                                 nils = add_bte_sht_dbl(lft, incr1, rgt, incr2,
    2952             :                                                        dst, GDK_dbl_max,
    2953             :                                                        ci1, ci2, candoff1, candoff2,
    2954             :                                                        abort_on_error);
    2955           0 :                                 break;
    2956           0 :                         default:
    2957           0 :                                 goto unsupported;
    2958             :                         }
    2959             :                         break;
    2960           0 :                 case TYPE_int:
    2961             :                         switch (tp) {
    2962           0 :                         case TYPE_int:
    2963           0 :                                 nils = add_bte_int_int(lft, incr1, rgt, incr2,
    2964             :                                                        dst, GDK_int_max,
    2965             :                                                        ci1, ci2, candoff1, candoff2,
    2966             :                                                        abort_on_error);
    2967           0 :                                 break;
    2968           0 :                         case TYPE_lng:
    2969           0 :                                 nils = add_bte_int_lng(lft, incr1, rgt, incr2,
    2970             :                                                        dst, GDK_lng_max,
    2971             :                                                        ci1, ci2, candoff1, candoff2,
    2972             :                                                        abort_on_error);
    2973           0 :                                 break;
    2974             : #ifdef HAVE_HGE
    2975           0 :                         case TYPE_hge:
    2976           0 :                                 nils = add_bte_int_hge(lft, incr1, rgt, incr2,
    2977             :                                                        dst, GDK_hge_max,
    2978             :                                                        ci1, ci2, candoff1, candoff2,
    2979             :                                                        abort_on_error);
    2980           0 :                                 break;
    2981             : #endif
    2982           0 :                         case TYPE_flt:
    2983           0 :                                 nils = add_bte_int_flt(lft, incr1, rgt, incr2,
    2984             :                                                        dst, GDK_flt_max,
    2985             :                                                        ci1, ci2, candoff1, candoff2,
    2986             :                                                        abort_on_error);
    2987           0 :                                 break;
    2988           0 :                         case TYPE_dbl:
    2989           0 :                                 nils = add_bte_int_dbl(lft, incr1, rgt, incr2,
    2990             :                                                        dst, GDK_dbl_max,
    2991             :                                                        ci1, ci2, candoff1, candoff2,
    2992             :                                                        abort_on_error);
    2993           0 :                                 break;
    2994           0 :                         default:
    2995           0 :                                 goto unsupported;
    2996             :                         }
    2997             :                         break;
    2998           0 :                 case TYPE_lng:
    2999             :                         switch (tp) {
    3000           0 :                         case TYPE_lng:
    3001           0 :                                 nils = add_bte_lng_lng(lft, incr1, rgt, incr2,
    3002             :                                                        dst, GDK_lng_max,
    3003             :                                                        ci1, ci2, candoff1, candoff2,
    3004             :                                                        abort_on_error);
    3005           0 :                                 break;
    3006             : #ifdef HAVE_HGE
    3007           0 :                         case TYPE_hge:
    3008           0 :                                 nils = add_bte_lng_hge(lft, incr1, rgt, incr2,
    3009             :                                                        dst, GDK_hge_max,
    3010             :                                                        ci1, ci2, candoff1, candoff2,
    3011             :                                                        abort_on_error);
    3012           0 :                                 break;
    3013             : #endif
    3014           0 :                         case TYPE_flt:
    3015           0 :                                 nils = add_bte_lng_flt(lft, incr1, rgt, incr2,
    3016             :                                                        dst, GDK_flt_max,
    3017             :                                                        ci1, ci2, candoff1, candoff2,
    3018             :                                                        abort_on_error);
    3019           0 :                                 break;
    3020           0 :                         case TYPE_dbl:
    3021           0 :                                 nils = add_bte_lng_dbl(lft, incr1, rgt, incr2,
    3022             :                                                        dst, GDK_dbl_max,
    3023             :                                                        ci1, ci2, candoff1, candoff2,
    3024             :                                                        abort_on_error);
    3025           0 :                                 break;
    3026           0 :                         default:
    3027           0 :                                 goto unsupported;
    3028             :                         }
    3029             :                         break;
    3030             : #ifdef HAVE_HGE
    3031           0 :                 case TYPE_hge:
    3032             :                         switch (tp) {
    3033           0 :                         case TYPE_hge:
    3034           0 :                                 nils = add_bte_hge_hge(lft, incr1, rgt, incr2,
    3035             :                                                        dst, GDK_hge_max,
    3036             :                                                        ci1, ci2, candoff1, candoff2,
    3037             :                                                        abort_on_error);
    3038           0 :                                 break;
    3039           0 :                         case TYPE_flt:
    3040           0 :                                 nils = add_bte_hge_flt(lft, incr1, rgt, incr2,
    3041             :                                                        dst, GDK_flt_max,
    3042             :                                                        ci1, ci2, candoff1, candoff2,
    3043             :                                                        abort_on_error);
    3044           0 :                                 break;
    3045           0 :                         case TYPE_dbl:
    3046           0 :                                 nils = add_bte_hge_dbl(lft, incr1, rgt, incr2,
    3047             :                                                        dst, GDK_dbl_max,
    3048             :                                                        ci1, ci2, candoff1, candoff2,
    3049             :                                                        abort_on_error);
    3050           0 :                                 break;
    3051           0 :                         default:
    3052           0 :                                 goto unsupported;
    3053             :                         }
    3054             :                         break;
    3055             : #endif
    3056           0 :                 case TYPE_flt:
    3057             :                         switch (tp) {
    3058           0 :                         case TYPE_flt:
    3059           0 :                                 nils = add_bte_flt_flt(lft, incr1, rgt, incr2,
    3060             :                                                        dst, GDK_flt_max,
    3061             :                                                        ci1, ci2, candoff1, candoff2,
    3062             :                                                        abort_on_error);
    3063           0 :                                 break;
    3064           0 :                         case TYPE_dbl:
    3065           0 :                                 nils = add_bte_flt_dbl(lft, incr1, rgt, incr2,
    3066             :                                                        dst, GDK_dbl_max,
    3067             :                                                        ci1, ci2, candoff1, candoff2,
    3068             :                                                        abort_on_error);
    3069           0 :                                 break;
    3070           0 :                         default:
    3071           0 :                                 goto unsupported;
    3072             :                         }
    3073             :                         break;
    3074           0 :                 case TYPE_dbl:
    3075             :                         switch (tp) {
    3076           0 :                         case TYPE_dbl:
    3077           0 :                                 nils = add_bte_dbl_dbl(lft, incr1, rgt, incr2,
    3078             :                                                        dst, GDK_dbl_max,
    3079             :                                                        ci1, ci2, candoff1, candoff2,
    3080             :                                                        abort_on_error);
    3081             :                                 break;
    3082           0 :                         default:
    3083           0 :                                 goto unsupported;
    3084             :                         }
    3085           0 :                         break;
    3086           0 :                 default:
    3087           0 :                         goto unsupported;
    3088             :                 }
    3089             :                 break;
    3090         221 :         case TYPE_sht:
    3091             :                 switch (tp2) {
    3092           0 :                 case TYPE_bte:
    3093             :                         switch (tp) {
    3094           0 :                         case TYPE_sht:
    3095           0 :                                 nils = add_sht_bte_sht(lft, incr1, rgt, incr2,
    3096             :                                                        dst, GDK_sht_max,
    3097             :                                                        ci1, ci2, candoff1, candoff2,
    3098             :                                                        abort_on_error);
    3099           0 :                                 break;
    3100           0 :                         case TYPE_int:
    3101           0 :                                 nils = add_sht_bte_int(lft, incr1, rgt, incr2,
    3102             :                                                        dst, GDK_int_max,
    3103             :                                                        ci1, ci2, candoff1, candoff2,
    3104             :                                                        abort_on_error);
    3105           0 :                                 break;
    3106           0 :                         case TYPE_lng:
    3107           0 :                                 nils = add_sht_bte_lng(lft, incr1, rgt, incr2,
    3108             :                                                        dst, GDK_lng_max,
    3109             :                                                        ci1, ci2, candoff1, candoff2,
    3110             :                                                        abort_on_error);
    3111           0 :                                 break;
    3112             : #ifdef HAVE_HGE
    3113           0 :                         case TYPE_hge:
    3114           0 :                                 nils = add_sht_bte_hge(lft, incr1, rgt, incr2,
    3115             :                                                        dst, GDK_hge_max,
    3116             :                                                        ci1, ci2, candoff1, candoff2,
    3117             :                                                        abort_on_error);
    3118           0 :                                 break;
    3119             : #endif
    3120           0 :                         case TYPE_flt:
    3121           0 :                                 nils = add_sht_bte_flt(lft, incr1, rgt, incr2,
    3122             :                                                        dst, GDK_flt_max,
    3123             :                                                        ci1, ci2, candoff1, candoff2,
    3124             :                                                        abort_on_error);
    3125           0 :                                 break;
    3126           0 :                         case TYPE_dbl:
    3127           0 :                                 nils = add_sht_bte_dbl(lft, incr1, rgt, incr2,
    3128             :                                                        dst, GDK_dbl_max,
    3129             :                                                        ci1, ci2, candoff1, candoff2,
    3130             :                                                        abort_on_error);
    3131           0 :                                 break;
    3132           0 :                         default:
    3133           0 :                                 goto unsupported;
    3134             :                         }
    3135             :                         break;
    3136         221 :                 case TYPE_sht:
    3137             :                         switch (tp) {
    3138         221 :                         case TYPE_sht:
    3139         221 :                                 nils = add_sht_sht_sht(lft, incr1, rgt, incr2,
    3140             :                                                        dst, GDK_sht_max,
    3141             :                                                        ci1, ci2, candoff1, candoff2,
    3142             :                                                        abort_on_error);
    3143         221 :                                 break;
    3144           0 :                         case TYPE_int:
    3145           0 :                                 nils = add_sht_sht_int(lft, incr1, rgt, incr2,
    3146             :                                                        dst, GDK_int_max,
    3147             :                                                        ci1, ci2, candoff1, candoff2,
    3148             :                                                        abort_on_error);
    3149           0 :                                 break;
    3150           0 :                         case TYPE_lng:
    3151           0 :                                 nils = add_sht_sht_lng(lft, incr1, rgt, incr2,
    3152             :                                                        dst, GDK_lng_max,
    3153             :                                                        ci1, ci2, candoff1, candoff2,
    3154             :                                                        abort_on_error);
    3155           0 :                                 break;
    3156             : #ifdef HAVE_HGE
    3157           0 :                         case TYPE_hge:
    3158           0 :                                 nils = add_sht_sht_hge(lft, incr1, rgt, incr2,
    3159             :                                                        dst, GDK_hge_max,
    3160             :                                                        ci1, ci2, candoff1, candoff2,
    3161             :                                                        abort_on_error);
    3162           0 :                                 break;
    3163             : #endif
    3164           0 :                         case TYPE_flt:
    3165           0 :                                 nils = add_sht_sht_flt(lft, incr1, rgt, incr2,
    3166             :                                                        dst, GDK_flt_max,
    3167             :                                                        ci1, ci2, candoff1, candoff2,
    3168             :                                                        abort_on_error);
    3169           0 :                                 break;
    3170           0 :                         case TYPE_dbl:
    3171           0 :                                 nils = add_sht_sht_dbl(lft, incr1, rgt, incr2,
    3172             :                                                        dst, GDK_dbl_max,
    3173             :                                                        ci1, ci2, candoff1, candoff2,
    3174             :                                                        abort_on_error);
    3175           0 :                                 break;
    3176           0 :                         default:
    3177           0 :                                 goto unsupported;
    3178             :                         }
    3179             :                         break;
    3180           0 :                 case TYPE_int:
    3181             :                         switch (tp) {
    3182           0 :                         case TYPE_int:
    3183           0 :                                 nils = add_sht_int_int(lft, incr1, rgt, incr2,
    3184             :                                                        dst, GDK_int_max,
    3185             :                                                        ci1, ci2, candoff1, candoff2,
    3186             :                                                        abort_on_error);
    3187           0 :                                 break;
    3188           0 :                         case TYPE_lng:
    3189           0 :                                 nils = add_sht_int_lng(lft, incr1, rgt, incr2,
    3190             :                                                        dst, GDK_lng_max,
    3191             :                                                        ci1, ci2, candoff1, candoff2,
    3192             :                                                        abort_on_error);
    3193           0 :                                 break;
    3194             : #ifdef HAVE_HGE
    3195           0 :                         case TYPE_hge:
    3196           0 :                                 nils = add_sht_int_hge(lft, incr1, rgt, incr2,
    3197             :                                                        dst, GDK_hge_max,
    3198             :                                                        ci1, ci2, candoff1, candoff2,
    3199             :                                                        abort_on_error);
    3200           0 :                                 break;
    3201             : #endif
    3202           0 :                         case TYPE_flt:
    3203           0 :                                 nils = add_sht_int_flt(lft, incr1, rgt, incr2,
    3204             :                                                        dst, GDK_flt_max,
    3205             :                                                        ci1, ci2, candoff1, candoff2,
    3206             :                                                        abort_on_error);
    3207           0 :                                 break;
    3208           0 :                         case TYPE_dbl:
    3209           0 :                                 nils = add_sht_int_dbl(lft, incr1, rgt, incr2,
    3210             :                                                        dst, GDK_dbl_max,
    3211             :                                                        ci1, ci2, candoff1, candoff2,
    3212             :                                                        abort_on_error);
    3213           0 :                                 break;
    3214           0 :                         default:
    3215           0 :                                 goto unsupported;
    3216             :                         }
    3217             :                         break;
    3218           0 :                 case TYPE_lng:
    3219             :                         switch (tp) {
    3220           0 :                         case TYPE_lng:
    3221           0 :                                 nils = add_sht_lng_lng(lft, incr1, rgt, incr2,
    3222             :                                                        dst, GDK_lng_max,
    3223             :                                                        ci1, ci2, candoff1, candoff2,
    3224             :                                                        abort_on_error);
    3225           0 :                                 break;
    3226             : #ifdef HAVE_HGE
    3227           0 :                         case TYPE_hge:
    3228           0 :                                 nils = add_sht_lng_hge(lft, incr1, rgt, incr2,
    3229             :                                                        dst, GDK_hge_max,
    3230             :                                                        ci1, ci2, candoff1, candoff2,
    3231             :                                                        abort_on_error);
    3232           0 :                                 break;
    3233             : #endif
    3234           0 :                         case TYPE_flt:
    3235           0 :                                 nils = add_sht_lng_flt(lft, incr1, rgt, incr2,
    3236             :                                                        dst, GDK_flt_max,
    3237             :                                                        ci1, ci2, candoff1, candoff2,
    3238             :                                                        abort_on_error);
    3239           0 :                                 break;
    3240           0 :                         case TYPE_dbl:
    3241           0 :                                 nils = add_sht_lng_dbl(lft, incr1, rgt, incr2,
    3242             :                                                        dst, GDK_dbl_max,
    3243             :                                                        ci1, ci2, candoff1, candoff2,
    3244             :                                                        abort_on_error);
    3245           0 :                                 break;
    3246           0 :                         default:
    3247           0 :                                 goto unsupported;
    3248             :                         }
    3249             :                         break;
    3250             : #ifdef HAVE_HGE
    3251           0 :                 case TYPE_hge:
    3252             :                         switch (tp) {
    3253           0 :                         case TYPE_hge:
    3254           0 :                                 nils = add_sht_hge_hge(lft, incr1, rgt, incr2,
    3255             :                                                        dst, GDK_hge_max,
    3256             :                                                        ci1, ci2, candoff1, candoff2,
    3257             :                                                        abort_on_error);
    3258           0 :                                 break;
    3259           0 :                         case TYPE_flt:
    3260           0 :                                 nils = add_sht_hge_flt(lft, incr1, rgt, incr2,
    3261             :                                                        dst, GDK_flt_max,
    3262             :                                                        ci1, ci2, candoff1, candoff2,
    3263             :                                                        abort_on_error);
    3264           0 :                                 break;
    3265           0 :                         case TYPE_dbl:
    3266           0 :                                 nils = add_sht_hge_dbl(lft, incr1, rgt, incr2,
    3267             :                                                        dst, GDK_dbl_max,
    3268             :                                                        ci1, ci2, candoff1, candoff2,
    3269             :                                                        abort_on_error);
    3270           0 :                                 break;
    3271           0 :                         default:
    3272           0 :                                 goto unsupported;
    3273             :                         }
    3274             :                         break;
    3275             : #endif
    3276           0 :                 case TYPE_flt:
    3277             :                         switch (tp) {
    3278           0 :                         case TYPE_flt:
    3279           0 :                                 nils = add_sht_flt_flt(lft, incr1, rgt, incr2,
    3280             :                                                        dst, GDK_flt_max,
    3281             :                                                        ci1, ci2, candoff1, candoff2,
    3282             :                                                        abort_on_error);
    3283           0 :                                 break;
    3284           0 :                         case TYPE_dbl:
    3285           0 :                                 nils = add_sht_flt_dbl(lft, incr1, rgt, incr2,
    3286             :                                                        dst, GDK_dbl_max,
    3287             :                                                        ci1, ci2, candoff1, candoff2,
    3288             :                                                        abort_on_error);
    3289           0 :                                 break;
    3290           0 :                         default:
    3291           0 :                                 goto unsupported;
    3292             :                         }
    3293             :                         break;
    3294           0 :                 case TYPE_dbl:
    3295             :                         switch (tp) {
    3296           0 :                         case TYPE_dbl:
    3297           0 :                                 nils = add_sht_dbl_dbl(lft, incr1, rgt, incr2,
    3298             :                                                        dst, GDK_dbl_max,
    3299             :                                                        ci1, ci2, candoff1, candoff2,
    3300             :                                                        abort_on_error);
    3301             :                                 break;
    3302           0 :                         default:
    3303           0 :                                 goto unsupported;
    3304             :                         }
    3305           0 :                         break;
    3306           0 :                 default:
    3307           0 :                         goto unsupported;
    3308             :                 }
    3309             :                 break;
    3310      100802 :         case TYPE_int:
    3311             :                 switch (tp2) {
    3312           0 :                 case TYPE_bte:
    3313             :                         switch (tp) {
    3314           0 :                         case TYPE_int:
    3315           0 :                                 nils = add_int_bte_int(lft, incr1, rgt, incr2,
    3316             :                                                        dst, GDK_int_max,
    3317             :                                                        ci1, ci2, candoff1, candoff2,
    3318             :                                                        abort_on_error);
    3319           0 :                                 break;
    3320           0 :                         case TYPE_lng:
    3321           0 :                                 nils = add_int_bte_lng(lft, incr1, rgt, incr2,
    3322             :                                                        dst, GDK_lng_max,
    3323             :                                                        ci1, ci2, candoff1, candoff2,
    3324             :                                                        abort_on_error);
    3325           0 :                                 break;
    3326             : #ifdef HAVE_HGE
    3327           0 :                         case TYPE_hge:
    3328           0 :                                 nils = add_int_bte_hge(lft, incr1, rgt, incr2,
    3329             :                                                        dst, GDK_hge_max,
    3330             :                                                        ci1, ci2, candoff1, candoff2,
    3331             :                                                        abort_on_error);
    3332           0 :                                 break;
    3333             : #endif
    3334           0 :                         case TYPE_flt:
    3335           0 :                                 nils = add_int_bte_flt(lft, incr1, rgt, incr2,
    3336             :                                                        dst, GDK_flt_max,
    3337             :                                                        ci1, ci2, candoff1, candoff2,
    3338             :                                                        abort_on_error);
    3339           0 :                                 break;
    3340           0 :                         case TYPE_dbl:
    3341           0 :                                 nils = add_int_bte_dbl(lft, incr1, rgt, incr2,
    3342             :                                                        dst, GDK_dbl_max,
    3343             :                                                        ci1, ci2, candoff1, candoff2,
    3344             :                                                        abort_on_error);
    3345           0 :                                 break;
    3346           0 :                         default:
    3347           0 :                                 goto unsupported;
    3348             :                         }
    3349             :                         break;
    3350           0 :                 case TYPE_sht:
    3351             :                         switch (tp) {
    3352           0 :                         case TYPE_int:
    3353           0 :                                 nils = add_int_sht_int(lft, incr1, rgt, incr2,
    3354             :                                                        dst, GDK_int_max,
    3355             :                                                        ci1, ci2, candoff1, candoff2,
    3356             :                                                        abort_on_error);
    3357           0 :                                 break;
    3358           0 :                         case TYPE_lng:
    3359           0 :                                 nils = add_int_sht_lng(lft, incr1, rgt, incr2,
    3360             :                                                        dst, GDK_lng_max,
    3361             :                                                        ci1, ci2, candoff1, candoff2,
    3362             :                                                        abort_on_error);
    3363           0 :                                 break;
    3364             : #ifdef HAVE_HGE
    3365           0 :                         case TYPE_hge:
    3366           0 :                                 nils = add_int_sht_hge(lft, incr1, rgt, incr2,
    3367             :                                                        dst, GDK_hge_max,
    3368             :                                                        ci1, ci2, candoff1, candoff2,
    3369             :                                                        abort_on_error);
    3370           0 :                                 break;
    3371             : #endif
    3372           0 :                         case TYPE_flt:
    3373           0 :                                 nils = add_int_sht_flt(lft, incr1, rgt, incr2,
    3374             :                                                        dst, GDK_flt_max,
    3375             :                                                        ci1, ci2, candoff1, candoff2,
    3376             :                                                        abort_on_error);
    3377           0 :                                 break;
    3378           0 :                         case TYPE_dbl:
    3379           0 :                                 nils = add_int_sht_dbl(lft, incr1, rgt, incr2,
    3380             :                                                        dst, GDK_dbl_max,
    3381             :                                                        ci1, ci2, candoff1, candoff2,
    3382             :                                                        abort_on_error);
    3383           0 :                                 break;
    3384           0 :                         default:
    3385           0 :                                 goto unsupported;
    3386             :                         }
    3387             :                         break;
    3388      100802 :                 case TYPE_int:
    3389             :                         switch (tp) {
    3390      100802 :                         case TYPE_int:
    3391      100802 :                                 nils = add_int_int_int(lft, incr1, rgt, incr2,
    3392             :                                                        dst, GDK_int_max,
    3393             :                                                        ci1, ci2, candoff1, candoff2,
    3394             :                                                        abort_on_error);
    3395      100802 :                                 break;
    3396           0 :                         case TYPE_lng:
    3397           0 :                                 nils = add_int_int_lng(lft, incr1, rgt, incr2,
    3398             :                                                        dst, GDK_lng_max,
    3399             :                                                        ci1, ci2, candoff1, candoff2,
    3400             :                                                        abort_on_error);
    3401           0 :                                 break;
    3402             : #ifdef HAVE_HGE
    3403           0 :                         case TYPE_hge:
    3404           0 :                                 nils = add_int_int_hge(lft, incr1, rgt, incr2,
    3405             :                                                        dst, GDK_hge_max,
    3406             :                                                        ci1, ci2, candoff1, candoff2,
    3407             :                                                        abort_on_error);
    3408           0 :                                 break;
    3409             : #endif
    3410           0 :                         case TYPE_flt:
    3411           0 :                                 nils = add_int_int_flt(lft, incr1, rgt, incr2,
    3412             :                                                        dst, GDK_flt_max,
    3413             :                                                        ci1, ci2, candoff1, candoff2,
    3414             :                                                        abort_on_error);
    3415           0 :                                 break;
    3416           0 :                         case TYPE_dbl:
    3417           0 :                                 nils = add_int_int_dbl(lft, incr1, rgt, incr2,
    3418             :                                                        dst, GDK_dbl_max,
    3419             :                                                        ci1, ci2, candoff1, candoff2,
    3420             :                                                        abort_on_error);
    3421           0 :                                 break;
    3422           0 :                         default:
    3423           0 :                                 goto unsupported;
    3424             :                         }
    3425             :                         break;
    3426           0 :                 case TYPE_lng:
    3427             :                         switch (tp) {
    3428           0 :                         case TYPE_lng:
    3429           0 :                                 nils = add_int_lng_lng(lft, incr1, rgt, incr2,
    3430             :                                                        dst, GDK_lng_max,
    3431             :                                                        ci1, ci2, candoff1, candoff2,
    3432             :                                                        abort_on_error);
    3433           0 :                                 break;
    3434             : #ifdef HAVE_HGE
    3435           0 :                         case TYPE_hge:
    3436           0 :                                 nils = add_int_lng_hge(lft, incr1, rgt, incr2,
    3437             :                                                        dst, GDK_hge_max,
    3438             :                                                        ci1, ci2, candoff1, candoff2,
    3439             :                                                        abort_on_error);
    3440           0 :                                 break;
    3441             : #endif
    3442           0 :                         case TYPE_flt:
    3443           0 :                                 nils = add_int_lng_flt(lft, incr1, rgt, incr2,
    3444             :                                                        dst, GDK_flt_max,
    3445             :                                                        ci1, ci2, candoff1, candoff2,
    3446             :                                                        abort_on_error);
    3447           0 :                                 break;
    3448           0 :                         case TYPE_dbl:
    3449           0 :                                 nils = add_int_lng_dbl(lft, incr1, rgt, incr2,
    3450             :                                                        dst, GDK_dbl_max,
    3451             :                                                        ci1, ci2, candoff1, candoff2,
    3452             :                                                        abort_on_error);
    3453           0 :                                 break;
    3454           0 :                         default:
    3455           0 :                                 goto unsupported;
    3456             :                         }
    3457             :                         break;
    3458             : #ifdef HAVE_HGE
    3459           0 :                 case TYPE_hge:
    3460             :                         switch (tp) {
    3461           0 :                         case TYPE_hge:
    3462           0 :                                 nils = add_int_hge_hge(lft, incr1, rgt, incr2,
    3463             :                                                        dst, GDK_hge_max,
    3464             :                                                        ci1, ci2, candoff1, candoff2,
    3465             :                                                        abort_on_error);
    3466           0 :                                 break;
    3467           0 :                         case TYPE_flt:
    3468           0 :                                 nils = add_int_hge_flt(lft, incr1, rgt, incr2,
    3469             :                                                        dst, GDK_flt_max,
    3470             :                                                        ci1, ci2, candoff1, candoff2,
    3471             :                                                        abort_on_error);
    3472           0 :                                 break;
    3473           0 :                         case TYPE_dbl:
    3474           0 :                                 nils = add_int_hge_dbl(lft, incr1, rgt, incr2,
    3475             :                                                        dst, GDK_dbl_max,
    3476             :                                                        ci1, ci2, candoff1, candoff2,
    3477             :                                                        abort_on_error);
    3478           0 :                                 break;
    3479           0 :                         default:
    3480           0 :                                 goto unsupported;
    3481             :                         }
    3482             :                         break;
    3483             : #endif
    3484           0 :                 case TYPE_flt:
    3485             :                         switch (tp) {
    3486           0 :                         case TYPE_flt:
    3487           0 :                                 nils = add_int_flt_flt(lft, incr1, rgt, incr2,
    3488             :                                                        dst, GDK_flt_max,
    3489             :                                                        ci1, ci2, candoff1, candoff2,
    3490             :                                                        abort_on_error);
    3491           0 :                                 break;
    3492           0 :                         case TYPE_dbl:
    3493           0 :                                 nils = add_int_flt_dbl(lft, incr1, rgt, incr2,
    3494             :                                                        dst, GDK_dbl_max,
    3495             :                                                        ci1, ci2, candoff1, candoff2,
    3496             :                                                        abort_on_error);
    3497           0 :                                 break;
    3498           0 :                         default:
    3499           0 :                                 goto unsupported;
    3500             :                         }
    3501             :                         break;
    3502           0 :                 case TYPE_dbl:
    3503             :                         switch (tp) {
    3504           0 :                         case TYPE_dbl:
    3505           0 :                                 nils = add_int_dbl_dbl(lft, incr1, rgt, incr2,
    3506             :                                                        dst, GDK_dbl_max,
    3507             :                                                        ci1, ci2, candoff1, candoff2,
    3508             :                                                        abort_on_error);
    3509             :                                 break;
    3510           0 :                         default:
    3511           0 :                                 goto unsupported;
    3512             :                         }
    3513           0 :                         break;
    3514           0 :                 default:
    3515           0 :                         goto unsupported;
    3516             :                 }
    3517             :                 break;
    3518       51085 :         case TYPE_lng:
    3519             :                 switch (tp2) {
    3520           0 :                 case TYPE_bte:
    3521             :                         switch (tp) {
    3522           0 :                         case TYPE_lng:
    3523           0 :                                 nils = add_lng_bte_lng(lft, incr1, rgt, incr2,
    3524             :                                                        dst, GDK_lng_max,
    3525             :                                                        ci1, ci2, candoff1, candoff2,
    3526             :                                                        abort_on_error);
    3527           0 :                                 break;
    3528             : #ifdef HAVE_HGE
    3529           0 :                         case TYPE_hge:
    3530           0 :                                 nils = add_lng_bte_hge(lft, incr1, rgt, incr2,
    3531             :                                                        dst, GDK_hge_max,
    3532             :                                                        ci1, ci2, candoff1, candoff2,
    3533             :                                                        abort_on_error);
    3534           0 :                                 break;
    3535             : #endif
    3536           0 :                         case TYPE_flt:
    3537           0 :                                 nils = add_lng_bte_flt(lft, incr1, rgt, incr2,
    3538             :                                                        dst, GDK_flt_max,
    3539             :                                                        ci1, ci2, candoff1, candoff2,
    3540             :                                                        abort_on_error);
    3541           0 :                                 break;
    3542           0 :                         case TYPE_dbl:
    3543           0 :                                 nils = add_lng_bte_dbl(lft, incr1, rgt, incr2,
    3544             :                                                        dst, GDK_dbl_max,
    3545             :                                                        ci1, ci2, candoff1, candoff2,
    3546             :                                                        abort_on_error);
    3547           0 :                                 break;
    3548           0 :                         default:
    3549           0 :                                 goto unsupported;
    3550             :                         }
    3551             :                         break;
    3552           0 :                 case TYPE_sht:
    3553             :                         switch (tp) {
    3554           0 :                         case TYPE_lng:
    3555           0 :                                 nils = add_lng_sht_lng(lft, incr1, rgt, incr2,
    3556             :                                                        dst, GDK_lng_max,
    3557             :                                                        ci1, ci2, candoff1, candoff2,
    3558             :                                                        abort_on_error);
    3559           0 :                                 break;
    3560             : #ifdef HAVE_HGE
    3561           0 :                         case TYPE_hge:
    3562           0 :                                 nils = add_lng_sht_hge(lft, incr1, rgt, incr2,
    3563             :                                                        dst, GDK_hge_max,
    3564             :                                                        ci1, ci2, candoff1, candoff2,
    3565             :                                                        abort_on_error);
    3566           0 :                                 break;
    3567             : #endif
    3568           0 :                         case TYPE_flt:
    3569           0 :                                 nils = add_lng_sht_flt(lft, incr1, rgt, incr2,
    3570             :                                                        dst, GDK_flt_max,
    3571             :                                                        ci1, ci2, candoff1, candoff2,
    3572             :                                                        abort_on_error);
    3573           0 :                                 break;
    3574           0 :                         case TYPE_dbl:
    3575           0 :                                 nils = add_lng_sht_dbl(lft, incr1, rgt, incr2,
    3576             :                                                        dst, GDK_dbl_max,
    3577             :                                                        ci1, ci2, candoff1, candoff2,
    3578             :                                                        abort_on_error);
    3579           0 :                                 break;
    3580           0 :                         default:
    3581           0 :                                 goto unsupported;
    3582             :                         }
    3583             :                         break;
    3584          10 :                 case TYPE_int:
    3585             :                         switch (tp) {
    3586          10 :                         case TYPE_lng:
    3587          10 :                                 nils = add_lng_int_lng(lft, incr1, rgt, incr2,
    3588             :                                                        dst, GDK_lng_max,
    3589             :                                                        ci1, ci2, candoff1, candoff2,
    3590             :                                                        abort_on_error);
    3591          10 :                                 break;
    3592             : #ifdef HAVE_HGE
    3593           0 :                         case TYPE_hge:
    3594           0 :                                 nils = add_lng_int_hge(lft, incr1, rgt, incr2,
    3595             :                                                        dst, GDK_hge_max,
    3596             :                                                        ci1, ci2, candoff1, candoff2,
    3597             :                                                        abort_on_error);
    3598           0 :                                 break;
    3599             : #endif
    3600           0 :                         case TYPE_flt:
    3601           0 :                                 nils = add_lng_int_flt(lft, incr1, rgt, incr2,
    3602             :                                                        dst, GDK_flt_max,
    3603             :                                                        ci1, ci2, candoff1, candoff2,
    3604             :                                                        abort_on_error);
    3605           0 :                                 break;
    3606           0 :                         case TYPE_dbl:
    3607           0 :                                 nils = add_lng_int_dbl(lft, incr1, rgt, incr2,
    3608             :                                                        dst, GDK_dbl_max,
    3609             :                                                        ci1, ci2, candoff1, candoff2,
    3610             :                                                        abort_on_error);
    3611           0 :                                 break;
    3612           0 :                         default:
    3613           0 :                                 goto unsupported;
    3614             :                         }
    3615             :                         break;
    3616       51075 :                 case TYPE_lng:
    3617             :                         switch (tp) {
    3618       51075 :                         case TYPE_lng:
    3619       51075 :                                 nils = add_lng_lng_lng(lft, incr1, rgt, incr2,
    3620             :                                                        dst, GDK_lng_max,
    3621             :                                                        ci1, ci2, candoff1, candoff2,
    3622             :                                                        abort_on_error);
    3623       51342 :                                 break;
    3624             : #ifdef HAVE_HGE
    3625           0 :                         case TYPE_hge:
    3626           0 :                                 nils = add_lng_lng_hge(lft, incr1, rgt, incr2,
    3627             :                                                        dst, GDK_hge_max,
    3628             :                                                        ci1, ci2, candoff1, candoff2,
    3629             :                                                        abort_on_error);
    3630           0 :                                 break;
    3631             : #endif
    3632           0 :                         case TYPE_flt:
    3633           0 :                                 nils = add_lng_lng_flt(lft, incr1, rgt, incr2,
    3634             :                                                        dst, GDK_flt_max,
    3635             :                                                        ci1, ci2, candoff1, candoff2,
    3636             :                                                        abort_on_error);
    3637           0 :                                 break;
    3638           0 :                         case TYPE_dbl:
    3639           0 :                                 nils = add_lng_lng_dbl(lft, incr1, rgt, incr2,
    3640             :                                                        dst, GDK_dbl_max,
    3641             :                                                        ci1, ci2, candoff1, candoff2,
    3642             :                                                        abort_on_error);
    3643           0 :                                 break;
    3644           0 :                         default:
    3645           0 :                                 goto unsupported;
    3646             :                         }
    3647             :                         break;
    3648             : #ifdef HAVE_HGE
    3649           0 :                 case TYPE_hge:
    3650             :                         switch (tp) {
    3651           0 :                         case TYPE_hge:
    3652           0 :                                 nils = add_lng_hge_hge(lft, incr1, rgt, incr2,
    3653             :                                                        dst, GDK_hge_max,
    3654             :                                                        ci1, ci2, candoff1, candoff2,
    3655             :                                                        abort_on_error);
    3656           0 :                                 break;
    3657           0 :                         case TYPE_flt:
    3658           0 :                                 nils = add_lng_hge_flt(lft, incr1, rgt, incr2,
    3659             :                                                        dst, GDK_flt_max,
    3660             :                                                        ci1, ci2, candoff1, candoff2,
    3661             :                                                        abort_on_error);
    3662           0 :                                 break;
    3663           0 :                         case TYPE_dbl:
    3664           0 :                                 nils = add_lng_hge_dbl(lft, incr1, rgt, incr2,
    3665             :                                                        dst, GDK_dbl_max,
    3666             :                                                        ci1, ci2, candoff1, candoff2,
    3667             :                                                        abort_on_error);
    3668           0 :                                 break;
    3669           0 :                         default:
    3670           0 :                                 goto unsupported;
    3671             :                         }
    3672             :                         break;
    3673             : #endif
    3674           0 :                 case TYPE_flt:
    3675             :                         switch (tp) {
    3676           0 :                         case TYPE_flt:
    3677           0 :                                 nils = add_lng_flt_flt(lft, incr1, rgt, incr2,
    3678             :                                                        dst, GDK_flt_max,
    3679             :                                                        ci1, ci2, candoff1, candoff2,
    3680             :                                                        abort_on_error);
    3681           0 :                                 break;
    3682           0 :                         case TYPE_dbl:
    3683           0 :                                 nils = add_lng_flt_dbl(lft, incr1, rgt, incr2,
    3684             :                                                        dst, GDK_dbl_max,
    3685             :                                                        ci1, ci2, candoff1, candoff2,
    3686             :                                                        abort_on_error);
    3687           0 :                                 break;
    3688           0 :                         default:
    3689           0 :                                 goto unsupported;
    3690             :                         }
    3691             :                         break;
    3692           0 :                 case TYPE_dbl:
    3693             :                         switch (tp) {
    3694           0 :                         case TYPE_dbl:
    3695           0 :                                 nils = add_lng_dbl_dbl(lft, incr1, rgt, incr2,
    3696             :                                                        dst, GDK_dbl_max,
    3697             :                                                        ci1, ci2, candoff1, candoff2,
    3698             :                                                        abort_on_error);
    3699             :                                 break;
    3700           0 :                         default:
    3701           0 :                                 goto unsupported;
    3702             :                         }
    3703           0 :                         break;
    3704           0 :                 default:
    3705           0 :                         goto unsupported;
    3706             :                 }
    3707             :                 break;
    3708             : #ifdef HAVE_HGE
    3709       20838 :         case TYPE_hge:
    3710             :                 switch (tp2) {
    3711           0 :                 case TYPE_bte:
    3712             :                         switch (tp) {
    3713           0 :                         case TYPE_hge:
    3714           0 :                                 nils = add_hge_bte_hge(lft, incr1, rgt, incr2,
    3715             :                                                        dst, GDK_hge_max,
    3716             :                                                        ci1, ci2, candoff1, candoff2,
    3717             :                                                        abort_on_error);
    3718           0 :                                 break;
    3719           0 :                         case TYPE_flt:
    3720           0 :                                 nils = add_hge_bte_flt(lft, incr1, rgt, incr2,
    3721             :                                                        dst, GDK_flt_max,
    3722             :                                                        ci1, ci2, candoff1, candoff2,
    3723             :                                                        abort_on_error);
    3724           0 :                                 break;
    3725           0 :                         case TYPE_dbl:
    3726           0 :                                 nils = add_hge_bte_dbl(lft, incr1, rgt, incr2,
    3727             :                                                        dst, GDK_dbl_max,
    3728             :                                                        ci1, ci2, candoff1, candoff2,
    3729             :                                                        abort_on_error);
    3730           0 :                                 break;
    3731           0 :                         default:
    3732           0 :                                 goto unsupported;
    3733             :                         }
    3734             :                         break;
    3735           0 :                 case TYPE_sht:
    3736             :                         switch (tp) {
    3737           0 :                         case TYPE_hge:
    3738           0 :                                 nils = add_hge_sht_hge(lft, incr1, rgt, incr2,
    3739             :                                                        dst, GDK_hge_max,
    3740             :                                                        ci1, ci2, candoff1, candoff2,
    3741             :                                                        abort_on_error);
    3742           0 :                                 break;
    3743           0 :                         case TYPE_flt:
    3744           0 :                                 nils = add_hge_sht_flt(lft, incr1, rgt, incr2,
    3745             :                                                        dst, GDK_flt_max,
    3746             :                                                        ci1, ci2, candoff1, candoff2,
    3747             :                                                        abort_on_error);
    3748           0 :                                 break;
    3749           0 :                         case TYPE_dbl:
    3750           0 :                                 nils = add_hge_sht_dbl(lft, incr1, rgt, incr2,
    3751             :                                                        dst, GDK_dbl_max,
    3752             :                                                        ci1, ci2, candoff1, candoff2,
    3753             :                                                        abort_on_error);
    3754           0 :                                 break;
    3755           0 :                         default:
    3756           0 :                                 goto unsupported;
    3757             :                         }
    3758             :                         break;
    3759           0 :                 case TYPE_int:
    3760             :                         switch (tp) {
    3761           0 :                         case TYPE_hge:
    3762           0 :                                 nils = add_hge_int_hge(lft, incr1, rgt, incr2,
    3763             :                                                        dst, GDK_hge_max,
    3764             :                                                        ci1, ci2, candoff1, candoff2,
    3765             :                                                        abort_on_error);
    3766           0 :                                 break;
    3767           0 :                         case TYPE_flt:
    3768           0 :                                 nils = add_hge_int_flt(lft, incr1, rgt, incr2,
    3769             :                                                        dst, GDK_flt_max,
    3770             :                                                        ci1, ci2, candoff1, candoff2,
    3771             :                                                        abort_on_error);
    3772           0 :                                 break;
    3773           0 :                         case TYPE_dbl:
    3774           0 :                                 nils = add_hge_int_dbl(lft, incr1, rgt, incr2,
    3775             :                                                        dst, GDK_dbl_max,
    3776             :                                                        ci1, ci2, candoff1, candoff2,
    3777             :                                                        abort_on_error);
    3778           0 :                                 break;
    3779           0 :                         default:
    3780           0 :                                 goto unsupported;
    3781             :                         }
    3782             :                         break;
    3783           0 :                 case TYPE_lng:
    3784             :                         switch (tp) {
    3785           0 :                         case TYPE_hge:
    3786           0 :                                 nils = add_hge_lng_hge(lft, incr1, rgt, incr2,
    3787             :                                                        dst, GDK_hge_max,
    3788             :                                                        ci1, ci2, candoff1, candoff2,
    3789             :                                                        abort_on_error);
    3790           0 :                                 break;
    3791           0 :                         case TYPE_flt:
    3792           0 :                                 nils = add_hge_lng_flt(lft, incr1, rgt, incr2,
    3793             :                                                        dst, GDK_flt_max,
    3794             :                                                        ci1, ci2, candoff1, candoff2,
    3795             :                                                        abort_on_error);
    3796           0 :                                 break;
    3797           0 :                         case TYPE_dbl:
    3798           0 :                                 nils = add_hge_lng_dbl(lft, incr1, rgt, incr2,
    3799             :                                                        dst, GDK_dbl_max,
    3800             :                                                        ci1, ci2, candoff1, candoff2,
    3801             :                                                        abort_on_error);
    3802           0 :                                 break;
    3803           0 :                         default:
    3804           0 :                                 goto unsupported;
    3805             :                         }
    3806             :                         break;
    3807       20838 :                 case TYPE_hge:
    3808             :                         switch (tp) {
    3809       20838 :                         case TYPE_hge:
    3810       20838 :                                 nils = add_hge_hge_hge(lft, incr1, rgt, incr2,
    3811             :                                                        dst, GDK_hge_max,
    3812             :                                                        ci1, ci2, candoff1, candoff2,
    3813             :                                                        abort_on_error);
    3814       20910 :                                 break;
    3815           0 :                         case TYPE_flt:
    3816           0 :                                 nils = add_hge_hge_flt(lft, incr1, rgt, incr2,
    3817             :                                                        dst, GDK_flt_max,
    3818             :                                                        ci1, ci2, candoff1, candoff2,
    3819             :                                                        abort_on_error);
    3820           0 :                                 break;
    3821           0 :                         case TYPE_dbl:
    3822           0 :                                 nils = add_hge_hge_dbl(lft, incr1, rgt, incr2,
    3823             :                                                        dst, GDK_dbl_max,
    3824             :                                                        ci1, ci2, candoff1, candoff2,
    3825             :                                                        abort_on_error);
    3826           0 :                                 break;
    3827           0 :                         default:
    3828           0 :                                 goto unsupported;
    3829             :                         }
    3830             :                         break;
    3831           0 :                 case TYPE_flt:
    3832             :                         switch (tp) {
    3833           0 :                         case TYPE_flt:
    3834           0 :                                 nils = add_hge_flt_flt(lft, incr1, rgt, incr2,
    3835             :                                                        dst, GDK_flt_max,
    3836             :                                                        ci1, ci2, candoff1, candoff2,
    3837             :                                                        abort_on_error);
    3838           0 :                                 break;
    3839           0 :                         case TYPE_dbl:
    3840           0 :                                 nils = add_hge_flt_dbl(lft, incr1, rgt, incr2,
    3841             :                                                        dst, GDK_dbl_max,
    3842             :                                                        ci1, ci2, candoff1, candoff2,
    3843             :                                                        abort_on_error);
    3844           0 :                                 break;
    3845           0 :                         default:
    3846           0 :                                 goto unsupported;
    3847             :                         }
    3848             :                         break;
    3849           0 :                 case TYPE_dbl:
    3850             :                         switch (tp) {
    3851           0 :                         case TYPE_dbl:
    3852           0 :                                 nils = add_hge_dbl_dbl(lft, incr1, rgt, incr2,
    3853             :                                                        dst, GDK_dbl_max,
    3854             :                                                        ci1, ci2, candoff1, candoff2,
    3855             :                                                        abort_on_error);
    3856             :                                 break;
    3857           0 :                         default:
    3858           0 :                                 goto unsupported;
    3859             :                         }
    3860           0 :                         break;
    3861           0 :                 default:
    3862           0 :                         goto unsupported;
    3863             :                 }
    3864             :                 break;
    3865             : #endif
    3866          47 :         case TYPE_flt:
    3867             :                 switch (tp2) {
    3868           0 :                 case TYPE_bte:
    3869             :                         switch (tp) {
    3870           0 :                         case TYPE_flt:
    3871           0 :                                 nils = add_flt_bte_flt(lft, incr1, rgt, incr2,
    3872             :                                                        dst, GDK_flt_max,
    3873             :                                                        ci1, ci2, candoff1, candoff2,
    3874             :                                                        abort_on_error);
    3875           0 :                                 break;
    3876           0 :                         case TYPE_dbl:
    3877           0 :                                 nils = add_flt_bte_dbl(lft, incr1, rgt, incr2,
    3878             :                                                        dst, GDK_dbl_max,
    3879             :                                                        ci1, ci2, candoff1, candoff2,
    3880             :                                                        abort_on_error);
    3881           0 :                                 break;
    3882           0 :                         default:
    3883           0 :                                 goto unsupported;
    3884             :                         }
    3885             :                         break;
    3886           0 :                 case TYPE_sht:
    3887             :                         switch (tp) {
    3888           0 :                         case TYPE_flt:
    3889           0 :                                 nils = add_flt_sht_flt(lft, incr1, rgt, incr2,
    3890             :                                                        dst, GDK_flt_max,
    3891             :                                                        ci1, ci2, candoff1, candoff2,
    3892             :                                                        abort_on_error);
    3893           0 :                                 break;
    3894           0 :                         case TYPE_dbl:
    3895           0 :                                 nils = add_flt_sht_dbl(lft, incr1, rgt, incr2,
    3896             :                                                        dst, GDK_dbl_max,
    3897             :                                                        ci1, ci2, candoff1, candoff2,
    3898             :                                                        abort_on_error);
    3899           0 :                                 break;
    3900           0 :                         default:
    3901           0 :                                 goto unsupported;
    3902             :                         }
    3903             :                         break;
    3904           1 :                 case TYPE_int:
    3905             :                         switch (tp) {
    3906           1 :                         case TYPE_flt:
    3907           1 :                                 nils = add_flt_int_flt(lft, incr1, rgt, incr2,
    3908             :                                                        dst, GDK_flt_max,
    3909             :                                                        ci1, ci2, candoff1, candoff2,
    3910             :                                                        abort_on_error);
    3911           1 :                                 break;
    3912           0 :                         case TYPE_dbl:
    3913           0 :                                 nils = add_flt_int_dbl(lft, incr1, rgt, incr2,
    3914             :                                                        dst, GDK_dbl_max,
    3915             :                                                        ci1, ci2, candoff1, candoff2,
    3916             :                                                        abort_on_error);
    3917           0 :                                 break;
    3918           0 :                         default:
    3919           0 :                                 goto unsupported;
    3920             :                         }
    3921             :                         break;
    3922           0 :                 case TYPE_lng:
    3923             :                         switch (tp) {
    3924           0 :                         case TYPE_flt:
    3925           0 :                                 nils = add_flt_lng_flt(lft, incr1, rgt, incr2,
    3926             :                                                        dst, GDK_flt_max,
    3927             :                                                        ci1, ci2, candoff1, candoff2,
    3928             :                                                        abort_on_error);
    3929           0 :                                 break;
    3930           0 :                         case TYPE_dbl:
    3931           0 :                                 nils = add_flt_lng_dbl(lft, incr1, rgt, incr2,
    3932             :                                                        dst, GDK_dbl_max,
    3933             :                                                        ci1, ci2, candoff1, candoff2,
    3934             :                                                        abort_on_error);
    3935           0 :                                 break;
    3936           0 :                         default:
    3937           0 :                                 goto unsupported;
    3938             :                         }
    3939             :                         break;
    3940             : #ifdef HAVE_HGE
    3941           0 :                 case TYPE_hge:
    3942             :                         switch (tp) {
    3943           0 :                         case TYPE_flt:
    3944           0 :                                 nils = add_flt_hge_flt(lft, incr1, rgt, incr2,
    3945             :                                                        dst, GDK_flt_max,
    3946             :                                                        ci1, ci2, candoff1, candoff2,
    3947             :                                                        abort_on_error);
    3948           0 :                                 break;
    3949           0 :                         case TYPE_dbl:
    3950           0 :                                 nils = add_flt_hge_dbl(lft, incr1, rgt, incr2,
    3951             :                                                        dst, GDK_dbl_max,
    3952             :                                                        ci1, ci2, candoff1, candoff2,
    3953             :                                                        abort_on_error);
    3954           0 :                                 break;
    3955           0 :                         default:
    3956           0 :                                 goto unsupported;
    3957             :                         }
    3958             :                         break;
    3959             : #endif
    3960          46 :                 case TYPE_flt:
    3961             :                         switch (tp) {
    3962          46 :                         case TYPE_flt:
    3963          46 :                                 nils = add_flt_flt_flt(lft, incr1, rgt, incr2,
    3964             :                                                        dst, GDK_flt_max,
    3965             :                                                        ci1, ci2, candoff1, candoff2,
    3966             :                                                        abort_on_error);
    3967          46 :                                 break;
    3968           0 :                         case TYPE_dbl:
    3969           0 :                                 nils = add_flt_flt_dbl(lft, incr1, rgt, incr2,
    3970             :                                                        dst, GDK_dbl_max,
    3971             :                                                        ci1, ci2, candoff1, candoff2,
    3972             :                                                        abort_on_error);
    3973           0 :                                 break;
    3974           0 :                         default:
    3975           0 :                                 goto unsupported;
    3976             :                         }
    3977             :                         break;
    3978           0 :                 case TYPE_dbl:
    3979             :                         switch (tp) {
    3980           0 :                         case TYPE_dbl:
    3981           0 :                                 nils = add_flt_dbl_dbl(lft, incr1, rgt, incr2,
    3982             :                                                        dst, GDK_dbl_max,
    3983             :                                                        ci1, ci2, candoff1, candoff2,
    3984             :                                                        abort_on_error);
    3985             :                                 break;
    3986           0 :                         default:
    3987           0 :                                 goto unsupported;
    3988             :                         }
    3989           0 :                         break;
    3990           0 :                 default:
    3991           0 :                         goto unsupported;
    3992             :                 }
    3993             :                 break;
    3994          96 :         case TYPE_dbl:
    3995             :                 switch (tp2) {
    3996           0 :                 case TYPE_bte:
    3997             :                         switch (tp) {
    3998           0 :                         case TYPE_dbl:
    3999           0 :                                 nils = add_dbl_bte_dbl(lft, incr1, rgt, incr2,
    4000             :                                                        dst, GDK_dbl_max,
    4001             :                                                        ci1, ci2, candoff1, candoff2,
    4002             :                                                        abort_on_error);
    4003             :                                 break;
    4004           0 :                         default:
    4005           0 :                                 goto unsupported;
    4006             :                         }
    4007           0 :                         break;
    4008           0 :                 case TYPE_sht:
    4009             :                         switch (tp) {
    4010           0 :                         case TYPE_dbl:
    4011           0 :                                 nils = add_dbl_sht_dbl(lft, incr1, rgt, incr2,
    4012             :                                                        dst, GDK_dbl_max,
    4013             :                                                        ci1, ci2, candoff1, candoff2,
    4014             :                                                        abort_on_error);
    4015             :                                 break;
    4016           0 :                         default:
    4017           0 :                                 goto unsupported;
    4018             :                         }
    4019           0 :                         break;
    4020           0 :                 case TYPE_int:
    4021             :                         switch (tp) {
    4022           0 :                         case TYPE_dbl:
    4023           0 :                                 nils = add_dbl_int_dbl(lft, incr1, rgt, incr2,
    4024             :                                                        dst, GDK_dbl_max,
    4025             :                                                        ci1, ci2, candoff1, candoff2,
    4026             :                                                        abort_on_error);
    4027             :                                 break;
    4028           0 :                         default:
    4029           0 :                                 goto unsupported;
    4030             :                         }
    4031           0 :                         break;
    4032           0 :                 case TYPE_lng:
    4033             :                         switch (tp) {
    4034           0 :                         case TYPE_dbl:
    4035           0 :                                 nils = add_dbl_lng_dbl(lft, incr1, rgt, incr2,
    4036             :                                                        dst, GDK_dbl_max,
    4037             :                                                        ci1, ci2, candoff1, candoff2,
    4038             :                                                        abort_on_error);
    4039             :                                 break;
    4040           0 :                         default:
    4041           0 :                                 goto unsupported;
    4042             :                         }
    4043           0 :                         break;
    4044             : #ifdef HAVE_HGE
    4045           0 :                 case TYPE_hge:
    4046             :                         switch (tp) {
    4047           0 :                         case TYPE_dbl:
    4048           0 :                                 nils = add_dbl_hge_dbl(lft, incr1, rgt, incr2,
    4049             :                                                        dst, GDK_dbl_max,
    4050             :                                                        ci1, ci2, candoff1, candoff2,
    4051             :                                                        abort_on_error);
    4052             :                                 break;
    4053           0 :                         default:
    4054           0 :                                 goto unsupported;
    4055             :                         }
    4056           0 :                         break;
    4057             : #endif
    4058           0 :                 case TYPE_flt:
    4059             :                         switch (tp) {
    4060           0 :                         case TYPE_dbl:
    4061           0 :                                 nils = add_dbl_flt_dbl(lft, incr1, rgt, incr2,
    4062             :                                                        dst, GDK_dbl_max,
    4063             :                                                        ci1, ci2, candoff1, candoff2,
    4064             :                                                        abort_on_error);
    4065             :                                 break;
    4066           0 :                         default:
    4067           0 :                                 goto unsupported;
    4068             :                         }
    4069           0 :                         break;
    4070          96 :                 case TYPE_dbl:
    4071             :                         switch (tp) {
    4072          96 :                         case TYPE_dbl:
    4073          96 :                                 nils = add_dbl_dbl_dbl(lft, incr1, rgt, incr2,
    4074             :                                                        dst, GDK_dbl_max,
    4075             :                                                        ci1, ci2, candoff1, candoff2,
    4076             :                                                        abort_on_error);
    4077             :                                 break;
    4078           0 :                         default:
    4079           0 :                                 goto unsupported;
    4080             :                         }
    4081          97 :                         break;
    4082           0 :                 default:
    4083           0 :                         goto unsupported;
    4084             :                 }
    4085             :                 break;
    4086           0 :         default:
    4087           0 :                 goto unsupported;
    4088             :         }
    4089             : 
    4090             :         return nils;
    4091             : 
    4092           0 :   unsupported:
    4093           0 :         GDKerror("%s: type combination (add(%s,%s)->%s) not supported.\n",
    4094             :                  func, ATOMname(tp1), ATOMname(tp2), ATOMname(tp));
    4095           0 :         return BUN_NONE;
    4096             : }
    4097             : 
    4098             : static BUN
    4099        2331 : addstr_loop(BAT *b1, const char *l, BAT *b2, const char *r, BAT *bn,
    4100             :             struct canditer *restrict ci1, struct canditer *restrict ci2)
    4101             : {
    4102        2331 :         BUN nils = 0, ncand = ci1->ncand;
    4103             :         char *s;
    4104             :         size_t slen, llen, rlen;
    4105             :         BATiter b1i, b2i;
    4106             :         oid candoff1, candoff2;
    4107             : 
    4108        2331 :         assert(b1 != NULL || b2 != NULL); /* at least one not NULL */
    4109        2331 :         candoff1 = b1 ? b1->hseqbase : 0;
    4110        2331 :         candoff2 = b2 ? b2->hseqbase : 0;
    4111             :         slen = 1024;
    4112        2331 :         s = GDKmalloc(slen);
    4113        2339 :         if (s == NULL)
    4114             :                 return BUN_NONE;
    4115        2339 :         b1i = bat_iterator(b1);
    4116        2321 :         b2i = bat_iterator(b2);
    4117     3961977 :         for (BUN i = 0; i < ncand; i++) {
    4118     3959635 :                 oid x1 = canditer_next(ci1) - candoff1;
    4119     3518193 :                 oid x2 = canditer_next(ci2) - candoff2;
    4120     3227675 :                 if (b1)
    4121     1017335 :                         l = BUNtvar(b1i, x1);
    4122     3227675 :                 if (b2)
    4123     2810069 :                         r = BUNtvar(b2i, x2);
    4124     6487832 :                 if (strNil(l) || strNil(r)) {
    4125           0 :                         nils++;
    4126           0 :                         if (tfastins_nocheckVAR(bn, i, str_nil) != GDK_SUCCEED)
    4127           0 :                                 goto bunins_failed;
    4128             :                 } else {
    4129     3396782 :                         llen = strlen(l);
    4130     3396782 :                         rlen = strlen(r);
    4131     3396782 :                         if (llen + rlen >= slen) {
    4132           0 :                                 slen = llen + rlen + 1024;
    4133           0 :                                 GDKfree(s);
    4134           0 :                                 s = GDKmalloc(slen);
    4135           0 :                                 if (s == NULL)
    4136           0 :                                         goto bunins_failed;
    4137             :                         }
    4138     3396782 :                         (void) stpcpy(stpcpy(s, l), r);
    4139     3396782 :                         if (tfastins_nocheckVAR(bn, i, s) != GDK_SUCCEED)
    4140           0 :                                 goto bunins_failed;
    4141             :                 }
    4142             :         }
    4143        2342 :         bat_iterator_end(&b1i);
    4144        2350 :         bat_iterator_end(&b2i);
    4145        2352 :         GDKfree(s);
    4146        2350 :         bn->theap->dirty = true;
    4147        2350 :         return nils;
    4148             : 
    4149           0 :   bunins_failed:
    4150           0 :         bat_iterator_end(&b1i);
    4151           0 :         bat_iterator_end(&b2i);
    4152           0 :         GDKfree(s);
    4153           0 :         return BUN_NONE;
    4154             : }
    4155             : 
    4156             : BAT *
    4157       60801 : BATcalcadd(BAT *b1, BAT *b2, BAT *s1, BAT *s2, int tp, bool abort_on_error)
    4158             : {
    4159             :         lng t0 = 0;
    4160             :         BAT *bn;
    4161             :         BUN nils;
    4162             :         BUN ncand;
    4163             :         struct canditer ci1, ci2;
    4164             : 
    4165       60801 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    4166             : 
    4167       60801 :         BATcheck(b1, NULL);
    4168       60801 :         BATcheck(b2, NULL);
    4169             : 
    4170       60801 :         ncand = canditer_init(&ci1, b1, s1);
    4171       60740 :         if (canditer_init(&ci2, b2, s2) != ncand ||
    4172       60711 :             ci1.hseq != ci2.hseq) {
    4173           0 :                 GDKerror("inputs not the same size.\n");
    4174           0 :                 return NULL;
    4175             :         }
    4176             : 
    4177       60711 :         bn = COLnew(ci1.hseq, tp, ncand, TRANSIENT);
    4178       60764 :         if (bn == NULL)
    4179             :                 return NULL;
    4180       60764 :         if (ncand == 0)
    4181             :                 return bn;
    4182             : 
    4183       43571 :         if (b1->ttype == TYPE_str && b2->ttype == TYPE_str && tp == TYPE_str) {
    4184         929 :                 nils = addstr_loop(b1, NULL, b2, NULL, bn, &ci1, &ci2);
    4185             :         } else {
    4186       42642 :                 BATiter b1i = bat_iterator(b1);
    4187       42606 :                 BATiter b2i = bat_iterator(b2);
    4188       42731 :                 nils = add_typeswitchloop(b1i.base, b1->ttype, true,
    4189       42731 :                                           b2i.base, b2->ttype, true,
    4190       42731 :                                           Tloc(bn, 0), tp,
    4191             :                                           &ci1, &ci2,
    4192             :                                           b1->hseqbase, b2->hseqbase,
    4193             :                                           abort_on_error, __func__);
    4194       42674 :                 bat_iterator_end(&b1i);
    4195       42697 :                 bat_iterator_end(&b2i);
    4196             :         }
    4197             : 
    4198       43495 :         if (nils == BUN_NONE) {
    4199           0 :                 BBPunfix(bn->batCacheid);
    4200           0 :                 return NULL;
    4201             :         }
    4202             : 
    4203       43495 :         BATsetcount(bn, ncand);
    4204             : 
    4205             :         /* if both inputs are sorted the same way, and no overflow
    4206             :          * occurred (we only know for sure if abort_on_error is set),
    4207             :          * the result is also sorted */
    4208       42732 :         bn->tsorted = (abort_on_error && b1->tsorted && b2->tsorted && nils == 0)
    4209       72211 :                 || ncand <= 1 || nils == ncand;
    4210       42635 :         bn->trevsorted = (abort_on_error && b1->trevsorted && b2->trevsorted && nils == 0)
    4211       78611 :                 || ncand <= 1 || nils == ncand;
    4212       43658 :         bn->tkey = ncand <= 1;
    4213       43658 :         bn->tnil = nils != 0;
    4214       43658 :         bn->tnonil = nils == 0;
    4215             : 
    4216       43658 :         TRC_DEBUG(ALGO, "b1=" ALGOBATFMT ",b2=" ALGOBATFMT
    4217             :                   ",s1=" ALGOOPTBATFMT ",s2=" ALGOOPTBATFMT
    4218             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    4219             :                   ALGOBATPAR(b1), ALGOBATPAR(b2),
    4220             :                   ALGOOPTBATPAR(s1), ALGOOPTBATPAR(s2),
    4221             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    4222             : 
    4223             :         return bn;
    4224             : }
    4225             : 
    4226             : BAT *
    4227       69346 : BATcalcaddcst(BAT *b, const ValRecord *v, BAT *s, int tp, bool abort_on_error)
    4228             : {
    4229             :         lng t0 = 0;
    4230             :         BAT *bn;
    4231             :         BUN nils;
    4232             :         BUN ncand;
    4233             :         struct canditer ci;
    4234             : 
    4235       69346 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    4236             : 
    4237       69346 :         BATcheck(b, NULL);
    4238             : 
    4239       69346 :         ncand = canditer_init(&ci, b, s);
    4240             : 
    4241       69324 :         bn = COLnew(ci.hseq, tp, ncand, TRANSIENT);
    4242       69403 :         if (bn == NULL)
    4243             :                 return NULL;
    4244       69403 :         if (ncand == 0)
    4245             :                 return bn;
    4246             : 
    4247       29676 :         if (b->ttype == TYPE_str && v->vtype == TYPE_str && tp == TYPE_str) {
    4248         925 :                 nils = addstr_loop(b, NULL, NULL, v->val.sval, bn, &ci, &(struct canditer){.tpe=cand_dense, .ncand=ncand});
    4249             :         } else {
    4250       27827 :                 BATiter bi = bat_iterator(b);
    4251       27773 :                 nils = add_typeswitchloop(bi.base, b->ttype, true,
    4252             :                                           VALptr(v), v->vtype, false,
    4253       27773 :                                           Tloc(bn, 0), tp,
    4254             :                                           &ci,
    4255       27773 :                                           &(struct canditer){.tpe=cand_dense, .ncand=ncand},
    4256             :                                           b->hseqbase, 0,
    4257             :                                           abort_on_error, __func__);
    4258       27812 :                 bat_iterator_end(&bi);
    4259             :         }
    4260             : 
    4261       28779 :         if (nils == BUN_NONE) {
    4262           0 :                 BBPunfix(bn->batCacheid);
    4263           0 :                 return NULL;
    4264             :         }
    4265             : 
    4266       28779 :         BATsetcount(bn, ncand);
    4267             : 
    4268             :         /* if the input is sorted, and no overflow occurred (we only
    4269             :          * know for sure if abort_on_error is set), the result is also
    4270             :          * sorted */
    4271       27860 :         bn->tsorted = (abort_on_error && b->tsorted && nils == 0) ||
    4272       49054 :                 ncand <= 1 || nils == ncand;
    4273       27829 :         bn->trevsorted = (abort_on_error && b->trevsorted && nils == 0) ||
    4274       52479 :                 ncand <= 1 || nils == ncand;
    4275       28761 :         bn->tkey = ncand <= 1;
    4276       28761 :         bn->tnil = nils != 0;
    4277       28761 :         bn->tnonil = nils == 0;
    4278             : 
    4279       28761 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
    4280             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    4281             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
    4282             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    4283             : 
    4284             :         return bn;
    4285             : }
    4286             : 
    4287             : BAT *
    4288         752 : BATcalccstadd(const ValRecord *v, BAT *b, BAT *s, int tp, bool abort_on_error)
    4289             : {
    4290             :         lng t0 = 0;
    4291             :         BAT *bn;
    4292             :         BUN nils;
    4293             :         BUN ncand;
    4294             :         struct canditer ci;
    4295             : 
    4296         752 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    4297             : 
    4298         752 :         BATcheck(b, NULL);
    4299             : 
    4300         752 :         ncand = canditer_init(&ci, b, s);
    4301             : 
    4302         752 :         bn = COLnew(ci.hseq, tp, ncand, TRANSIENT);
    4303         749 :         if (bn == NULL)
    4304             :                 return NULL;
    4305         749 :         if (ncand == 0)
    4306             :                 return bn;
    4307             : 
    4308         987 :         if (b->ttype == TYPE_str && v->vtype == TYPE_str && tp == TYPE_str) {
    4309         490 :                 nils = addstr_loop(NULL, v->val.sval, b, NULL, bn, &(struct canditer){.tpe=cand_dense, .ncand=ncand}, &ci);
    4310             :         } else {
    4311           4 :                 BATiter bi = bat_iterator(b);
    4312           7 :                 nils = add_typeswitchloop(VALptr(v), v->vtype, false,
    4313           7 :                                           bi.base, b->ttype, true,
    4314           7 :                                           Tloc(bn, 0), tp,
    4315           7 :                                           &(struct canditer){.tpe=cand_dense, .ncand=ncand},
    4316             :                                           &ci,
    4317             :                                           0, b->hseqbase,
    4318             :                                           abort_on_error, __func__);
    4319           7 :                 bat_iterator_end(&bi);
    4320             :         }
    4321             : 
    4322         500 :         if (nils == BUN_NONE) {
    4323           0 :                 BBPunfix(bn->batCacheid);
    4324           0 :                 return NULL;
    4325             :         }
    4326             : 
    4327         500 :         BATsetcount(bn, ncand);
    4328             : 
    4329             :         /* if the input is sorted, and no overflow occurred (we only
    4330             :          * know for sure if abort_on_error is set), the result is also
    4331             :          * sorted */
    4332           7 :         bn->tsorted = (abort_on_error && b->tsorted && nils == 0) ||
    4333         501 :                 ncand <= 1 || nils == ncand;
    4334           7 :         bn->trevsorted = (abort_on_error && b->trevsorted && nils == 0) ||
    4335         502 :                 ncand <= 1 || nils == ncand;
    4336         496 :         bn->tkey = ncand <= 1;
    4337         496 :         bn->tnil = nils != 0;
    4338         496 :         bn->tnonil = nils == 0;
    4339             : 
    4340         496 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
    4341             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    4342             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
    4343             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    4344             : 
    4345             :         return bn;
    4346             : }
    4347             : 
    4348             : gdk_return
    4349      103118 : VARcalcadd(ValPtr ret, const ValRecord *lft, const ValRecord *rgt,
    4350             :            bool abort_on_error)
    4351             : {
    4352      103118 :         if (add_typeswitchloop(VALptr(lft), lft->vtype, false,
    4353             :                                VALptr(rgt), rgt->vtype, false,
    4354             :                                VALget(ret), ret->vtype,
    4355      103118 :                                &(struct canditer){.tpe=cand_dense, .ncand=1},
    4356      103118 :                                &(struct canditer){.tpe=cand_dense, .ncand=1},
    4357             :                                0, 0, abort_on_error, __func__) == BUN_NONE)
    4358           0 :                 return GDK_FAIL;
    4359      103118 :         return GDK_SUCCEED;
    4360             : }
    4361             : 
    4362             : static BAT *
    4363           0 : BATcalcincrdecr(BAT *b, BAT *s, bool abort_on_error,
    4364             :                 BUN (*typeswitchloop)(const void *, int, bool,
    4365             :                                       const void *, int, bool,
    4366             :                                       void *, int,
    4367             :                                       struct canditer *restrict,
    4368             :                                       struct canditer *restrict,
    4369             :                                       oid, oid, bool, const char *),
    4370             :                 const char *func)
    4371             : {
    4372             :         lng t0 = 0;
    4373             :         BAT *bn;
    4374             :         BUN nils= 0;
    4375             :         BUN ncand;
    4376             :         struct canditer ci;
    4377             : 
    4378           0 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    4379             : 
    4380           0 :         BATcheck(b, NULL);
    4381             : 
    4382           0 :         ncand = canditer_init(&ci, b, s);
    4383             : 
    4384           0 :         bn = COLnew(ci.hseq, b->ttype, ncand, TRANSIENT);
    4385           0 :         if (bn == NULL)
    4386             :                 return NULL;
    4387           0 :         if (ncand == 0)
    4388             :                 return bn;
    4389             : 
    4390           0 :         BATiter bi = bat_iterator(b);
    4391           0 :         nils = (*typeswitchloop)(bi.base, b->ttype, true,
    4392           0 :                                  &(bte){1}, TYPE_bte, false,
    4393           0 :                                  Tloc(bn, 0), bn->ttype,
    4394           0 :                                  &(struct canditer){.tpe=cand_dense, .ncand=1},
    4395             :                                  &ci,
    4396             :                                  0, b->hseqbase,
    4397             :                                  abort_on_error, func);
    4398           0 :         bat_iterator_end(&bi);
    4399             : 
    4400           0 :         if (nils == BUN_NONE) {
    4401           0 :                 BBPunfix(bn->batCacheid);
    4402           0 :                 return NULL;
    4403             :         }
    4404             : 
    4405           0 :         BATsetcount(bn, ncand);
    4406             : 
    4407             :         /* if the input is sorted, and no overflow occurred (we only
    4408             :          * know for sure if abort_on_error is set), the result is also
    4409             :          * sorted */
    4410           0 :         bn->tsorted = (abort_on_error && b->tsorted) ||
    4411           0 :                 ncand <= 1 || nils == ncand;
    4412           0 :         bn->trevsorted = (abort_on_error && b->trevsorted) ||
    4413           0 :                 ncand <= 1 || nils == ncand;
    4414           0 :         bn->tkey = ncand <= 1;
    4415           0 :         bn->tnil = nils != 0;
    4416           0 :         bn->tnonil = nils == 0;
    4417             : 
    4418           0 :         TRC_DEBUG(ALGO, "%s: b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
    4419             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    4420             :                   func, ALGOBATPAR(b), ALGOOPTBATPAR(s),
    4421             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    4422             : 
    4423             :         return bn;
    4424             : }
    4425             : 
    4426             : BAT *
    4427           0 : BATcalcincr(BAT *b, BAT *s, bool abort_on_error)
    4428             : {
    4429           0 :         return BATcalcincrdecr(b, s, abort_on_error, add_typeswitchloop,
    4430             :                                __func__);
    4431             : }
    4432             : 
    4433             : gdk_return
    4434           0 : VARcalcincr(ValPtr ret, const ValRecord *v, bool abort_on_error)
    4435             : {
    4436           0 :         if (add_typeswitchloop(VALptr(v), v->vtype, false,
    4437           0 :                                &(bte){1}, TYPE_bte, false,
    4438             :                                VALget(ret), ret->vtype,
    4439           0 :                                &(struct canditer){.tpe=cand_dense, .ncand=1},
    4440           0 :                                &(struct canditer){.tpe=cand_dense, .ncand=1},
    4441             :                                0, 0, abort_on_error, __func__) == BUN_NONE)
    4442           0 :                 return GDK_FAIL;
    4443           0 :         return GDK_SUCCEED;
    4444             : }
    4445             : 
    4446             : /* ---------------------------------------------------------------------- */
    4447             : /* subtraction (any numeric type) */
    4448             : 
    4449             : #define SUB_3TYPE(TYPE1, TYPE2, TYPE3, IF)                              \
    4450             : static BUN                                                              \
    4451             : sub_##TYPE1##_##TYPE2##_##TYPE3(const TYPE1 *lft, bool incr1,           \
    4452             :                                 const TYPE2 *rgt, bool incr2,           \
    4453             :                                 TYPE3 *restrict dst, TYPE3 max,         \
    4454             :                                 struct canditer *restrict ci1,          \
    4455             :                                 struct canditer *restrict ci2,          \
    4456             :                                 oid candoff1, oid candoff2,             \
    4457             :                                 bool abort_on_error)                    \
    4458             : {                                                                       \
    4459             :         BUN nils = 0;                                                   \
    4460             :         BUN i = 0, j = 0, ncand = ci1->ncand;                                \
    4461             :                                                                         \
    4462             :         if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {           \
    4463             :                 for (BUN k = 0; k < ncand; k++) {                    \
    4464             :                         if (incr1)                                      \
    4465             :                                 i = canditer_next_dense(ci1) - candoff1; \
    4466             :                         if (incr2)                                      \
    4467             :                                 j = canditer_next_dense(ci2) - candoff2; \
    4468             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    4469             :                                 dst[k] = TYPE3##_nil;                   \
    4470             :                                 nils++;                                 \
    4471             :                         } else {                                        \
    4472             :                                 SUB##IF##_WITH_CHECK(lft[i], rgt[j],    \
    4473             :                                                      TYPE3, dst[k],     \
    4474             :                                                      max,               \
    4475             :                                                      ON_OVERFLOW(TYPE1, TYPE2, "-")); \
    4476             :                         }                                               \
    4477             :                 }                                                       \
    4478             :         } else {                                                        \
    4479             :                 for (BUN k = 0; k < ncand; k++) {                    \
    4480             :                         if (incr1)                                      \
    4481             :                                 i = canditer_next(ci1) - candoff1;      \
    4482             :                         if (incr2)                                      \
    4483             :                                 j = canditer_next(ci2) - candoff2;      \
    4484             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    4485             :                                 dst[k] = TYPE3##_nil;                   \
    4486             :                                 nils++;                                 \
    4487             :                         } else {                                        \
    4488             :                                 SUB##IF##_WITH_CHECK(lft[i], rgt[j],    \
    4489             :                                                      TYPE3, dst[k],     \
    4490             :                                                      max,               \
    4491             :                                                      ON_OVERFLOW(TYPE1, TYPE2, "-")); \
    4492             :                         }                                               \
    4493             :                 }                                                       \
    4494             :         }                                                               \
    4495             :         return nils;                                                    \
    4496             : }
    4497             : 
    4498             : #define SUB_3TYPE_enlarge(TYPE1, TYPE2, TYPE3, IF)                      \
    4499             : static BUN                                                              \
    4500             : sub_##TYPE1##_##TYPE2##_##TYPE3(const TYPE1 *lft, bool incr1,           \
    4501             :                                 const TYPE2 *rgt, bool incr2,           \
    4502             :                                 TYPE3 *restrict dst, TYPE3 max,         \
    4503             :                                 struct canditer *restrict ci1,          \
    4504             :                                 struct canditer *restrict ci2,          \
    4505             :                                 oid candoff1, oid candoff2,             \
    4506             :                                 bool abort_on_error)                    \
    4507             : {                                                                       \
    4508             :         BUN nils = 0;                                                   \
    4509             :         BUN i = 0, j = 0, ncand = ci1->ncand;                                \
    4510             :         const bool couldoverflow = (max < (TYPE3) GDK_##TYPE1##_max + (TYPE3) GDK_##TYPE2##_max); \
    4511             :                                                                         \
    4512             :         if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {           \
    4513             :                 for (BUN k = 0; k < ncand; k++) {                    \
    4514             :                         if (incr1)                                      \
    4515             :                                 i = canditer_next_dense(ci1) - candoff1; \
    4516             :                         if (incr2)                                      \
    4517             :                                 j = canditer_next_dense(ci2) - candoff2; \
    4518             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    4519             :                                 dst[k] = TYPE3##_nil;                   \
    4520             :                                 nils++;                                 \
    4521             :                         } else if (couldoverflow) {                     \
    4522             :                                 SUB##IF##_WITH_CHECK(lft[i], rgt[j],    \
    4523             :                                                      TYPE3, dst[k],     \
    4524             :                                                      max,               \
    4525             :                                                      ON_OVERFLOW(TYPE1, TYPE2, "-")); \
    4526             :                         } else {                                        \
    4527             :                                 dst[k] = (TYPE3) lft[i] - rgt[j];       \
    4528             :                         }                                               \
    4529             :                 }                                                       \
    4530             :         } else {                                                        \
    4531             :                 for (BUN k = 0; k < ncand; k++) {                    \
    4532             :                         if (incr1)                                      \
    4533             :                                 i = canditer_next(ci1) - candoff1;      \
    4534             :                         if (incr2)                                      \
    4535             :                                 j = canditer_next(ci2) - candoff2;      \
    4536             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    4537             :                                 dst[k] = TYPE3##_nil;                   \
    4538             :                                 nils++;                                 \
    4539             :                         } else if (couldoverflow) {                     \
    4540             :                                 SUB##IF##_WITH_CHECK(lft[i], rgt[j],    \
    4541             :                                                      TYPE3, dst[k],     \
    4542             :                                                      max,               \
    4543             :                                                      ON_OVERFLOW(TYPE1, TYPE2, "-")); \
    4544             :                         } else {                                        \
    4545             :                                 dst[k] = (TYPE3) lft[i] - rgt[j];       \
    4546             :                         }                                               \
    4547             :                 }                                                       \
    4548             :         }                                                               \
    4549             :         return nils;                                                    \
    4550             : }
    4551             : 
    4552          78 : SUB_3TYPE(bte, bte, bte, I)
    4553           0 : SUB_3TYPE_enlarge(bte, bte, sht, I)
    4554           0 : SUB_3TYPE_enlarge(bte, bte, int, I)
    4555           0 : SUB_3TYPE_enlarge(bte, bte, lng, I)
    4556             : #ifdef HAVE_HGE
    4557           0 : SUB_3TYPE_enlarge(bte, bte, hge, I)
    4558             : #endif
    4559           0 : SUB_3TYPE_enlarge(bte, bte, flt, F)
    4560           0 : SUB_3TYPE_enlarge(bte, bte, dbl, F)
    4561           0 : SUB_3TYPE(bte, sht, sht, I)
    4562           0 : SUB_3TYPE_enlarge(bte, sht, int, I)
    4563           0 : SUB_3TYPE_enlarge(bte, sht, lng, I)
    4564             : #ifdef HAVE_HGE
    4565           0 : SUB_3TYPE_enlarge(bte, sht, hge, I)
    4566             : #endif
    4567           0 : SUB_3TYPE_enlarge(bte, sht, flt, F)
    4568           0 : SUB_3TYPE_enlarge(bte, sht, dbl, F)
    4569           0 : SUB_3TYPE(bte, int, int, I)
    4570           0 : SUB_3TYPE_enlarge(bte, int, lng, I)
    4571             : #ifdef HAVE_HGE
    4572           0 : SUB_3TYPE_enlarge(bte, int, hge, I)
    4573             : #endif
    4574           0 : SUB_3TYPE_enlarge(bte, int, flt, F)
    4575           0 : SUB_3TYPE_enlarge(bte, int, dbl, F)
    4576           0 : SUB_3TYPE(bte, lng, lng, I)
    4577             : #ifdef HAVE_HGE
    4578           0 : SUB_3TYPE_enlarge(bte, lng, hge, I)
    4579             : #endif
    4580           0 : SUB_3TYPE_enlarge(bte, lng, flt, F)
    4581           0 : SUB_3TYPE_enlarge(bte, lng, dbl, F)
    4582             : #ifdef HAVE_HGE
    4583           0 : SUB_3TYPE(bte, hge, hge, I)
    4584           0 : SUB_3TYPE_enlarge(bte, hge, flt, F)
    4585           0 : SUB_3TYPE_enlarge(bte, hge, dbl, F)
    4586             : #endif
    4587           0 : SUB_3TYPE(bte, flt, flt, F)
    4588           0 : SUB_3TYPE_enlarge(bte, flt, dbl, F)
    4589           0 : SUB_3TYPE(bte, dbl, dbl, F)
    4590           0 : SUB_3TYPE(sht, bte, sht, I)
    4591           0 : SUB_3TYPE_enlarge(sht, bte, int, I)
    4592           0 : SUB_3TYPE_enlarge(sht, bte, lng, I)
    4593             : #ifdef HAVE_HGE
    4594           0 : SUB_3TYPE_enlarge(sht, bte, hge, I)
    4595             : #endif
    4596           0 : SUB_3TYPE_enlarge(sht, bte, flt, F)
    4597           0 : SUB_3TYPE_enlarge(sht, bte, dbl, F)
    4598          42 : SUB_3TYPE(sht, sht, sht, I)
    4599           0 : SUB_3TYPE_enlarge(sht, sht, int, I)
    4600           0 : SUB_3TYPE_enlarge(sht, sht, lng, I)
    4601             : #ifdef HAVE_HGE
    4602           0 : SUB_3TYPE_enlarge(sht, sht, hge, I)
    4603             : #endif
    4604           0 : SUB_3TYPE_enlarge(sht, sht, flt, F)
    4605           0 : SUB_3TYPE_enlarge(sht, sht, dbl, F)
    4606           0 : SUB_3TYPE(sht, int, int, I)
    4607           0 : SUB_3TYPE_enlarge(sht, int, lng, I)
    4608             : #ifdef HAVE_HGE
    4609           0 : SUB_3TYPE_enlarge(sht, int, hge, I)
    4610             : #endif
    4611           0 : SUB_3TYPE_enlarge(sht, int, flt, F)
    4612           0 : SUB_3TYPE_enlarge(sht, int, dbl, F)
    4613           0 : SUB_3TYPE(sht, lng, lng, I)
    4614             : #ifdef HAVE_HGE
    4615           0 : SUB_3TYPE_enlarge(sht, lng, hge, I)
    4616             : #endif
    4617           0 : SUB_3TYPE_enlarge(sht, lng, flt, F)
    4618           0 : SUB_3TYPE_enlarge(sht, lng, dbl, F)
    4619             : #ifdef HAVE_HGE
    4620           0 : SUB_3TYPE(sht, hge, hge, I)
    4621           0 : SUB_3TYPE_enlarge(sht, hge, flt, F)
    4622           0 : SUB_3TYPE_enlarge(sht, hge, dbl, F)
    4623             : #endif
    4624           0 : SUB_3TYPE(sht, flt, flt, F)
    4625           0 : SUB_3TYPE_enlarge(sht, flt, dbl, F)
    4626           0 : SUB_3TYPE(sht, dbl, dbl, F)
    4627           0 : SUB_3TYPE(int, bte, int, I)
    4628           0 : SUB_3TYPE_enlarge(int, bte, lng, I)
    4629             : #ifdef HAVE_HGE
    4630           0 : SUB_3TYPE_enlarge(int, bte, hge, I)
    4631             : #endif
    4632           0 : SUB_3TYPE_enlarge(int, bte, flt, F)
    4633           0 : SUB_3TYPE_enlarge(int, bte, dbl, F)
    4634           0 : SUB_3TYPE(int, sht, int, I)
    4635           0 : SUB_3TYPE_enlarge(int, sht, lng, I)
    4636             : #ifdef HAVE_HGE
    4637           0 : SUB_3TYPE_enlarge(int, sht, hge, I)
    4638             : #endif
    4639           0 : SUB_3TYPE_enlarge(int, sht, flt, F)
    4640           0 : SUB_3TYPE_enlarge(int, sht, dbl, F)
    4641    13569944 : SUB_3TYPE(int, int, int, I)
    4642           0 : SUB_3TYPE_enlarge(int, int, lng, I)
    4643             : #ifdef HAVE_HGE
    4644           0 : SUB_3TYPE_enlarge(int, int, hge, I)
    4645             : #endif
    4646           0 : SUB_3TYPE_enlarge(int, int, flt, F)
    4647           0 : SUB_3TYPE_enlarge(int, int, dbl, F)
    4648           0 : SUB_3TYPE(int, lng, lng, I)
    4649             : #ifdef HAVE_HGE
    4650           0 : SUB_3TYPE_enlarge(int, lng, hge, I)
    4651             : #endif
    4652           0 : SUB_3TYPE_enlarge(int, lng, flt, F)
    4653           0 : SUB_3TYPE_enlarge(int, lng, dbl, F)
    4654             : #ifdef HAVE_HGE
    4655           0 : SUB_3TYPE(int, hge, hge, I)
    4656           0 : SUB_3TYPE_enlarge(int, hge, flt, F)
    4657           0 : SUB_3TYPE_enlarge(int, hge, dbl, F)
    4658             : #endif
    4659           0 : SUB_3TYPE(int, flt, flt, F)
    4660           0 : SUB_3TYPE_enlarge(int, flt, dbl, F)
    4661           0 : SUB_3TYPE(int, dbl, dbl, F)
    4662           0 : SUB_3TYPE(lng, bte, lng, I)
    4663             : #ifdef HAVE_HGE
    4664           0 : SUB_3TYPE_enlarge(lng, bte, hge, I)
    4665             : #endif
    4666           0 : SUB_3TYPE_enlarge(lng, bte, flt, F)
    4667           0 : SUB_3TYPE_enlarge(lng, bte, dbl, F)
    4668           0 : SUB_3TYPE(lng, sht, lng, I)
    4669             : #ifdef HAVE_HGE
    4670           0 : SUB_3TYPE_enlarge(lng, sht, hge, I)
    4671             : #endif
    4672           0 : SUB_3TYPE_enlarge(lng, sht, flt, F)
    4673           0 : SUB_3TYPE_enlarge(lng, sht, dbl, F)
    4674        1544 : SUB_3TYPE(lng, int, lng, I)
    4675             : #ifdef HAVE_HGE
    4676           0 : SUB_3TYPE_enlarge(lng, int, hge, I)
    4677             : #endif
    4678           0 : SUB_3TYPE_enlarge(lng, int, flt, F)
    4679           0 : SUB_3TYPE_enlarge(lng, int, dbl, F)
    4680     1383676 : SUB_3TYPE(lng, lng, lng, I)
    4681             : #ifdef HAVE_HGE
    4682           0 : SUB_3TYPE_enlarge(lng, lng, hge, I)
    4683             : #endif
    4684           0 : SUB_3TYPE_enlarge(lng, lng, flt, F)
    4685           0 : SUB_3TYPE_enlarge(lng, lng, dbl, F)
    4686             : #ifdef HAVE_HGE
    4687           0 : SUB_3TYPE(lng, hge, hge, I)
    4688           0 : SUB_3TYPE_enlarge(lng, hge, flt, F)
    4689           0 : SUB_3TYPE_enlarge(lng, hge, dbl, F)
    4690             : #endif
    4691           0 : SUB_3TYPE(lng, flt, flt, F)
    4692           0 : SUB_3TYPE_enlarge(lng, flt, dbl, F)
    4693           0 : SUB_3TYPE(lng, dbl, dbl, F)
    4694             : #ifdef HAVE_HGE
    4695           0 : SUB_3TYPE(hge, bte, hge, I)
    4696           0 : SUB_3TYPE_enlarge(hge, bte, flt, F)
    4697           0 : SUB_3TYPE_enlarge(hge, bte, dbl, F)
    4698           0 : SUB_3TYPE(hge, sht, hge, I)
    4699           0 : SUB_3TYPE_enlarge(hge, sht, flt, F)
    4700           0 : SUB_3TYPE_enlarge(hge, sht, dbl, F)
    4701           0 : SUB_3TYPE(hge, int, hge, I)
    4702           0 : SUB_3TYPE_enlarge(hge, int, flt, F)
    4703           0 : SUB_3TYPE_enlarge(hge, int, dbl, F)
    4704           0 : SUB_3TYPE(hge, lng, hge, I)
    4705           0 : SUB_3TYPE_enlarge(hge, lng, flt, F)
    4706           0 : SUB_3TYPE_enlarge(hge, lng, dbl, F)
    4707    23690511 : SUB_3TYPE(hge, hge, hge, I)
    4708           0 : SUB_3TYPE_enlarge(hge, hge, flt, F)
    4709           0 : SUB_3TYPE_enlarge(hge, hge, dbl, F)
    4710           0 : SUB_3TYPE(hge, flt, flt, F)
    4711           0 : SUB_3TYPE_enlarge(hge, flt, dbl, F)
    4712           0 : SUB_3TYPE(hge, dbl, dbl, F)
    4713             : #endif
    4714           0 : SUB_3TYPE(flt, bte, flt, F)
    4715           0 : SUB_3TYPE_enlarge(flt, bte, dbl, F)
    4716           0 : SUB_3TYPE(flt, sht, flt, F)
    4717           0 : SUB_3TYPE_enlarge(flt, sht, dbl, F)
    4718           0 : SUB_3TYPE(flt, int, flt, F)
    4719           0 : SUB_3TYPE_enlarge(flt, int, dbl, F)
    4720           0 : SUB_3TYPE(flt, lng, flt, F)
    4721           0 : SUB_3TYPE_enlarge(flt, lng, dbl, F)
    4722             : #ifdef HAVE_HGE
    4723           0 : SUB_3TYPE(flt, hge, flt, F)
    4724           0 : SUB_3TYPE_enlarge(flt, hge, dbl, F)
    4725             : #endif
    4726          24 : SUB_3TYPE(flt, flt, flt, F)
    4727           0 : SUB_3TYPE_enlarge(flt, flt, dbl, F)
    4728           0 : SUB_3TYPE(flt, dbl, dbl, F)
    4729           0 : SUB_3TYPE(dbl, bte, dbl, F)
    4730           0 : SUB_3TYPE(dbl, sht, dbl, F)
    4731           0 : SUB_3TYPE(dbl, int, dbl, F)
    4732           0 : SUB_3TYPE(dbl, lng, dbl, F)
    4733             : #ifdef HAVE_HGE
    4734           0 : SUB_3TYPE(dbl, hge, dbl, F)
    4735             : #endif
    4736           0 : SUB_3TYPE(dbl, flt, dbl, F)
    4737     5750969 : SUB_3TYPE(dbl, dbl, dbl, F)
    4738             : 
    4739             : static BUN
    4740       39520 : sub_typeswitchloop(const void *lft, int tp1, bool incr1,
    4741             :                    const void *rgt, int tp2, bool incr2,
    4742             :                    void *restrict dst, int tp,
    4743             :                    struct canditer *restrict ci1, struct canditer *restrict ci2,
    4744             :                    oid candoff1, oid candoff2,
    4745             :                    bool abort_on_error, const char *func)
    4746             : {
    4747             :         BUN nils;
    4748             : 
    4749       39520 :         tp1 = ATOMbasetype(tp1);
    4750       39520 :         tp2 = ATOMbasetype(tp2);
    4751       39520 :         tp = ATOMbasetype(tp);
    4752       39520 :         switch (tp1) {
    4753          39 :         case TYPE_bte:
    4754             :                 switch (tp2) {
    4755          39 :                 case TYPE_bte:
    4756             :                         switch (tp) {
    4757          39 :                         case TYPE_bte:
    4758          39 :                                 nils = sub_bte_bte_bte(lft, incr1, rgt, incr2,
    4759             :                                                        dst, GDK_bte_max,
    4760             :                                                        ci1, ci2, candoff1, candoff2,
    4761             :                                                        abort_on_error);
    4762          39 :                                 break;
    4763           0 :                         case TYPE_sht:
    4764           0 :                                 nils = sub_bte_bte_sht(lft, incr1, rgt, incr2,
    4765             :                                                        dst, GDK_sht_max,
    4766             :                                                        ci1, ci2, candoff1, candoff2,
    4767             :                                                        abort_on_error);
    4768           0 :                                 break;
    4769           0 :                         case TYPE_int:
    4770           0 :                                 nils = sub_bte_bte_int(lft, incr1, rgt, incr2,
    4771             :                                                        dst, GDK_int_max,
    4772             :                                                        ci1, ci2, candoff1, candoff2,
    4773             :                                                        abort_on_error);
    4774           0 :                                 break;
    4775           0 :                         case TYPE_lng:
    4776           0 :                                 nils = sub_bte_bte_lng(lft, incr1, rgt, incr2,
    4777             :                                                        dst, GDK_lng_max,
    4778             :                                                        ci1, ci2, candoff1, candoff2,
    4779             :                                                        abort_on_error);
    4780           0 :                                 break;
    4781             : #ifdef HAVE_HGE
    4782           0 :                         case TYPE_hge:
    4783           0 :                                 nils = sub_bte_bte_hge(lft, incr1, rgt, incr2,
    4784             :                                                        dst, GDK_hge_max,
    4785             :                                                        ci1, ci2, candoff1, candoff2,
    4786             :                                                        abort_on_error);
    4787           0 :                                 break;
    4788             : #endif
    4789           0 :                         case TYPE_flt:
    4790           0 :                                 nils = sub_bte_bte_flt(lft, incr1, rgt, incr2,
    4791             :                                                        dst, GDK_flt_max,
    4792             :                                                        ci1, ci2, candoff1, candoff2,
    4793             :                                                        abort_on_error);
    4794           0 :                                 break;
    4795           0 :                         case TYPE_dbl:
    4796           0 :                                 nils = sub_bte_bte_dbl(lft, incr1, rgt, incr2,
    4797             :                                                        dst, GDK_dbl_max,
    4798             :                                                        ci1, ci2, candoff1, candoff2,
    4799             :                                                        abort_on_error);
    4800           0 :                                 break;
    4801           0 :                         default:
    4802           0 :                                 goto unsupported;
    4803             :                         }
    4804             :                         break;
    4805           0 :                 case TYPE_sht:
    4806             :                         switch (tp) {
    4807           0 :                         case TYPE_sht:
    4808           0 :                                 nils = sub_bte_sht_sht(lft, incr1, rgt, incr2,
    4809             :                                                        dst, GDK_sht_max,
    4810             :                                                        ci1, ci2, candoff1, candoff2,
    4811             :                                                        abort_on_error);
    4812           0 :                                 break;
    4813           0 :                         case TYPE_int:
    4814           0 :                                 nils = sub_bte_sht_int(lft, incr1, rgt, incr2,
    4815             :                                                        dst, GDK_int_max,
    4816             :                                                        ci1, ci2, candoff1, candoff2,
    4817             :                                                        abort_on_error);
    4818           0 :                                 break;
    4819           0 :                         case TYPE_lng:
    4820           0 :                                 nils = sub_bte_sht_lng(lft, incr1, rgt, incr2,
    4821             :                                                        dst, GDK_lng_max,
    4822             :                                                        ci1, ci2, candoff1, candoff2,
    4823             :                                                        abort_on_error);
    4824           0 :                                 break;
    4825             : #ifdef HAVE_HGE
    4826           0 :                         case TYPE_hge:
    4827           0 :                                 nils = sub_bte_sht_hge(lft, incr1, rgt, incr2,
    4828             :                                                        dst, GDK_hge_max,
    4829             :                                                        ci1, ci2, candoff1, candoff2,
    4830             :                                                        abort_on_error);
    4831           0 :                                 break;
    4832             : #endif
    4833           0 :                         case TYPE_flt:
    4834           0 :                                 nils = sub_bte_sht_flt(lft, incr1, rgt, incr2,
    4835             :                                                        dst, GDK_flt_max,
    4836             :                                                        ci1, ci2, candoff1, candoff2,
    4837             :                                                        abort_on_error);
    4838           0 :                                 break;
    4839           0 :                         case TYPE_dbl:
    4840           0 :                                 nils = sub_bte_sht_dbl(lft, incr1, rgt, incr2,
    4841             :                                                        dst, GDK_dbl_max,
    4842             :                                                        ci1, ci2, candoff1, candoff2,
    4843             :                                                        abort_on_error);
    4844           0 :                                 break;
    4845           0 :                         default:
    4846           0 :                                 goto unsupported;
    4847             :                         }
    4848             :                         break;
    4849           0 :                 case TYPE_int:
    4850             :                         switch (tp) {
    4851           0 :                         case TYPE_int:
    4852           0 :                                 nils = sub_bte_int_int(lft, incr1, rgt, incr2,
    4853             :                                                        dst, GDK_int_max,
    4854             :                                                        ci1, ci2, candoff1, candoff2,
    4855             :                                                        abort_on_error);
    4856           0 :                                 break;
    4857           0 :                         case TYPE_lng:
    4858           0 :                                 nils = sub_bte_int_lng(lft, incr1, rgt, incr2,
    4859             :                                                        dst, GDK_lng_max,
    4860             :                                                        ci1, ci2, candoff1, candoff2,
    4861             :                                                        abort_on_error);
    4862           0 :                                 break;
    4863             : #ifdef HAVE_HGE
    4864           0 :                         case TYPE_hge:
    4865           0 :                                 nils = sub_bte_int_hge(lft, incr1, rgt, incr2,
    4866             :                                                        dst, GDK_hge_max,
    4867             :                                                        ci1, ci2, candoff1, candoff2,
    4868             :                                                        abort_on_error);
    4869           0 :                                 break;
    4870             : #endif
    4871           0 :                         case TYPE_flt:
    4872           0 :                                 nils = sub_bte_int_flt(lft, incr1, rgt, incr2,
    4873             :                                                        dst, GDK_flt_max,
    4874             :                                                        ci1, ci2, candoff1, candoff2,
    4875             :                                                        abort_on_error);
    4876           0 :                                 break;
    4877           0 :                         case TYPE_dbl:
    4878           0 :                                 nils = sub_bte_int_dbl(lft, incr1, rgt, incr2,
    4879             :                                                        dst, GDK_dbl_max,
    4880             :                                                        ci1, ci2, candoff1, candoff2,
    4881             :                                                        abort_on_error);
    4882           0 :                                 break;
    4883           0 :                         default:
    4884           0 :                                 goto unsupported;
    4885             :                         }
    4886             :                         break;
    4887           0 :                 case TYPE_lng:
    4888             :                         switch (tp) {
    4889           0 :                         case TYPE_lng:
    4890           0 :                                 nils = sub_bte_lng_lng(lft, incr1, rgt, incr2,
    4891             :                                                        dst, GDK_lng_max,
    4892             :                                                        ci1, ci2, candoff1, candoff2,
    4893             :                                                        abort_on_error);
    4894           0 :                                 break;
    4895             : #ifdef HAVE_HGE
    4896           0 :                         case TYPE_hge:
    4897           0 :                                 nils = sub_bte_lng_hge(lft, incr1, rgt, incr2,
    4898             :                                                        dst, GDK_hge_max,
    4899             :                                                        ci1, ci2, candoff1, candoff2,
    4900             :                                                        abort_on_error);
    4901           0 :                                 break;
    4902             : #endif
    4903           0 :                         case TYPE_flt:
    4904           0 :                                 nils = sub_bte_lng_flt(lft, incr1, rgt, incr2,
    4905             :                                                        dst, GDK_flt_max,
    4906             :                                                        ci1, ci2, candoff1, candoff2,
    4907             :                                                        abort_on_error);
    4908           0 :                                 break;
    4909           0 :                         case TYPE_dbl:
    4910           0 :                                 nils = sub_bte_lng_dbl(lft, incr1, rgt, incr2,
    4911             :                                                        dst, GDK_dbl_max,
    4912             :                                                        ci1, ci2, candoff1, candoff2,
    4913             :                                                        abort_on_error);
    4914           0 :                                 break;
    4915           0 :                         default:
    4916           0 :                                 goto unsupported;
    4917             :                         }
    4918             :                         break;
    4919             : #ifdef HAVE_HGE
    4920           0 :                 case TYPE_hge:
    4921             :                         switch (tp) {
    4922           0 :                         case TYPE_hge:
    4923           0 :                                 nils = sub_bte_hge_hge(lft, incr1, rgt, incr2,
    4924             :                                                        dst, GDK_hge_max,
    4925             :                                                        ci1, ci2, candoff1, candoff2,
    4926             :                                                        abort_on_error);
    4927           0 :                                 break;
    4928           0 :                         case TYPE_flt:
    4929           0 :                                 nils = sub_bte_hge_flt(lft, incr1, rgt, incr2,
    4930             :                                                        dst, GDK_flt_max,
    4931             :                                                        ci1, ci2, candoff1, candoff2,
    4932             :                                                        abort_on_error);
    4933           0 :                                 break;
    4934           0 :                         case TYPE_dbl:
    4935           0 :                                 nils = sub_bte_hge_dbl(lft, incr1, rgt, incr2,
    4936             :                                                        dst, GDK_dbl_max,
    4937             :                                                        ci1, ci2, candoff1, candoff2,
    4938             :                                                        abort_on_error);
    4939           0 :                                 break;
    4940           0 :                         default:
    4941           0 :                                 goto unsupported;
    4942             :                         }
    4943             :                         break;
    4944             : #endif
    4945           0 :                 case TYPE_flt:
    4946             :                         switch (tp) {
    4947           0 :                         case TYPE_flt:
    4948           0 :                                 nils = sub_bte_flt_flt(lft, incr1, rgt, incr2,
    4949             :                                                        dst, GDK_flt_max,
    4950             :                                                        ci1, ci2, candoff1, candoff2,
    4951             :                                                        abort_on_error);
    4952           0 :                                 break;
    4953           0 :                         case TYPE_dbl:
    4954           0 :                                 nils = sub_bte_flt_dbl(lft, incr1, rgt, incr2,
    4955             :                                                        dst, GDK_dbl_max,
    4956             :                                                        ci1, ci2, candoff1, candoff2,
    4957             :                                                        abort_on_error);
    4958           0 :                                 break;
    4959           0 :                         default:
    4960           0 :                                 goto unsupported;
    4961             :                         }
    4962             :                         break;
    4963           0 :                 case TYPE_dbl:
    4964             :                         switch (tp) {
    4965           0 :                         case TYPE_dbl:
    4966           0 :                                 nils = sub_bte_dbl_dbl(lft, incr1, rgt, incr2,
    4967             :                                                        dst, GDK_dbl_max,
    4968             :                                                        ci1, ci2, candoff1, candoff2,
    4969             :                                                        abort_on_error);
    4970             :                                 break;
    4971           0 :                         default:
    4972           0 :                                 goto unsupported;
    4973             :                         }
    4974           0 :                         break;
    4975           0 :                 default:
    4976           0 :                         goto unsupported;
    4977             :                 }
    4978             :                 break;
    4979          21 :         case TYPE_sht:
    4980             :                 switch (tp2) {
    4981           0 :                 case TYPE_bte:
    4982             :                         switch (tp) {
    4983           0 :                         case TYPE_sht:
    4984           0 :                                 nils = sub_sht_bte_sht(lft, incr1, rgt, incr2,
    4985             :                                                        dst, GDK_sht_max,
    4986             :                                                        ci1, ci2, candoff1, candoff2,
    4987             :                                                        abort_on_error);
    4988           0 :                                 break;
    4989           0 :                         case TYPE_int:
    4990           0 :                                 nils = sub_sht_bte_int(lft, incr1, rgt, incr2,
    4991             :                                                        dst, GDK_int_max,
    4992             :                                                        ci1, ci2, candoff1, candoff2,
    4993             :                                                        abort_on_error);
    4994           0 :                                 break;
    4995           0 :                         case TYPE_lng:
    4996           0 :                                 nils = sub_sht_bte_lng(lft, incr1, rgt, incr2,
    4997             :                                                        dst, GDK_lng_max,
    4998             :                                                        ci1, ci2, candoff1, candoff2,
    4999             :                                                        abort_on_error);
    5000           0 :                                 break;
    5001             : #ifdef HAVE_HGE
    5002           0 :                         case TYPE_hge:
    5003           0 :                                 nils = sub_sht_bte_hge(lft, incr1, rgt, incr2,
    5004             :                                                        dst, GDK_hge_max,
    5005             :                                                        ci1, ci2, candoff1, candoff2,
    5006             :                                                        abort_on_error);
    5007           0 :                                 break;
    5008             : #endif
    5009           0 :                         case TYPE_flt:
    5010           0 :                                 nils = sub_sht_bte_flt(lft, incr1, rgt, incr2,
    5011             :                                                        dst, GDK_flt_max,
    5012             :                                                        ci1, ci2, candoff1, candoff2,
    5013             :                                                        abort_on_error);
    5014           0 :                                 break;
    5015           0 :                         case TYPE_dbl:
    5016           0 :                                 nils = sub_sht_bte_dbl(lft, incr1, rgt, incr2,
    5017             :                                                        dst, GDK_dbl_max,
    5018             :                                                        ci1, ci2, candoff1, candoff2,
    5019             :                                                        abort_on_error);
    5020           0 :                                 break;
    5021           0 :                         default:
    5022           0 :                                 goto unsupported;
    5023             :                         }
    5024             :                         break;
    5025          21 :                 case TYPE_sht:
    5026             :                         switch (tp) {
    5027          21 :                         case TYPE_sht:
    5028          21 :                                 nils = sub_sht_sht_sht(lft, incr1, rgt, incr2,
    5029             :                                                        dst, GDK_sht_max,
    5030             :                                                        ci1, ci2, candoff1, candoff2,
    5031             :                                                        abort_on_error);
    5032          21 :                                 break;
    5033           0 :                         case TYPE_int:
    5034           0 :                                 nils = sub_sht_sht_int(lft, incr1, rgt, incr2,
    5035             :                                                        dst, GDK_int_max,
    5036             :                                                        ci1, ci2, candoff1, candoff2,
    5037             :                                                        abort_on_error);
    5038           0 :                                 break;
    5039           0 :                         case TYPE_lng:
    5040           0 :                                 nils = sub_sht_sht_lng(lft, incr1, rgt, incr2,
    5041             :                                                        dst, GDK_lng_max,
    5042             :                                                        ci1, ci2, candoff1, candoff2,
    5043             :                                                        abort_on_error);
    5044           0 :                                 break;
    5045             : #ifdef HAVE_HGE
    5046           0 :                         case TYPE_hge:
    5047           0 :                                 nils = sub_sht_sht_hge(lft, incr1, rgt, incr2,
    5048             :                                                        dst, GDK_hge_max,
    5049             :                                                        ci1, ci2, candoff1, candoff2,
    5050             :                                                        abort_on_error);
    5051           0 :                                 break;
    5052             : #endif
    5053           0 :                         case TYPE_flt:
    5054           0 :                                 nils = sub_sht_sht_flt(lft, incr1, rgt, incr2,
    5055             :                                                        dst, GDK_flt_max,
    5056             :                                                        ci1, ci2, candoff1, candoff2,
    5057             :                                                        abort_on_error);
    5058           0 :                                 break;
    5059           0 :                         case TYPE_dbl:
    5060           0 :                                 nils = sub_sht_sht_dbl(lft, incr1, rgt, incr2,
    5061             :                                                        dst, GDK_dbl_max,
    5062             :                                                        ci1, ci2, candoff1, candoff2,
    5063             :                                                        abort_on_error);
    5064           0 :                                 break;
    5065           0 :                         default:
    5066           0 :                                 goto unsupported;
    5067             :                         }
    5068             :                         break;
    5069           0 :                 case TYPE_int:
    5070             :                         switch (tp) {
    5071           0 :                         case TYPE_int:
    5072           0 :                                 nils = sub_sht_int_int(lft, incr1, rgt, incr2,
    5073             :                                                        dst, GDK_int_max,
    5074             :                                                        ci1, ci2, candoff1, candoff2,
    5075             :                                                        abort_on_error);
    5076           0 :                                 break;
    5077           0 :                         case TYPE_lng:
    5078           0 :                                 nils = sub_sht_int_lng(lft, incr1, rgt, incr2,
    5079             :                                                        dst, GDK_lng_max,
    5080             :                                                        ci1, ci2, candoff1, candoff2,
    5081             :                                                        abort_on_error);
    5082           0 :                                 break;
    5083             : #ifdef HAVE_HGE
    5084           0 :                         case TYPE_hge:
    5085           0 :                                 nils = sub_sht_int_hge(lft, incr1, rgt, incr2,
    5086             :                                                        dst, GDK_hge_max,
    5087             :                                                        ci1, ci2, candoff1, candoff2,
    5088             :                                                        abort_on_error);
    5089           0 :                                 break;
    5090             : #endif
    5091           0 :                         case TYPE_flt:
    5092           0 :                                 nils = sub_sht_int_flt(lft, incr1, rgt, incr2,
    5093             :                                                        dst, GDK_flt_max,
    5094             :                                                        ci1, ci2, candoff1, candoff2,
    5095             :                                                        abort_on_error);
    5096           0 :                                 break;
    5097           0 :                         case TYPE_dbl:
    5098           0 :                                 nils = sub_sht_int_dbl(lft, incr1, rgt, incr2,
    5099             :                                                        dst, GDK_dbl_max,
    5100             :                                                        ci1, ci2, candoff1, candoff2,
    5101             :                                                        abort_on_error);
    5102           0 :                                 break;
    5103           0 :                         default:
    5104           0 :                                 goto unsupported;
    5105             :                         }
    5106             :                         break;
    5107           0 :                 case TYPE_lng:
    5108             :                         switch (tp) {
    5109           0 :                         case TYPE_lng:
    5110           0 :                                 nils = sub_sht_lng_lng(lft, incr1, rgt, incr2,
    5111             :                                                        dst, GDK_lng_max,
    5112             :                                                        ci1, ci2, candoff1, candoff2,
    5113             :                                                        abort_on_error);
    5114           0 :                                 break;
    5115             : #ifdef HAVE_HGE
    5116           0 :                         case TYPE_hge:
    5117           0 :                                 nils = sub_sht_lng_hge(lft, incr1, rgt, incr2,
    5118             :                                                        dst, GDK_hge_max,
    5119             :                                                        ci1, ci2, candoff1, candoff2,
    5120             :                                                        abort_on_error);
    5121           0 :                                 break;
    5122             : #endif
    5123           0 :                         case TYPE_flt:
    5124           0 :                                 nils = sub_sht_lng_flt(lft, incr1, rgt, incr2,
    5125             :                                                        dst, GDK_flt_max,
    5126             :                                                        ci1, ci2, candoff1, candoff2,
    5127             :                                                        abort_on_error);
    5128           0 :                                 break;
    5129           0 :                         case TYPE_dbl:
    5130           0 :                                 nils = sub_sht_lng_dbl(lft, incr1, rgt, incr2,
    5131             :                                                        dst, GDK_dbl_max,
    5132             :                                                        ci1, ci2, candoff1, candoff2,
    5133             :                                                        abort_on_error);
    5134           0 :                                 break;
    5135           0 :                         default:
    5136           0 :                                 goto unsupported;
    5137             :                         }
    5138             :                         break;
    5139             : #ifdef HAVE_HGE
    5140           0 :                 case TYPE_hge:
    5141             :                         switch (tp) {
    5142           0 :                         case TYPE_hge:
    5143           0 :                                 nils = sub_sht_hge_hge(lft, incr1, rgt, incr2,
    5144             :                                                        dst, GDK_hge_max,
    5145             :                                                        ci1, ci2, candoff1, candoff2,
    5146             :                                                        abort_on_error);
    5147           0 :                                 break;
    5148           0 :                         case TYPE_flt:
    5149           0 :                                 nils = sub_sht_hge_flt(lft, incr1, rgt, incr2,
    5150             :                                                        dst, GDK_flt_max,
    5151             :                                                        ci1, ci2, candoff1, candoff2,
    5152             :                                                        abort_on_error);
    5153           0 :                                 break;
    5154           0 :                         case TYPE_dbl:
    5155           0 :                                 nils = sub_sht_hge_dbl(lft, incr1, rgt, incr2,
    5156             :                                                        dst, GDK_dbl_max,
    5157             :                                                        ci1, ci2, candoff1, candoff2,
    5158             :                                                        abort_on_error);
    5159           0 :                                 break;
    5160           0 :                         default:
    5161           0 :                                 goto unsupported;
    5162             :                         }
    5163             :                         break;
    5164             : #endif
    5165           0 :                 case TYPE_flt:
    5166             :                         switch (tp) {
    5167           0 :                         case TYPE_flt:
    5168           0 :                                 nils = sub_sht_flt_flt(lft, incr1, rgt, incr2,
    5169             :                                                        dst, GDK_flt_max,
    5170             :                                                        ci1, ci2, candoff1, candoff2,
    5171             :                                                        abort_on_error);
    5172           0 :                                 break;
    5173           0 :                         case TYPE_dbl:
    5174           0 :                                 nils = sub_sht_flt_dbl(lft, incr1, rgt, incr2,
    5175             :                                                        dst, GDK_dbl_max,
    5176             :                                                        ci1, ci2, candoff1, candoff2,
    5177             :                                                        abort_on_error);
    5178           0 :                                 break;
    5179           0 :                         default:
    5180           0 :                                 goto unsupported;
    5181             :                         }
    5182             :                         break;
    5183           0 :                 case TYPE_dbl:
    5184             :                         switch (tp) {
    5185           0 :                         case TYPE_dbl:
    5186           0 :                                 nils = sub_sht_dbl_dbl(lft, incr1, rgt, incr2,
    5187             :                                                        dst, GDK_dbl_max,
    5188             :                                                        ci1, ci2, candoff1, candoff2,
    5189             :                                                        abort_on_error);
    5190             :                                 break;
    5191           0 :                         default:
    5192           0 :                                 goto unsupported;
    5193             :                         }
    5194           0 :                         break;
    5195           0 :                 default:
    5196           0 :                         goto unsupported;
    5197             :                 }
    5198             :                 break;
    5199          62 :         case TYPE_int:
    5200             :                 switch (tp2) {
    5201           0 :                 case TYPE_bte:
    5202             :                         switch (tp) {
    5203           0 :                         case TYPE_int:
    5204           0 :                                 nils = sub_int_bte_int(lft, incr1, rgt, incr2,
    5205             :                                                        dst, GDK_int_max,
    5206             :                                                        ci1, ci2, candoff1, candoff2,
    5207             :                                                        abort_on_error);
    5208           0 :                                 break;
    5209           0 :                         case TYPE_lng:
    5210           0 :                                 nils = sub_int_bte_lng(lft, incr1, rgt, incr2,
    5211             :                                                        dst, GDK_lng_max,
    5212             :                                                        ci1, ci2, candoff1, candoff2,
    5213             :                                                        abort_on_error);
    5214           0 :                                 break;
    5215             : #ifdef HAVE_HGE
    5216           0 :                         case TYPE_hge:
    5217           0 :                                 nils = sub_int_bte_hge(lft, incr1, rgt, incr2,
    5218             :                                                        dst, GDK_hge_max,
    5219             :                                                        ci1, ci2, candoff1, candoff2,
    5220             :                                                        abort_on_error);
    5221           0 :                                 break;
    5222             : #endif
    5223           0 :                         case TYPE_flt:
    5224           0 :                                 nils = sub_int_bte_flt(lft, incr1, rgt, incr2,
    5225             :                                                        dst, GDK_flt_max,
    5226             :                                                        ci1, ci2, candoff1, candoff2,
    5227             :                                                        abort_on_error);
    5228           0 :                                 break;
    5229           0 :                         case TYPE_dbl:
    5230           0 :                                 nils = sub_int_bte_dbl(lft, incr1, rgt, incr2,
    5231             :                                                        dst, GDK_dbl_max,
    5232             :                                                        ci1, ci2, candoff1, candoff2,
    5233             :                                                        abort_on_error);
    5234           0 :                                 break;
    5235           0 :                         default:
    5236           0 :                                 goto unsupported;
    5237             :                         }
    5238             :                         break;
    5239           0 :                 case TYPE_sht:
    5240             :                         switch (tp) {
    5241           0 :                         case TYPE_int:
    5242           0 :                                 nils = sub_int_sht_int(lft, incr1, rgt, incr2,
    5243             :                                                        dst, GDK_int_max,
    5244             :                                                        ci1, ci2, candoff1, candoff2,
    5245             :                                                        abort_on_error);
    5246           0 :                                 break;
    5247           0 :                         case TYPE_lng:
    5248           0 :                                 nils = sub_int_sht_lng(lft, incr1, rgt, incr2,
    5249             :                                                        dst, GDK_lng_max,
    5250             :                                                        ci1, ci2, candoff1, candoff2,
    5251             :                                                        abort_on_error);
    5252           0 :                                 break;
    5253             : #ifdef HAVE_HGE
    5254           0 :                         case TYPE_hge:
    5255           0 :                                 nils = sub_int_sht_hge(lft, incr1, rgt, incr2,
    5256             :                                                        dst, GDK_hge_max,
    5257             :                                                        ci1, ci2, candoff1, candoff2,
    5258             :                                                        abort_on_error);
    5259           0 :                                 break;
    5260             : #endif
    5261           0 :                         case TYPE_flt:
    5262           0 :                                 nils = sub_int_sht_flt(lft, incr1, rgt, incr2,
    5263             :                                                        dst, GDK_flt_max,
    5264             :                                                        ci1, ci2, candoff1, candoff2,
    5265             :                                                        abort_on_error);
    5266           0 :                                 break;
    5267           0 :                         case TYPE_dbl:
    5268           0 :                                 nils = sub_int_sht_dbl(lft, incr1, rgt, incr2,
    5269             :                                                        dst, GDK_dbl_max,
    5270             :                                                        ci1, ci2, candoff1, candoff2,
    5271             :                                                        abort_on_error);
    5272           0 :                                 break;
    5273           0 :                         default:
    5274           0 :                                 goto unsupported;
    5275             :                         }
    5276             :                         break;
    5277          62 :                 case TYPE_int:
    5278             :                         switch (tp) {
    5279          62 :                         case TYPE_int:
    5280          62 :                                 nils = sub_int_int_int(lft, incr1, rgt, incr2,
    5281             :                                                        dst, GDK_int_max,
    5282             :                                                        ci1, ci2, candoff1, candoff2,
    5283             :                                                        abort_on_error);
    5284          62 :                                 break;
    5285           0 :                         case TYPE_lng:
    5286           0 :                                 nils = sub_int_int_lng(lft, incr1, rgt, incr2,
    5287             :                                                        dst, GDK_lng_max,
    5288             :                                                        ci1, ci2, candoff1, candoff2,
    5289             :                                                        abort_on_error);
    5290           0 :                                 break;
    5291             : #ifdef HAVE_HGE
    5292           0 :                         case TYPE_hge:
    5293           0 :                                 nils = sub_int_int_hge(lft, incr1, rgt, incr2,
    5294             :                                                        dst, GDK_hge_max,
    5295             :                                                        ci1, ci2, candoff1, candoff2,
    5296             :                                                        abort_on_error);
    5297           0 :                                 break;
    5298             : #endif
    5299           0 :                         case TYPE_flt:
    5300           0 :                                 nils = sub_int_int_flt(lft, incr1, rgt, incr2,
    5301             :                                                        dst, GDK_flt_max,
    5302             :                                                        ci1, ci2, candoff1, candoff2,
    5303             :                                                        abort_on_error);
    5304           0 :                                 break;
    5305           0 :                         case TYPE_dbl:
    5306           0 :                                 nils = sub_int_int_dbl(lft, incr1, rgt, incr2,
    5307             :                                                        dst, GDK_dbl_max,
    5308             :                                                        ci1, ci2, candoff1, candoff2,
    5309             :                                                        abort_on_error);
    5310           0 :                                 break;
    5311           0 :                         default:
    5312           0 :                                 goto unsupported;
    5313             :                         }
    5314             :                         break;
    5315           0 :                 case TYPE_lng:
    5316             :                         switch (tp) {
    5317           0 :                         case TYPE_lng:
    5318           0 :                                 nils = sub_int_lng_lng(lft, incr1, rgt, incr2,
    5319             :                                                        dst, GDK_lng_max,
    5320             :                                                        ci1, ci2, candoff1, candoff2,
    5321             :                                                        abort_on_error);
    5322           0 :                                 break;
    5323             : #ifdef HAVE_HGE
    5324           0 :                         case TYPE_hge:
    5325           0 :                                 nils = sub_int_lng_hge(lft, incr1, rgt, incr2,
    5326             :                                                        dst, GDK_hge_max,
    5327             :                                                        ci1, ci2, candoff1, candoff2,
    5328             :                                                        abort_on_error);
    5329           0 :                                 break;
    5330             : #endif
    5331           0 :                         case TYPE_flt:
    5332           0 :                                 nils = sub_int_lng_flt(lft, incr1, rgt, incr2,
    5333             :                                                        dst, GDK_flt_max,
    5334             :                                                        ci1, ci2, candoff1, candoff2,
    5335             :                                                        abort_on_error);
    5336           0 :                                 break;
    5337           0 :                         case TYPE_dbl:
    5338           0 :                                 nils = sub_int_lng_dbl(lft, incr1, rgt, incr2,
    5339             :                                                        dst, GDK_dbl_max,
    5340             :                                                        ci1, ci2, candoff1, candoff2,
    5341             :                                                        abort_on_error);
    5342           0 :                                 break;
    5343           0 :                         default:
    5344           0 :                                 goto unsupported;
    5345             :                         }
    5346             :                         break;
    5347             : #ifdef HAVE_HGE
    5348           0 :                 case TYPE_hge:
    5349             :                         switch (tp) {
    5350           0 :                         case TYPE_hge:
    5351           0 :                                 nils = sub_int_hge_hge(lft, incr1, rgt, incr2,
    5352             :                                                        dst, GDK_hge_max,
    5353             :                                                        ci1, ci2, candoff1, candoff2,
    5354             :                                                        abort_on_error);
    5355           0 :                                 break;
    5356           0 :                         case TYPE_flt:
    5357           0 :                                 nils = sub_int_hge_flt(lft, incr1, rgt, incr2,
    5358             :                                                        dst, GDK_flt_max,
    5359             :                                                        ci1, ci2, candoff1, candoff2,
    5360             :                                                        abort_on_error);
    5361           0 :                                 break;
    5362           0 :                         case TYPE_dbl:
    5363           0 :                                 nils = sub_int_hge_dbl(lft, incr1, rgt, incr2,
    5364             :                                                        dst, GDK_dbl_max,
    5365             :                                                        ci1, ci2, candoff1, candoff2,
    5366             :                                                        abort_on_error);
    5367           0 :                                 break;
    5368           0 :                         default:
    5369           0 :                                 goto unsupported;
    5370             :                         }
    5371             :                         break;
    5372             : #endif
    5373           0 :                 case TYPE_flt:
    5374             :                         switch (tp) {
    5375           0 :                         case TYPE_flt:
    5376           0 :                                 nils = sub_int_flt_flt(lft, incr1, rgt, incr2,
    5377             :                                                        dst, GDK_flt_max,
    5378             :                                                        ci1, ci2, candoff1, candoff2,
    5379             :                                                        abort_on_error);
    5380           0 :                                 break;
    5381           0 :                         case TYPE_dbl:
    5382           0 :                                 nils = sub_int_flt_dbl(lft, incr1, rgt, incr2,
    5383             :                                                        dst, GDK_dbl_max,
    5384             :                                                        ci1, ci2, candoff1, candoff2,
    5385             :                                                        abort_on_error);
    5386           0 :                                 break;
    5387           0 :                         default:
    5388           0 :                                 goto unsupported;
    5389             :                         }
    5390             :                         break;
    5391           0 :                 case TYPE_dbl:
    5392             :                         switch (tp) {
    5393           0 :                         case TYPE_dbl:
    5394           0 :                                 nils = sub_int_dbl_dbl(lft, incr1, rgt, incr2,
    5395             :                                                        dst, GDK_dbl_max,
    5396             :                                                        ci1, ci2, candoff1, candoff2,
    5397             :                                                        abort_on_error);
    5398             :                                 break;
    5399           0 :                         default:
    5400           0 :                                 goto unsupported;
    5401             :                         }
    5402           0 :                         break;
    5403           0 :                 default:
    5404           0 :                         goto unsupported;
    5405             :                 }
    5406             :                 break;
    5407       33826 :         case TYPE_lng:
    5408             :                 switch (tp2) {
    5409           0 :                 case TYPE_bte:
    5410             :                         switch (tp) {
    5411           0 :                         case TYPE_lng:
    5412           0 :                                 nils = sub_lng_bte_lng(lft, incr1, rgt, incr2,
    5413             :                                                        dst, GDK_lng_max,
    5414             :                                                        ci1, ci2, candoff1, candoff2,
    5415             :                                                        abort_on_error);
    5416           0 :                                 break;
    5417             : #ifdef HAVE_HGE
    5418           0 :                         case TYPE_hge:
    5419           0 :                                 nils = sub_lng_bte_hge(lft, incr1, rgt, incr2,
    5420             :                                                        dst, GDK_hge_max,
    5421             :                                                        ci1, ci2, candoff1, candoff2,
    5422             :                                                        abort_on_error);
    5423           0 :                                 break;
    5424             : #endif
    5425           0 :                         case TYPE_flt:
    5426           0 :                                 nils = sub_lng_bte_flt(lft, incr1, rgt, incr2,
    5427             :                                                        dst, GDK_flt_max,
    5428             :                                                        ci1, ci2, candoff1, candoff2,
    5429             :                                                        abort_on_error);
    5430           0 :                                 break;
    5431           0 :                         case TYPE_dbl:
    5432           0 :                                 nils = sub_lng_bte_dbl(lft, incr1, rgt, incr2,
    5433             :                                                        dst, GDK_dbl_max,
    5434             :                                                        ci1, ci2, candoff1, candoff2,
    5435             :                                                        abort_on_error);
    5436           0 :                                 break;
    5437           0 :                         default:
    5438           0 :                                 goto unsupported;
    5439             :                         }
    5440             :                         break;
    5441           0 :                 case TYPE_sht:
    5442             :                         switch (tp) {
    5443           0 :                         case TYPE_lng:
    5444           0 :                                 nils = sub_lng_sht_lng(lft, incr1, rgt, incr2,
    5445             :                                                        dst, GDK_lng_max,
    5446             :                                                        ci1, ci2, candoff1, candoff2,
    5447             :                                                        abort_on_error);
    5448           0 :                                 break;
    5449             : #ifdef HAVE_HGE
    5450           0 :                         case TYPE_hge:
    5451           0 :                                 nils = sub_lng_sht_hge(lft, incr1, rgt, incr2,
    5452             :                                                        dst, GDK_hge_max,
    5453             :                                                        ci1, ci2, candoff1, candoff2,
    5454             :                                                        abort_on_error);
    5455           0 :                                 break;
    5456             : #endif
    5457           0 :                         case TYPE_flt:
    5458           0 :                                 nils = sub_lng_sht_flt(lft, incr1, rgt, incr2,
    5459             :                                                        dst, GDK_flt_max,
    5460             :                                                        ci1, ci2, candoff1, candoff2,
    5461             :                                                        abort_on_error);
    5462           0 :                                 break;
    5463           0 :                         case TYPE_dbl:
    5464           0 :                                 nils = sub_lng_sht_dbl(lft, incr1, rgt, incr2,
    5465             :                                                        dst, GDK_dbl_max,
    5466             :                                                        ci1, ci2, candoff1, candoff2,
    5467             :                                                        abort_on_error);
    5468           0 :                                 break;
    5469           0 :                         default:
    5470           0 :                                 goto unsupported;
    5471             :                         }
    5472             :                         break;
    5473         772 :                 case TYPE_int:
    5474             :                         switch (tp) {
    5475         772 :                         case TYPE_lng:
    5476         772 :                                 nils = sub_lng_int_lng(lft, incr1, rgt, incr2,
    5477             :                                                        dst, GDK_lng_max,
    5478             :                                                        ci1, ci2, candoff1, candoff2,
    5479             :                                                        abort_on_error);
    5480         772 :                                 break;
    5481             : #ifdef HAVE_HGE
    5482           0 :                         case TYPE_hge:
    5483           0 :                                 nils = sub_lng_int_hge(lft, incr1, rgt, incr2,
    5484             :                                                        dst, GDK_hge_max,
    5485             :                                                        ci1, ci2, candoff1, candoff2,
    5486             :                                                        abort_on_error);
    5487           0 :                                 break;
    5488             : #endif
    5489           0 :                         case TYPE_flt:
    5490           0 :                                 nils = sub_lng_int_flt(lft, incr1, rgt, incr2,
    5491             :                                                        dst, GDK_flt_max,
    5492             :                                                        ci1, ci2, candoff1, candoff2,
    5493             :                                                        abort_on_error);
    5494           0 :                                 break;
    5495           0 :                         case TYPE_dbl:
    5496           0 :                                 nils = sub_lng_int_dbl(lft, incr1, rgt, incr2,
    5497             :                                                        dst, GDK_dbl_max,
    5498             :                                                        ci1, ci2, candoff1, candoff2,
    5499             :                                                        abort_on_error);
    5500           0 :                                 break;
    5501           0 :                         default:
    5502           0 :                                 goto unsupported;
    5503             :                         }
    5504             :                         break;
    5505       33054 :                 case TYPE_lng:
    5506             :                         switch (tp) {
    5507       33054 :                         case TYPE_lng:
    5508       33054 :                                 nils = sub_lng_lng_lng(lft, incr1, rgt, incr2,
    5509             :                                                        dst, GDK_lng_max,
    5510             :                                                        ci1, ci2, candoff1, candoff2,
    5511             :                                                        abort_on_error);
    5512       33095 :                                 break;
    5513             : #ifdef HAVE_HGE
    5514           0 :                         case TYPE_hge:
    5515           0 :                                 nils = sub_lng_lng_hge(lft, incr1, rgt, incr2,
    5516             :                                                        dst, GDK_hge_max,
    5517             :                                                        ci1, ci2, candoff1, candoff2,
    5518             :                                                        abort_on_error);
    5519           0 :                                 break;
    5520             : #endif
    5521           0 :                         case TYPE_flt:
    5522           0 :                                 nils = sub_lng_lng_flt(lft, incr1, rgt, incr2,
    5523             :                                                        dst, GDK_flt_max,
    5524             :                                                        ci1, ci2, candoff1, candoff2,
    5525             :                                                        abort_on_error);
    5526           0 :                                 break;
    5527           0 :                         case TYPE_dbl:
    5528           0 :                                 nils = sub_lng_lng_dbl(lft, incr1, rgt, incr2,
    5529             :                                                        dst, GDK_dbl_max,
    5530             :                                                        ci1, ci2, candoff1, candoff2,
    5531             :                                                        abort_on_error);
    5532           0 :                                 break;
    5533           0 :                         default:
    5534           0 :                                 goto unsupported;
    5535             :                         }
    5536             :                         break;
    5537             : #ifdef HAVE_HGE
    5538           0 :                 case TYPE_hge:
    5539             :                         switch (tp) {
    5540           0 :                         case TYPE_hge:
    5541           0 :                                 nils = sub_lng_hge_hge(lft, incr1, rgt, incr2,
    5542             :                                                        dst, GDK_hge_max,
    5543             :                                                        ci1, ci2, candoff1, candoff2,
    5544             :                                                        abort_on_error);
    5545           0 :                                 break;
    5546           0 :                         case TYPE_flt:
    5547           0 :                                 nils = sub_lng_hge_flt(lft, incr1, rgt, incr2,
    5548             :                                                        dst, GDK_flt_max,
    5549             :                                                        ci1, ci2, candoff1, candoff2,
    5550             :                                                        abort_on_error);
    5551           0 :                                 break;
    5552           0 :                         case TYPE_dbl:
    5553           0 :                                 nils = sub_lng_hge_dbl(lft, incr1, rgt, incr2,
    5554             :                                                        dst, GDK_dbl_max,
    5555             :                                                        ci1, ci2, candoff1, candoff2,
    5556             :                                                        abort_on_error);
    5557           0 :                                 break;
    5558           0 :                         default:
    5559           0 :                                 goto unsupported;
    5560             :                         }
    5561             :                         break;
    5562             : #endif
    5563           0 :                 case TYPE_flt:
    5564             :                         switch (tp) {
    5565           0 :                         case TYPE_flt:
    5566           0 :                                 nils = sub_lng_flt_flt(lft, incr1, rgt, incr2,
    5567             :                                                        dst, GDK_flt_max,
    5568             :                                                        ci1, ci2, candoff1, candoff2,
    5569             :                                                        abort_on_error);
    5570           0 :                                 break;
    5571           0 :                         case TYPE_dbl:
    5572           0 :                                 nils = sub_lng_flt_dbl(lft, incr1, rgt, incr2,
    5573             :                                                        dst, GDK_dbl_max,
    5574             :                                                        ci1, ci2, candoff1, candoff2,
    5575             :                                                        abort_on_error);
    5576           0 :                                 break;
    5577           0 :                         default:
    5578           0 :                                 goto unsupported;
    5579             :                         }
    5580             :                         break;
    5581           0 :                 case TYPE_dbl:
    5582             :                         switch (tp) {
    5583           0 :                         case TYPE_dbl:
    5584           0 :                                 nils = sub_lng_dbl_dbl(lft, incr1, rgt, incr2,
    5585             :                                                        dst, GDK_dbl_max,
    5586             :                                                        ci1, ci2, candoff1, candoff2,
    5587             :                                                        abort_on_error);
    5588             :                                 break;
    5589           0 :                         default:
    5590           0 :                                 goto unsupported;
    5591             :                         }
    5592           0 :                         break;
    5593           0 :                 default:
    5594           0 :                         goto unsupported;
    5595             :                 }
    5596             :                 break;
    5597             : #ifdef HAVE_HGE
    5598        5414 :         case TYPE_hge:
    5599             :                 switch (tp2) {
    5600           0 :                 case TYPE_bte:
    5601             :                         switch (tp) {
    5602           0 :                         case TYPE_hge:
    5603           0 :                                 nils = sub_hge_bte_hge(lft, incr1, rgt, incr2,
    5604             :                                                        dst, GDK_hge_max,
    5605             :                                                        ci1, ci2, candoff1, candoff2,
    5606             :                                                        abort_on_error);
    5607           0 :                                 break;
    5608           0 :                         case TYPE_flt:
    5609           0 :                                 nils = sub_hge_bte_flt(lft, incr1, rgt, incr2,
    5610             :                                                        dst, GDK_flt_max,
    5611             :                                                        ci1, ci2, candoff1, candoff2,
    5612             :                                                        abort_on_error);
    5613           0 :                                 break;
    5614           0 :                         case TYPE_dbl:
    5615           0 :                                 nils = sub_hge_bte_dbl(lft, incr1, rgt, incr2,
    5616             :                                                        dst, GDK_dbl_max,
    5617             :                                                        ci1, ci2, candoff1, candoff2,
    5618             :                                                        abort_on_error);
    5619           0 :                                 break;
    5620           0 :                         default:
    5621           0 :                                 goto unsupported;
    5622             :                         }
    5623             :                         break;
    5624           0 :                 case TYPE_sht:
    5625             :                         switch (tp) {
    5626           0 :                         case TYPE_hge:
    5627           0 :                                 nils = sub_hge_sht_hge(lft, incr1, rgt, incr2,
    5628             :                                                        dst, GDK_hge_max,
    5629             :                                                        ci1, ci2, candoff1, candoff2,
    5630             :                                                        abort_on_error);
    5631           0 :                                 break;
    5632           0 :                         case TYPE_flt:
    5633           0 :                                 nils = sub_hge_sht_flt(lft, incr1, rgt, incr2,
    5634             :                                                        dst, GDK_flt_max,
    5635             :                                                        ci1, ci2, candoff1, candoff2,
    5636             :                                                        abort_on_error);
    5637           0 :                                 break;
    5638           0 :                         case TYPE_dbl:
    5639           0 :                                 nils = sub_hge_sht_dbl(lft, incr1, rgt, incr2,
    5640             :                                                        dst, GDK_dbl_max,
    5641             :                                                        ci1, ci2, candoff1, candoff2,
    5642             :                                                        abort_on_error);
    5643           0 :                                 break;
    5644           0 :                         default:
    5645           0 :                                 goto unsupported;
    5646             :                         }
    5647             :                         break;
    5648           0 :                 case TYPE_int:
    5649             :                         switch (tp) {
    5650           0 :                         case TYPE_hge:
    5651           0 :                                 nils = sub_hge_int_hge(lft, incr1, rgt, incr2,
    5652             :                                                        dst, GDK_hge_max,
    5653             :                                                        ci1, ci2, candoff1, candoff2,
    5654             :                                                        abort_on_error);
    5655           0 :                                 break;
    5656           0 :                         case TYPE_flt:
    5657           0 :                                 nils = sub_hge_int_flt(lft, incr1, rgt, incr2,
    5658             :                                                        dst, GDK_flt_max,
    5659             :                                                        ci1, ci2, candoff1, candoff2,
    5660             :                                                        abort_on_error);
    5661           0 :                                 break;
    5662           0 :                         case TYPE_dbl:
    5663           0 :                                 nils = sub_hge_int_dbl(lft, incr1, rgt, incr2,
    5664             :                                                        dst, GDK_dbl_max,
    5665             :                                                        ci1, ci2, candoff1, candoff2,
    5666             :                                                        abort_on_error);
    5667           0 :                                 break;
    5668           0 :                         default:
    5669           0 :                                 goto unsupported;
    5670             :                         }
    5671             :                         break;
    5672           0 :                 case TYPE_lng:
    5673             :                         switch (tp) {
    5674           0 :                         case TYPE_hge:
    5675           0 :                                 nils = sub_hge_lng_hge(lft, incr1, rgt, incr2,
    5676             :                                                        dst, GDK_hge_max,
    5677             :                                                        ci1, ci2, candoff1, candoff2,
    5678             :                                                        abort_on_error);
    5679           0 :                                 break;
    5680           0 :                         case TYPE_flt:
    5681           0 :                                 nils = sub_hge_lng_flt(lft, incr1, rgt, incr2,
    5682             :                                                        dst, GDK_flt_max,
    5683             :                                                        ci1, ci2, candoff1, candoff2,
    5684             :                                                        abort_on_error);
    5685           0 :                                 break;
    5686           0 :                         case TYPE_dbl:
    5687           0 :                                 nils = sub_hge_lng_dbl(lft, incr1, rgt, incr2,
    5688             :                                                        dst, GDK_dbl_max,
    5689             :                                                        ci1, ci2, candoff1, candoff2,
    5690             :                                                        abort_on_error);
    5691           0 :                                 break;
    5692           0 :                         default:
    5693           0 :                                 goto unsupported;
    5694             :                         }
    5695             :                         break;
    5696        5414 :                 case TYPE_hge:
    5697             :                         switch (tp) {
    5698        5414 :                         case TYPE_hge:
    5699        5414 :                                 nils = sub_hge_hge_hge(lft, incr1, rgt, incr2,
    5700             :                                                        dst, GDK_hge_max,
    5701             :                                                        ci1, ci2, candoff1, candoff2,
    5702             :                                                        abort_on_error);
    5703        5423 :                                 break;
    5704           0 :                         case TYPE_flt:
    5705           0 :                                 nils = sub_hge_hge_flt(lft, incr1, rgt, incr2,
    5706             :                                                        dst, GDK_flt_max,
    5707             :                                                        ci1, ci2, candoff1, candoff2,
    5708             :                                                        abort_on_error);
    5709           0 :                                 break;
    5710           0 :                         case TYPE_dbl:
    5711           0 :                                 nils = sub_hge_hge_dbl(lft, incr1, rgt, incr2,
    5712             :                                                        dst, GDK_dbl_max,
    5713             :                                                        ci1, ci2, candoff1, candoff2,
    5714             :                                                        abort_on_error);
    5715           0 :                                 break;
    5716           0 :                         default:
    5717           0 :                                 goto unsupported;
    5718             :                         }
    5719             :                         break;
    5720           0 :                 case TYPE_flt:
    5721             :                         switch (tp) {
    5722           0 :                         case TYPE_flt:
    5723           0 :                                 nils = sub_hge_flt_flt(lft, incr1, rgt, incr2,
    5724             :                                                        dst, GDK_flt_max,
    5725             :                                                        ci1, ci2, candoff1, candoff2,
    5726             :                                                        abort_on_error);
    5727           0 :                                 break;
    5728           0 :                         case TYPE_dbl:
    5729           0 :                                 nils = sub_hge_flt_dbl(lft, incr1, rgt, incr2,
    5730             :                                                        dst, GDK_dbl_max,
    5731             :                                                        ci1, ci2, candoff1, candoff2,
    5732             :                                                        abort_on_error);
    5733           0 :                                 break;
    5734           0 :                         default:
    5735           0 :                                 goto unsupported;
    5736             :                         }
    5737             :                         break;
    5738           0 :                 case TYPE_dbl:
    5739             :                         switch (tp) {
    5740           0 :                         case TYPE_dbl:
    5741           0 :                                 nils = sub_hge_dbl_dbl(lft, incr1, rgt, incr2,
    5742             :                                                        dst, GDK_dbl_max,
    5743             :                                                        ci1, ci2, candoff1, candoff2,
    5744             :                                                        abort_on_error);
    5745             :                                 break;
    5746           0 :                         default:
    5747           0 :                                 goto unsupported;
    5748             :                         }
    5749           0 :                         break;
    5750           0 :                 default:
    5751           0 :                         goto unsupported;
    5752             :                 }
    5753             :                 break;
    5754             : #endif
    5755           9 :         case TYPE_flt:
    5756             :                 switch (tp2) {
    5757           0 :                 case TYPE_bte:
    5758             :                         switch (tp) {
    5759           0 :                         case TYPE_flt:
    5760           0 :                                 nils = sub_flt_bte_flt(lft, incr1, rgt, incr2,
    5761             :                                                        dst, GDK_flt_max,
    5762             :                                                        ci1, ci2, candoff1, candoff2,
    5763             :                                                        abort_on_error);
    5764           0 :                                 break;
    5765           0 :                         case TYPE_dbl:
    5766           0 :                                 nils = sub_flt_bte_dbl(lft, incr1, rgt, incr2,
    5767             :                                                        dst, GDK_dbl_max,
    5768             :                                                        ci1, ci2, candoff1, candoff2,
    5769             :                                                        abort_on_error);
    5770           0 :                                 break;
    5771           0 :                         default:
    5772           0 :                                 goto unsupported;
    5773             :                         }
    5774             :                         break;
    5775           0 :                 case TYPE_sht:
    5776             :                         switch (tp) {
    5777           0 :                         case TYPE_flt:
    5778           0 :                                 nils = sub_flt_sht_flt(lft, incr1, rgt, incr2,
    5779             :                                                        dst, GDK_flt_max,
    5780             :                                                        ci1, ci2, candoff1, candoff2,
    5781             :                                                        abort_on_error);
    5782           0 :                                 break;
    5783           0 :                         case TYPE_dbl:
    5784           0 :                                 nils = sub_flt_sht_dbl(lft, incr1, rgt, incr2,
    5785             :                                                        dst, GDK_dbl_max,
    5786             :                                                        ci1, ci2, candoff1, candoff2,
    5787             :                                                        abort_on_error);
    5788           0 :                                 break;
    5789           0 :                         default:
    5790           0 :                                 goto unsupported;
    5791             :                         }
    5792             :                         break;
    5793           0 :                 case TYPE_int:
    5794             :                         switch (tp) {
    5795           0 :                         case TYPE_flt:
    5796           0 :                                 nils = sub_flt_int_flt(lft, incr1, rgt, incr2,
    5797             :                                                        dst, GDK_flt_max,
    5798             :                                                        ci1, ci2, candoff1, candoff2,
    5799             :                                                        abort_on_error);
    5800           0 :                                 break;
    5801           0 :                         case TYPE_dbl:
    5802           0 :                                 nils = sub_flt_int_dbl(lft, incr1, rgt, incr2,
    5803             :                                                        dst, GDK_dbl_max,
    5804             :                                                        ci1, ci2, candoff1, candoff2,
    5805             :                                                        abort_on_error);
    5806           0 :                                 break;
    5807           0 :                         default:
    5808           0 :                                 goto unsupported;
    5809             :                         }
    5810             :                         break;
    5811           0 :                 case TYPE_lng:
    5812             :                         switch (tp) {
    5813           0 :                         case TYPE_flt:
    5814           0 :                                 nils = sub_flt_lng_flt(lft, incr1, rgt, incr2,
    5815             :                                                        dst, GDK_flt_max,
    5816             :                                                        ci1, ci2, candoff1, candoff2,
    5817             :                                                        abort_on_error);
    5818           0 :                                 break;
    5819           0 :                         case TYPE_dbl:
    5820           0 :                                 nils = sub_flt_lng_dbl(lft, incr1, rgt, incr2,
    5821             :                                                        dst, GDK_dbl_max,
    5822             :                                                        ci1, ci2, candoff1, candoff2,
    5823             :                                                        abort_on_error);
    5824           0 :                                 break;
    5825           0 :                         default:
    5826           0 :                                 goto unsupported;
    5827             :                         }
    5828             :                         break;
    5829             : #ifdef HAVE_HGE
    5830           0 :                 case TYPE_hge:
    5831             :                         switch (tp) {
    5832           0 :                         case TYPE_flt:
    5833           0 :                                 nils = sub_flt_hge_flt(lft, incr1, rgt, incr2,
    5834             :                                                        dst, GDK_flt_max,
    5835             :                                                        ci1, ci2, candoff1, candoff2,
    5836             :                                                        abort_on_error);
    5837           0 :                                 break;
    5838           0 :                         case TYPE_dbl:
    5839           0 :                                 nils = sub_flt_hge_dbl(lft, incr1, rgt, incr2,
    5840             :                                                        dst, GDK_dbl_max,
    5841             :                                                        ci1, ci2, candoff1, candoff2,
    5842             :                                                        abort_on_error);
    5843           0 :                                 break;
    5844           0 :                         default:
    5845           0 :                                 goto unsupported;
    5846             :                         }
    5847             :                         break;
    5848             : #endif
    5849           9 :                 case TYPE_flt:
    5850             :                         switch (tp) {
    5851           9 :                         case TYPE_flt:
    5852           9 :                                 nils = sub_flt_flt_flt(lft, incr1, rgt, incr2,
    5853             :                                                        dst, GDK_flt_max,
    5854             :                                                        ci1, ci2, candoff1, candoff2,
    5855             :                                                        abort_on_error);
    5856           9 :                                 break;
    5857           0 :                         case TYPE_dbl:
    5858           0 :                                 nils = sub_flt_flt_dbl(lft, incr1, rgt, incr2,
    5859             :                                                        dst, GDK_dbl_max,
    5860             :                                                        ci1, ci2, candoff1, candoff2,
    5861             :                                                        abort_on_error);
    5862           0 :                                 break;
    5863           0 :                         default:
    5864           0 :                                 goto unsupported;
    5865             :                         }
    5866             :                         break;
    5867           0 :                 case TYPE_dbl:
    5868             :                         switch (tp) {
    5869           0 :                         case TYPE_dbl:
    5870           0 :                                 nils = sub_flt_dbl_dbl(lft, incr1, rgt, incr2,
    5871             :                                                        dst, GDK_dbl_max,
    5872             :                                                        ci1, ci2, candoff1, candoff2,
    5873             :                                                        abort_on_error);
    5874             :                                 break;
    5875           0 :                         default:
    5876           0 :                                 goto unsupported;
    5877             :                         }
    5878           0 :                         break;
    5879           0 :                 default:
    5880           0 :                         goto unsupported;
    5881             :                 }
    5882             :                 break;
    5883         149 :         case TYPE_dbl:
    5884             :                 switch (tp2) {
    5885           0 :                 case TYPE_bte:
    5886             :                         switch (tp) {
    5887           0 :                         case TYPE_dbl:
    5888           0 :                                 nils = sub_dbl_bte_dbl(lft, incr1, rgt, incr2,
    5889             :                                                        dst, GDK_dbl_max,
    5890             :                                                        ci1, ci2, candoff1, candoff2,
    5891             :                                                        abort_on_error);
    5892             :                                 break;
    5893           0 :                         default:
    5894           0 :                                 goto unsupported;
    5895             :                         }
    5896           0 :                         break;
    5897           0 :                 case TYPE_sht:
    5898             :                         switch (tp) {
    5899           0 :                         case TYPE_dbl:
    5900           0 :                                 nils = sub_dbl_sht_dbl(lft, incr1, rgt, incr2,
    5901             :                                                        dst, GDK_dbl_max,
    5902             :                                                        ci1, ci2, candoff1, candoff2,
    5903             :                                                        abort_on_error);
    5904             :                                 break;
    5905           0 :                         default:
    5906           0 :                                 goto unsupported;
    5907             :                         }
    5908           0 :                         break;
    5909           0 :                 case TYPE_int:
    5910             :                         switch (tp) {
    5911           0 :                         case TYPE_dbl:
    5912           0 :                                 nils = sub_dbl_int_dbl(lft, incr1, rgt, incr2,
    5913             :                                                        dst, GDK_dbl_max,
    5914             :                                                        ci1, ci2, candoff1, candoff2,
    5915             :                                                        abort_on_error);
    5916             :                                 break;
    5917           0 :                         default:
    5918           0 :                                 goto unsupported;
    5919             :                         }
    5920           0 :                         break;
    5921           0 :                 case TYPE_lng:
    5922             :                         switch (tp) {
    5923           0 :                         case TYPE_dbl:
    5924           0 :                                 nils = sub_dbl_lng_dbl(lft, incr1, rgt, incr2,
    5925             :                                                        dst, GDK_dbl_max,
    5926             :                                                        ci1, ci2, candoff1, candoff2,
    5927             :                                                        abort_on_error);
    5928             :                                 break;
    5929           0 :                         default:
    5930           0 :                                 goto unsupported;
    5931             :                         }
    5932           0 :                         break;
    5933             : #ifdef HAVE_HGE
    5934           0 :                 case TYPE_hge:
    5935             :                         switch (tp) {
    5936           0 :                         case TYPE_dbl:
    5937           0 :                                 nils = sub_dbl_hge_dbl(lft, incr1, rgt, incr2,
    5938             :                                                        dst, GDK_dbl_max,
    5939             :                                                        ci1, ci2, candoff1, candoff2,
    5940             :                                                        abort_on_error);
    5941             :                                 break;
    5942           0 :                         default:
    5943           0 :                                 goto unsupported;
    5944             :                         }
    5945           0 :                         break;
    5946             : #endif
    5947           0 :                 case TYPE_flt:
    5948             :                         switch (tp) {
    5949           0 :                         case TYPE_dbl:
    5950           0 :                                 nils = sub_dbl_flt_dbl(lft, incr1, rgt, incr2,
    5951             :                                                        dst, GDK_dbl_max,
    5952             :                                                        ci1, ci2, candoff1, candoff2,
    5953             :                                                        abort_on_error);
    5954             :                                 break;
    5955           0 :                         default:
    5956           0 :                                 goto unsupported;
    5957             :                         }
    5958           0 :                         break;
    5959         149 :                 case TYPE_dbl:
    5960             :                         switch (tp) {
    5961         149 :                         case TYPE_dbl:
    5962         149 :                                 nils = sub_dbl_dbl_dbl(lft, incr1, rgt, incr2,
    5963             :                                                        dst, GDK_dbl_max,
    5964             :                                                        ci1, ci2, candoff1, candoff2,
    5965             :                                                        abort_on_error);
    5966             :                                 break;
    5967           0 :                         default:
    5968           0 :                                 goto unsupported;
    5969             :                         }
    5970         150 :                         break;
    5971           0 :                 default:
    5972           0 :                         goto unsupported;
    5973             :                 }
    5974             :                 break;
    5975           0 :         default:
    5976           0 :                 goto unsupported;
    5977             :         }
    5978             : 
    5979             :         return nils;
    5980             : 
    5981           0 :   unsupported:
    5982           0 :         GDKerror("%s: type combination (sub(%s,%s)->%s) not supported.\n",
    5983             :                  func, ATOMname(tp1), ATOMname(tp2), ATOMname(tp));
    5984           0 :         return BUN_NONE;
    5985             : }
    5986             : 
    5987             : BAT *
    5988       20961 : BATcalcsub(BAT *b1, BAT *b2, BAT *s1, BAT *s2, int tp, bool abort_on_error)
    5989             : {
    5990             :         lng t0 = 0;
    5991             :         BAT *bn;
    5992             :         BUN nils;
    5993             :         BUN ncand;
    5994             :         struct canditer ci1, ci2;
    5995             : 
    5996       20961 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    5997             : 
    5998       20961 :         BATcheck(b1, NULL);
    5999       20961 :         BATcheck(b2, NULL);
    6000             : 
    6001       20961 :         ncand = canditer_init(&ci1, b1, s1);
    6002       20950 :         if (canditer_init(&ci2, b2, s2) != ncand ||
    6003       20950 :             ci1.hseq != ci2.hseq) {
    6004           0 :                 GDKerror("inputs not the same size.\n");
    6005           0 :                 return NULL;
    6006             :         }
    6007             : 
    6008       20950 :         bn = COLnew(ci1.hseq, tp, ncand, TRANSIENT);
    6009       20949 :         if (bn == NULL)
    6010             :                 return NULL;
    6011       20949 :         if (ncand == 0)
    6012             :                 return bn;
    6013             : 
    6014       15079 :         BATiter b1i = bat_iterator(b1);
    6015       15067 :         BATiter b2i = bat_iterator(b2);
    6016       15098 :         nils = sub_typeswitchloop(b1i.base, b1->ttype, true,
    6017       15098 :                                   b2i.base, b2->ttype, true,
    6018       15098 :                                   Tloc(bn, 0), tp,
    6019             :                                   &ci1, &ci2,
    6020             :                                   b1->hseqbase, b2->hseqbase,
    6021             :                                   abort_on_error, __func__);
    6022       15071 :         bat_iterator_end(&b1i);
    6023       15093 :         bat_iterator_end(&b2i);
    6024             : 
    6025       15087 :         if (nils == BUN_NONE) {
    6026           0 :                 BBPunfix(bn->batCacheid);
    6027           0 :                 return NULL;
    6028             :         }
    6029             : 
    6030       15087 :         BATsetcount(bn, ncand);
    6031             : 
    6032       15099 :         bn->tsorted = ncand <= 1 || nils == ncand;
    6033       15099 :         bn->trevsorted = ncand <= 1 || nils == ncand;
    6034       15099 :         bn->tkey = ncand <= 1;
    6035       15099 :         bn->tnil = nils != 0;
    6036       15099 :         bn->tnonil = nils == 0;
    6037             : 
    6038       15099 :         TRC_DEBUG(ALGO, "b1=" ALGOBATFMT ",b2=" ALGOBATFMT
    6039             :                   ",s1=" ALGOOPTBATFMT ",s2=" ALGOOPTBATFMT
    6040             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    6041             :                   ALGOBATPAR(b1), ALGOBATPAR(b2),
    6042             :                   ALGOOPTBATPAR(s1), ALGOOPTBATPAR(s2),
    6043             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    6044             : 
    6045             :         return bn;
    6046             : }
    6047             : 
    6048             : BAT *
    6049       28055 : BATcalcsubcst(BAT *b, const ValRecord *v, BAT *s, int tp, bool abort_on_error)
    6050             : {
    6051             :         lng t0 = 0;
    6052             :         BAT *bn;
    6053             :         BUN nils;
    6054             :         BUN ncand;
    6055             :         struct canditer ci;
    6056             : 
    6057       28055 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    6058             : 
    6059       28055 :         BATcheck(b, NULL);
    6060             : 
    6061       28055 :         ncand = canditer_init(&ci, b, s);
    6062             : 
    6063       28049 :         bn = COLnew(ci.hseq, tp, ncand, TRANSIENT);
    6064       28088 :         if (bn == NULL)
    6065             :                 return NULL;
    6066       28088 :         if (ncand == 0)
    6067             :                 return bn;
    6068             : 
    6069       23143 :         BATiter bi = bat_iterator(b);
    6070       23125 :         nils = sub_typeswitchloop(bi.base, b->ttype, true,
    6071             :                                   VALptr(v), v->vtype, false,
    6072       23125 :                                   Tloc(bn, 0), tp,
    6073             :                                   &ci,
    6074       23125 :                                   &(struct canditer){.tpe=cand_dense, .ncand=ncand},
    6075             :                                   b->hseqbase, 0,
    6076             :                                   abort_on_error, __func__);
    6077       23121 :         bat_iterator_end(&bi);
    6078             : 
    6079       23160 :         if (nils == BUN_NONE) {
    6080           0 :                 BBPunfix(bn->batCacheid);
    6081           0 :                 return NULL;
    6082             :         }
    6083             : 
    6084       23160 :         BATsetcount(bn, ncand);
    6085             : 
    6086             :         /* if the input is sorted, and no overflow occurred (we only
    6087             :          * know for sure if abort_on_error is set), the result is also
    6088             :          * sorted */
    6089       23165 :         bn->tsorted = (abort_on_error && b->tsorted && nils == 0) ||
    6090       41053 :                 ncand <= 1 || nils == ncand;
    6091       23164 :         bn->trevsorted = (abort_on_error && b->trevsorted && nils == 0) ||
    6092       43531 :                 ncand <= 1 || nils == ncand;
    6093       23163 :         bn->tkey = ncand <= 1;
    6094       23163 :         bn->tnil = nils != 0;
    6095       23163 :         bn->tnonil = nils == 0;
    6096             : 
    6097       23163 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
    6098             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    6099             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
    6100             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    6101             : 
    6102             :         return bn;
    6103             : }
    6104             : 
    6105             : BAT *
    6106         135 : BATcalccstsub(const ValRecord *v, BAT *b, BAT *s, int tp, bool abort_on_error)
    6107             : {
    6108             :         lng t0 = 0;
    6109             :         BAT *bn;
    6110             :         BUN nils;
    6111             :         BUN ncand;
    6112             :         struct canditer ci;
    6113             : 
    6114         135 :         TRC_DEBUG_IF(ALGO) t0 = GDKusec();
    6115             : 
    6116         135 :         BATcheck(b, NULL);
    6117             : 
    6118         135 :         ncand = canditer_init(&ci, b, s);
    6119             : 
    6120         135 :         bn = COLnew(ci.hseq, tp, ncand, TRANSIENT);
    6121         135 :         if (bn == NULL)
    6122             :                 return NULL;
    6123         135 :         if (ncand == 0)
    6124             :                 return bn;
    6125             : 
    6126         107 :         BATiter bi = bat_iterator(b);
    6127         107 :         nils = sub_typeswitchloop(VALptr(v), v->vtype, false,
    6128         107 :                                   bi.base, b->ttype, true,
    6129         107 :                                   Tloc(bn, 0), tp,
    6130         107 :                                   &(struct canditer){.tpe=cand_dense, .ncand=ncand},
    6131             :                                   &ci,
    6132             :                                   0, b->hseqbase,
    6133             :                                   abort_on_error, __func__);
    6134         107 :         bat_iterator_end(&bi);
    6135             : 
    6136         107 :         if (nils == BUN_NONE) {
    6137           0 :                 BBPunfix(bn->batCacheid);
    6138           0 :                 return NULL;
    6139             :         }
    6140             : 
    6141         107 :         BATsetcount(bn, ncand);
    6142             : 
    6143             :         /* if the input is sorted, and no overflow occurred (we only
    6144             :          * know for sure if abort_on_error is set), the result is
    6145             :          * sorted in the opposite direction (except that NILs mess
    6146             :          * things up */
    6147         103 :         bn->tsorted = (abort_on_error && nils == 0 && b->trevsorted) ||
    6148         187 :                 ncand <= 1 || nils == ncand;
    6149         103 :         bn->trevsorted = (abort_on_error && nils == 0 && b->tsorted) ||
    6150         187 :                 ncand <= 1 || nils == ncand;
    6151         107 :         bn->tkey = ncand <= 1;
    6152         107 :         bn->tnil = nils != 0;
    6153         107 :         bn->tnonil = nils == 0;
    6154             : 
    6155         107 :         TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
    6156             :                   " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
    6157             :                   ALGOBATPAR(b), ALGOOPTBATPAR(s),
    6158             :                   ALGOOPTBATPAR(bn), GDKusec() - t0);
    6159             : 
    6160             :         return bn;
    6161             : }
    6162             : 
    6163             : gdk_return
    6164        1251 : VARcalcsub(ValPtr ret, const ValRecord *lft, const ValRecord *rgt,
    6165             :            bool abort_on_error)
    6166             : {
    6167        1251 :         if (sub_typeswitchloop(VALptr(lft), lft->vtype, false,
    6168             :                                VALptr(rgt), rgt->vtype, false,
    6169             :                                VALget(ret), ret->vtype,
    6170        1251 :                                &(struct canditer){.tpe=cand_dense, .ncand=1},
    6171        1251 :                                &(struct canditer){.tpe=cand_dense, .ncand=1},
    6172             :                                0, 0, abort_on_error, __func__) == BUN_NONE)
    6173           0 :                 return GDK_FAIL;
    6174        1251 :         return GDK_SUCCEED;
    6175             : }
    6176             : 
    6177             : BAT *
    6178           0 : BATcalcdecr(BAT *b, BAT *s, bool abort_on_error)
    6179             : {
    6180           0 :         return BATcalcincrdecr(b, s, abort_on_error, sub_typeswitchloop,
    6181             :                                __func__);
    6182             : }
    6183             : 
    6184             : gdk_return
    6185           0 : VARcalcdecr(ValPtr ret, const ValRecord *v, bool abort_on_error)
    6186             : {
    6187           0 :         if (sub_typeswitchloop(VALptr(v), v->vtype, false,
    6188           0 :                                &(bte){1}, TYPE_bte, false,
    6189             :                                VALget(ret), ret->vtype,
    6190           0 :                                &(struct canditer){.tpe=cand_dense, .ncand=1},
    6191           0 :                                &(struct canditer){.tpe=cand_dense, .ncand=1},
    6192             :                                0, 0, abort_on_error, __func__) == BUN_NONE)
    6193           0 :                 return GDK_FAIL;
    6194           0 :         return GDK_SUCCEED;
    6195             : }
    6196             : 
    6197             : /* ---------------------------------------------------------------------- */
    6198             : /* multiplication (any numeric type) */
    6199             : 
    6200             : /* TYPE4 must be a type larger than both TYPE1 and TYPE2 so that
    6201             :  * multiplying into it doesn't cause overflow */
    6202             : #define MUL_4TYPE(TYPE1, TYPE2, TYPE3, TYPE4, IF)                       \
    6203             : static BUN                                                              \
    6204             : mul_##TYPE1##_##TYPE2##_##TYPE3(const TYPE1 *lft, bool incr1,           \
    6205             :                                 const TYPE2 *rgt, bool incr2,           \
    6206             :                                 TYPE3 *restrict dst, TYPE3 max,         \
    6207             :                                 struct canditer *restrict ci1,          \
    6208             :                                 struct canditer *restrict ci2,          \
    6209             :                                 oid candoff1, oid candoff2,             \
    6210             :                                 bool abort_on_error)                    \
    6211             : {                                                                       \
    6212             :         BUN nils = 0;                                                   \
    6213             :         BUN i = 0, j = 0, ncand = ci1->ncand;                                \
    6214             :                                                                         \
    6215             :         if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {           \
    6216             :                 for (BUN k = 0; k < ncand; k++) {                    \
    6217             :                         if (incr1)                                      \
    6218             :                                 i = canditer_next_dense(ci1) - candoff1; \
    6219             :                         if (incr2)                                      \
    6220             :                                 j = canditer_next_dense(ci2) - candoff2; \
    6221             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    6222             :                                 dst[k] = TYPE3##_nil;                   \
    6223             :                                 nils++;                                 \
    6224             :                         } else {                                        \
    6225             :                                 MUL##IF##4_WITH_CHECK(lft[i], rgt[j],   \
    6226             :                                                       TYPE3, dst[k],    \
    6227             :                                                       max,              \
    6228             :                                                       TYPE4,            \
    6229             :                                                       ON_OVERFLOW(TYPE1, TYPE2, "*")); \
    6230             :                         }                                               \
    6231             :                 }                                                       \
    6232             :         } else {                                                        \
    6233             :                 for (BUN k = 0; k < ncand; k++) {                    \
    6234             :                         if (incr1)                                      \
    6235             :                                 i = canditer_next(ci1) - candoff1;      \
    6236             :                         if (incr2)                                      \
    6237             :                                 j = canditer_next(ci2) - candoff2;      \
    6238             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    6239             :                                 dst[k] = TYPE3##_nil;                   \
    6240             :                                 nils++;                                 \
    6241             :                         } else {                                        \
    6242             :                                 MUL##IF##4_WITH_CHECK(lft[i], rgt[j],   \
    6243             :                                                       TYPE3, dst[k],    \
    6244             :                                                       max,              \
    6245             :                                                       TYPE4,            \
    6246             :                                                       ON_OVERFLOW(TYPE1, TYPE2, "*")); \
    6247             :                         }                                               \
    6248             :                 }                                                       \
    6249             :         }                                                               \
    6250             :         return nils;                                                    \
    6251             : }
    6252             : 
    6253             : #define MUL_3TYPE_enlarge(TYPE1, TYPE2, TYPE3, IF)                      \
    6254             : static BUN                                                              \
    6255             : mul_##TYPE1##_##TYPE2##_##TYPE3(const TYPE1 *lft, bool incr1,           \
    6256             :                                 const TYPE2 *rgt, bool incr2,           \
    6257             :                                 TYPE3 *restrict dst, TYPE3 max,         \
    6258             :                                 struct canditer *restrict ci1,          \
    6259             :                                 struct canditer *restrict ci2,          \
    6260             :                                 oid candoff1, oid candoff2,             \
    6261             :                                 bool abort_on_error)                    \
    6262             : {                                                                       \
    6263             :         BUN nils = 0;                                                   \
    6264             :         BUN i = 0, j = 0, ncand = ci1->ncand;                                \
    6265             :         const bool couldoverflow = (max < (TYPE3) GDK_##TYPE1##_max * (TYPE3) GDK_##TYPE2##_max); \
    6266             :                                                                         \
    6267             :         if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {           \
    6268             :                 for (BUN k = 0; k < ncand; k++) {                    \
    6269             :                         if (incr1)                                      \
    6270             :                                 i = canditer_next_dense(ci1) - candoff1; \
    6271             :                         if (incr2)                                      \
    6272             :                                 j = canditer_next_dense(ci2) - candoff2; \
    6273             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    6274             :                                 dst[k] = TYPE3##_nil;                   \
    6275             :                                 nils++;                                 \
    6276             :                         } else if (couldoverflow) {                     \
    6277             :                                 MUL##IF##4_WITH_CHECK(lft[i], rgt[j],   \
    6278             :                                                       TYPE3, dst[k],    \
    6279             :                                                       max,              \
    6280             :                                                       TYPE3,            \
    6281             :                                                       ON_OVERFLOW(TYPE1, TYPE2, "*")); \
    6282             :                         } else {                                        \
    6283             :                                 dst[k] = (TYPE3) lft[i] * rgt[j];       \
    6284             :                         }                                               \
    6285             :                 }                                                       \
    6286             :         } else {                                                        \
    6287             :                 for (BUN k = 0; k < ncand; k++) {                    \
    6288             :                         if (incr1)                                      \
    6289             :                                 i = canditer_next(ci1) - candoff1;      \
    6290             :                         if (incr2)                                      \
    6291             :                                 j = canditer_next(ci2) - candoff2;      \
    6292             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    6293             :                                 dst[k] = TYPE3##_nil;                   \
    6294             :                                 nils++;                                 \
    6295             :                         } else if (couldoverflow) {                     \
    6296             :                                 MUL##IF##4_WITH_CHECK(lft[i], rgt[j],   \
    6297             :                                                       TYPE3, dst[k],    \
    6298             :                                                       max,              \
    6299             :                                                       TYPE3,            \
    6300             :                                                       ON_OVERFLOW(TYPE1, TYPE2, "*")); \
    6301             :                         } else {                                        \
    6302             :                                 dst[k] = (TYPE3) lft[i] * rgt[j];       \
    6303             :                         }                                               \
    6304             :                 }                                                       \
    6305             :         }                                                               \
    6306             :         return nils;                                                    \
    6307             : }
    6308             : 
    6309             : #ifdef HAVE_HGE
    6310             : 
    6311             : #define MUL_2TYPE_lng(TYPE1, TYPE2)     MUL_4TYPE(TYPE1, TYPE2, lng, hge, I)
    6312             : 
    6313             : #define MUL_2TYPE_hge(TYPE1, TYPE2)                                     \
    6314             : static BUN                                                              \
    6315             : mul_##TYPE1##_##TYPE2##_hge(const TYPE1 *lft, bool incr1,               \
    6316             :                             const TYPE2 *rgt, bool incr2,               \
    6317             :                             hge *restrict dst, hge max,                 \
    6318             :                             struct canditer *restrict ci1,              \
    6319             :                             struct canditer *restrict ci2,              \
    6320             :                             oid candoff1, oid candoff2,                 \
    6321             :                             bool abort_on_error)                        \
    6322             : {                                                                       \
    6323             :         BUN nils = 0;                                                   \
    6324             :         BUN i = 0, j = 0, ncand = ci1->ncand;                                \
    6325             :                                                                         \
    6326             :         if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {           \
    6327             :                 for (BUN k = 0; k < ncand; k++) {                    \
    6328             :                         if (incr1)                                      \
    6329             :                                 i = canditer_next_dense(ci1) - candoff1; \
    6330             :                         if (incr2)                                      \
    6331             :                                 j = canditer_next_dense(ci2) - candoff2; \
    6332             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    6333             :                                 dst[k] = hge_nil;                       \
    6334             :                                 nils++;                                 \
    6335             :                         } else {                                        \
    6336             :                                 HGEMUL_CHECK(lft[i], rgt[j],            \
    6337             :                                              dst[k],                    \
    6338             :                                              max,                       \
    6339             :                                              ON_OVERFLOW(TYPE1, TYPE2, "*")); \
    6340             :                         }                                               \
    6341             :                 }                                                       \
    6342             :         } else {                                                        \
    6343             :                 for (BUN k = 0; k < ncand; k++) {                    \
    6344             :                         if (incr1)                                      \
    6345             :                                 i = canditer_next(ci1) - candoff1;      \
    6346             :                         if (incr2)                                      \
    6347             :                                 j = canditer_next(ci2) - candoff2;      \
    6348             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    6349             :                                 dst[k] = hge_nil;                       \
    6350             :                                 nils++;                                 \
    6351             :                         } else {                                        \
    6352             :                                 HGEMUL_CHECK(lft[i], rgt[j],            \
    6353             :                                              dst[k],                    \
    6354             :                                              max,                       \
    6355             :                                              ON_OVERFLOW(TYPE1, TYPE2, "*")); \
    6356             :                         }                                               \
    6357             :                 }                                                       \
    6358             :         }                                                               \
    6359             :         return nils;                                                    \
    6360             : }
    6361             : 
    6362             : #else
    6363             : 
    6364             : #define MUL_2TYPE_lng(TYPE1, TYPE2)                                     \
    6365             : static BUN                                                              \
    6366             : mul_##TYPE1##_##TYPE2##_lng(const TYPE1 *lft, bool incr1,               \
    6367             :                             const TYPE2 *rgt, bool incr2,               \
    6368             :                             lng *restrict dst, lng max,                 \
    6369             :                             struct canditer *restrict ci1,              \
    6370             :                             struct canditer *restrict ci2,              \
    6371             :                             oid candoff1, oid candoff2,                 \
    6372             :                             bool abort_on_error)                        \
    6373             : {                                                                       \
    6374             :         BUN nils = 0;                                                   \
    6375             :         BUN i = 0, j = 0, ncand = ci1->ncand;                                \
    6376             :                                                                         \
    6377             :         if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {           \
    6378             :                 for (BUN k = 0; k < ncand; k++) {                    \
    6379             :                         if (incr1)                                      \
    6380             :                                 i = canditer_next_dense(ci1) - candoff1; \
    6381             :                         if (incr2)                                      \
    6382             :                                 j = canditer_next_dense(ci2) - candoff2; \
    6383             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    6384             :                                 dst[k] = lng_nil;                       \
    6385             :                                 nils++;                                 \
    6386             :                         } else {                                        \
    6387             :                                 LNGMUL_CHECK(lft[i], rgt[j],            \
    6388             :                                              dst[k],                    \
    6389             :                                              max,                       \
    6390             :                                              ON_OVERFLOW(TYPE1, TYPE2, "*")); \
    6391             :                         }                                               \
    6392             :                 }                                                       \
    6393             :         } else {                                                        \
    6394             :                 for (BUN k = 0; k < ncand; k++) {                    \
    6395             :                         if (incr1)                                      \
    6396             :                                 i = canditer_next(ci1) - candoff1;      \
    6397             :                         if (incr2)                                      \
    6398             :                                 j = canditer_next(ci2) - candoff2;      \
    6399             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    6400             :                                 dst[k] = lng_nil;                       \
    6401             :                                 nils++;                                 \
    6402             :                         } else {                                        \
    6403             :                                 LNGMUL_CHECK(lft[i], rgt[j],            \
    6404             :                                              dst[k],                    \
    6405             :                                              max,                       \
    6406             :                                              ON_OVERFLOW(TYPE1, TYPE2, "*")); \
    6407             :                         }                                               \
    6408             :                 }                                                       \
    6409             :         }                                                               \
    6410             :         return nils;                                                    \
    6411             : }
    6412             : 
    6413             : #endif
    6414             : 
    6415             : #define MUL_2TYPE_float(TYPE1, TYPE2, TYPE3)                            \
    6416             : static BUN                                                              \
    6417             : mul_##TYPE1##_##TYPE2##_##TYPE3(const TYPE1 *lft, bool incr1,           \
    6418             :                                 const TYPE2 *rgt, bool incr2,           \
    6419             :                                 TYPE3 *restrict dst, TYPE3 max,         \
    6420             :                                 struct canditer *restrict ci1,          \
    6421             :                                 struct canditer *restrict ci2,          \
    6422             :                                 oid candoff1, oid candoff2,             \
    6423             :                                 bool abort_on_error)                    \
    6424             : {                                                                       \
    6425             :         BUN nils = 0;                                                   \
    6426             :         BUN i = 0, j = 0, ncand = ci1->ncand;                                \
    6427             :                                                                         \
    6428             :         if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {           \
    6429             :                 for (BUN k = 0; k < ncand; k++) {                    \
    6430             :                         if (incr1)                                      \
    6431             :                                 i = canditer_next_dense(ci1) - candoff1; \
    6432             :                         if (incr2)                                      \
    6433             :                                 j = canditer_next_dense(ci2) - candoff2; \
    6434             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    6435             :                                 dst[k] = TYPE3##_nil;                   \
    6436             :                                 nils++;                                 \
    6437             :                         } else {                                        \
    6438             :                                 /* only check for overflow, not for underflow */ \
    6439             :                                 dst[k] = (TYPE3) (lft[i] * rgt[j]);     \
    6440             :                                 if (isinf(dst[k]) || ABSOLUTE(dst[k]) > max) { \
    6441             :                                         if (abort_on_error)             \
    6442             :                                                 ON_OVERFLOW(TYPE1, TYPE2, "*");       \
    6443             :                                         dst[k] = TYPE3##_nil;           \
    6444             :                                         nils++;                         \
    6445             :                                 }                                       \
    6446             :                         }                                               \
    6447             :                 }                                                       \
    6448             :         } else {                                                        \
    6449             :                 for (BUN k = 0; k < ncand; k++) {                    \
    6450             :                         if (incr1)                                      \
    6451             :                                 i = canditer_next(ci1) - candoff1;      \
    6452             :                         if (incr2)                                      \
    6453             :                                 j = canditer_next(ci2) - candoff2;      \
    6454             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    6455             :                                 dst[k] = TYPE3##_nil;                   \
    6456             :                                 nils++;                                 \
    6457             :                         } else {                                        \
    6458             :                                 /* only check for overflow, not for underflow */ \
    6459             :                                 dst[k] = (TYPE3) (lft[i] * rgt[j]);     \
    6460             :                                 if (isinf(dst[k]) || ABSOLUTE(dst[k]) > max) { \
    6461             :                                         if (abort_on_error)             \
    6462             :                                                 ON_OVERFLOW(TYPE1, TYPE2, "*");       \
    6463             :                                         dst[k] = TYPE3##_nil;           \
    6464             :                                         nils++;                         \
    6465             :                                 }                                       \
    6466             :                         }                                               \
    6467             :                 }                                                       \
    6468             :         }                                                               \
    6469             :         return nils;                                                    \
    6470             : }
    6471             : 
    6472             : #ifdef TRUNCATE_NUMBERS
    6473             : #define roundflt(x)     (x)
    6474             : #define rounddbl(x)     (x)
    6475             : #else
    6476             : #define roundflt(x)     roundf(x)
    6477             : #define rounddbl(x)     round(x)
    6478             : #endif
    6479             : 
    6480             : #define absbte(x)       abs(x)
    6481             : #define abssht(x)       abs(x)
    6482             : #define absint(x)       abs(x)
    6483             : #define abslng(x)       llabs(x)
    6484             : #define abshge(x)       ABSOLUTE(x)
    6485             : 
    6486             : #define MUL_INT_FLT_INT(TYPE1, TYPE2, TYPE3)                            \
    6487             : static BUN                                                              \
    6488             : mul_##TYPE1##_##TYPE2##_##TYPE3(                                        \
    6489             :         const TYPE1 *lft, bool incr1, const TYPE2 *rgt, bool incr2,     \
    6490             :         TYPE3 *restrict dst, TYPE3 max,                                 \
    6491             :         struct canditer *restrict ci1, struct canditer *restrict ci2,   \
    6492             :         oid candoff1, oid candoff2, bool abort_on_error)                \
    6493             : {                                                                       \
    6494             :         BUN nils = 0;                                                   \
    6495             :         BUN i = 0, j = 0, ncand = ci1->ncand;                                \
    6496             :                                                                         \
    6497             :         if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) {           \
    6498             :                 for (BUN k = 0; k < ncand; k++) {                    \
    6499             :                         if (incr1)                                      \
    6500             :                                 i = canditer_next_dense(ci1) - candoff1; \
    6501             :                         if (incr2)                                      \
    6502             :                                 j = canditer_next_dense(ci2) - candoff2; \
    6503             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    6504             :                                 dst[k] = TYPE3##_nil;                   \
    6505             :                                 nils++;                                 \
    6506             :                         } else if (lft[i] == 0 || rgt[j] == 0) {        \
    6507             :                                 dst[k] = 0;                             \
    6508             :                         } else if (max / fabs(rgt[j]) < abs##TYPE1(lft[i])) { \
    6509             :                                 if (abort_on_error)                     \
    6510             :                                         ON_OVERFLOW(TYPE1, TYPE2, "*"); \
    6511             :                                 dst[k] = TYPE3##_nil;                   \
    6512             :                                 nils++;                                 \
    6513             :                         } else {                                        \
    6514             :                                 double m = lft[i] * rgt[j];             \
    6515             :                                 dst[k] = (TYPE3) rounddbl(m);           \
    6516             :                         }                                               \
    6517             :                 }                                                       \
    6518             :         } else {                                                        \
    6519             :                 for (BUN k = 0; k < ncand; k++) {                    \
    6520             :                         if (incr1)                                      \
    6521             :                                 i = canditer_next(ci1) - candoff1;      \
    6522             :                         if (incr2)                                      \
    6523             :                                 j = canditer_next(ci2) - candoff2;      \
    6524             :                         if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
    6525             :                                 dst[k] = TYPE3##_nil;                   \
    6526             :                                 nils++;                                 \
    6527             :                         } else if (lft[i] == 0 || rgt[j] == 0) {        \
    6528             :                                 dst[k] = 0;                             \
    6529             :                         } else if (max / fabs(rgt[j]) < abs##TYPE1(lft[i])) { \
    6530             :                                 if (abort_on_error)                     \
    6531             :                                         ON_OVERFLOW(TYPE1, TYPE2, "*"); \
    6532             :                                 dst[k] = TYPE3##_nil;                   \
    6533             :                                 nils++;                                 \
    6534             :                         } else {                                        \
    6535             :                                 double m = lft[i] * rgt[j];             \
    6536             :                                 dst[k] = (TYPE3) rounddbl(m);           \
    6537             :                         }                                               \
    6538             :                 }                                                       \
    6539             :         }                                                               \
    6540             :         return nils;                                                    \
    6541             : }
    6542             : 
    6543           0 : MUL_INT_FLT_INT(bte, flt, bte)
    6544           0 : MUL_INT_FLT_INT(bte, flt, sht)
    6545           0 : MUL_INT_FLT_INT(bte, flt, int)
    6546           0 : MUL_INT_FLT_INT(bte, flt, lng)
    6547           0 : MUL_INT_FLT_INT(sht, flt, bte)
    6548           0 : MUL_INT_FLT_INT(sht, flt, sht)
    6549           0 : MUL_INT_FLT_INT(sht, flt, int)
    6550           0 : MUL_INT_FLT_INT(sht, flt, lng)
    6551           0 : MUL_INT_FLT_INT(int, flt, bte)
    6552           0 : MUL_INT_FLT_INT(int, flt, sht)
    6553           2 : MUL_INT_FLT_INT(int, flt, int)
    6554           2 : MUL_INT_FLT_INT(int, flt, lng)
    6555           0 : MUL_INT_FLT_INT(lng, flt, bte)
    6556           0 : MUL_INT_FLT_INT(lng, flt, sht)
    6557           0 : MUL_INT_FLT_INT(lng, flt, int)
    6558           4 : MUL_INT_FLT_INT(lng, flt, lng)
    6559             : #ifdef HAVE_HGE
    6560           0 : MUL_INT_FLT_INT(bte, flt, hge)
    6561           0 : MUL_INT_FLT_INT(sht, flt, hge)
    6562           0 : MUL_INT_FLT_INT(int, flt, hge)
    6563           0 : MUL_INT_FLT_INT(lng, flt, hge)
    6564           0 : MUL_INT_FLT_INT(hge, flt, bte)
    6565           0 : MUL_INT_FLT_INT(hge, flt, sht)
    6566           0 : MUL_INT_FLT_INT(hge, flt, int)
    6567           0 : MUL_INT_FLT_INT(hge, flt, lng)
    6568           0 : MUL_INT_FLT_INT(hge, flt, hge)
    6569             : #endif
    6570             : 
    6571           0 : MUL_INT_FLT_INT(bte, dbl, bte)
    6572           0 : MUL_INT_FLT_INT(bte, dbl, sht)
    6573           0 : MUL_INT_FLT_INT(bte, dbl, int)
    6574           0 : MUL_INT_FLT_INT(bte, dbl, lng)
    6575           0 : MUL_INT_FLT_INT(sht, dbl, bte)
    6576           0 : MUL_INT_FLT_INT(sht, dbl, sht)
    6577           0 : MUL_INT_FLT_INT(sht, dbl, int)
    6578           0 : MUL_INT_FLT_INT(sht, dbl, lng)
    6579           0 : MUL_INT_FLT_INT(int, dbl, bte)
    6580           0 : MUL_INT_FLT_INT(int, dbl, sht)
    6581          18 : MUL_INT_FLT_INT(int, dbl, int)
    6582           0 : MUL_INT_FLT_INT(int, dbl, lng)
    6583           0 : MUL_INT_FLT_INT(lng, dbl, bte)
    6584           0 : MUL_INT_FLT_INT(lng, dbl, sht)
    6585           0 : MUL_INT_FLT_INT(lng, dbl, int)
    6586           8 : MUL_INT_FLT_INT(lng, dbl, lng)
    6587             : #ifdef HAVE_HGE
    6588           0 : MUL_INT_FLT_INT(bte, dbl, hge)
    6589           0 : MUL_INT_FLT_INT(sht, dbl, hge)
    6590           0 : MUL_INT_FLT_INT(int, dbl, hge)
    6591           0 : MUL_INT_FLT_INT(lng, dbl, hge)
    6592           0 : MUL_INT_FLT_INT(hge, dbl, bte)
    6593           0 : MUL_INT_FLT_INT(hge, dbl, sht)
    6594           0 : MUL_INT_FLT_INT(hge, dbl, int)
    6595           0 : MUL_INT_FLT_INT(hge, dbl, lng)
    6596           0 : MUL_INT_FLT_INT(hge, dbl, hge)
    6597             : #endif
    6598             : 
    6599          70 : MUL_4TYPE(bte, bte, bte, sht, I)
    6600         302 : MUL_3TYPE_enlarge(bte, bte, sht, I)
    6601          22 : MUL_3TYPE_enlarge(bte, bte, int, I)
    6602           0 : MUL_3TYPE_enlarge(bte, bte, lng, I)
    6603             : #ifdef HAVE_HGE
    6604           0 : MUL_3TYPE_enlarge(bte, bte, hge, I)
    6605             : #endif
    6606           0 : MUL_3TYPE_enlarge(bte, bte, flt, F)
    6607           0 : MUL_3TYPE_enlarge(bte, bte, dbl, F)
    6608           0 : MUL_4TYPE(bte, sht, sht, int, I)
    6609           4 : MUL_3TYPE_enlarge(bte, sht, int, I)
    6610           0 : MUL_3TYPE_enlarge(bte, sht, lng, I)
    6611             : #ifdef HAVE_HGE
    6612           0 : MUL_3TYPE_enlarge(bte, sht, hge, I)
    6613             : #endif
    6614           0 : MUL_3TYPE_enlarge(bte, sht, flt, F)
    6615           0 : MUL_3TYPE_enlarge(bte, sht, dbl, F)
    6616     3500032 : MUL_4TYPE(bte, int, int, lng, I)
    6617       36194 : MUL_3TYPE_enlarge(bte, int, lng, I)
    6618             : #ifdef HAVE_HGE
    6619           0 : MUL_3TYPE_enlarge(bte, int, hge, I)
    6620             : #endif
    6621           0 : MUL_3TYPE_enlarge(bte, int, flt, F)
    6622           0 : MUL_3TYPE_enlarge(bte, int, dbl, F)
    6623           0 : MUL_2TYPE_lng(bte, lng)
    6624             : #ifdef HAVE_HGE
    6625          26 : MUL_3TYPE_enlarge(bte, lng, hge, I)
    6626             : #endif
    6627           0 : MUL_3TYPE_enlarge(bte, lng, flt, F)
    6628           0 : MUL_3TYPE_enlarge(bte, lng, dbl, F)
    6629             : #ifdef HAVE_HGE
    6630          62 : MUL_2TYPE_hge(bte, hge)
    6631           0 : MUL_3TYPE_enlarge(bte, hge, flt, F)
    6632           0 : MUL_3TYPE_enlarge(bte, hge, dbl, F)
    6633             : #endif
    6634           0 : MUL_2TYPE_float(bte, flt, flt)
    6635           0 : MUL_3TYPE_enlarge(bte, flt, dbl, F)
    6636           0 : MUL_2TYPE_float(bte, dbl, dbl)
    6637           8 : MUL_4TYPE(sht, bte, sht, int, I)
    6638          50 : MUL_3TYPE_enlarge(sht, bte, int, I)
    6639     4000034 : MUL_3TYPE_enlarge(sht, bte, lng, I)
    6640             : #ifdef HAVE_HGE
    6641           0 : MUL_3TYPE_enlarge(sht, bte, hge, I)
    6642             : #endif
    6643           0 : MUL_3TYPE_enlarge(sht, bte, flt, F)
    6644           0 : MUL_3TYPE_enlarge(sht, bte, dbl, F)
    6645           2 : MUL_4TYPE(sht, sht, sht, int, I)
    6646     4000036 : MUL_3TYPE_enlarge(sht, sht, int, I)
    6647          14 : MUL_3TYPE_enlarge(sht, sht, lng, I)
    6648             : #ifdef HAVE_HGE
    6649           0 : MUL_3TYPE_enlarge(sht, sht, hge, I)
    6650             : #endif
    6651           0 : MUL_3TYPE_enlarge(sht, sht, flt, F)
    6652           0 : MUL_3TYPE_enlarge(sht, sht, dbl, F)
    6653           2 : MUL_4TYPE(sht, int, int, lng, I)
    6654          18 : MUL_3TYPE_enlarge(sht, int, lng, I)
    6655             : #ifdef HAVE_HGE
    6656           0 : MUL_3TYPE_enlarge(sht, int, hge, I)
    6657             : #endif
    6658           0 : MUL_3TYPE_enlarge(sht, int, flt, F)
    6659           0 : MUL_3TYPE_enlarge(sht, int, dbl, F)
    6660           0 : MUL_2TYPE_lng(sht, lng)
    6661             : #ifdef HAVE_HGE
    6662           2 : MUL_3TYPE_enlarge(sht, lng, hge, I)
    6663             : #endif
    6664           0 : MUL_3TYPE_enlarge(sht, lng, flt, F)
    6665           0 : MUL_3TYPE_enlarge(sht, lng, dbl, F)
    6666             : #ifdef HAVE_HGE
    6667           6 : MUL_2TYPE_hge(sht, hge)
    6668           0 : MUL_3TYPE_enlarge(sht, hge, flt, F)
    6669           0 : MUL_3TYPE_enlarge(sht, hge, dbl, F)
    6670             : #endif
    6671           0 : MUL_2TYPE_float(sht, flt, flt)
    6672           0 : MUL_3TYPE_enlarge(sht, flt, dbl, F)
    6673           0 : MUL_2TYPE_float(sht, dbl, dbl)
    6674          30 : MUL_4TYPE(int, bte, int, lng, I)
    6675     4222801 : MUL_3TYPE_enlarge(int, bte, lng, I)
    6676             : #ifdef HAVE_HGE
    6677           0 : MUL_3TYPE_enlarge(int, bte, hge, I)
    6678             : #endif
    6679           0 : MUL_3TYPE_enlarge(int, bte, flt, F)
    6680           0 : MUL_3TYPE_enlarge(int, bte, dbl, F)
    6681           2 : MUL_4TYPE(int, sht, int, lng, I)
    6682      520227 : MUL_3TYPE_enlarge(int, sht, lng, I)
    6683             : #ifdef HAVE_HGE
    6684           0 : MUL_3TYPE_enlarge(int, sht, hge, I)
    6685             : #endif
    6686           0 : MUL_3TYPE_enlarge(int, sht, flt, F)
    6687           0 : MUL_3TYPE_enlarge(int, sht, dbl, F)
    6688          55 : MUL_4TYPE(int, int, int, lng, I)
    6689          14 : MUL_3TYPE_enlarge(int, int, lng, I)
    6690             : #ifdef HAVE_HGE
    6691       18935 : MUL_3TYPE_enlarge(int, int, hge, I)
    6692             : #endif
    6693           0 : MUL_3TYPE_enlarge(int, int, flt, F)
    6694           0 : MUL_3TYPE_enlarge(int, int, dbl, F)
    6695           0 : MUL_2TYPE_lng(int, lng)
    6696             : #ifdef HAVE_HGE
    6697          90 : MUL_3TYPE_enlarge(int, lng, hge, I)
    6698             : #endif
    6699           0 : MUL_3TYPE_enlarge(int, lng, flt, F)
    6700           0 : MUL_3TYPE_enlarge(int, lng, dbl, F)
    6701             : #ifdef HAVE_HGE
    6702          19 : MUL_2TYPE_hge(int, hge)
    6703           0 : MUL_3TYPE_enlarge(int, hge, flt, F)
    6704           0 : MUL_3TYPE_enlarge(int, hge, dbl, F)
    6705             : #endif
    6706           0 : MUL_2TYPE_float(int, flt, flt)
    6707           0 : MUL_3TYPE_enlarge(int, flt, dbl, F)
    6708           0 : MUL_2TYPE_float(int, dbl, dbl)
    6709     2000048 : MUL_2TYPE_lng(lng, bte)
    6710             : #ifdef HAVE_HGE
    6711     1750053 : MUL_3TYPE_enlarge(lng, bte, hge, I)
    6712             : #endif
    6713           0 : MUL_3TYPE_enlarge(lng, bte, flt, F)
    6714           0 : MUL_3TYPE_enlarge(lng, bte, dbl, F)
    6715           4 : MUL_2TYPE_lng(lng, sht)
    6716             : #ifdef HAVE_HGE
    6717           2 : MUL_3TYPE_enlarge(lng, sht, hge, I)
    6718             : #endif
    6719           0 : MUL_3TYPE_enlarge(lng, sht, flt, F)
    6720           0 : MUL_3TYPE_enlarge(lng, sht, dbl, F)
    6721           4 : MUL_2TYPE_lng(lng, int)
    6722             : #ifdef HAVE_HGE
    6723     3500856 : MUL_3TYPE_enlarge(lng, int, hge, I)
    6724             : #endif
    6725           0 : MUL_3TYPE_enlarge(lng, int, flt, F)
    6726           0 : MUL_3TYPE_enlarge(lng, int, dbl, F)
    6727          52 : MUL_2TYPE_lng(lng, lng)
    6728             : #ifdef HAVE_HGE
    6729    21174093 : MUL_3TYPE_enlarge(lng, lng, hge, I)
    6730             : #endif
    6731           0 : MUL_3TYPE_enlarge(lng, lng, flt, F)
    6732           0 : MUL_3TYPE_enlarge(lng, lng, dbl, F)
    6733             : #ifdef HAVE_HGE
    6734          32 : MUL_2TYPE_hge(lng, hge)
    6735           0 : MUL_3TYPE_enlarge(lng, hge, flt, F)
    6736           0 : MUL_3TYPE_enlarge(lng, hge, dbl, F)
    6737             : #endif
    6738           0 : MUL_2TYPE_float(lng, flt, flt)
    6739           0 : MUL_3TYPE_enlarge(lng, flt, dbl, F)
    6740           0 : MUL_2TYPE_float(lng, dbl, dbl)
    6741             : #ifdef HAVE_HGE
    6742     2338027 : MUL_2TYPE_hge(hge, bte)
    6743           0 : MUL_3TYPE_enlarge(hge, bte, flt, F)
    6744           0 : MUL_3TYPE_enlarge(hge, bte, dbl, F)
    6745           8 : MUL_2TYPE_hge(hge, sht)
    6746           0 : MUL_3TYPE_enlarge(hge, sht, flt, F)
    6747           0 : MUL_3TYPE_enlarge(hge, sht, dbl, F)
    6748       10254 : MUL_2TYPE_hge(hge, int)
    6749           0 : MUL_3TYPE_enlarge(hge, int, flt, F)
    6750           0 : MUL_3TYPE_enlarge(hge, int, dbl, F)
    6751       59393 : MUL_2TYPE_hge(hge, lng)
    6752           0 : MUL_3TYPE_enlarge(hge, lng, flt, F)
    6753           0 : MUL_3TYPE_enlarge(hge, lng, dbl, F)
    6754       11011 : MUL_2TYPE_hge(hge, hge)
    6755           0 : MUL_3TYPE_enlarge(hge, hge, flt, F)
    6756           0 : MUL_3TYPE_enlarge(hge, hge, dbl, F)
    6757           0 : MUL_2TYPE_float(hge, flt, flt)
    6758           0 : MUL_3TYPE_enlarge(hge, flt, dbl, F)
    6759           0 : MUL_2TYPE_float(hge, dbl, dbl)
    6760             : #endif
    6761           0 : MUL_2TYPE_float(flt, bte, flt)
    6762           0 : MUL_3TYPE_enlarge(flt, bte, dbl, F)
    6763           0 : MUL_2TYPE_float(flt, sht, flt)
    6764           0 : MUL_3TYPE_enlarge(flt, sht, dbl, F)
    6765           0 : MUL_2TYPE_float(flt, int, flt)
    6766           0 : MUL_3TYPE_enlarge(flt, int, dbl, F)
    6767           0 : MUL_2TYPE_float(flt, lng, flt)
    6768           0 : MUL_3TYPE_enlarge(flt, lng, dbl, F)
    6769             : #ifdef HAVE_HGE
    6770           0 : MUL_2TYPE_float(flt, hge, flt)
    6771           0 : MUL_3TYPE_enlarge(flt, hge, dbl, F)
    6772             : #endif
    6773          36 : MUL_2TYPE_float(flt, flt, flt)
    6774           0 : MUL_3TYPE_enlarge(flt, flt, dbl, F)
    6775           0 : MUL_2TYPE_float(flt, dbl, dbl)
    6776           0 : MUL_2TYPE_float(dbl, bte, dbl)
    6777           0 : MUL_2TYPE_float(dbl, sht, dbl)
    6778           0 : MUL_2TYPE_float(dbl, int, dbl)
    6779           0 : MUL_2TYPE_float(dbl, lng, dbl)
    6780             : #ifdef HAVE_HGE
    6781           0 : MUL_2TYPE_float(dbl, hge, dbl)
    6782             : #endif
    6783           0 : MUL_2TYPE_float(dbl, flt, dbl)
    6784      564919 : MUL_2TYPE_float(dbl, dbl, dbl)
    6785             : 
    6786             : static BUN
    6787       26439 : mul_typeswitchloop(const void *lft, int tp1, bool incr1,
    6788             :                    const void *rgt, int tp2, bool incr2,
    6789             :                    void *restrict dst, int tp,
    6790             :                    struct canditer *restrict ci1,
    6791             :                    struct canditer *restrict ci2,
    6792             :                    oid candoff1, oid candoff2,
    6793             :                    bool abort_on_error, const char *func)
    6794             : {
    6795             :         BUN nils;
    6796             : 
    6797       26439 :         tp1 = ATOMbasetype(tp1);
    6798       26439 :         tp2 = ATOMbasetype(tp2);
    6799       26439 :         tp = ATOMbasetype(tp);
    6800       26439 :         switch (tp1) {
    6801         224 :         case TYPE_bte:
    6802             :                 switch (tp2) {
    6803         142 :                 case TYPE_bte:
    6804             :                         switch (tp) {
    6805          36 :                         case TYPE_bte:
    6806          36 :                                 nils = mul_bte_bte_bte(lft, incr1, rgt, incr2,
    6807             :                                                        dst, GDK_bte_max,
    6808             :                                                        ci1, ci2, candoff1, candoff2,
    6809             :                                                        abort_on_error);
    6810          36 :                                 break;
    6811         105 :                         case TYPE_sht:
    6812         105 :                                 nils = mul_bte_bte_sht(lft, incr1, rgt, incr2,
    6813             :                                                        dst, GDK_sht_max,
    6814             :                                                        ci1, ci2, candoff1, candoff2,
    6815             :                                                        abort_on_error);
    6816         105 :                                 break;
    6817           1 :                         case TYPE_int:
    6818           1 :                                 nils = mul_bte_bte_int(lft, incr1, rgt, incr2,
    6819             :                                                        dst, GDK_int_max,
    6820             :                                                        ci1, ci2, candoff1, candoff2,
    6821             :                                                        abort_on_error);
    6822           1 :                                 break;
    6823           0 :                         case TYPE_lng:
    6824           0 :                                 nils = mul_bte_bte_lng(lft, incr1, rgt, incr2,
    6825             :                                                        dst, GDK_lng_max,
    6826             :                                                        ci1, ci2, candoff1, candoff2,
    6827             :                                                        abort_on_error);
    6828           0 :                                 break;
    6829             : #ifdef HAVE_HGE
    6830           0 :                         case TYPE_hge:
    6831           0 :                                 nils = mul_bte_bte_hge(lft, incr1, rgt, incr2,
    6832             :                                                        dst, GDK_hge_max,
    6833             :                                                        ci1, ci2, candoff1, candoff2,
    6834             :                                                        abort_on_error);
    6835           0 :                                 break;
    6836             : #endif
    6837           0 :                         case TYPE_flt:
    6838           0 :                                 nils = mul_bte_bte_flt(lft, incr1, rgt, incr2,
    6839             :                                                        dst, GDK_flt_max,
    6840             :                                                        ci1, ci2, candoff1, candoff2,
    6841             :                                                        abort_on_error);
    6842           0 :                                 break;
    6843           0 :                         case TYPE_dbl:
    6844           0 :                                 nils = mul_bte_bte_dbl(lft, incr1, rgt, incr2,
    6845             :                                                        dst, GDK_dbl_max,
    6846             :                                                        ci1, ci2, candoff1, candoff2,
    6847             :                                                        abort_on_error);
    6848           0 :                                 break;
    6849           0 :                         default:
    6850           0 :                                 goto unsupported;
    6851             :                         }
    6852             :                         break;
    6853           2 :                 case TYPE_sht:
    6854             :                         switch (tp) {
    6855           0 :                         case TYPE_sht:
    6856           0 :                                 nils = mul_bte_sht_sht(lft, incr1, rgt, incr2,
    6857             :                                                        dst, GDK_sht_max,
    6858             :                                                        ci1, ci2, candoff1, candoff2,
    6859             :                                                        abort_on_error);
    6860           0 :                                 break;
    6861           2 :                         case TYPE_int:
    6862           2 :                                 nils = mul_bte_sht_int(lft, incr1, rgt, incr2,
    6863             :                                                        dst, GDK_int_max,
    6864             :                                                        ci1, ci2, candoff1, candoff2,
    6865             :                                                        abort_on_error);
    6866           2 :                                 break;
    6867           0 :                         case TYPE_lng:
    6868           0 :                                 nils = mul_bte_sht_lng(lft, incr1, rgt, incr2,
    6869             :                                                        dst, GDK_lng_max,
    6870             :                                                        ci1, ci2, candoff1, candoff2,
    6871             :                                                        abort_on_error);
    6872           0 :                                 break;
    6873             : #ifdef HAVE_HGE
    6874           0 :                         case TYPE_hge:
    6875           0 :                                 nils = mul_bte_sht_hge(lft, incr1, rgt, incr2,
    6876             :                                                        dst, GDK_hge_max,
    6877             :                                                        ci1, ci2, candoff1, candoff2,
    6878             :                                                        abort_on_error);
    6879           0 :                                 break;
    6880             : #endif
    6881           0 :                         case TYPE_flt:
    6882           0 :                                 nils = mul_bte_sht_flt(lft, incr1, rgt, incr2,
    6883             :                                                        dst, GDK_flt_max,
    6884             :                                                        ci1, ci2, candoff1, candoff2,
    6885             :                                                        abort_on_error);
    6886           0 :                                 break;
    6887           0 :                         case TYPE_dbl:
    6888           0 :                                 nils = mul_bte_sht_dbl(lft, incr1, rgt, incr2,
    6889             :                                                        dst, GDK_dbl_max,
    6890             :                                                        ci1, ci2, candoff1, candoff2,
    6891             :                                                        abort_on_error);
    6892           0 :                                 break;
    6893           0 :                         default:
    6894           0 :                                 goto unsupported;
    6895             :                         }
    6896             :                         break;
    6897          61 :                 case TYPE_int:
    6898             :                         switch (tp) {
    6899          32 :                         case TYPE_int:
    6900          32 :                                 nils = mul_bte_int_int(lft, incr1, rgt, incr2,
    6901             :                                                        dst, GDK_int_max,
    6902             :                                                        ci1, ci2, candoff1, candoff2,
    6903             :                                                        abort_on_error);
    6904          32 :                                 break;
    6905          29 :                         case TYPE_lng:
    6906          29 :                                 nils = mul_bte_int_lng(lft, incr1, rgt, incr2,
    6907             :                                                        dst, GDK_lng_max,
    6908             :                                                        ci1, ci2, candoff1, candoff2,
    6909             :                                                        abort_on_error);
    6910          29 :                                 break;
    6911             : #ifdef HAVE_HGE
    6912           0 :                         case TYPE_hge:
    6913           0 :                                 nils = mul_bte_int_hge(lft, incr1, rgt, incr2,
    6914             :                                                        dst, GDK_hge_max,
    6915             :                                                        ci1, ci2, candoff1, candoff2,
    6916             :                                                        abort_on_error);
    6917           0 :                                 break;
    6918             : #endif
    6919           0 :                         case TYPE_flt:
    6920           0 :                                 nils = mul_bte_int_flt(lft, incr1, rgt, incr2,
    6921             :                                                        dst, GDK_flt_max,
    6922             :                                                        ci1, ci2, candoff1, candoff2,
    6923             :                                                        abort_on_error);
    6924           0 :                                 break;
    6925           0 :                         case TYPE_dbl:
    6926           0 :                                 nils = mul_bte_int_dbl(lft, incr1, rgt, incr2,
    6927             :                                                        dst, GDK_dbl_max,
    6928             :                                                        ci1, ci2, candoff1, candoff2,
    6929             :                                                        abort_on_error);
    6930           0 :                                 break;
    6931           0 :                         default:
    6932           0 :                                 goto unsupported;
    6933             :                         }
    6934             :                         break;
    6935          13 :                 case TYPE_lng:
    6936             :                         switch (tp) {
    6937           0 :                         case TYPE_lng:
    6938           0 :                                 nils = mul_bte_lng_lng(lft, incr1, rgt, incr2,
    6939             :                                                        dst, GDK_lng_max,
    6940             :                                                        ci1, ci2, candoff1, candoff2,
    6941             :                                                        abort_on_error);
    6942           0 :                                 break;
    6943             : #ifdef HAVE_HGE
    6944          13 :                         case TYPE_hge:
    6945          13 :                                 nils = mul_bte_lng_hge(lft, incr1, rgt, incr2,
    6946             :                                                        dst, GDK_hge_max,
    6947             :                                                        ci1, ci2, candoff1, candoff2,
    6948             :                                                        abort_on_error);
    6949          13 :                                 break;
    6950             : #endif
    6951           0 :                         case TYPE_flt:
    6952           0 :                                 nils = mul_bte_lng_flt(lft, incr1, rgt, incr2,
    6953             :                                                        dst, GDK_flt_max,
    6954             :                                                        ci1, ci2, candoff1, candoff2,
    6955             :                                                        abort_on_error);
    6956           0 :                                 break;
    6957           0 :                         case TYPE_dbl:
    6958           0 :                                 nils = mul_bte_lng_dbl(lft, incr1, rgt, incr2,
    6959             :                                                        dst, GDK_dbl_max,
    6960             :                                                        ci1, ci2, candoff1, candoff2,
    6961             :                                                        abort_on_error);
    6962           0 :                                 break;
    6963           0 :                         default:
    6964           0 :                                 goto unsupported;
    6965             :                         }
    6966             :                         break;
    6967             : #ifdef HAVE_HGE
    6968           6 :                 case TYPE_hge:
    6969             :                         switch (tp) {
    6970           6 :                         case TYPE_hge:
    6971           6 :                                 nils = mul_bte_hge_hge(lft, incr1, rgt, incr2,
    6972             :                                                        dst, GDK_hge_max,
    6973             :                                                        ci1, ci2, candoff1, candoff2,
    6974             :                                                        abort_on_error);
    6975           6 :                                 break;
    6976           0 :                         case TYPE_flt:
    6977           0 :                                 nils = mul_bte_hge_flt(lft, incr1, rgt, incr2,
    6978             :                                                        dst, GDK_flt_max,
    6979             :                                                        ci1, ci2, candoff1, candoff2,
    6980             :                                                        abort_on_error);
    6981           0 :                                 break;
    6982           0 :                         case TYPE_dbl:
    6983           0 :                                 nils = mul_bte_hge_dbl(lft, incr1, rgt, incr2,
    6984             :                                                        dst, GDK_dbl_max,
    6985             :                                                        ci1, ci2, candoff1, candoff2,
    6986             :                                                        abort_on_error);
    6987           0 :                                 break;
    6988           0 :                         default:
    6989           0 :                                 goto unsupported;
    6990             :                         }
    6991             :                         break;
    6992             : #endif
    6993           0 :                 case TYPE_flt:
    6994             :                         switch (tp) {
    6995           0 :                         case TYPE_bte:
    6996           0 :                                 nils = mul_bte_flt_bte(lft, incr1, rgt, incr2,
    6997             :                                                        dst, GDK_bte_max,
    6998             :                                                        ci1, ci2,
    6999             :                                                        candoff1, candoff2,
    7000             :                                                        abort_on_error);
    7001           0 :                                 break;
    7002           0 :                         case TYPE_sht:
    7003           0 :                                 nils = mul_bte_flt_sht(lft, incr1, rgt, incr2,
    7004             :                                                        dst, GDK_sht_max,
    7005             :                                                        ci1, ci2,
    7006             :                                                        candoff1, candoff2,
    7007             :                                                        abort_on_error);
    7008           0 :                                 break;
    7009           0 :                         case TYPE_int:
    7010           0 :                                 nils = mul_bte_flt_int(lft, incr1, rgt, incr2,
    7011             :                                                        dst, GDK_int_max,
    7012             :                                                        ci1, ci2,
    7013             :                                                        candoff1, candoff2,
    7014             :                                                        abort_on_error);
    7015           0 :                                 break;
    7016           0 :                         case TYPE_lng:
    7017           0 :                                 nils = mul_bte_flt_lng(lft, incr1, rgt, incr2,
    7018             :                                                        dst, GDK_lng_max,
    7019             :                                                        ci1, ci2,
    7020             :                                                        candoff1, candoff2,
    7021             :                                                        abort_on_error);
    7022           0 :                                 break;
    7023             : #ifdef HAVE_HGE
    7024           0 :                         case TYPE_hge:
    7025           0 :                                 nils = mul_bte_flt_hge(lft, incr1, rgt, incr2,
    7026             :                                                        dst, GDK_hge_max,
    7027             :                                                        ci1, ci2,
    7028             :                                                        candoff1, candoff2,
    7029             :                                                        abort_on_error);
    7030           0 :                                 break;
    7031             : #endif
    7032           0 :                         case TYPE_flt:
    7033           0 :                                 nils = mul_bte_flt_flt(lft, incr1, rgt, incr2,
    7034             :                                                        dst, GDK_flt_max,
    7035             :                                                        ci1, ci2, candoff1, candoff2,
    7036             :                                                        abort_on_error);
    7037           0 :                                 break;
    7038           0 :                         case TYPE_dbl:
    7039           0 :                                 nils = mul_bte_flt_dbl(lft, incr1, rgt, incr2,
    7040             :                                                        dst, GDK_dbl_max,
    7041             :                                                        ci1, ci2, candoff1, candoff2,
    7042             :                                                        abort_on_error);
    7043           0 :                                 break;
    7044           0 :                         default:
    7045           0 :                                 goto unsupported;
    7046             :                         }
    7047             :                         break;
    7048           0 :                 case TYPE_dbl:
    7049             :                         switch (tp) {
    7050           0 :                         case TYPE_bte:
    7051           0 :                                 nils = mul_bte_dbl_bte(lft, incr1, rgt, incr2,
    7052             :                                                        dst, GDK_bte_max,
    7053             :                                                        ci1, ci2,
    7054             :                                                        candoff1, candoff2,
    7055             :                                                        abort_on_error);
    7056           0 :                                 break;
    7057           0 :                         case TYPE_sht:
    7058           0 :                                 nils = mul_bte_dbl_sht(lft, incr1, rgt, incr2,
    7059             :                                                        dst, GDK_sht_max,
    7060             :                                                        ci1, ci2,
    7061             :                                                        candoff1, candoff2,
    7062             :                                                        abort_on_error);
    7063           0 :                                 break;
    7064           0 :                         case TYPE_int:
    7065           0 :                                 nils = mul_bte_dbl_int(lft, incr1, rgt, incr2,
    7066             :                                                        dst, GDK_int_max,
    7067             :                                                        ci1, ci2,
    7068             :                                                        candoff1, candoff2,
    7069             :                                                        abort_on_error);
    7070           0 :                                 break;
    7071           0 :                         case TYPE_lng:
    7072           0 :                                 nils = mul_bte_dbl_lng(lft, incr1, rgt, incr2,
    7073             :                                                        dst, GDK_lng_max,
    7074             :                                                        ci1, ci2,
    7075             :                                                        candoff1, candoff2,
    7076             :                                                        abort_on_error);
    7077           0 :                                 break;
    7078             : #ifdef HAVE_HGE
    7079           0 :                         case TYPE_hge:
    7080           0 :                                 nils = mul_bte_dbl_hge(lft, incr1, rgt, incr2,
    7081             :                                                        dst, GDK_hge_max,
    7082             :                                                        ci1, ci2,
    7083             :                                                        candoff1, candoff2,
    7084             :                                                        abort_on_error);
    7085           0 :                                 break;
    7086             : #endif
    7087           0 :                         case TYPE_dbl:
    7088           0 :                                 nils = mul_bte_dbl_dbl(lft, incr1, rgt, incr2,
    7089             :                                                        dst, GDK_dbl_max,
    7090             :                                                        ci1, ci2, candoff1, candoff2,
    7091             :                                                        abort_on_error);
    7092           0 :                                 break;
    7093           0 :                         default:
    7094           0 :                                 goto unsupported;
    7095             :                         }
    7096             :                         break;
    7097           0 :                 default:
    7098           0 :                         goto unsupported;
    7099             :                 }
    7100             :                 break;
    7101         114 :         case TYPE_sht:
    7102             :                 switch (tp2) {
    7103          62 :                 case TYPE_bte:
    7104             :                         switch (tp) {
    7105           4 :                         case TYPE_sht:
    7106           4 :                                 nils = mul_sht_bte_sht(lft, incr1, rgt, incr2,
    7107             :                                                        dst, GDK_sht_max,
    7108             :                                                        ci1, ci2, candoff1, candoff2,
    7109             :                                                        abort_on_error);
    7110           4 :                                 break;
    7111          25 :                         case TYPE_int:
    7112          25 :                                 nils = mul_sht_bte_int(lft, incr1, rgt, incr2,
    7113             :                                                        dst, GDK_int_max,
    7114             :                                                        ci1, ci2, candoff1, candoff2,
    7115             :                                                        abort_on_error);
    7116          24 :                                 break;
    7117          33 :                         case TYPE_lng:
    7118          33 :                                 nils = mul_sht_bte_lng(lft, incr1, rgt, incr2,
    7119             :                                                        dst, GDK_lng_max,
    7120             :                                                        ci1, ci2, candoff1, candoff2,
    7121             :                                                        abort_on_error);
    7122          33 :                                 break;
    7123             : #ifdef HAVE_HGE
    7124           0 :                         case TYPE_hge:
    7125           0 :                                 nils = mul_sht_bte_hge(lft, incr1, rgt, incr2,
    7126             :                                                        dst, GDK_hge_max,
    7127             :                                                        ci1, ci2, candoff1, candoff2,
    7128             :                                                        abort_on_error);
    7129           0 :                                 break;
    7130             : #endif
    7131           0 :                         case TYPE_flt:
    7132           0 :                                 nils = mul_sht_bte_flt(lft, incr1, rgt, incr2,
    7133             :                                                        dst, GDK_flt_max,
    7134             :                                                        ci1, ci2, candoff1, candoff2,
    7135             :                                                        abort_on_error);
    7136           0 :                                 break;
    7137           0 :                         case TYPE_dbl:
    7138           0 :                                 nils = mul_sht_bte_dbl(lft, incr1, rgt, incr2,
    7139             :                                                        dst, GDK_dbl_max,
    7140             :                                                        ci1, ci2, candoff1, candoff2,
    7141             :                                                        abort_on_error);
    7142           0 :                                 break;
    7143           0 :                         default:
    7144           0 :                                 goto unsupported;
    7145             :                         }
    7146             :                         break;
    7147          40 :                 case TYPE_sht:
    7148             :                         switch (tp) {
    7149           1 :                         case TYPE_sht:
    7150           1 :                                 nils = mul_sht_sht_sht(lft, incr1, rgt, incr2,
    7151             :                                                        dst, GDK_sht_max,
    7152             :                                                        ci1, ci2, candoff1, candoff2,
    7153             :                                                        abort_on_error);
    7154           1 :                                 break;
    7155          34 :                         case TYPE_int:
    7156          34 :                                 nils = mul_sht_sht_int(lft, incr1, rgt, incr2,
    7157             :                                                        dst, GDK_int_max,
    7158             :                                                        ci1, ci2, candoff1, candoff2,
    7159             :                                                        abort_on_error);
    7160          34 :                                 break;
    7161           5 :                         case TYPE_lng:
    7162           5 :                                 nils = mul_sht_sht_lng(lft, incr1, rgt, incr2,
    7163             :                                                        dst, GDK_lng_max,
    7164             :                                                        ci1, ci2, candoff1, candoff2,
    7165             :                                                        abort_on_error);
    7166           5 :                                 break;
    7167             : #ifdef HAVE_HGE
    7168           0 :                         case TYPE_hge:
    7169           0 :                                 nils = mul_sht_sht_hge(lft, incr1, rgt, incr2,
    7170             :                                                        dst, GDK_hge_max,
    7171             :                                                        ci1, ci2, candoff1, candoff2,
    7172             :                                                        abort_on_error);
    7173           0 :                                 break;
    7174             : #endif
    7175           0 :                         case TYPE_flt:
    7176           0 :                                 nils = mul_sht_sht_flt(lft, incr1, rgt, incr2,
    7177             :                                                        dst, GDK_flt_max,
    7178             :                                                        ci1, ci2, candoff1, candoff2,
    7179             :                                                        abort_on_error);
    7180           0 :                                 break;
    7181           0 :                         case TYPE_dbl:
    7182           0 :                                 nils = mul_sht_sht_dbl(lft, incr1, rgt, incr2,
    7183             :                                                        dst, GDK_dbl_max,
    7184             :                                                        ci1, ci2, candoff1, candoff2,
    7185             :                                                        abort_on_error);
    7186           0 :                                 break;
    7187           0 :                         default:
    7188           0 :                                 goto unsupported;
    7189             :                         }
    7190             :                         break;
    7191           8 :                 case TYPE_int:
    7192             :                         switch (tp) {
    7193           1 :                         case TYPE_int:
    7194           1 :                                 nils = mul_sht_int_int(lft, incr1, rgt, incr2,
    7195             :                                                        dst, GDK_int_max,
    7196             :                                                        ci1, ci2, candoff1, candoff2,
    7197             :                                                        abort_on_error);
    7198           1 :                                 break;
    7199           7 :                         case TYPE_lng:
    7200           7 :                                 nils = mul_sht_int_lng(lft, incr1, rgt, incr2,
    7201             :                                                        dst, GDK_lng_max,
    7202             :                                                        ci1, ci2, candoff1, candoff2,
    7203             :                                                        abort_on_error);
    7204           7 :                                 break;
    7205             : #ifdef HAVE_HGE
    7206           0 :                         case TYPE_hge:
    7207           0 :                                 nils = mul_sht_int_hge(lft, incr1, rgt, incr2,
    7208             :                                                        dst, GDK_hge_max,
    7209             :                                                        ci1, ci2, candoff1, candoff2,
    7210             :                                                        abort_on_error);
    7211           0 :                                 break;
    7212             : #endif
    7213           0 :                         case TYPE_flt:
    7214           0 :                                 nils = mul_sht_int_flt(lft, incr1, rgt, incr2,
    7215             :                                                        dst, GDK_flt_max,
    7216             :                                                        ci1, ci2, candoff1, candoff2,
    7217             :                                                        abort_on_error);
    7218           0 :                                 break;
    7219           0 :                         case TYPE_dbl:
    7220           0 :                                 nils = mul_sht_int_dbl(lft, incr1, rgt, incr2,
    7221             :                                                        dst, GDK_dbl_max,
    7222             :                                                        ci1, ci2, candoff1, candoff2,
    7223             :                                                        abort_on_error);
    7224           0 :                                 break;
    7225           0 :                         default:
    7226           0 :                                 goto unsupported;
    7227             :                         }
    7228             :                         break;
    7229           1 :                 case TYPE_lng:
    7230             :                         switch (tp) {
    7231           0 :                         case TYPE_lng:
    7232           0 :                                 nils = mul_sht_lng_lng(lft, incr1, rgt, incr2,
    7233             :                                                        dst, GDK_lng_max,
    7234             :                                                        ci1, ci2, candoff1, candoff2,
    7235             :                                                        abort_on_error);
    7236           0 :                                 break;
    7237             : #ifdef HAVE_HGE
    7238           1 :                         case TYPE_hge:
    7239           1 :                                 nils = mul_sht_lng_hge(lft, incr1, rgt, incr2,
    7240             :                                                        dst, GDK_hge_max,
    7241             :                                                        ci1, ci2, candoff1, candoff2,
    7242             :                                                        abort_on_error);
    7243           1 :                                 break;
    7244             : #endif
    7245           0 :                         case TYPE_flt:
    7246           0 :                                 nils = mul_sht_lng_flt(lft, incr1, rgt, incr2,
    7247             :                                                        dst, GDK_flt_max,
    7248             :                                                        ci1, ci2, candoff1, candoff2,
    7249             :                                                        abort_on_error);
    7250           0 :                                 break;
    7251           0 :                         case TYPE_dbl:
    7252           0 :                                 nils = mul_sht_lng_dbl(lft, incr1, rgt, incr2,
    7253             :                                                        dst, GDK_dbl_max,
    7254             :                                                        ci1, ci2, candoff1, candoff2,
    7255             :                                                        abort_on_error);
    7256           0 :                                 break;
    7257           0 :                         default:
    7258           0 :                                 goto unsupported;
    7259             :                         }
    7260             :                         break;
    7261             : #ifdef HAVE_HGE
    7262           3 :                 case TYPE_hge:
    7263             :                         switch (tp) {
    7264           3 :                         case TYPE_hge:
    7265           3 :                                 nils = mul_sht_hge_hge(lft, incr1, rgt, incr2,
    7266             :                                                        dst, GDK_hge_max,
    7267             :                                                        ci1, ci2, candoff1, candoff2,
    7268             :                                                        abort_on_error);
    7269           3 :                                 break;
    7270           0 :                         case TYPE_flt:
    7271           0 :                                 nils = mul_sht_hge_flt(lft, incr1, rgt, incr2,
    7272             :                                                        dst, GDK_flt_max,
    7273             :                                                        ci1, ci2, candoff1, candoff2,
    7274             :                                                        abort_on_error);
    7275           0 :                                 break;
    7276           0 :                         case TYPE_dbl:
    7277           0 :                                 nils = mul_sht_hge_dbl(lft, incr1, rgt, incr2,
    7278             :                                                        dst, GDK_dbl_max,
    7279             :                                                        ci1, ci2, candoff1, candoff2,
    7280             :                                                        abort_on_error);
    7281           0 :                                 break;
    7282           0 :                         default:
    7283           0 :                                 goto unsupported;
    7284             :                         }
    7285             :                         break;
    7286             : #endif
    7287           0 :                 case TYPE_flt:
    7288             :                         switch (tp) {
    7289           0 :                         case TYPE_bte:
    7290           0 :                                 nils = mul_sht_flt_bte(lft, incr1, rgt, incr2,
    7291             :                                                        dst, GDK_bte_max,
    7292             :                                                        ci1, ci2,
    7293             :                                                        candoff1, candoff2,
    7294             :                                                        abort_on_error);
    7295           0 :                                 break;
    7296           0 :                         case TYPE_sht:
    7297           0 :                                 nils = mul_sht_flt_sht(lft, incr1, rgt, incr2,
    7298             :                                                        dst, GDK_sht_max,
    7299             :                                                        ci1, ci2,
    7300             :                                                        candoff1, candoff2,
    7301             :                                                        abort_on_error);
    7302           0 :                                 break;
    7303           0 :                         case TYPE_int:
    7304           0 :                                 nils = mul_sht_flt_int(lft, incr1, rgt, incr2,
    7305             :                                                        dst, GDK_int_max,
    7306             :                                                        ci1, ci2,
    7307             :                                                        candoff1, candoff2,
    7308             :                                                        abort_on_error);
    7309           0 :                                 break;
    7310           0 :                         case TYPE_lng:
    7311           0 :                                 nils = mul_sht_flt_lng(lft, incr1, rgt, incr2,
    7312             :                                                        dst, GDK_lng_max,
    7313             :                                                        ci1, ci2,
    7314             :                                                        candoff1, candoff2,
    7315             :                                                        abort_on_error);
    7316           0 :                                 break;
    7317             : #ifdef HAVE_HGE
    7318           0 :                         case TYPE_hge:
    7319           0 :                                 nils = mul_sht_flt_hge(lft, incr1, rgt, incr2,
    7320             :                                                        dst, GDK_hge_max,
    7321             :                                                        ci1, ci2,
    7322             :                                                        candoff1, candoff2,
    7323             :                                                        abort_on_error);
    7324           0 :                                 break;
    7325             : #endif
    7326           0 :                         case TYPE_flt:
    7327           0 :                                 nils = mul_sht_flt_flt(lft, incr1, rgt, incr2,
    7328             :                                                        dst, GDK_flt_max,
    7329             :                                                        ci1, ci2, candoff1, candoff2,
    7330             :                                                        abort_on_error);
    7331           0 :                                 break;
    7332           0 :                         case TYPE_dbl:
    7333           0 :                                 nils = mul_sht_flt_dbl(lft, incr1, rgt, incr2,
    7334             :                                                        dst, GDK_dbl_max,
    7335             :                                                        ci1, ci2, candoff1, candoff2,
    7336             :                                                        abort_on_error);
    7337           0 :                                 break;
    7338           0 :                         default:
    7339           0 :                                 goto unsupported;
    7340             :                         }
    7341             :                         break;
    7342           0 :                 case TYPE_dbl:
    7343             :                         switch (tp) {
    7344           0 :                         case TYPE_bte:
    7345           0 :                                 nils = mul_sht_dbl_bte(lft, incr1, rgt, incr2,
    7346             :                                                        dst, GDK_bte_max,
    7347             :                                                        ci1, ci2,
    7348             :                                                        candoff1, candoff2,
    7349             :                                                        abort_on_error);
    7350           0 :                                 break;
    7351           0 :                         case TYPE_sht:
    7352           0 :                                 nils = mul_sht_dbl_sht(lft, incr1, rgt, incr2,
    7353             :                                                        dst, GDK_sht_max,
    7354             :                                                        ci1, ci2,
    7355             :                                                        candoff1, candoff2,
    7356             :                                                        abort_on_error);
    7357           0 :                                 break;
    7358           0 :                         case TYPE_int:
    7359           0 :                                 nils = mul_sht_dbl_int(lft, incr1, rgt, incr2,
    7360             :                                                        dst, GDK_int_max,
    7361             :                                                        ci1, ci2,
    7362             :                                                        candoff1, candoff2,
    7363             :                                                        abort_on_error);
    7364           0 :                                 break;
    7365           0 :                         case TYPE_lng:
    7366           0 :                                 nils = mul_sht_dbl_lng(lft, incr1, rgt, incr2,
    7367             :                                                        dst, GDK_lng_max,
    7368             :                                                        ci1, ci2,
    7369             :                                                        candoff1, candoff2,
    7370             :                                                        abort_on_error);
    7371           0 :                                 break;
    7372             : #ifdef HAVE_HGE
    7373           0 :                         case TYPE_hge:
    7374           0 :                                 nils = mul_sht_dbl_hge(lft, incr1, rgt, incr2,
    7375             :                                                        dst, GDK_hge_max,
    7376             :                                                        ci1, ci2,
    7377             :                                                        candoff1, candoff2,
    7378             :                                                        abort_on_error);
    7379           0 :                                 break;
    7380             : #endif
    7381           0 :                         case TYPE_dbl:
    7382           0 :                                 nils = mul_sht_dbl_dbl(lft, incr1, rgt, incr2,
    7383             :                                                        dst, GDK_dbl_max,
    7384             :                                                        ci1, ci2, candoff1, candoff2,
    7385             :                                                        abort_on_error);
    7386           0 :                                 break;
    7387           0 :                         default:
    7388           0 :                                 goto unsupported;
    7389             :                         }
    7390             :                         break;
    7391           0 :                 default:
    7392           0 :                         goto unsupported;
    7393             :                 }
    7394             :                 break;
    7395       24126 :         case TYPE_int:
    7396             :                 switch (tp2) {
    7397       22957 :                 case TYPE_bte:
    7398             :                         switch (tp) {
    7399          11 :                         case TYPE_int:
    7400          11 :                                 nils = mul_int_bte_int(lft, incr1, rgt, incr2,
    7401             :                                                        dst, GDK_int_max,
    7402             :                                                        ci1, ci2, candoff1, candoff2,
    7403             :                                                        abort_on_error);
    7404          11 :                                 break;
    7405       22946 :                         case TYPE_lng:
    7406       22946 :                                 nils = mul_int_bte_lng(lft, incr1, rgt, incr2,
    7407             :                                                        dst, GDK_lng_max,
    7408             :                                                        ci1, ci2, candoff1, candoff2,
    7409             :                                                        abort_on_error);
    7410       23026 :                                 break;
    7411             : #ifdef HAVE_HGE
    7412           0 :                         case TYPE_hge:
    7413           0 :                                 nils = mul_int_bte_hge(lft, incr1, rgt, incr2,
    7414             :                                                        dst, GDK_hge_max,
    7415             :                                                        ci1, ci2, candoff1, candoff2,
    7416             :                                                        abort_on_error);
    7417           0 :                                 break;
    7418             : #endif
    7419           0 :                         case TYPE_flt:
    7420           0 :                                 nils = mul_int_bte_flt(lft, incr1, rgt, incr2,
    7421             :                                                        dst, GDK_flt_max,
    7422             :                                                        ci1, ci2, candoff1, candoff2,
    7423             :                                                        abort_on_error);
    7424           0 :                                 break;
    7425           0 :                         case TYPE_dbl:
    7426           0 :                                 nils = mul_int_bte_dbl(lft, incr1, rgt, incr2,
    7427             :                                                        dst, GDK_dbl_max,
    7428             :                                                        ci1, ci2, candoff1, candoff2,
    7429             :                                                        abort_on_error);
    7430           0 :                                 break;
    7431           0 :                         default:
    7432           0 :                                 goto unsupported;
    7433             :                         }
    7434             :                         break;
    7435        1018 :                 case TYPE_sht:
    7436             :                         switch (tp) {
    7437           1 :                         case TYPE_int:
    7438           1 :                                 nils = mul_int_sht_int(lft, incr1, rgt, incr2,
    7439             :                                                        dst, GDK_int_max,
    7440             :                                                        ci1, ci2, candoff1, candoff2,
    7441             :                                                        abort_on_error);
    7442           1 :                                 break;
    7443        1017 :                         case TYPE_lng:
    7444        1017 :                                 nils = mul_int_sht_lng(lft, incr1, rgt, incr2,
    7445             :                                                        dst, GDK_lng_max,
    7446             :                                                        ci1, ci2, candoff1, candoff2,
    7447             :                                                        abort_on_error);
    7448        1017 :                                 break;
    7449             : #ifdef HAVE_HGE
    7450           0 :                         case TYPE_hge:
    7451           0 :                                 nils = mul_int_sht_hge(lft, incr1, rgt, incr2,
    7452             :                                                        dst, GDK_hge_max,
    7453             :                                                        ci1, ci2, candoff1, candoff2,
    7454             :                                                        abort_on_error);
    7455           0 :                                 break;
    7456             : #endif
    7457           0 :                         case TYPE_flt:
    7458           0 :                                 nils = mul_int_sht_flt(lft, incr1, rgt, incr2,
    7459             :                                                        dst, GDK_flt_max,
    7460             :                                                        ci1, ci2, candoff1, candoff2,
    7461             :                                                        abort_on_error);
    7462           0 :                                 break;
    7463           0 :                         case TYPE_dbl:
    7464           0 :                                 nils = mul_int_sht_dbl(lft, incr1, rgt, incr2,
    7465             :                                                        dst, GDK_dbl_max,
    7466             :                                                        ci1, ci2, candoff1, candoff2,
    7467             :                                                        abort_on_error);
    7468           0 :                                 break;
    7469           0 :                         default:
    7470           0 :                                 goto unsupported;
    7471             :                         }
    7472             :                         break;
    7473         132 :                 case TYPE_int:
    7474             :                         switch (tp) {
    7475          23 :                         case TYPE_int:
    7476          23 :                                 nils = mul_int_int_int(lft, incr1, rgt, incr2,
    7477             :                                                        dst, GDK_int_max,
    7478             :                                                        ci1, ci2, candoff1, candoff2,
    7479             :                                                        abort_on_error);
    7480          23 :                                 break;
    7481           7 :                         case TYPE_lng:
    7482           7 :                                 nils = mul_int_int_lng(lft, incr1, rgt, incr2,
    7483             :                                                        dst, GDK_lng_max,
    7484             :                                                        ci1, ci2, candoff1, candoff2,
    7485             :                                                        abort_on_error);
    7486           7 :                                 break;
    7487             : #ifdef HAVE_HGE
    7488         102 :                         case TYPE_hge:
    7489         102 :                                 nils = mul_int_int_hge(lft, incr1, rgt, incr2,
    7490             :                                                        dst, GDK_hge_max,
    7491             :                                                        ci1, ci2, candoff1, candoff2,
    7492             :                                                        abort_on_error);
    7493         103 :                                 break;
    7494             : #endif
    7495           0 :                         case TYPE_flt:
    7496           0 :                                 nils = mul_int_int_flt(lft, incr1, rgt, incr2,
    7497             :                                                        dst, GDK_flt_max,
    7498             :                                                        ci1, ci2, candoff1, candoff2,
    7499             :                                                        abort_on_error);
    7500           0 :                                 break;
    7501           0 :                         case TYPE_dbl:
    7502           0 :                                 nils = mul_int_int_dbl(lft, incr1, rgt, incr2,
    7503             :                                                        dst, GDK_dbl_max,
    7504             :                                                        ci1, ci2, candoff1, candoff2,
    7505             :                                                        abort_on_error);
    7506           0 :                                 break;
    7507           0 :                         default:
    7508           0 :                                 goto unsupported;
    7509             :                         }
    7510             :                         break;
    7511           6 :                 case TYPE_lng:
    7512             :                         switch (tp) {
    7513           0 :                         case TYPE_lng:
    7514           0 :                                 nils = mul_int_lng_lng(lft, incr1, rgt, incr2,
    7515             :                                                        dst, GDK_lng_max,
    7516             :                                                        ci1, ci2, candoff1, candoff2,
    7517             :                                                        abort_on_error);
    7518           0 :                                 break;
    7519             : #ifdef HAVE_HGE
    7520           6 :                         case TYPE_hge:
    7521           6 :                                 nils = mul_int_lng_hge(lft, incr1, rgt, incr2,
    7522             :                                                        dst, GDK_hge_max,
    7523             :                                                        ci1, ci2, candoff1, candoff2,
    7524             :                                                        abort_on_error);
    7525           6 :                                 break;
    7526             : #endif
    7527           0 :                         case TYPE_flt:
    7528           0 :                                 nils = mul_int_lng_flt(lft, incr1, rgt, incr2,
    7529             :                                                        dst, GDK_flt_max,
    7530             :                                                        ci1, ci2, candoff1, candoff2,
    7531             :                                                        abort_on_error);
    7532           0 :                                 break;
    7533           0 :                         case TYPE_dbl:
    7534           0 :                                 nils = mul_int_lng_dbl(lft, incr1, rgt, incr2,
    7535             :                                                        dst, GDK_dbl_max,
    7536             :                                                        ci1, ci2, candoff1, candoff2,
    7537             :                                                        abort_on_error);
    7538           0 :                                 break;
    7539           0 :                         default:
    7540           0 :                                 goto unsupported;
    7541             :                         }
    7542             :                         break;
    7543             : #ifdef HAVE_HGE
    7544           6 :                 case TYPE_hge:
    7545             :                         switch (tp) {
    7546           6 :                         case TYPE_hge:
    7547           6 :                                 nils = mul_int_hge_hge(lft, incr1, rgt, incr2,
    7548             :                                                        dst, GDK_hge_max,
    7549             :                                                        ci1, ci2, candoff1, candoff2,
    7550             :                                                        abort_on_error);
    7551           6 :                                 break;
    7552           0 :                         case TYPE_flt:
    7553           0 :                                 nils = mul_int_hge_flt(lft, incr1, rgt, incr2,
    7554             :                                                        dst, GDK_flt_max,
    7555             :                                                        ci1, ci2, candoff1, candoff2,
    7556             :                                                        abort_on_error);
    7557           0 :                                 break;
    7558           0 :                         case TYPE_dbl:
    7559           0 :                                 nils = mul_int_hge_dbl(lft, incr1, rgt, incr2,
    7560             :                                                        dst, GDK_dbl_max,
    7561             :                                                        ci1, ci2, candoff1, candoff2,
    7562             :                                                        abort_on_error);
    7563           0 :                                 break;
    7564           0 :                         default:
    7565           0 :                                 goto unsupported;
    7566             :                         }
    7567             :                         break;
    7568             : #endif
    7569           2 :                 case TYPE_flt:
    7570             :                         switch (tp) {
    7571           0 :                         case TYPE_bte:
    7572           0 :                                 nils = mul_int_flt_bte(lft, incr1, rgt, incr2,
    7573             :                                                        dst, GDK_bte_max,
    7574             :                                                        ci1, ci2,
    7575             :                                                        candoff1, candoff2,
    7576             :                                                        abort_on_error);
    7577           0 :                                 break;
    7578           0 :                         case TYPE_sht:
    7579           0 :                                 nils = mul_int_flt_sht(lft, incr1, rgt, incr2,
    7580             :                                                        dst, GDK_sht_max,
    7581             :                                                        ci1, ci2,
    7582             :                                                        candoff1, candoff2,
    7583             :                                                        abort_on_error);
    7584           0 :                                 break;
    7585           1 :                         case TYPE_int:
    7586           1 :                                 nils = mul_int_flt_int(lft, incr1, rgt, incr2,
    7587             :                                                        dst, GDK_int_max,
    7588             :                                                        ci1, ci2,
    7589             :                                                        candoff1, candoff2,
    7590             :                                                        abort_on_error);
    7591           1 :                                 break;
    7592           1 :                         case TYPE_lng:
    7593           1 :                                 nils = mul_int_flt_lng(lft, incr1, rgt, incr2,
    7594             :                                                        dst, GDK_lng_max,
    7595             :                                                        ci1, ci2,
    7596             :                                                        candoff1, candoff2,
    7597             :                                                        abort_on_error);
    7598           1 :                                 break;
    7599             : #ifdef HAVE_HGE
    7600           0 :                         case TYPE_hge:
    7601           0 :                                 nils = mul_int_flt_hge(lft, incr1, rgt, incr2,
    7602             :                                                        dst, GDK_hge_max,
    7603             :                                                        ci1, ci2,
    7604             :                                                        candoff1, candoff2,
    7605             :                                                        abort_on_error);
    7606           0 :                                 break;
    7607             : #endif
    7608           0 :                         case TYPE_flt:
    7609           0 :                                 nils = mul_int_flt_flt(lft, incr1, rgt, incr2,
    7610             :                                                        dst, GDK_flt_max,
    7611             :                                                        ci1, ci2, candoff1, candoff2,
    7612             :                                                        abort_on_error);
    7613           0 :                                 break;
    7614           0 :                         case TYPE_dbl:
    7615           0 :                                 nils = mul_int_flt_dbl(lft, incr1, rgt, incr2,
    7616             :                                                        dst, GDK_dbl_max,
    7617             :                                                        ci1, ci2, candoff1, candoff2,
    7618             :                                                        abort_on_error);
    7619           0 :                                 break;
    7620           0 :                         default:
    7621           0 :                                 goto unsupported;
    7622             :                         }
    7623             :                         break;
    7624           5 :                 case TYPE_dbl:
    7625             :                         switch (tp) {
    7626           0 :                         case TYPE_bte:
    7627           0 :                                 nils = mul_int_dbl_bte(lft, incr1, rgt, incr2,
    7628             :                                                        dst, GDK_bte_max,
    7629             :                                                        ci1, ci2,
    7630             :                                                        candoff1, candoff2,
    7631             :                                                        abort_on_error);
    7632           0 :                                 break;
    7633           0 :                         case TYPE_sht:
    7634           0 :                                 nils = mul_int_dbl_sht(lft, incr1, rgt, incr2,
    7635             :                                                        dst, GDK_sht_max,
    7636             :                                                        ci1, ci2,
    7637             :                                                        candoff1, candoff2,
    7638             :                                                        abort_on_error);
    7639           0 :                                 break;
    7640           5 :                         case TYPE_int:
    7641           5 :                                 nils = mul_int_dbl_int(lft, incr1, rgt, incr2,
    7642             :                                                        dst, GDK_int_max,
    7643             :                                                        ci1, ci2,
    7644             :                                                        candoff1, candoff2,
    7645             :                                                        abort_on_error);
    7646           5 :                                 break;
    7647           0 :                         case TYPE_lng:
    7648           0 :                                 nils = mul_int_dbl_lng(lft, incr1, rgt, incr2,
    7649             :                                                        dst, GDK_lng_max,
    7650             :                                                        ci1, ci2,
    7651             :                                                        candoff1, candoff2,
    7652             :                                                        abort_on_error);
    7653           0 :                                 break;
    7654             : #ifdef HAVE_HGE
    7655           0 :                         case TYPE_hge:
    7656           0 :                                 nils = mul_int_dbl_hge(lft, incr1, rgt, incr2,
    7657             :                                                        dst, GDK_hge_max,
    7658             :                                                        ci1, ci2,
    7659             :                                                        candoff1, candoff2,
    7660             :                                                        abort_on_error);
    7661           0 :                                 break;
    7662             : #endif
    7663           0 :                         case TYPE_dbl:
    7664           0 :                                 nils = mul_int_dbl_dbl(lft, incr1, rgt, incr2,
    7665             :                                                        dst, GDK_dbl_max,
    7666             :                                                        ci1, ci2, candoff1, candoff2,
    7667             :                                                        abort_on_error);
    7668           0 :                                 break;
    7669           0 :                         default:
    7670           0 :                                 goto unsupported;
    7671             :                         }
    7672             :                         break;
    7673           0 :                 default:
    7674           0 :                         goto unsupported;
    7675             :                 }
    7676             :                 break;
    7677         401 :         case TYPE_lng:
    7678             :                 switch (tp2) {
    7679          60 :                 case TYPE_bte:
    7680             :                         switch (tp) {
    7681          33 :                         case TYPE_lng:
    7682          33 :                                 nils = mul_lng_bte_lng(lft, incr1, rgt, incr2,
    7683             :                                                        dst, GDK_lng_max,
    7684             :                                                        ci1, ci2, candoff1, candoff2,
    7685             :                                                        abort_on_error);
    7686          32 :                                 break;
    7687             : #ifdef HAVE_HGE
    7688          27 :                         case TYPE_hge:
    7689          27 :                                 nils = mul_lng_bte_hge(lft, incr1, rgt, incr2,
    7690             :                                                        dst, GDK_hge_max,
    7691             :                                                        ci1, ci2, candoff1, candoff2,
    7692             :                                                        abort_on_error);
    7693          27 :                                 break;
    7694             : #endif
    7695           0 :                         case TYPE_flt:
    7696           0 :                                 nils = mul_lng_bte_flt(lft, incr1, rgt, incr2,
    7697             :                                                        dst, GDK_flt_max,
    7698             :                                                        ci1, ci2, candoff1, candoff2,
    7699             :                                                        abort_on_error);
    7700           0 :                                 break;
    7701           0 :                         case TYPE_dbl:
    7702           0 :                                 nils = mul_lng_bte_dbl(lft, incr1, rgt, incr2,
    7703             :                                                        dst, GDK_dbl_max,
    7704             :                                                        ci1, ci2, candoff1, candoff2,
    7705             :                                                        abort_on_error);
    7706           0 :                                 break;
    7707           0 :                         default:
    7708           0 :                                 goto unsupported;
    7709             :                         }
    7710             :                         break;
    7711           3 :                 case TYPE_sht:
    7712             :                         switch (tp) {
    7713           2 :                         case TYPE_lng:
    7714           2 :                                 nils = mul_lng_sht_lng(lft, incr1, rgt, incr2,
    7715             :                                                        dst, GDK_lng_max,
    7716             :                                                        ci1, ci2, candoff1, candoff2,
    7717             :                                                        abort_on_error);
    7718           2 :                                 break;
    7719             : #ifdef HAVE_HGE
    7720           1 :                         case TYPE_hge:
    7721           1 :                                 nils = mul_lng_sht_hge(lft, incr1, rgt, incr2,
    7722             :                                                        dst, GDK_hge_max,
    7723             :                                                        ci1, ci2, candoff1, candoff2,
    7724             :                                                        abort_on_error);
    7725           1 :                                 break;
    7726             : #endif
    7727           0 :                         case TYPE_flt:
    7728           0 :                                 nils = mul_lng_sht_flt(lft, incr1, rgt, incr2,
    7729             :                                                        dst, GDK_flt_max,
    7730             :                                                        ci1, ci2, candoff1, candoff2,
    7731             :                                                        abort_on_error);
    7732           0 :                                 break;
    7733           0 :                         case TYPE_dbl:
    7734           0 :                                 nils = mul_lng_sht_dbl(lft, incr1, rgt, incr2,
    7735             :                                                        dst, GDK_dbl_max,
    7736             :                                                        ci1, ci2, candoff1, candoff2,
    7737             :                                                        abort_on_error);
    7738           0 :                                 break;
    7739           0 :                         default:
    7740           0 :                                 goto unsupported;
    7741             :                         }
    7742             :                         break;
    7743          54 :                 case TYPE_int:
    7744             :                         switch (tp) {
    7745           2 :                         case TYPE_lng:
    7746           2 :                                 nils = mul_lng_int_lng(lft, incr1, rgt, incr2,
    7747             :                                                        dst, GDK_lng_max,
    7748             :                                                        ci1, ci2, candoff1, candoff2,
    7749             :                                                        abort_on_error);
    7750           2 :                                 break;
    7751             : #ifdef HAVE_HGE
    7752          52 :                         case TYPE_hge:
    7753          52 :                                 nils = mul_lng_int_hge(lft, incr1, rgt, incr2,
    7754             :                                                        dst, GDK_hge_max,
    7755             :                                                        ci1, ci2, candoff1, candoff2,
    7756             :                                                        abort_on_error);
    7757          52 :                                 break;
    7758             : #endif
    7759           0 :                         case TYPE_flt:
    7760           0 :                                 nils = mul_lng_int_flt(lft, incr1, rgt, incr2,
    7761             :                                                        dst, GDK_flt_max,
    7762             :                                                        ci1, ci2, candoff1, candoff2,
    7763             :                                                        abort_on_error);
    7764           0 :                                 break;
    7765           0 :                         case TYPE_dbl:
    7766           0 :                                 nils = mul_lng_int_dbl(lft, incr1, rgt, incr2,
    7767             :                                                        dst, GDK_dbl_max,
    7768             :                                                        ci1, ci2, candoff1, candoff2,
    7769             :                                                        abort_on_error);
    7770           0 :                                 break;
    7771           0 :                         default:
    7772           0 :                                 goto unsupported;
    7773             :                         }
    7774             :                         break;
    7775         262 :                 case TYPE_lng:
    7776             :                         switch (tp) {
    7777          17 :                         case TYPE_lng:
    7778          17 :                                 nils = mul_lng_lng_lng(lft, incr1, rgt, incr2,
    7779             :                                                        dst, GDK_lng_max,
    7780             :                                                        ci1, ci2, candoff1, candoff2,
    7781             :                                                        abort_on_error);
    7782          17 :                                 break;
    7783             : #ifdef HAVE_HGE
    7784         245 :                         case TYPE_hge:
    7785         245 :                                 nils = mul_lng_lng_hge(lft, incr1, rgt, incr2,
    7786             :                                                        dst, GDK_hge_max,
    7787             :                                                        ci1, ci2, candoff1, candoff2,
    7788             :                                                        abort_on_error);
    7789         245 :                                 break;
    7790             : #endif
    7791           0 :                         case TYPE_flt:
    7792           0 :                                 nils = mul_lng_lng_flt(lft, incr1, rgt, incr2,
    7793             :                                                        dst, GDK_flt_max,
    7794             :                                                        ci1, ci2, candoff1, candoff2,
    7795             :                                                        abort_on_error);
    7796           0 :                                 break;
    7797           0 :                         case TYPE_dbl:
    7798           0 :                                 nils = mul_lng_lng_dbl(lft, incr1, rgt, incr2,
    7799             :                                                        dst, GDK_dbl_max,
    7800             :                                                        ci1, ci2, candoff1, candoff2,
    7801             :                                                        abort_on_error);
    7802           0 :                                 break;
    7803           0 :                         default:
    7804           0 :                                 goto unsupported;
    7805             :                         }
    7806             :                         break;
    7807             : #ifdef HAVE_HGE
    7808          16 :                 case TYPE_hge:
    7809             :                         switch (tp) {
    7810          16 :                         case TYPE_hge:
    7811          16 :                                 nils = mul_lng_hge_hge(lft, incr1, rgt, incr2,
    7812             :                                                        dst, GDK_hge_max,
    7813             :                                                        ci1, ci2, candoff1, candoff2,
    7814             :                                                        abort_on_error);
    7815          16 :                                 break;
    7816           0 :                         case TYPE_flt:
    7817           0 :                                 nils = mul_lng_hge_flt(lft, incr1, rgt, incr2,
    7818             :                                                        dst, GDK_flt_max,
    7819             :                                                        ci1, ci2, candoff1, candoff2,
    7820             :                                                        abort_on_error);
    7821           0 :                                 break;
    7822           0 :                         case TYPE_dbl:
    7823           0 :                                 nils = mul_lng_hge_dbl(lft, incr1, rgt, incr2,
    7824             :                                                        dst, GDK_dbl_max,
    7825             :                                                        ci1, ci2, candoff1, candoff2,
    7826             :                                                        abort_on_error);
    7827           0 :                                 break;
    7828           0 :                         default:
    7829           0 :                                 goto unsupported;
    7830             :                         }
    7831             :                         break;
    7832             : #endif
    7833           2 :                 case TYPE_flt:
    7834             :                         switch (tp) {
    7835           0 :                         case TYPE_bte:
    7836           0 :                                 nils = mul_lng_flt_bte(lft, incr1, rgt, incr2,
    7837             :                                                        dst, GDK_bte_max,
    7838             :                                                        ci1, ci2,
    7839             :                                                        candoff1, candoff2,
    7840             :                                                        abort_on_error);
    7841           0 :                                 break;
    7842           0 :                         case TYPE_sht:
    7843           0 :                                 nils = mul_lng_fl