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