LCOV - code coverage report
Current view: top level - monetdb5/modules/mal - calc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 233 369 63.1 %
Date: 2021-01-13 20:07:21 Functions: 37 51 72.5 %

          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 "mal_exception.h"
      12             : #include "mal_interpreter.h"
      13             : 
      14             : static str
      15         399 : mythrow(enum malexception type, const char *fcn, const char *msg)
      16             : {
      17         399 :         char *errbuf = GDKerrbuf;
      18             :         char *s;
      19             : 
      20         399 :         if (errbuf && *errbuf) {
      21         399 :                 if (strncmp(errbuf, "!ERROR: ", 8) == 0)
      22         399 :                         errbuf += 8;
      23         399 :                 if (strchr(errbuf, '!') == errbuf + 5) {
      24           0 :                         s = createException(type, fcn, "%s", errbuf);
      25         399 :                 } else if ((s = strchr(errbuf, ':')) != NULL && s[1] == ' ') {
      26         399 :                         s = createException(type, fcn, "%s", s + 2);
      27             :                 } else {
      28           0 :                         s = createException(type, fcn, "%s", errbuf);
      29             :                 }
      30         399 :                 GDKclrerr();
      31         399 :                 return s;
      32             :         }
      33           0 :         return createException(type, fcn, "%s", msg);
      34             : }
      35             : 
      36             : 
      37             : static str
      38        1015 : CMDvarSUBsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
      39             : {
      40             :         (void) cntxt;
      41             :         (void) mb;
      42             : 
      43        1015 :         if (VARcalcsub(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 1) != GDK_SUCCEED)
      44           0 :                 return mythrow(MAL, "calc.-", OPERATION_FAILED);
      45             :         return MAL_SUCCEED;
      46             : }
      47             : 
      48             : 
      49             : static str
      50           0 : CMDvarSUB(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
      51             : {
      52             :         (void) cntxt;
      53             :         (void) mb;
      54             : 
      55           0 :         if (VARcalcsub(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 0) != GDK_SUCCEED)
      56           0 :                 return mythrow(MAL, "calc.sub_noerror", OPERATION_FAILED);
      57             :         return MAL_SUCCEED;
      58             : }
      59             : 
      60             : 
      61             : static str
      62      102623 : CMDvarADDsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
      63             : {
      64             :         (void) cntxt;
      65             :         (void) mb;
      66             : 
      67      102623 :         if (VARcalcadd(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 1) != GDK_SUCCEED)
      68           0 :                 return mythrow(MAL, "calc.+", OPERATION_FAILED);
      69             :         return MAL_SUCCEED;
      70             : }
      71             : 
      72             : 
      73             : static str
      74           0 : CMDvarADD(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
      75             : {
      76             :         (void) cntxt;
      77             :         (void) mb;
      78             : 
      79           0 :         if (VARcalcadd(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 0) != GDK_SUCCEED)
      80           0 :                 return mythrow(MAL, "calc.add_noerror", OPERATION_FAILED);
      81             :         return MAL_SUCCEED;
      82             : }
      83             : 
      84             : 
      85             : static str
      86        1284 : CMDvarADDstr(str *ret, str *s1, str *s2)
      87             : {
      88             :         str s;
      89             :         size_t l1;
      90             : 
      91        3848 :         if (strNil(*s1) || strNil(*s2)) {
      92           5 :                 *ret= GDKstrdup(str_nil);
      93           5 :                 if (*ret == NULL)
      94           0 :                         return mythrow(MAL, "calc.+", SQLSTATE(HY013) MAL_MALLOC_FAIL);
      95             :                 return MAL_SUCCEED;
      96             :         }
      97        1279 :         s = GDKzalloc((l1 = strlen(*s1)) + strlen(*s2) + 1);
      98        1279 :         if (s == NULL)
      99           0 :                 return mythrow(MAL, "calc.+", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     100        1279 :         strcpy(s, *s1);
     101        1279 :         strcpy(s + l1, *s2);
     102        1279 :         *ret = s;
     103        1279 :         return MAL_SUCCEED;
     104             : }
     105             : 
     106             : 
     107             : static str
     108           0 : CMDvarADDstrint(str *ret, str *s1, int *i)
     109             : {
     110             :         str s;
     111             :         size_t len;
     112             : 
     113           0 :         if (strNil(*s1) || is_int_nil(*i)) {
     114           0 :                 *ret= GDKstrdup(str_nil);
     115           0 :                 if (*ret == NULL)
     116           0 :                         return mythrow(MAL, "calc.+", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     117             :                 return MAL_SUCCEED;
     118             :         }
     119           0 :         len = strlen(*s1) + 16;         /* maxint = 2147483647 which fits easily */
     120           0 :         s = GDKmalloc(len);
     121           0 :         if (s == NULL)
     122           0 :                 return mythrow(MAL, "calc.+", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     123           0 :         snprintf(s, len, "%s%d", *s1, *i);
     124           0 :         *ret = s;
     125           0 :         return MAL_SUCCEED;
     126             : }
     127             : 
     128             : 
     129             : static str
     130         561 : CMDvarMULsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     131             : {
     132             :         (void) cntxt;
     133             :         (void) mb;
     134             : 
     135         561 :         if (VARcalcmul(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 1) != GDK_SUCCEED)
     136           2 :                 return mythrow(MAL, "calc.*", OPERATION_FAILED);
     137             :         return MAL_SUCCEED;
     138             : }
     139             : 
     140             : 
     141             : static str
     142           0 : CMDvarMUL(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     143             : {
     144             :         (void) cntxt;
     145             :         (void) mb;
     146             : 
     147           0 :         if (VARcalcmul(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 0) != GDK_SUCCEED)
     148           0 :                 return mythrow(MAL, "calc.mul_noerror", OPERATION_FAILED);
     149             :         return MAL_SUCCEED;
     150             : }
     151             : 
     152             : 
     153             : static str
     154         235 : CMDvarDIVsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     155             : {
     156             :         (void) cntxt;
     157             :         (void) mb;
     158             : 
     159         235 :         if (VARcalcdiv(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 1) != GDK_SUCCEED)
     160           9 :                 return mythrow(MAL, "calc./", OPERATION_FAILED);
     161             :         return MAL_SUCCEED;
     162             : }
     163             : 
     164             : 
     165             : static str
     166           0 : CMDvarDIV(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     167             : {
     168             :         (void) cntxt;
     169             :         (void) mb;
     170             : 
     171           0 :         if (VARcalcdiv(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 0) != GDK_SUCCEED)
     172           0 :                 return mythrow(MAL, "calc.div_noerror", OPERATION_FAILED);
     173             :         return MAL_SUCCEED;
     174             : }
     175             : 
     176             : 
     177             : static str
     178          34 : CMDvarMODsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     179             : {
     180             :         (void) cntxt;
     181             :         (void) mb;
     182             : 
     183          34 :         if (VARcalcmod(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 1) != GDK_SUCCEED)
     184           0 :                 return mythrow(MAL, "calc.%", OPERATION_FAILED);
     185             :         return MAL_SUCCEED;
     186             : }
     187             : 
     188             : 
     189             : static str
     190           0 : CMDvarMOD(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     191             : {
     192             :         (void) cntxt;
     193             :         (void) mb;
     194             : 
     195           0 :         if (VARcalcmod(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 0) != GDK_SUCCEED)
     196           0 :                 return mythrow(MAL, "calc.modmod", OPERATION_FAILED);
     197             :         return MAL_SUCCEED;
     198             : }
     199             : 
     200             : 
     201             : static str
     202          11 : CMDvarLSHsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     203             : {
     204             :         (void) cntxt;
     205             :         (void) mb;
     206             : 
     207          11 :         if (VARcalclsh(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 1) != GDK_SUCCEED)
     208           0 :                 return mythrow(MAL, "calc.<<", OPERATION_FAILED);
     209             :         return MAL_SUCCEED;
     210             : }
     211             : 
     212             : 
     213             : static str
     214           0 : CMDvarLSH(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     215             : {
     216             :         (void) cntxt;
     217             :         (void) mb;
     218             : 
     219           0 :         if (VARcalclsh(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 0) != GDK_SUCCEED)
     220           0 :                 return mythrow(MAL, "calc.lsh_noerror", OPERATION_FAILED);
     221             :         return MAL_SUCCEED;
     222             : }
     223             : 
     224             : 
     225             : static str
     226           5 : CMDvarRSHsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     227             : {
     228             :         (void) cntxt;
     229             :         (void) mb;
     230             : 
     231           5 :         if (VARcalcrsh(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 1) != GDK_SUCCEED)
     232           2 :                 return mythrow(MAL, "calc.>>", OPERATION_FAILED);
     233             :         return MAL_SUCCEED;
     234             : }
     235             : 
     236             : 
     237             : static str
     238           0 : CMDvarRSH(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     239             : {
     240             :         (void) cntxt;
     241             :         (void) mb;
     242             : 
     243           0 :         if (VARcalcrsh(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], 0) != GDK_SUCCEED)
     244           0 :                 return mythrow(MAL, "calc.rsh_noerror", OPERATION_FAILED);
     245             :         return MAL_SUCCEED;
     246             : }
     247             : 
     248             : 
     249             : static str
     250         335 : CMDvarAND(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     251             : {
     252             :         (void) cntxt;
     253             :         (void) mb;
     254             : 
     255         335 :         if (VARcalcand(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)]) != GDK_SUCCEED)
     256           0 :                 return mythrow(MAL, "calc.and", OPERATION_FAILED);
     257             :         return MAL_SUCCEED;
     258             : }
     259             : 
     260             : 
     261             : static str
     262        4744 : CMDvarOR(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     263             : {
     264             :         (void) cntxt;
     265             :         (void) mb;
     266             : 
     267        4744 :         if (VARcalcor(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)]) != GDK_SUCCEED)
     268           0 :                 return mythrow(MAL, "calc.or", OPERATION_FAILED);
     269             :         return MAL_SUCCEED;
     270             : }
     271             : 
     272             : 
     273             : static str
     274          28 : CMDvarXOR(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     275             : {
     276             :         (void) cntxt;
     277             :         (void) mb;
     278             : 
     279          28 :         if (VARcalcxor(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)]) != GDK_SUCCEED)
     280           0 :                 return mythrow(MAL, "calc.xor", OPERATION_FAILED);
     281             :         return MAL_SUCCEED;
     282             : }
     283             : 
     284             : 
     285             : static str
     286          45 : CMDvarLT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     287             : {
     288             :         (void) cntxt;
     289             :         (void) mb;
     290             : 
     291          45 :         if (VARcalclt(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)]) != GDK_SUCCEED)
     292           0 :                 return mythrow(MAL, "calc.<", OPERATION_FAILED);
     293             :         return MAL_SUCCEED;
     294             : }
     295             : 
     296             : 
     297             : static str
     298         327 : CMDvarLE(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     299             : {
     300             :         (void) cntxt;
     301             :         (void) mb;
     302             : 
     303         327 :         if (VARcalcle(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)]) != GDK_SUCCEED)
     304           0 :                 return mythrow(MAL, "calc.<=", OPERATION_FAILED);
     305             :         return MAL_SUCCEED;
     306             : }
     307             : 
     308             : 
     309             : static str
     310         242 : CMDvarGT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     311             : {
     312             :         (void) cntxt;
     313             :         (void) mb;
     314             : 
     315         242 :         if (VARcalcgt(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)]) != GDK_SUCCEED)
     316           0 :                 return mythrow(MAL, "calc.>", OPERATION_FAILED);
     317             :         return MAL_SUCCEED;
     318             : }
     319             : 
     320             : 
     321             : static str
     322       11115 : CMDvarGE(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     323             : {
     324             :         (void) cntxt;
     325             :         (void) mb;
     326             : 
     327       11115 :         if (VARcalcge(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)]) != GDK_SUCCEED)
     328           0 :                 return mythrow(MAL, "calc.>=", OPERATION_FAILED);
     329             :         return MAL_SUCCEED;
     330             : }
     331             : 
     332             : 
     333             : static str
     334        2036 : CMDvarEQ(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     335             : {
     336             :         (void) cntxt;
     337             :         (void) mb;
     338             : 
     339        2036 :         if (VARcalceq(&stk->stk[getArg(pci, 0)],
     340        2036 :                                   &stk->stk[getArg(pci, 1)],
     341        2036 :                                   &stk->stk[getArg(pci, 2)],
     342        2036 :                                   pci->argc == 3 ? false : *getArgReference_bit(stk, pci, 3)
     343             :                         ) != GDK_SUCCEED)
     344           0 :                 return mythrow(MAL, "calc.==", OPERATION_FAILED);
     345             :         return MAL_SUCCEED;
     346             : }
     347             : 
     348             : 
     349             : static str
     350       12822 : CMDvarNE(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     351             : {
     352             :         (void) cntxt;
     353             :         (void) mb;
     354             : 
     355       12821 :         if (VARcalcne(&stk->stk[getArg(pci, 0)],
     356       12822 :                                   &stk->stk[getArg(pci, 1)],
     357       12822 :                                   &stk->stk[getArg(pci, 2)],
     358       12822 :                                   pci->argc == 3 ? false : *getArgReference_bit(stk, pci, 3)
     359             :                         ) != GDK_SUCCEED)
     360           0 :                 return mythrow(MAL, "calc.!=", OPERATION_FAILED);
     361             :         return MAL_SUCCEED;
     362             : }
     363             : 
     364             : 
     365             : static str
     366           0 : CMDvarCMP(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     367             : {
     368             :         (void) cntxt;
     369             :         (void) mb;
     370             : 
     371           0 :         if (VARcalccmp(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)]) != GDK_SUCCEED)
     372           0 :                 return mythrow(MAL, "calc.cmp", OPERATION_FAILED);
     373             :         return MAL_SUCCEED;
     374             : }
     375             : 
     376             : 
     377             : static str
     378          22 : CMDvarBETWEEN(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     379             : {
     380             :         (void) cntxt;
     381             :         (void) mb;
     382             :         bool symmetric, linc, hinc, nils_false, anti;
     383             : 
     384          22 :         symmetric = *getArgReference_bit(stk, pci, 4);
     385          22 :         linc = *getArgReference_bit(stk, pci, 5);
     386          22 :         hinc = *getArgReference_bit(stk, pci, 6);
     387          22 :         nils_false = *getArgReference_bit(stk, pci, 7);
     388          22 :         anti = *getArgReference_bit(stk, pci, 8);
     389          22 :         if (VARcalcbetween(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], &stk->stk[getArg(pci, 2)], &stk->stk[getArg(pci, 3)], symmetric, linc, hinc, nils_false, anti) != GDK_SUCCEED)
     390           0 :                 return mythrow(MAL, "calc.between", OPERATION_FAILED);
     391             :         return MAL_SUCCEED;
     392             : }
     393             : 
     394             : 
     395             : static str
     396           0 : CMDstrlength(int *ret, str *v)
     397             : {
     398           0 :         size_t l = strlen(*v);
     399             : 
     400           0 :         if (l > (size_t) GDK_int_max)
     401           0 :                 return mythrow(MAL, "calc.length", OPERATION_FAILED);
     402           0 :         *ret = (int) l;
     403           0 :         return MAL_SUCCEED;
     404             : }
     405             : 
     406             : 
     407             : static str
     408     3115080 : CMDvarCONVERT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     409             : {
     410             :         char buf[20];
     411             : 
     412             :         (void) cntxt;
     413             :         (void) mb;
     414             : 
     415     3115080 :         if (VARconvert(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], 1, 0, 0, 0) != GDK_SUCCEED) {
     416         358 :                 snprintf(buf, sizeof(buf), "%s.%s", pci->modname, pci->fcnname);
     417         358 :                 return mythrow(MAL, buf, OPERATION_FAILED);
     418             :         }
     419             :         return MAL_SUCCEED;
     420             : }
     421             : 
     422             : 
     423             : static str
     424           0 : CMDvarCONVERTptr(ptr *ret, ptr *v)
     425             : {
     426           0 :         *ret = *v;
     427           0 :         return MAL_SUCCEED;
     428             : }
     429             : 
     430             : 
     431             : static str
     432           0 : CMDvarISZERO(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     433             : {
     434             :         char buf[20];
     435             : 
     436             :         (void) cntxt;
     437             :         (void) mb;
     438             : 
     439           0 :         if (VARcalciszero(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)]) != GDK_SUCCEED) {
     440           0 :                 snprintf(buf, sizeof(buf), "%s.%s", pci->modname, pci->fcnname);
     441           0 :                 return mythrow(MAL, buf, OPERATION_FAILED);
     442             :         }
     443             :         return MAL_SUCCEED;
     444             : }
     445             : 
     446             : 
     447             : static str
     448       13469 : CMDvarISNIL(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     449             : {
     450             :         char buf[20];
     451             : 
     452             :         (void) cntxt;
     453             :         (void) mb;
     454             : 
     455       13469 :         if (VARcalcisnil(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)]) != GDK_SUCCEED) {
     456           0 :                 snprintf(buf, sizeof(buf), "%s.%s", pci->modname, pci->fcnname);
     457           0 :                 return mythrow(MAL, buf, OPERATION_FAILED);
     458             :         }
     459             :         return MAL_SUCCEED;
     460             : }
     461             : 
     462             : 
     463             : static str
     464         161 : CMDvarISNOTNIL(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     465             : {
     466             :         char buf[20];
     467             : 
     468             :         (void) cntxt;
     469             :         (void) mb;
     470             : 
     471         161 :         if (VARcalcisnotnil(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)]) != GDK_SUCCEED) {
     472           0 :                 snprintf(buf, sizeof(buf), "%s.%s", pci->modname, pci->fcnname);
     473           0 :                 return mythrow(MAL, buf, OPERATION_FAILED);
     474             :         }
     475             :         return MAL_SUCCEED;
     476             : }
     477             : 
     478             : 
     479             : static str
     480         664 : CMDvarNOT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     481             : {
     482             :         char buf[20];
     483             : 
     484             :         (void) cntxt;
     485             :         (void) mb;
     486             : 
     487         664 :         if (VARcalcnot(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)]) != GDK_SUCCEED) {
     488           0 :                 snprintf(buf, sizeof(buf), "%s.%s", pci->modname, pci->fcnname);
     489           0 :                 return mythrow(MAL, buf, OPERATION_FAILED);
     490             :         }
     491             :         return MAL_SUCCEED;
     492             : }
     493             : 
     494             : 
     495             : static str
     496          40 : CMDvarABS(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     497             : {
     498             :         char buf[20];
     499             : 
     500             :         (void) cntxt;
     501             :         (void) mb;
     502             : 
     503          40 :         if (VARcalcabsolute(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)]) != GDK_SUCCEED) {
     504           0 :                 snprintf(buf, sizeof(buf), "%s.%s", pci->modname, pci->fcnname);
     505           0 :                 return mythrow(MAL, buf, OPERATION_FAILED);
     506             :         }
     507             :         return MAL_SUCCEED;
     508             : }
     509             : 
     510             : 
     511             : static str
     512           4 : CMDvarSIGN(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     513             : {
     514             :         char buf[20];
     515             : 
     516             :         (void) cntxt;
     517             :         (void) mb;
     518             : 
     519           4 :         if (VARcalcsign(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)]) != GDK_SUCCEED) {
     520           0 :                 snprintf(buf, sizeof(buf), "%s.%s", pci->modname, pci->fcnname);
     521           0 :                 return mythrow(MAL, buf, OPERATION_FAILED);
     522             :         }
     523             :         return MAL_SUCCEED;
     524             : }
     525             : 
     526             : 
     527             : static str
     528        1536 : CMDvarNEG(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     529             : {
     530             :         char buf[20];
     531             : 
     532             :         (void) cntxt;
     533             :         (void) mb;
     534             : 
     535        1536 :         if (VARcalcnegate(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)]) != GDK_SUCCEED) {
     536           0 :                 snprintf(buf, sizeof(buf), "%s.%s", pci->modname, pci->fcnname);
     537           0 :                 return mythrow(MAL, buf, OPERATION_FAILED);
     538             :         }
     539             :         return MAL_SUCCEED;
     540             : }
     541             : 
     542             : 
     543             : static str
     544           0 : CMDvarINCRsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     545             : {
     546             :         char buf[20];
     547             : 
     548             :         (void) cntxt;
     549             :         (void) mb;
     550             : 
     551           0 :         if (VARcalcincr(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], 1) != GDK_SUCCEED) {
     552           0 :                 snprintf(buf, sizeof(buf), "%s.%s", pci->modname, pci->fcnname);
     553           0 :                 return mythrow(MAL, buf, OPERATION_FAILED);
     554             :         }
     555             :         return MAL_SUCCEED;
     556             : }
     557             : 
     558             : 
     559             : static str
     560           0 : CMDvarDECRsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     561             : {
     562             :         char buf[20];
     563             : 
     564             :         (void) cntxt;
     565             :         (void) mb;
     566             : 
     567           0 :         if (VARcalcdecr(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], 1) != GDK_SUCCEED) {
     568           0 :                 snprintf(buf, sizeof(buf), "%s.%s", pci->modname, pci->fcnname);
     569           0 :                 return mythrow(MAL, buf, OPERATION_FAILED);
     570             :         }
     571             :         return MAL_SUCCEED;
     572             : }
     573             : 
     574             : 
     575             : static str
     576        4719 : CALCswitchbit(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     577             : {
     578             :         ptr p;
     579        4719 :         ptr retval = getArgReference(stk, pci, 0);
     580        4719 :         bit b = *getArgReference_bit(stk, pci, 1);
     581        4719 :         int t1 = getArgType(mb, pci, 2);
     582        4719 :         int t2 = getArgType(mb, pci, 3);
     583             : 
     584             :         (void) cntxt;
     585        4719 :         if (t1 != t2)
     586           0 :                 return mythrow(MAL, "ifthenelse", SEMANTIC_TYPE_MISMATCH);
     587             : 
     588        4719 :         if (b && !is_bit_nil(b)) {
     589         134 :                 p = getArgReference(stk, pci, 2);
     590             :         } else {
     591        4585 :                 p = getArgReference(stk, pci, 3);
     592             :         }
     593        4719 :         if (ATOMextern(t1)) {
     594           2 :                 *(ptr **) retval = ATOMdup(t1, *(ptr**)p);
     595           2 :                 if (*(ptr **) retval == NULL)
     596           0 :                         throw(MAL, "ifthenelse", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     597        4717 :         } else if (t1 == TYPE_void) {
     598           0 :                 memcpy(retval, p, sizeof(oid));
     599             :         } else {
     600        4717 :                 memcpy(retval, p, ATOMsize(t1));
     601             :         }
     602             :         return MAL_SUCCEED;
     603             : }
     604             : 
     605             : 
     606             : static str
     607          18 : CALCmin(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     608             : {
     609          18 :         int t = getArgType(mb, pci, 1);
     610          18 :         const void *p1 = getArgReference(stk, pci, 1);
     611          18 :         const void *p2 = getArgReference(stk, pci, 2);
     612             :         const void *nil;
     613             : 
     614             :         (void) cntxt;
     615          18 :         if (t != getArgType(mb, pci, 2))
     616           0 :                 return mythrow(MAL, "calc.min", SEMANTIC_TYPE_MISMATCH);
     617          18 :         nil = ATOMnilptr(t);
     618          18 :         if (t >= TYPE_str && ATOMstorage(t) >= TYPE_str) {
     619           8 :                 p1 = *(ptr *)p1;
     620           8 :                 p2 = *(ptr *)p2;
     621             :         }
     622          18 :         if (ATOMcmp(t, p1, nil) == 0 || ATOMcmp(t, p2, nil) == 0)
     623             :                 p1 = nil;
     624          17 :         else if (ATOMcmp(t, p1, p2) > 0)
     625             :                 p1 = p2;
     626          18 :         if (VALinit(&stk->stk[getArg(pci, 0)], t, p1) == NULL)
     627           0 :                 return mythrow(MAL, "calc.min", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     628             :         return MAL_SUCCEED;
     629             : }
     630             : 
     631             : 
     632             : static str
     633          54 : CALCmin_no_nil(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     634             : {
     635          54 :         int t = getArgType(mb, pci, 1);
     636          54 :         ptr p1 = getArgReference(stk, pci, 1);
     637          54 :         ptr p2 = getArgReference(stk, pci, 2);
     638             :         const void *nil;
     639             : 
     640             :         (void) cntxt;
     641          54 :         if (t != getArgType(mb, pci, 2))
     642           0 :                 return mythrow(MAL, "calc.min", SEMANTIC_TYPE_MISMATCH);
     643          54 :         nil = ATOMnilptr(t);
     644          54 :         if (t >= TYPE_str && ATOMstorage(t) >= TYPE_str) {
     645           9 :                 p1 = *(ptr *)p1;
     646           9 :                 p2 = *(ptr *)p2;
     647             :         }
     648         108 :         if (ATOMcmp(t, p1, nil) == 0 ||
     649         107 :                 (ATOMcmp(t, p2, nil) != 0 && ATOMcmp(t, p1, p2) > 0))
     650             :                 p1 = p2;
     651          54 :         if (VALinit(&stk->stk[getArg(pci, 0)], t, p1) == NULL)
     652           0 :                 return mythrow(MAL, "calc.min", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     653             :         return MAL_SUCCEED;
     654             : }
     655             : 
     656             : 
     657             : static str
     658           9 : CALCmax(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     659             : {
     660           9 :         int t = getArgType(mb, pci, 1);
     661           9 :         const void *p1 = getArgReference(stk, pci, 1);
     662           9 :         const void *p2 = getArgReference(stk, pci, 2);
     663             :         const void *nil;
     664             : 
     665             :         (void) cntxt;
     666           9 :         if (t != getArgType(mb, pci, 2))
     667           0 :                 return mythrow(MAL, "calc.max", SEMANTIC_TYPE_MISMATCH);
     668           9 :         nil = ATOMnilptr(t);
     669           9 :         if (t >= TYPE_str && ATOMstorage(t) >= TYPE_str) {
     670           5 :                 p1 = *(ptr *)p1;
     671           5 :                 p2 = *(ptr *)p2;
     672             :         }
     673           9 :         if (ATOMcmp(t, p1, nil) == 0 || ATOMcmp(t, p2, nil) == 0)
     674             :                 p1 = nil;
     675           8 :         else if (ATOMcmp(t, p1, p2) < 0)
     676             :                 p1 = p2;
     677           9 :         if (VALinit(&stk->stk[getArg(pci, 0)], t, p1) == NULL)
     678           0 :                 return mythrow(MAL, "calc.max", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     679             :         return MAL_SUCCEED;
     680             : }
     681             : 
     682             : 
     683             : static str
     684          52 : CALCmax_no_nil(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     685             : {
     686          52 :         int t = getArgType(mb, pci, 1);
     687          52 :         ptr p1 = getArgReference(stk, pci, 1);
     688          52 :         ptr p2 = getArgReference(stk, pci, 2);
     689             :         const void *nil;
     690             : 
     691             :         (void) cntxt;
     692          52 :         if (t != getArgType(mb, pci, 2))
     693           0 :                 return mythrow(MAL, "calc.max", SEMANTIC_TYPE_MISMATCH);
     694          52 :         nil = ATOMnilptr(t);
     695          52 :         if (t >= TYPE_str && ATOMstorage(t) >= TYPE_str) {
     696          14 :                 p1 = *(ptr *)p1;
     697          14 :                 p2 = *(ptr *)p2;
     698             :         }
     699         103 :         if (ATOMcmp(t, p1, nil) == 0 ||
     700         101 :                 (ATOMcmp(t, p2, nil) != 0 && ATOMcmp(t, p1, p2) < 0))
     701             :                 p1 = p2;
     702          52 :         if (VALinit(&stk->stk[getArg(pci, 0)], t, p1) == NULL)
     703           0 :                 return mythrow(MAL, "calc.max", SQLSTATE(HY013) MAL_MALLOC_FAIL);
     704             :         return MAL_SUCCEED;
     705             : }
     706             : 
     707             : static str
     708             : CMDBATsumprod(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci,
     709             :                           gdk_return (*sumprod)(void *, int, BAT *, BAT *, bool, bool, bool),
     710             :                           const char *func)
     711             : {
     712             :         ValPtr ret = &stk->stk[getArg(pci, 0)];
     713             :         bat bid = * getArgReference_bat(stk, pci, 1);
     714             :         BAT *b;
     715             :         BAT *s = NULL;
     716             :         bool nil_if_empty = true;
     717             :         gdk_return r;
     718             : 
     719             :         if ((b = BATdescriptor(bid)) == NULL)
     720             :                 throw(MAL, func, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     721             :         if (pci->argc >= 3) {
     722             :                 if (getArgType(mb, pci, 2) == TYPE_bit) {
     723             :                         assert(pci->argc == 3);
     724             :                         nil_if_empty = * getArgReference_bit(stk, pci, 2);
     725             :                 } else {
     726             :                         bat sid = * getArgReference_bat(stk, pci, 2);
     727             :                         if (!is_bat_nil(sid) && (s = BATdescriptor(sid)) == NULL) {
     728             :                                 BBPunfix(b->batCacheid);
     729             :                                 throw(MAL, func, SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     730             :                         }
     731             :                         if (pci->argc >= 4) {
     732             :                                 assert(pci->argc == 4);
     733             :                                 assert(getArgType(mb, pci, 3) == TYPE_bit);
     734             :                                 nil_if_empty = * getArgReference_bit(stk, pci, 3);
     735             :                         }
     736             :                 }
     737             :         }
     738             :         r = (*sumprod)(VALget(ret), ret->vtype, b, s, true, true, nil_if_empty);
     739             :         BBPunfix(b->batCacheid);
     740             :         if (s)
     741             :                 BBPunfix(s->batCacheid);
     742             :         if (r != GDK_SUCCEED)
     743             :                 return mythrow(MAL, func, OPERATION_FAILED);
     744             :         return MAL_SUCCEED;
     745             : }
     746             : 
     747             : 
     748             : static str
     749        7215 : CMDBATsum(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     750             : {
     751             :         (void) cntxt;
     752             : 
     753        7215 :         return CMDBATsumprod(mb, stk, pci, BATsum, "aggr.sum");
     754             : }
     755             : 
     756             : 
     757             : static str
     758          30 : CMDBATprod(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     759             : {
     760             :         (void) cntxt;
     761             : 
     762          30 :         return CMDBATsumprod(mb, stk, pci, BATprod, "aggr.prod");
     763             : }
     764             : 
     765             : #define arg_type(stk, pci, k) ((stk)->stk[pci->argv[k]].vtype)
     766             : 
     767             : static str
     768         114 : CMDBATavg3(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     769             : {
     770         114 :         ValPtr ret = &stk->stk[getArg(pci, 0)];
     771             :         lng *rest = NULL, *cnt = NULL;
     772             :         bat *bid, *sid;
     773             :         bit *skip_nils;
     774             :         BAT *b = NULL, *s = NULL, *avgs, *cnts, *rems;
     775             : 
     776             :         gdk_return rc;
     777             :         (void)cntxt;
     778             :         (void)mb;
     779             : 
     780             :         /* optional results rest and count */
     781         114 :         if (arg_type(stk, pci, 1) == TYPE_lng)
     782         114 :                 rest = getArgReference_lng(stk, pci, 1);
     783         114 :         if (arg_type(stk, pci, 2) == TYPE_lng)
     784         114 :                 cnt = getArgReference_lng(stk, pci, 2);
     785         114 :         bid = getArgReference_bat(stk, pci, 3);
     786         114 :         sid = getArgReference_bat(stk, pci, 4);
     787         114 :         skip_nils = getArgReference_bit(stk, pci, 5);
     788         114 :         b = BATdescriptor(*bid);
     789         114 :         s = sid != NULL && !is_bat_nil(*sid) ? BATdescriptor(*sid) : NULL;
     790         114 :         if (b == NULL ||
     791         114 :                 (sid != NULL && !is_bat_nil(*sid) && s == NULL)) {
     792           0 :                 if (b)
     793           0 :                         BBPunfix(b->batCacheid);
     794           0 :                 throw(MAL, "aggr.avg", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     795             :         }
     796         114 :         rc = BATgroupavg3(&avgs, &rems, &cnts, b, NULL, NULL, s, *skip_nils);
     797         114 :         if (avgs && BATcount(avgs) == 1) {
     798             :                 /* only type bte, sht, int, lng and hge */
     799         114 :                 ptr res = VALget(ret);
     800             :                 lng xcnt = 0;
     801             : 
     802         114 :                 if (avgs->ttype == TYPE_bte) {
     803           8 :                         *(bte*)res = *(bte*) Tloc(avgs, 0);
     804         106 :                 } else if (avgs->ttype == TYPE_sht) {
     805           1 :                         *(sht*)res = *(sht*) Tloc(avgs, 0);
     806         105 :                 } else if (avgs->ttype == TYPE_int) {
     807          83 :                         *(int*)res = *(int*) Tloc(avgs, 0);
     808          22 :                 } else if (avgs->ttype == TYPE_lng) {
     809          18 :                         *(lng*)res = *(lng*) Tloc(avgs, 0);
     810             : #ifdef HAVE_HGE
     811           4 :                 } else if (avgs->ttype == TYPE_hge) {
     812           4 :                         *(hge*)res = *(hge*) Tloc(avgs, 0);
     813             : #endif
     814             :                 }
     815         114 :                 if (cnt)
     816         114 :                         xcnt = *cnt = *(lng*) Tloc(cnts, 0);
     817         114 :                 if (rest)
     818         114 :                         *rest = *(lng*) Tloc(rems, 0);
     819         114 :                 if (xcnt == 0)
     820           6 :                         VALset(ret, ret->vtype, (ptr)ATOMnilptr(ret->vtype));
     821             :         } else {
     822           0 :                 VALset(ret, ret->vtype, (ptr)ATOMnilptr(ret->vtype));
     823           0 :                 if (rest)
     824           0 :                         *rest = lng_nil;
     825           0 :                 if (cnt)
     826           0 :                         *cnt = lng_nil;
     827             :         }
     828         114 :         if (avgs)
     829         114 :                 BBPunfix(avgs->batCacheid);
     830         114 :         if (rems)
     831         114 :                 BBPunfix(rems->batCacheid);
     832         114 :         if (cnts)
     833         114 :                 BBPunfix(cnts->batCacheid);
     834         114 :         BBPunfix(b->batCacheid);
     835         114 :         if (s)
     836           0 :                 BBPunfix(s->batCacheid);
     837         114 :         if (rc != GDK_SUCCEED)
     838           0 :                 return mythrow(MAL, "aggr.avg", OPERATION_FAILED);
     839             :         return MAL_SUCCEED;
     840             : }
     841             : 
     842             : static str
     843          23 : CMDBATavg3comb(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     844             : {
     845          23 :         ValPtr ret = &stk->stk[getArg(pci, 0)];
     846             :         BAT *b = NULL, *r = NULL, *c = NULL, *avgs;
     847          23 :         bat *bid = getArgReference_bat(stk, pci, 1);
     848          23 :         bat *rid = getArgReference_bat(stk, pci, 2);
     849          23 :         bat *cid = getArgReference_bat(stk, pci, 3);
     850             : 
     851             :         (void)cntxt;
     852             :         (void)mb;
     853             : 
     854          23 :         b = BATdescriptor(*bid);
     855          23 :         r = BATdescriptor(*rid);
     856          23 :         c = BATdescriptor(*cid);
     857          23 :         if (b == NULL || r == NULL || c == NULL) {
     858           0 :                 if (b)
     859           0 :                         BBPunfix(b->batCacheid);
     860           0 :                 if (r)
     861           0 :                         BBPunfix(r->batCacheid);
     862           0 :                 if (c)
     863           0 :                         BBPunfix(c->batCacheid);
     864           0 :                 throw(MAL, "aggr.avg", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     865             :         }
     866          23 :         avgs = BATgroupavg3combine(b, r, c, NULL, NULL, TRUE);
     867          23 :         if (avgs && BATcount(avgs) == 1) {
     868             :                 /* only type bte, sht, int, lng and hge */
     869          23 :                 ptr res = VALget(ret);
     870             : 
     871          23 :                 if (avgs->ttype == TYPE_bte) {
     872           2 :                         *(bte*)res = *(bte*) Tloc(avgs, 0);
     873          21 :                 } else if (avgs->ttype == TYPE_sht) {
     874           0 :                         *(sht*)res = *(sht*) Tloc(avgs, 0);
     875          21 :                 } else if (avgs->ttype == TYPE_int) {
     876          20 :                         *(int*)res = *(int*) Tloc(avgs, 0);
     877           1 :                 } else if (avgs->ttype == TYPE_lng) {
     878           1 :                         *(lng*)res = *(lng*) Tloc(avgs, 0);
     879             : #ifdef HAVE_HGE
     880           0 :                 } else if (avgs->ttype == TYPE_hge) {
     881           0 :                         *(hge*)res = *(hge*) Tloc(avgs, 0);
     882             : #endif
     883             :                 }
     884             :         } else {
     885           0 :                 VALset(ret, ret->vtype, (ptr)ATOMnilptr(ret->vtype));
     886             :         }
     887          23 :         if (avgs)
     888          23 :                 BBPunfix(avgs->batCacheid);
     889          23 :         BBPunfix(b->batCacheid);
     890          23 :         BBPunfix(r->batCacheid);
     891          23 :         BBPunfix(c->batCacheid);
     892          23 :         if (avgs == NULL)
     893           0 :                 throw(MAL, "aggr.avg", GDK_EXCEPTION);
     894             :         return MAL_SUCCEED;
     895             : }
     896             : 
     897             : static str
     898          42 : CMDBATstr_group_concat(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
     899             : {
     900          42 :         ValPtr ret = &stk->stk[getArg(pci, 0)];
     901          42 :         bat bid = *getArgReference_bat(stk, pci, 1), sid = 0;
     902             :         BAT *b, *s = NULL, *sep = NULL;
     903             :         bool nil_if_empty = true;
     904             :         int next_argument = 2;
     905             :         const char *separator = ",";
     906             :         gdk_return r;
     907             : 
     908             :         (void) cntxt;
     909             : 
     910          42 :         if ((b = BATdescriptor(bid)) == NULL)
     911           0 :                 throw(MAL, "aggr.str_group_concat", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     912             : 
     913          42 :         if (isaBatType(getArgType(mb, pci, 2))) {
     914          16 :                 sid = *getArgReference_bat(stk, pci, 2);
     915          16 :                 if ((sep = BATdescriptor(sid)) == NULL) {
     916           0 :                         BBPunfix(b->batCacheid);
     917           0 :                         throw(MAL, "aggr.str_group_concat", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     918             :                 }
     919          16 :                 if (sep->ttype == TYPE_str) { /* the separator bat */
     920             :                         next_argument = 3;
     921             :                         separator = NULL;
     922             :                 }
     923             :         }
     924             : 
     925          42 :         if (pci->argc >= (next_argument + 1)) {
     926           0 :                 if (getArgType(mb, pci, next_argument) == TYPE_bit) {
     927             :                         assert(pci->argc == (next_argument + 1));
     928           0 :                         nil_if_empty = *getArgReference_bit(stk, pci, next_argument);
     929             :                 } else {
     930           0 :                         if (next_argument == 3) {
     931           0 :                                 bat sid = *getArgReference_bat(stk, pci, next_argument);
     932           0 :                                 if (!is_bat_nil(sid) && (s = BATdescriptor(sid)) == NULL) {
     933           0 :                                         BBPunfix(b->batCacheid);
     934           0 :                                         BBPunfix(sep->batCacheid);
     935           0 :                                         throw(MAL, "aggr.str_group_concat", SQLSTATE(HY002) RUNTIME_OBJECT_MISSING);
     936             :                                 }
     937             :                         } else {
     938             :                                 s = sep;
     939             :                                 sep = NULL;
     940             :                         }
     941           0 :                         if (pci->argc >= (next_argument + 2)) {
     942             :                                 assert(pci->argc == (next_argument + 2));
     943             :                                 assert(getArgType(mb, pci, (next_argument + 1)) == TYPE_bit);
     944           0 :                                 nil_if_empty = * getArgReference_bit(stk, pci, (next_argument + 1));
     945             :                         }
     946             :                 }
     947             :         }
     948             : 
     949             :         assert((separator && !sep) || (!separator && sep));
     950          42 :         r = BATstr_group_concat(ret, b, s, sep, true, true, nil_if_empty, separator);
     951          42 :         BBPunfix(b->batCacheid);
     952          42 :         if (sep)
     953          16 :                 BBPunfix(sep->batCacheid);
     954          42 :         if (s)
     955           0 :                 BBPunfix(s->batCacheid);
     956          42 :         if (r != GDK_SUCCEED)
     957           0 :                 return mythrow(MAL, "aggr.str_group_concat", OPERATION_FAILED);
     958             :         return MAL_SUCCEED;
     959             : }
     960             : 
     961             : #include "mel.h"
     962             : mel_func calc_init_funcs[] = {
     963             : #ifdef HAVE_HGE
     964             :  pattern("calc", "iszero", CMDvarISZERO, false, "Unary check for zero of V", args(1,2, arg("",bit),arg("v",hge))),
     965             :  pattern("calc", "not", CMDvarNOT, false, "Unary bitwise not of V", args(1,2, arg("",hge),arg("v",hge))),
     966             :  pattern("calc", "sign", CMDvarSIGN, false, "Unary sign (-1,0,1) of V", args(1,2, arg("",bte),arg("v",hge))),
     967             :  pattern("calc", "abs", CMDvarABS, false, "Unary absolute value of V", args(1,2, arg("",hge),arg("v",hge))),
     968             :  pattern("calc", "-", CMDvarNEG, false, "Unary negation of V", args(1,2, arg("",hge),arg("v",hge))),
     969             :  pattern("calc", "++", CMDvarINCRsignal, false, "Unary V + 1", args(1,2, arg("",hge),arg("v",hge))),
     970             :  pattern("calc", "--", CMDvarDECRsignal, false, "Unary V - 1", args(1,2, arg("",hge),arg("v",hge))),
     971             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",bte),arg("v2",bte))),
     972             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",bte),arg("v2",sht))),
     973             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",bte),arg("v2",int))),
     974             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",bte),arg("v2",lng))),
     975             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",hge))),
     976             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",hge))),
     977             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",bte),arg("v2",hge))),
     978             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",hge))),
     979             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",sht),arg("v2",bte))),
     980             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",sht),arg("v2",sht))),
     981             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",sht),arg("v2",int))),
     982             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",sht),arg("v2",lng))),
     983             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",hge))),
     984             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",hge))),
     985             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",sht),arg("v2",hge))),
     986             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",hge))),
     987             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",int),arg("v2",bte))),
     988             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",int),arg("v2",sht))),
     989             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",int),arg("v2",int))),
     990             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",int),arg("v2",lng))),
     991             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",hge))),
     992             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",hge))),
     993             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",int),arg("v2",hge))),
     994             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",hge))),
     995             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",lng),arg("v2",bte))),
     996             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",lng),arg("v2",sht))),
     997             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",lng),arg("v2",int))),
     998             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",lng),arg("v2",lng))),
     999             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",hge))),
    1000             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",hge))),
    1001             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",lng),arg("v2",hge))),
    1002             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",hge))),
    1003             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",bte))),
    1004             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",bte))),
    1005             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1006             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1007             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",sht))),
    1008             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",sht))),
    1009             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1010             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1011             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",int))),
    1012             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",int))),
    1013             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1014             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1015             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",lng))),
    1016             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",lng))),
    1017             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1018             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1019             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",hge))),
    1020             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",hge))),
    1021             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1022             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1023             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",flt))),
    1024             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",hge),arg("v2",flt))),
    1025             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",hge),arg("v2",flt))),
    1026             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",dbl))),
    1027             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",dbl))),
    1028             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",hge))),
    1029             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",hge))),
    1030             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",hge))),
    1031             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",hge))),
    1032             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",hge))),
    1033             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",bte),arg("v2",bte))),
    1034             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",bte),arg("v2",sht))),
    1035             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",bte),arg("v2",int))),
    1036             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",bte),arg("v2",lng))),
    1037             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",hge))),
    1038             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",hge))),
    1039             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",bte),arg("v2",hge))),
    1040             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",hge))),
    1041             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",sht),arg("v2",bte))),
    1042             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",sht),arg("v2",sht))),
    1043             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",sht),arg("v2",int))),
    1044             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",sht),arg("v2",lng))),
    1045             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",hge))),
    1046             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",hge))),
    1047             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",sht),arg("v2",hge))),
    1048             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",hge))),
    1049             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",int),arg("v2",bte))),
    1050             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",int),arg("v2",sht))),
    1051             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",int),arg("v2",int))),
    1052             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",int),arg("v2",lng))),
    1053             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",hge))),
    1054             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",hge))),
    1055             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",int),arg("v2",hge))),
    1056             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",hge))),
    1057             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",lng),arg("v2",bte))),
    1058             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",lng),arg("v2",sht))),
    1059             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",lng),arg("v2",int))),
    1060             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",lng),arg("v2",lng))),
    1061             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",hge))),
    1062             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",hge))),
    1063             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",lng),arg("v2",hge))),
    1064             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",hge))),
    1065             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",bte))),
    1066             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",bte))),
    1067             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1068             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1069             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",sht))),
    1070             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",sht))),
    1071             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1072             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1073             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",int))),
    1074             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",int))),
    1075             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1076             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1077             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",lng))),
    1078             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",lng))),
    1079             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1080             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1081             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",hge))),
    1082             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",hge))),
    1083             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1084             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1085             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",flt))),
    1086             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",hge),arg("v2",flt))),
    1087             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",hge),arg("v2",flt))),
    1088             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",dbl))),
    1089             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",dbl))),
    1090             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",hge))),
    1091             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",hge))),
    1092             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",hge))),
    1093             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",hge))),
    1094             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",hge))),
    1095             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",bte),arg("v2",bte))),
    1096             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",bte),arg("v2",sht))),
    1097             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",bte),arg("v2",int))),
    1098             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",bte),arg("v2",lng))),
    1099             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",hge))),
    1100             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",hge))),
    1101             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",bte),arg("v2",hge))),
    1102             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",hge))),
    1103             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",sht),arg("v2",bte))),
    1104             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",sht),arg("v2",sht))),
    1105             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",sht),arg("v2",int))),
    1106             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",sht),arg("v2",lng))),
    1107             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",hge))),
    1108             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",hge))),
    1109             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",sht),arg("v2",hge))),
    1110             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",hge))),
    1111             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",int),arg("v2",bte))),
    1112             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",int),arg("v2",sht))),
    1113             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",int),arg("v2",int))),
    1114             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",int),arg("v2",lng))),
    1115             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",hge))),
    1116             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",hge))),
    1117             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",int),arg("v2",hge))),
    1118             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",hge))),
    1119             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",lng),arg("v2",bte))),
    1120             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",lng),arg("v2",sht))),
    1121             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",lng),arg("v2",int))),
    1122             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",hge),arg("v1",lng),arg("v2",lng))),
    1123             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",hge))),
    1124             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",hge))),
    1125             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",lng),arg("v2",hge))),
    1126             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",hge))),
    1127             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",bte))),
    1128             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",bte))),
    1129             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1130             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1131             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",sht))),
    1132             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",sht))),
    1133             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1134             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1135             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",int))),
    1136             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",int))),
    1137             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1138             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1139             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",lng))),
    1140             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",lng))),
    1141             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1142             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1143             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",hge))),
    1144             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",hge),arg("v2",hge))),
    1145             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1146             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1147             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",flt))),
    1148             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",hge),arg("v2",flt))),
    1149             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",hge),arg("v2",flt))),
    1150             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",dbl))),
    1151             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",dbl))),
    1152             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",hge))),
    1153             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",hge))),
    1154             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",hge))),
    1155             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",hge))),
    1156             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",hge))),
    1157             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",hge),arg("v2",flt))),
    1158             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",hge),arg("v2",flt))),
    1159             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",hge),arg("v2",flt))),
    1160             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",hge),arg("v2",flt))),
    1161             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",hge),arg("v2",flt))),
    1162             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",hge),arg("v2",flt))),
    1163             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",hge),arg("v2",flt))),
    1164             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",hge),arg("v2",flt))),
    1165             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",bte),arg("v2",flt))),
    1166             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",flt))),
    1167             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",sht),arg("v2",flt))),
    1168             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",flt))),
    1169             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",int),arg("v2",flt))),
    1170             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",flt))),
    1171             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",lng),arg("v2",flt))),
    1172             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",flt))),
    1173             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",flt))),
    1174             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",flt))),
    1175             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",flt),arg("v2",hge))),
    1176             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",flt),arg("v2",hge))),
    1177             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",flt),arg("v2",hge))),
    1178             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",flt),arg("v2",hge))),
    1179             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",flt),arg("v2",hge))),
    1180             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",flt),arg("v2",hge))),
    1181             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",flt),arg("v2",hge))),
    1182             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",flt),arg("v2",hge))),
    1183             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",flt),arg("v2",bte))),
    1184             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",flt),arg("v2",bte))),
    1185             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",flt),arg("v2",sht))),
    1186             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",flt),arg("v2",sht))),
    1187             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",flt),arg("v2",int))),
    1188             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",flt),arg("v2",int))),
    1189             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",flt),arg("v2",lng))),
    1190             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",flt),arg("v2",lng))),
    1191             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",flt),arg("v2",hge))),
    1192             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",flt),arg("v2",hge))),
    1193             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",hge),arg("v2",dbl))),
    1194             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",hge),arg("v2",dbl))),
    1195             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",hge),arg("v2",dbl))),
    1196             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",hge),arg("v2",dbl))),
    1197             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",hge),arg("v2",dbl))),
    1198             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",hge),arg("v2",dbl))),
    1199             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",hge),arg("v2",dbl))),
    1200             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",hge),arg("v2",dbl))),
    1201             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",bte),arg("v2",dbl))),
    1202             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",dbl))),
    1203             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",sht),arg("v2",dbl))),
    1204             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",dbl))),
    1205             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",int),arg("v2",dbl))),
    1206             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",dbl))),
    1207             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",lng),arg("v2",dbl))),
    1208             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",dbl))),
    1209             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",hge),arg("v2",dbl))),
    1210             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",dbl))),
    1211             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",hge))),
    1212             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",hge))),
    1213             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",dbl),arg("v2",hge))),
    1214             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",dbl),arg("v2",hge))),
    1215             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",dbl),arg("v2",hge))),
    1216             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",dbl),arg("v2",hge))),
    1217             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",dbl),arg("v2",hge))),
    1218             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",dbl),arg("v2",hge))),
    1219             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",dbl),arg("v2",bte))),
    1220             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",dbl),arg("v2",bte))),
    1221             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",dbl),arg("v2",sht))),
    1222             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",dbl),arg("v2",sht))),
    1223             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",dbl),arg("v2",int))),
    1224             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",dbl),arg("v2",int))),
    1225             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",dbl),arg("v2",lng))),
    1226             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",dbl),arg("v2",lng))),
    1227             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",hge),arg("v1",dbl),arg("v2",hge))),
    1228             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",hge),arg("v1",dbl),arg("v2",hge))),
    1229             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",bte),arg("v2",bte))),
    1230             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",bte))),
    1231             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",bte),arg("v2",sht))),
    1232             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",sht))),
    1233             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",bte),arg("v2",int))),
    1234             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",int))),
    1235             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",bte),arg("v2",lng))),
    1236             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",lng))),
    1237             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",hge))),
    1238             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",hge))),
    1239             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",bte),arg("v2",hge))),
    1240             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",bte),arg("v2",hge))),
    1241             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",bte),arg("v2",hge))),
    1242             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",hge))),
    1243             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",bte),arg("v2",hge))),
    1244             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",hge))),
    1245             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",bte),arg("v2",hge))),
    1246             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",hge))),
    1247             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",bte),arg("v2",hge))),
    1248             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",hge))),
    1249             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",bte),arg("v2",hge))),
    1250             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",hge))),
    1251             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",bte),arg("v2",flt))),
    1252             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",flt))),
    1253             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",bte),arg("v2",dbl))),
    1254             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",dbl))),
    1255             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",sht),arg("v2",bte))),
    1256             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",bte))),
    1257             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",sht),arg("v2",sht))),
    1258             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",sht))),
    1259             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",sht),arg("v2",int))),
    1260             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",int))),
    1261             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",sht),arg("v2",lng))),
    1262             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",lng))),
    1263             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",hge))),
    1264             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",hge))),
    1265             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",sht),arg("v2",hge))),
    1266             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",sht),arg("v2",hge))),
    1267             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",sht),arg("v2",hge))),
    1268             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",hge))),
    1269             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",sht),arg("v2",hge))),
    1270             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",hge))),
    1271             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",sht),arg("v2",hge))),
    1272             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",hge))),
    1273             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",sht),arg("v2",hge))),
    1274             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",hge))),
    1275             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",sht),arg("v2",flt))),
    1276             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",flt))),
    1277             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",sht),arg("v2",dbl))),
    1278             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",dbl))),
    1279             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",int),arg("v2",bte))),
    1280             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",bte))),
    1281             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",int),arg("v2",sht))),
    1282             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",sht))),
    1283             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",int),arg("v2",int))),
    1284             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",int))),
    1285             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",int),arg("v2",lng))),
    1286             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",lng))),
    1287             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",int),arg("v2",hge))),
    1288             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",int),arg("v2",hge))),
    1289             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",int),arg("v2",hge))),
    1290             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",int),arg("v2",hge))),
    1291             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",int),arg("v2",hge))),
    1292             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",hge))),
    1293             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",int),arg("v2",hge))),
    1294             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",hge))),
    1295             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",int),arg("v2",hge))),
    1296             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",hge))),
    1297             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",int),arg("v2",flt))),
    1298             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",flt))),
    1299             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",int),arg("v2",dbl))),
    1300             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",dbl))),
    1301             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",lng),arg("v2",bte))),
    1302             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",bte))),
    1303             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",lng),arg("v2",sht))),
    1304             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",sht))),
    1305             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",lng),arg("v2",int))),
    1306             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",int))),
    1307             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",lng),arg("v2",lng))),
    1308             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",lng))),
    1309             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",hge))),
    1310             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",hge))),
    1311             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",lng),arg("v2",hge))),
    1312             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",lng),arg("v2",hge))),
    1313             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",lng),arg("v2",hge))),
    1314             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",hge))),
    1315             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",lng),arg("v2",hge))),
    1316             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",hge))),
    1317             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",lng),arg("v2",flt))),
    1318             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",flt))),
    1319             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",lng),arg("v2",dbl))),
    1320             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",dbl))),
    1321             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",bte))),
    1322             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",bte))),
    1323             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",hge),arg("v2",bte))),
    1324             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",hge),arg("v2",bte))),
    1325             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1326             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1327             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",sht))),
    1328             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",sht))),
    1329             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",hge),arg("v2",sht))),
    1330             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",hge),arg("v2",sht))),
    1331             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1332             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1333             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",int))),
    1334             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",int))),
    1335             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",hge),arg("v2",int))),
    1336             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",hge),arg("v2",int))),
    1337             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1338             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1339             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",lng))),
    1340             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",lng))),
    1341             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",hge),arg("v2",lng))),
    1342             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",hge),arg("v2",lng))),
    1343             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1344             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1345             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",hge))),
    1346             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",hge))),
    1347             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",hge),arg("v2",hge))),
    1348             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",hge),arg("v2",hge))),
    1349             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1350             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1351             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",flt))),
    1352             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",flt))),
    1353             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",hge),arg("v2",flt))),
    1354             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",hge),arg("v2",flt))),
    1355             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",hge),arg("v2",flt))),
    1356             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",flt))),
    1357             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",dbl))),
    1358             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",dbl))),
    1359             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",hge),arg("v2",dbl))),
    1360             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",hge),arg("v2",dbl))),
    1361             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",hge),arg("v2",dbl))),
    1362             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",dbl))),
    1363             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",hge))),
    1364             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",hge))),
    1365             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",hge))),
    1366             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",hge))),
    1367             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",hge))),
    1368             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",hge))),
    1369             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",flt),arg("v2",hge))),
    1370             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",flt),arg("v2",hge))),
    1371             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",dbl),arg("v2",hge))),
    1372             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",dbl),arg("v2",hge))),
    1373             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",bte),arg("v2",bte))),
    1374             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",bte))),
    1375             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",bte),arg("v2",sht))),
    1376             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",sht))),
    1377             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",bte),arg("v2",int))),
    1378             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",int))),
    1379             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",bte),arg("v2",lng))),
    1380             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",lng))),
    1381             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",bte),arg("v2",hge))),
    1382             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",bte),arg("v2",hge))),
    1383             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",bte),arg("v2",hge))),
    1384             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",hge))),
    1385             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",bte),arg("v2",hge))),
    1386             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",hge))),
    1387             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",bte),arg("v2",hge))),
    1388             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",hge))),
    1389             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",bte),arg("v2",hge))),
    1390             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",hge))),
    1391             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",sht),arg("v2",bte))),
    1392             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",bte))),
    1393             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",sht),arg("v2",sht))),
    1394             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",sht))),
    1395             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",sht),arg("v2",int))),
    1396             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",int))),
    1397             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",sht),arg("v2",lng))),
    1398             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",lng))),
    1399             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",sht),arg("v2",hge))),
    1400             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",sht),arg("v2",hge))),
    1401             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",sht),arg("v2",hge))),
    1402             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",hge))),
    1403             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",sht),arg("v2",hge))),
    1404             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",hge))),
    1405             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",sht),arg("v2",hge))),
    1406             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",hge))),
    1407             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",int),arg("v2",bte))),
    1408             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",bte))),
    1409             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",int),arg("v2",sht))),
    1410             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",sht))),
    1411             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",int),arg("v2",int))),
    1412             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",int))),
    1413             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",int),arg("v2",lng))),
    1414             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",lng))),
    1415             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",int),arg("v2",hge))),
    1416             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",int),arg("v2",hge))),
    1417             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",int),arg("v2",hge))),
    1418             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",hge))),
    1419             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",int),arg("v2",hge))),
    1420             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",hge))),
    1421             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",lng),arg("v2",bte))),
    1422             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",bte))),
    1423             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",lng),arg("v2",sht))),
    1424             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",sht))),
    1425             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",lng),arg("v2",int))),
    1426             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",int))),
    1427             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",lng),arg("v2",lng))),
    1428             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",lng))),
    1429             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",lng),arg("v2",hge))),
    1430             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",lng),arg("v2",hge))),
    1431             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",lng),arg("v2",hge))),
    1432             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",hge))),
    1433             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1434             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1435             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",hge),arg("v2",bte))),
    1436             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",hge),arg("v2",bte))),
    1437             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",hge),arg("v2",bte))),
    1438             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",hge),arg("v2",bte))),
    1439             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",hge),arg("v2",bte))),
    1440             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",hge),arg("v2",bte))),
    1441             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",hge),arg("v2",bte))),
    1442             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",hge),arg("v2",bte))),
    1443             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1444             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1445             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",hge),arg("v2",sht))),
    1446             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",hge),arg("v2",sht))),
    1447             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",hge),arg("v2",sht))),
    1448             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",hge),arg("v2",sht))),
    1449             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",hge),arg("v2",sht))),
    1450             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",hge),arg("v2",sht))),
    1451             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1452             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1453             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",hge),arg("v2",int))),
    1454             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",hge),arg("v2",int))),
    1455             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",hge),arg("v2",int))),
    1456             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",hge),arg("v2",int))),
    1457             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1458             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1459             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",hge),arg("v2",lng))),
    1460             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",hge),arg("v2",lng))),
    1461             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1462             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1463             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",hge),arg("v2",flt))),
    1464             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",hge),arg("v2",flt))),
    1465             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",dbl))),
    1466             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",hge),arg("v2",dbl))),
    1467             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",hge))),
    1468             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",hge))),
    1469             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",hge))),
    1470             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",hge))),
    1471             :  pattern("calc", "and", CMDvarAND, false, "Return V1 AND V2", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1472             :  pattern("calc", "or", CMDvarOR, false, "Return V1 OR V2", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1473             :  pattern("calc", "xor", CMDvarXOR, false, "Return V1 XOR V2", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1474             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",bte),arg("v1",bte),arg("v2",hge))),
    1475             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",hge))),
    1476             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",sht),arg("v1",sht),arg("v2",hge))),
    1477             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",hge))),
    1478             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",int),arg("v1",int),arg("v2",hge))),
    1479             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",hge))),
    1480             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",lng),arg("v1",lng),arg("v2",hge))),
    1481             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",hge))),
    1482             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1483             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1484             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1485             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1486             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1487             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1488             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1489             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1490             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1491             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1492             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",bte),arg("v1",bte),arg("v2",hge))),
    1493             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",hge))),
    1494             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",sht),arg("v1",sht),arg("v2",hge))),
    1495             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",hge))),
    1496             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",int),arg("v1",int),arg("v2",hge))),
    1497             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",hge))),
    1498             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",lng),arg("v1",lng),arg("v2",hge))),
    1499             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",hge))),
    1500             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1501             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",bte))),
    1502             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1503             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",sht))),
    1504             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1505             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",int))),
    1506             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1507             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",lng))),
    1508             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1509             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",hge),arg("v1",hge),arg("v2",hge))),
    1510             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",hge))),
    1511             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",hge))),
    1512             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",hge))),
    1513             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",hge))),
    1514             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",bte))),
    1515             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",sht))),
    1516             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",int))),
    1517             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",lng))),
    1518             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",hge))),
    1519             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",flt))),
    1520             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",dbl))),
    1521             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",hge))),
    1522             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",hge))),
    1523             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",hge))),
    1524             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",hge))),
    1525             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",hge))),
    1526             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",hge))),
    1527             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",bte))),
    1528             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",sht))),
    1529             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",int))),
    1530             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",lng))),
    1531             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",hge))),
    1532             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",flt))),
    1533             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",dbl))),
    1534             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",hge))),
    1535             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",hge))),
    1536             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",hge))),
    1537             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",hge))),
    1538             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",hge))),
    1539             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",hge))),
    1540             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",bte))),
    1541             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",sht))),
    1542             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",int))),
    1543             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",lng))),
    1544             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",hge))),
    1545             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",flt))),
    1546             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",dbl))),
    1547             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",hge))),
    1548             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",hge))),
    1549             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",hge))),
    1550             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",hge))),
    1551             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",hge))),
    1552             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",hge))),
    1553             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",bte))),
    1554             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",sht))),
    1555             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",int))),
    1556             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",lng))),
    1557             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",hge))),
    1558             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",flt))),
    1559             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",dbl))),
    1560             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",hge))),
    1561             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",hge))),
    1562             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",hge))),
    1563             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",hge),arg("nil_matches",bit))),
    1564             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",hge))),
    1565             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",hge),arg("nil_matches",bit))),
    1566             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",hge))),
    1567             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",hge),arg("nil_matches",bit))),
    1568             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",hge))),
    1569             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",hge),arg("nil_matches",bit))),
    1570             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",bte))),
    1571             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",bte),arg("nil_matches",bit))),
    1572             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",sht))),
    1573             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",sht),arg("nil_matches",bit))),
    1574             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",int))),
    1575             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",int),arg("nil_matches",bit))),
    1576             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",lng))),
    1577             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",lng),arg("nil_matches",bit))),
    1578             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",hge))),
    1579             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",hge),arg("nil_matches",bit))),
    1580             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",flt))),
    1581             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",flt),arg("nil_matches",bit))),
    1582             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",dbl))),
    1583             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",dbl),arg("nil_matches",bit))),
    1584             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",hge))),
    1585             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",hge),arg("nil_matches",bit))),
    1586             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",hge))),
    1587             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",hge),arg("nil_matches",bit))),
    1588             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",hge))),
    1589             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",hge),arg("nil_matches",bit))),
    1590             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",hge))),
    1591             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",hge),arg("nil_matches",bit))),
    1592             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",hge))),
    1593             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",hge),arg("nil_matches",bit))),
    1594             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",hge))),
    1595             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",hge),arg("nil_matches",bit))),
    1596             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",bte))),
    1597             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",bte),arg("nil_matches",bit))),
    1598             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",sht))),
    1599             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",sht),arg("nil_matches",bit))),
    1600             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",int))),
    1601             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",int),arg("nil_matches",bit))),
    1602             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",lng))),
    1603             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",lng),arg("nil_matches",bit))),
    1604             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",hge))),
    1605             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",hge),arg("nil_matches",bit))),
    1606             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",flt))),
    1607             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",flt),arg("nil_matches",bit))),
    1608             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",hge),arg("v2",dbl))),
    1609             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",hge),arg("v2",dbl),arg("nil_matches",bit))),
    1610             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",hge))),
    1611             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",hge),arg("nil_matches",bit))),
    1612             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",hge))),
    1613             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",hge),arg("nil_matches",bit))),
    1614             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",bte),arg("v2",hge))),
    1615             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",sht),arg("v2",hge))),
    1616             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",int),arg("v2",hge))),
    1617             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",lng),arg("v2",hge))),
    1618             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",hge),arg("v2",bte))),
    1619             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",hge),arg("v2",sht))),
    1620             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",hge),arg("v2",int))),
    1621             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",hge),arg("v2",lng))),
    1622             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",hge),arg("v2",hge))),
    1623             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",hge),arg("v2",flt))),
    1624             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",hge),arg("v2",dbl))),
    1625             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",flt),arg("v2",hge))),
    1626             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",hge))),
    1627             :  pattern("calc", "void", CMDvarCONVERT, false, "Cast VALUE to void", args(1,2, arg("",void),arg("v",hge))),
    1628             :  pattern("calc", "bit", CMDvarCONVERT, false, "Cast VALUE to bit", args(1,2, arg("",bit),arg("v",hge))),
    1629             :  pattern("calc", "bte", CMDvarCONVERT, false, "Cast VALUE to bte", args(1,2, arg("",bte),arg("v",hge))),
    1630             :  pattern("calc", "sht", CMDvarCONVERT, false, "Cast VALUE to sht", args(1,2, arg("",sht),arg("v",hge))),
    1631             :  pattern("calc", "int", CMDvarCONVERT, false, "Cast VALUE to int", args(1,2, arg("",int),arg("v",hge))),
    1632             :  pattern("calc", "lng", CMDvarCONVERT, false, "Cast VALUE to lng", args(1,2, arg("",lng),arg("v",hge))),
    1633             :  pattern("calc", "hge", CMDvarCONVERT, false, "Cast VALUE to hge", args(1,2, arg("",hge),arg("v",void))),
    1634             :  pattern("calc", "hge", CMDvarCONVERT, false, "Cast VALUE to hge", args(1,2, arg("",hge),arg("v",bit))),
    1635             :  pattern("calc", "hge", CMDvarCONVERT, false, "Cast VALUE to hge", args(1,2, arg("",hge),arg("v",bte))),
    1636             :  pattern("calc", "hge", CMDvarCONVERT, false, "Cast VALUE to hge", args(1,2, arg("",hge),arg("v",sht))),
    1637             :  pattern("calc", "hge", CMDvarCONVERT, false, "Cast VALUE to hge", args(1,2, arg("",hge),arg("v",int))),
    1638             :  pattern("calc", "hge", CMDvarCONVERT, false, "Cast VALUE to hge", args(1,2, arg("",hge),arg("v",lng))),
    1639             :  pattern("calc", "hge", CMDvarCONVERT, false, "Cast VALUE to hge", args(1,2, arg("",hge),arg("v",hge))),
    1640             :  pattern("calc", "hge", CMDvarCONVERT, false, "Cast VALUE to hge", args(1,2, arg("",hge),arg("v",flt))),
    1641             :  pattern("calc", "hge", CMDvarCONVERT, false, "Cast VALUE to hge", args(1,2, arg("",hge),arg("v",dbl))),
    1642             :  pattern("calc", "hge", CMDvarCONVERT, false, "Cast VALUE to hge", args(1,2, arg("",hge),arg("v",oid))),
    1643             :  pattern("calc", "hge", CMDvarCONVERT, false, "Cast VALUE to hge", args(1,2, arg("",hge),arg("v",str))),
    1644             :  pattern("calc", "flt", CMDvarCONVERT, false, "Cast VALUE to flt", args(1,2, arg("",flt),arg("v",hge))),
    1645             :  pattern("calc", "dbl", CMDvarCONVERT, false, "Cast VALUE to dbl", args(1,2, arg("",dbl),arg("v",hge))),
    1646             :  pattern("calc", "oid", CMDvarCONVERT, false, "Cast VALUE to oid", args(1,2, arg("",oid),arg("v",hge))),
    1647             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",hge),batarg("b",bte))),
    1648             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",hge),batarg("b",bte),arg("nil_if_empty",bit))),
    1649             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",hge),batarg("b",bte),batarg("s",oid))),
    1650             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",hge),batarg("b",bte),batarg("s",oid),arg("nil_if_empty",bit))),
    1651             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",hge),batarg("b",sht))),
    1652             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",hge),batarg("b",sht),arg("nil_if_empty",bit))),
    1653             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",hge),batarg("b",sht),batarg("s",oid))),
    1654             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",hge),batarg("b",sht),batarg("s",oid),arg("nil_if_empty",bit))),
    1655             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",hge),batarg("b",int))),
    1656             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",hge),batarg("b",int),arg("nil_if_empty",bit))),
    1657             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",hge),batarg("b",int),batarg("s",oid))),
    1658             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",hge),batarg("b",int),batarg("s",oid),arg("nil_if_empty",bit))),
    1659             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",hge),batarg("b",lng))),
    1660             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",hge),batarg("b",lng),arg("nil_if_empty",bit))),
    1661             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",hge),batarg("b",lng),batarg("s",oid))),
    1662             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",hge),batarg("b",lng),batarg("s",oid),arg("nil_if_empty",bit))),
    1663             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",hge),batarg("b",hge))),
    1664             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",hge),batarg("b",hge),arg("nil_if_empty",bit))),
    1665             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",hge),batarg("b",hge),batarg("s",oid))),
    1666             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",hge),batarg("b",hge),batarg("s",oid),arg("nil_if_empty",bit))),
    1667             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",dbl),batarg("b",hge))),
    1668             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",dbl),batarg("b",hge),arg("nil_if_empty",bit))),
    1669             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",dbl),batarg("b",hge),batarg("s",oid))),
    1670             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",dbl),batarg("b",hge),batarg("s",oid),arg("nil_if_empty",bit))),
    1671             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",hge),batarg("b",bte))),
    1672             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",hge),batarg("b",bte),arg("nil_if_empty",bit))),
    1673             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",hge),batarg("b",bte),batarg("s",oid))),
    1674             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",hge),batarg("b",bte),batarg("s",oid),arg("nil_if_empty",bit))),
    1675             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",hge),batarg("b",sht))),
    1676             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",hge),batarg("b",sht),arg("nil_if_empty",bit))),
    1677             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",hge),batarg("b",sht),batarg("s",oid))),
    1678             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",hge),batarg("b",sht),batarg("s",oid),arg("nil_if_empty",bit))),
    1679             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",hge),batarg("b",int))),
    1680             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",hge),batarg("b",int),arg("nil_if_empty",bit))),
    1681             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",hge),batarg("b",int),batarg("s",oid))),
    1682             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",hge),batarg("b",int),batarg("s",oid),arg("nil_if_empty",bit))),
    1683             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",hge),batarg("b",lng))),
    1684             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",hge),batarg("b",lng),arg("nil_if_empty",bit))),
    1685             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",hge),batarg("b",lng),batarg("s",oid))),
    1686             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",hge),batarg("b",lng),batarg("s",oid),arg("nil_if_empty",bit))),
    1687             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",hge),batarg("b",hge))),
    1688             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",hge),batarg("b",hge),arg("nil_if_empty",bit))),
    1689             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",hge),batarg("b",hge),batarg("s",oid))),
    1690             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",hge),batarg("b",hge),batarg("s",oid),arg("nil_if_empty",bit))),
    1691             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",dbl),batarg("b",hge))),
    1692             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",dbl),batarg("b",hge),arg("nil_if_empty",bit))),
    1693             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",dbl),batarg("b",hge),batarg("s",oid))),
    1694             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",dbl),batarg("b",hge),batarg("s",oid),arg("nil_if_empty",bit))),
    1695             : #endif
    1696             : 
    1697             :  pattern("aggr", "avg", CMDBATavg3, false, "Calculate aggregate average of B.", args(3,6, arg("",bte),arg("",lng),arg("",lng),batarg("b",bte),batarg("s",oid),arg("skip_nils",bit))),
    1698             :  pattern("aggr", "avg", CMDBATavg3, false, "Calculate aggregate average of B.", args(3,6, arg("",sht),arg("",lng),arg("",lng),batarg("b",sht),batarg("s",oid),arg("skip_nils",bit))),
    1699             :  pattern("aggr", "avg", CMDBATavg3, false, "Calculate aggregate average of B.", args(3,6, arg("",int),arg("",lng),arg("",lng),batarg("b",int),batarg("s",oid),arg("skip_nils",bit))),
    1700             :  pattern("aggr", "avg", CMDBATavg3, false, "Calculate aggregate average of B.", args(3,6, arg("",lng),arg("",lng),arg("",lng),batarg("b",lng),batarg("s",oid),arg("skip_nils",bit))),
    1701             : #ifdef HAVE_HGE
    1702             :  pattern("aggr", "avg", CMDBATavg3, false, "Calculate aggregate average of B.", args(3,6, arg("",hge),arg("",lng),arg("",lng),batarg("b",hge),batarg("s",oid),arg("skip_nils",bit))),
    1703             : #endif
    1704             : 
    1705             :  pattern("aggr", "avg", CMDBATavg3comb, false, "Average aggregation combiner.", args(1,4, arg("",bte),batarg("b",bte),batarg("r",lng),batarg("c",lng))),
    1706             :  pattern("aggr", "avg", CMDBATavg3comb, false, "Average aggregation combiner.", args(1,4, arg("",sht),batarg("b",sht),batarg("r",lng),batarg("c",lng))),
    1707             :  pattern("aggr", "avg", CMDBATavg3comb, false, "Average aggregation combiner.", args(1,4, arg("",int),batarg("b",int),batarg("r",lng),batarg("c",lng))),
    1708             :  pattern("aggr", "avg", CMDBATavg3comb, false, "Average aggregation combiner.", args(1,4, arg("",lng),batarg("b",lng),batarg("r",lng),batarg("c",lng))),
    1709             : #ifdef HAVE_HGE
    1710             :  pattern("aggr", "avg", CMDBATavg3comb, false, "Average aggregation combiner.", args(1,4, arg("",hge),batarg("b",hge),batarg("r",lng),batarg("c",lng))),
    1711             : #endif
    1712             : 
    1713             :  /* calc ops from json */
    1714             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("l",json),arg("r",json))),
    1715             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("l",json),arg("r",json),arg("nil_matches",bit))),
    1716             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("l",json),arg("r",json))),
    1717             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("l",json),arg("r",json),arg("nil_matches",bit))),
    1718             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("l",json),arg("r",json))),
    1719             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("l",json),arg("r",json))),
    1720             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("l",json),arg("r",json))),
    1721             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("l",json),arg("r",json))),
    1722             :  /* calc ops from uuid */
    1723             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("l",uuid),arg("r",uuid))),
    1724             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("l",uuid),arg("r",uuid),arg("nil_matches",bit))),
    1725             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("l",uuid),arg("r",uuid))),
    1726             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("l",uuid),arg("r",uuid),arg("nil_matches",bit))),
    1727             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("l",uuid),arg("r",uuid))),
    1728             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("l",uuid),arg("r",uuid))),
    1729             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("l",uuid),arg("r",uuid))),
    1730             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("l",uuid),arg("r",uuid))),
    1731             :  /* calc ops from mtime */
    1732             :  pattern("calc", "==", CMDvarEQ, false, "Equality of two dates", args(1,3, arg("",bit),arg("v",date),arg("w",date))),
    1733             :  pattern("calc", "==", CMDvarEQ, false, "Equality of two dates", args(1,4, arg("",bit),arg("v",date),arg("w",date),arg("nil_matches",bit))),
    1734             :  pattern("calc", "!=", CMDvarNE, false, "Equality of two dates", args(1,3, arg("",bit),arg("v",date),arg("w",date))),
    1735             :  pattern("calc", "!=", CMDvarNE, false, "Equality of two dates", args(1,4, arg("",bit),arg("v",date),arg("w",date),arg("nil_matches",bit))),
    1736             :  pattern("calc", "<", CMDvarLT, false, "Equality of two dates", args(1,3, arg("",bit),arg("v",date),arg("w",date))),
    1737             :  pattern("calc", "<=", CMDvarLE, false, "Equality of two dates", args(1,3, arg("",bit),arg("v",date),arg("w",date))),
    1738             :  pattern("calc", ">", CMDvarGT, false, "Equality of two dates", args(1,3, arg("",bit),arg("v",date),arg("w",date))),
    1739             :  pattern("calc", ">=", CMDvarGE, false, "Equality of two dates", args(1,3, arg("",bit),arg("v",date),arg("w",date))),
    1740             :  pattern("calc", "==", CMDvarEQ, false, "Equality of two daytimes", args(1,3, arg("",bit),arg("v",daytime),arg("w",daytime))),
    1741             :  pattern("calc", "==", CMDvarEQ, false, "Equality of two daytimes", args(1,4, arg("",bit),arg("v",daytime),arg("w",daytime),arg("nil_matches",bit))),
    1742             :  pattern("calc", "!=", CMDvarNE, false, "Equality of two daytimes", args(1,3, arg("",bit),arg("v",daytime),arg("w",daytime))),
    1743             :  pattern("calc", "!=", CMDvarNE, false, "Equality of two daytimes", args(1,4, arg("",bit),arg("v",daytime),arg("w",daytime),arg("nil_matches",bit))),
    1744             :  pattern("calc", "<", CMDvarLT, false, "Equality of two daytimes", args(1,3, arg("",bit),arg("v",daytime),arg("w",daytime))),
    1745             :  pattern("calc", "<=", CMDvarLE, false, "Equality of two daytimes", args(1,3, arg("",bit),arg("v",daytime),arg("w",daytime))),
    1746             :  pattern("calc", ">", CMDvarGT, false, "Equality of two daytimes", args(1,3, arg("",bit),arg("v",daytime),arg("w",daytime))),
    1747             :  pattern("calc", ">=", CMDvarGE, false, "Equality of two daytimes", args(1,3, arg("",bit),arg("v",daytime),arg("w",daytime))),
    1748             :  pattern("calc", "==", CMDvarEQ, false, "Equality of two timestamps", args(1,3, arg("",bit),arg("v",timestamp),arg("w",timestamp))),
    1749             :  pattern("calc", "==", CMDvarEQ, false, "Equality of two timestamps", args(1,4, arg("",bit),arg("v",timestamp),arg("w",timestamp),arg("nil_matches",bit))),
    1750             :  pattern("calc", "!=", CMDvarNE, false, "Equality of two timestamps", args(1,3, arg("",bit),arg("v",timestamp),arg("w",timestamp))),
    1751             :  pattern("calc", "!=", CMDvarNE, false, "Equality of two timestamps", args(1,4, arg("",bit),arg("v",timestamp),arg("w",timestamp),arg("nil_matches",bit))),
    1752             :  pattern("calc", "<", CMDvarLT, false, "Equality of two timestamps", args(1,3, arg("",bit),arg("v",timestamp),arg("w",timestamp))),
    1753             :  pattern("calc", "<=", CMDvarLE, false, "Equality of two timestamps", args(1,3, arg("",bit),arg("v",timestamp),arg("w",timestamp))),
    1754             :  pattern("calc", ">", CMDvarGT, false, "Equality of two timestamps", args(1,3, arg("",bit),arg("v",timestamp),arg("w",timestamp))),
    1755             :  pattern("calc", ">=", CMDvarGE, false, "Equality of two timestamps", args(1,3, arg("",bit),arg("v",timestamp),arg("w",timestamp))),
    1756             :  /* calc ops from 01_calc.mal */
    1757             :  pattern("calc", "iszero", CMDvarISZERO, false, "Unary check for zero of V", args(1,2, arg("",bit),arg("v",bte))),
    1758             :  pattern("calc", "iszero", CMDvarISZERO, false, "Unary check for zero of V", args(1,2, arg("",bit),arg("v",sht))),
    1759             :  pattern("calc", "iszero", CMDvarISZERO, false, "Unary check for zero of V", args(1,2, arg("",bit),arg("v",int))),
    1760             :  pattern("calc", "iszero", CMDvarISZERO, false, "Unary check for zero of V", args(1,2, arg("",bit),arg("v",lng))),
    1761             :  pattern("calc", "iszero", CMDvarISZERO, false, "Unary check for zero of V", args(1,2, arg("",bit),arg("v",flt))),
    1762             :  pattern("calc", "iszero", CMDvarISZERO, false, "Unary check for zero of V", args(1,2, arg("",bit),arg("v",dbl))),
    1763             :  pattern("calc", "isnil", CMDvarISNIL, false, "Unary check for nil of V", args(1,2, arg("",bit),argany("v",0))),
    1764             :  pattern("calc", "isnotnil", CMDvarISNOTNIL, false, "Unary check for notnil of V", args(1,2, arg("",bit),argany("v",0))),
    1765             :  pattern("calc", "not", CMDvarNOT, false, "Return the Boolean inverse", args(1,2, arg("",bit),arg("v",bit))),
    1766             :  pattern("calc", "not", CMDvarNOT, false, "Unary bitwise not of V", args(1,2, arg("",bte),arg("v",bte))),
    1767             :  pattern("calc", "not", CMDvarNOT, false, "Unary bitwise not of V", args(1,2, arg("",sht),arg("v",sht))),
    1768             :  pattern("calc", "not", CMDvarNOT, false, "Unary bitwise not of V", args(1,2, arg("",int),arg("v",int))),
    1769             :  pattern("calc", "not", CMDvarNOT, false, "Unary bitwise not of V", args(1,2, arg("",lng),arg("v",lng))),
    1770             :  pattern("calc", "sign", CMDvarSIGN, false, "Unary sign (-1,0,1) of V", args(1,2, arg("",bte),arg("v",bte))),
    1771             :  pattern("calc", "sign", CMDvarSIGN, false, "Unary sign (-1,0,1) of V", args(1,2, arg("",bte),arg("v",sht))),
    1772             :  pattern("calc", "sign", CMDvarSIGN, false, "Unary sign (-1,0,1) of V", args(1,2, arg("",bte),arg("v",int))),
    1773             :  pattern("calc", "sign", CMDvarSIGN, false, "Unary sign (-1,0,1) of V", args(1,2, arg("",bte),arg("v",lng))),
    1774             :  pattern("calc", "sign", CMDvarSIGN, false, "Unary sign (-1,0,1) of V", args(1,2, arg("",bte),arg("v",flt))),
    1775             :  pattern("calc", "sign", CMDvarSIGN, false, "Unary sign (-1,0,1) of V", args(1,2, arg("",bte),arg("v",dbl))),
    1776             :  pattern("calc", "abs", CMDvarABS, false, "Unary absolute value of V", args(1,2, arg("",bte),arg("v",bte))),
    1777             :  pattern("calc", "abs", CMDvarABS, false, "Unary absolute value of V", args(1,2, arg("",sht),arg("v",sht))),
    1778             :  pattern("calc", "abs", CMDvarABS, false, "Unary absolute value of V", args(1,2, arg("",int),arg("v",int))),
    1779             :  pattern("calc", "abs", CMDvarABS, false, "Unary absolute value of V", args(1,2, arg("",lng),arg("v",lng))),
    1780             :  pattern("calc", "abs", CMDvarABS, false, "Unary absolute value of V", args(1,2, arg("",flt),arg("v",flt))),
    1781             :  pattern("calc", "abs", CMDvarABS, false, "Unary absolute value of V", args(1,2, arg("",dbl),arg("v",dbl))),
    1782             :  pattern("calc", "-", CMDvarNEG, false, "Unary negation of V", args(1,2, arg("",bte),arg("v",bte))),
    1783             :  pattern("calc", "-", CMDvarNEG, false, "Unary negation of V", args(1,2, arg("",sht),arg("v",sht))),
    1784             :  pattern("calc", "-", CMDvarNEG, false, "Unary negation of V", args(1,2, arg("",int),arg("v",int))),
    1785             :  pattern("calc", "-", CMDvarNEG, false, "Unary negation of V", args(1,2, arg("",lng),arg("v",lng))),
    1786             :  pattern("calc", "-", CMDvarNEG, false, "Unary negation of V", args(1,2, arg("",flt),arg("v",flt))),
    1787             :  pattern("calc", "-", CMDvarNEG, false, "Unary negation of V", args(1,2, arg("",dbl),arg("v",dbl))),
    1788             :  pattern("calc", "++", CMDvarINCRsignal, false, "Unary V + 1", args(1,2, arg("",bte),arg("v",bte))),
    1789             :  pattern("calc", "++", CMDvarINCRsignal, false, "Unary V + 1", args(1,2, arg("",sht),arg("v",sht))),
    1790             :  pattern("calc", "++", CMDvarINCRsignal, false, "Unary V + 1", args(1,2, arg("",int),arg("v",int))),
    1791             :  pattern("calc", "++", CMDvarINCRsignal, false, "Unary V + 1", args(1,2, arg("",lng),arg("v",lng))),
    1792             :  pattern("calc", "++", CMDvarINCRsignal, false, "Unary V + 1", args(1,2, arg("",flt),arg("v",flt))),
    1793             :  pattern("calc", "++", CMDvarINCRsignal, false, "Unary V + 1", args(1,2, arg("",dbl),arg("v",dbl))),
    1794             :  pattern("calc", "--", CMDvarDECRsignal, false, "Unary V - 1", args(1,2, arg("",bte),arg("v",bte))),
    1795             :  pattern("calc", "--", CMDvarDECRsignal, false, "Unary V - 1", args(1,2, arg("",sht),arg("v",sht))),
    1796             :  pattern("calc", "--", CMDvarDECRsignal, false, "Unary V - 1", args(1,2, arg("",int),arg("v",int))),
    1797             :  pattern("calc", "--", CMDvarDECRsignal, false, "Unary V - 1", args(1,2, arg("",lng),arg("v",lng))),
    1798             :  pattern("calc", "--", CMDvarDECRsignal, false, "Unary V - 1", args(1,2, arg("",flt),arg("v",flt))),
    1799             :  pattern("calc", "--", CMDvarDECRsignal, false, "Unary V - 1", args(1,2, arg("",dbl),arg("v",dbl))),
    1800             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",bte))),
    1801             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",bte))),
    1802             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",bte),arg("v2",bte))),
    1803             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",int),arg("v1",bte),arg("v2",bte))),
    1804             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",sht),arg("v1",bte),arg("v2",bte))),
    1805             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    1806             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    1807             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",sht))),
    1808             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",sht))),
    1809             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",bte),arg("v2",sht))),
    1810             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",int),arg("v1",bte),arg("v2",sht))),
    1811             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",bte),arg("v2",sht))),
    1812             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",sht))),
    1813             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",int))),
    1814             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",int))),
    1815             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",bte),arg("v2",int))),
    1816             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",int),arg("v1",bte),arg("v2",int))),
    1817             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",int))),
    1818             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",lng))),
    1819             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",lng))),
    1820             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",bte),arg("v2",lng))),
    1821             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",lng))),
    1822             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",flt))),
    1823             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",bte),arg("v2",flt))),
    1824             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",bte),arg("v2",flt))),
    1825             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",dbl))),
    1826             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",dbl))),
    1827             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",bte))),
    1828             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",bte))),
    1829             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",sht),arg("v2",bte))),
    1830             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",int),arg("v1",sht),arg("v2",bte))),
    1831             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    1832             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    1833             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",sht))),
    1834             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",sht))),
    1835             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",sht),arg("v2",sht))),
    1836             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",int),arg("v1",sht),arg("v2",sht))),
    1837             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    1838             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    1839             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",int))),
    1840             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",int))),
    1841             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",sht),arg("v2",int))),
    1842             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",int),arg("v1",sht),arg("v2",int))),
    1843             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",int))),
    1844             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",lng))),
    1845             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",lng))),
    1846             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",sht),arg("v2",lng))),
    1847             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",lng))),
    1848             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",flt))),
    1849             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",sht),arg("v2",flt))),
    1850             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",sht),arg("v2",flt))),
    1851             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",dbl))),
    1852             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",dbl))),
    1853             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",bte))),
    1854             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",bte))),
    1855             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",int),arg("v2",bte))),
    1856             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    1857             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    1858             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",sht))),
    1859             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",sht))),
    1860             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",int),arg("v2",sht))),
    1861             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    1862             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    1863             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",int))),
    1864             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",int))),
    1865             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",int),arg("v2",int))),
    1866             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    1867             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    1868             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",lng))),
    1869             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",lng))),
    1870             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",int),arg("v2",lng))),
    1871             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",lng))),
    1872             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",flt))),
    1873             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",int),arg("v2",flt))),
    1874             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",int),arg("v2",flt))),
    1875             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",int),arg("v2",dbl))),
    1876             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",int),arg("v2",dbl))),
    1877             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",bte))),
    1878             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",bte))),
    1879             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    1880             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    1881             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",sht))),
    1882             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",sht))),
    1883             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    1884             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    1885             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",int))),
    1886             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",int))),
    1887             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    1888             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    1889             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",lng))),
    1890             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",lng))),
    1891             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    1892             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    1893             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",flt))),
    1894             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",lng),arg("v2",flt))),
    1895             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",lng),arg("v2",flt))),
    1896             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",dbl))),
    1897             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",dbl))),
    1898             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",bte))),
    1899             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",bte))),
    1900             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",bte))),
    1901             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",sht))),
    1902             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",sht))),
    1903             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",sht))),
    1904             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",int))),
    1905             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",int))),
    1906             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",int))),
    1907             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",lng))),
    1908             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",lng))),
    1909             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",lng))),
    1910             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",flt))),
    1911             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",flt))),
    1912             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",flt))),
    1913             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",dbl))),
    1914             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",dbl))),
    1915             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",bte))),
    1916             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",bte))),
    1917             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",sht))),
    1918             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",sht))),
    1919             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",int))),
    1920             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",int))),
    1921             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",lng))),
    1922             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",lng))),
    1923             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",flt))),
    1924             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",flt))),
    1925             :  pattern("calc", "+", CMDvarADDsignal, false, "Return V1 + V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",dbl))),
    1926             :  pattern("calc", "add_noerror", CMDvarADD, false, "Return V1 + V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",dbl))),
    1927             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",bte))),
    1928             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",bte))),
    1929             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",bte),arg("v2",bte))),
    1930             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",int),arg("v1",bte),arg("v2",bte))),
    1931             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",sht),arg("v1",bte),arg("v2",bte))),
    1932             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    1933             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    1934             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",sht))),
    1935             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",sht))),
    1936             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",bte),arg("v2",sht))),
    1937             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",int),arg("v1",bte),arg("v2",sht))),
    1938             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",bte),arg("v2",sht))),
    1939             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",sht))),
    1940             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",int))),
    1941             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",int))),
    1942             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",bte),arg("v2",int))),
    1943             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",int),arg("v1",bte),arg("v2",int))),
    1944             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",int))),
    1945             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",lng))),
    1946             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",lng))),
    1947             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",bte),arg("v2",lng))),
    1948             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",lng))),
    1949             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",flt))),
    1950             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",bte),arg("v2",flt))),
    1951             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",bte),arg("v2",flt))),
    1952             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",dbl))),
    1953             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",dbl))),
    1954             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",bte))),
    1955             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",bte))),
    1956             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",sht),arg("v2",bte))),
    1957             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",int),arg("v1",sht),arg("v2",bte))),
    1958             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    1959             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    1960             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",sht))),
    1961             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",sht))),
    1962             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",sht),arg("v2",sht))),
    1963             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",int),arg("v1",sht),arg("v2",sht))),
    1964             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    1965             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    1966             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",int))),
    1967             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",int))),
    1968             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",sht),arg("v2",int))),
    1969             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",int),arg("v1",sht),arg("v2",int))),
    1970             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",int))),
    1971             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",lng))),
    1972             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",lng))),
    1973             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",sht),arg("v2",lng))),
    1974             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",lng))),
    1975             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",flt))),
    1976             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",sht),arg("v2",flt))),
    1977             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",sht),arg("v2",flt))),
    1978             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",dbl))),
    1979             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",dbl))),
    1980             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",bte))),
    1981             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",bte))),
    1982             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",int),arg("v2",bte))),
    1983             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    1984             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    1985             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",sht))),
    1986             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",sht))),
    1987             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",int),arg("v2",sht))),
    1988             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    1989             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    1990             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",int))),
    1991             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",int))),
    1992             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",int),arg("v2",int))),
    1993             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    1994             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    1995             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",lng))),
    1996             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",lng))),
    1997             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",int),arg("v2",lng))),
    1998             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",lng))),
    1999             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",flt))),
    2000             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",int),arg("v2",flt))),
    2001             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",int),arg("v2",flt))),
    2002             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",int),arg("v2",dbl))),
    2003             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",int),arg("v2",dbl))),
    2004             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",bte))),
    2005             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",bte))),
    2006             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    2007             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    2008             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",sht))),
    2009             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",sht))),
    2010             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    2011             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    2012             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",int))),
    2013             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",int))),
    2014             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    2015             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    2016             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",lng))),
    2017             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",lng))),
    2018             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2019             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2020             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",flt))),
    2021             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",lng),arg("v2",flt))),
    2022             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",lng),arg("v2",flt))),
    2023             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",dbl))),
    2024             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",dbl))),
    2025             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",bte))),
    2026             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",bte))),
    2027             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",bte))),
    2028             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",sht))),
    2029             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",sht))),
    2030             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",sht))),
    2031             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",int))),
    2032             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",int))),
    2033             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",int))),
    2034             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",lng))),
    2035             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",lng))),
    2036             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",lng))),
    2037             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",flt))),
    2038             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",flt))),
    2039             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",flt))),
    2040             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",dbl))),
    2041             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",dbl))),
    2042             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",bte))),
    2043             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",bte))),
    2044             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",sht))),
    2045             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",sht))),
    2046             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",int))),
    2047             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",int))),
    2048             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",lng))),
    2049             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",lng))),
    2050             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",flt))),
    2051             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",flt))),
    2052             :  pattern("calc", "-", CMDvarSUBsignal, false, "Return V1 - V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",dbl))),
    2053             :  pattern("calc", "sub_noerror", CMDvarSUB, false, "Return V1 - V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",dbl))),
    2054             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",bte))),
    2055             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",bte))),
    2056             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",bte),arg("v2",bte))),
    2057             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",int),arg("v1",bte),arg("v2",bte))),
    2058             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",sht),arg("v1",bte),arg("v2",bte))),
    2059             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2060             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2061             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",sht))),
    2062             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",sht))),
    2063             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",bte),arg("v2",sht))),
    2064             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",int),arg("v1",bte),arg("v2",sht))),
    2065             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",bte),arg("v2",sht))),
    2066             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",sht))),
    2067             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",int))),
    2068             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",int))),
    2069             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",bte),arg("v2",int))),
    2070             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",bte),arg("v2",int))),
    2071             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",int))),
    2072             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",lng))),
    2073             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",bte),arg("v2",lng))),
    2074             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",bte),arg("v2",lng))),
    2075             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",lng))),
    2076             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",flt))),
    2077             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",bte),arg("v2",flt))),
    2078             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",bte),arg("v2",flt))),
    2079             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",dbl))),
    2080             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",dbl))),
    2081             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",bte))),
    2082             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",bte))),
    2083             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",sht),arg("v2",bte))),
    2084             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",int),arg("v1",sht),arg("v2",bte))),
    2085             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    2086             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    2087             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",sht))),
    2088             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",sht))),
    2089             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",sht),arg("v2",sht))),
    2090             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",int),arg("v1",sht),arg("v2",sht))),
    2091             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2092             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2093             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",int))),
    2094             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",int))),
    2095             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",sht),arg("v2",int))),
    2096             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",sht),arg("v2",int))),
    2097             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",int))),
    2098             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",lng))),
    2099             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",sht),arg("v2",lng))),
    2100             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",sht),arg("v2",lng))),
    2101             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",lng))),
    2102             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",flt))),
    2103             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",sht),arg("v2",flt))),
    2104             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",sht),arg("v2",flt))),
    2105             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",dbl))),
    2106             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",dbl))),
    2107             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",bte))),
    2108             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",bte))),
    2109             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",int),arg("v2",bte))),
    2110             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    2111             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    2112             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",sht))),
    2113             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",sht))),
    2114             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",int),arg("v2",sht))),
    2115             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    2116             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    2117             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",int))),
    2118             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",int))),
    2119             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",lng),arg("v1",int),arg("v2",int))),
    2120             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2121             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2122             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",lng))),
    2123             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",int),arg("v2",lng))),
    2124             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",int),arg("v2",lng))),
    2125             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",lng))),
    2126             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",int),arg("v2",flt))),
    2127             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",int),arg("v2",flt))),
    2128             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",int),arg("v2",flt))),
    2129             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",int),arg("v2",dbl))),
    2130             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",int),arg("v2",dbl))),
    2131             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",bte))),
    2132             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",bte))),
    2133             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    2134             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    2135             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",sht))),
    2136             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",sht))),
    2137             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    2138             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    2139             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",int))),
    2140             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",int))),
    2141             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    2142             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    2143             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",lng))),
    2144             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",flt),arg("v1",lng),arg("v2",lng))),
    2145             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2146             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2147             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",flt))),
    2148             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",lng),arg("v2",flt))),
    2149             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",lng),arg("v2",flt))),
    2150             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",dbl))),
    2151             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",dbl))),
    2152             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",bte))),
    2153             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",bte))),
    2154             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",bte))),
    2155             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",sht))),
    2156             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",sht))),
    2157             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",sht))),
    2158             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",int))),
    2159             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",int))),
    2160             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",int))),
    2161             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",lng))),
    2162             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",lng))),
    2163             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",lng))),
    2164             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, guarantee no overflow by returning larger type", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",flt))),
    2165             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",flt),arg("v1",flt),arg("v2",flt))),
    2166             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",flt))),
    2167             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",dbl))),
    2168             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",dbl))),
    2169             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",bte))),
    2170             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",bte))),
    2171             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",sht))),
    2172             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",sht))),
    2173             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",int))),
    2174             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",int))),
    2175             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",lng))),
    2176             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",lng))),
    2177             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",flt))),
    2178             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",flt))),
    2179             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",dbl))),
    2180             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",dbl))),
    2181             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",bte),arg("v2",flt))),
    2182             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",flt))),
    2183             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",sht),arg("v2",flt))),
    2184             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",sht),arg("v2",flt))),
    2185             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",bte),arg("v2",flt))),
    2186             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",flt))),
    2187             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",sht),arg("v2",flt))),
    2188             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",flt))),
    2189             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",int),arg("v2",flt))),
    2190             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",int),arg("v2",flt))),
    2191             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",int),arg("v2",flt))),
    2192             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",int),arg("v2",flt))),
    2193             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",bte),arg("v2",flt))),
    2194             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",flt))),
    2195             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",sht),arg("v2",flt))),
    2196             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",flt))),
    2197             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",int),arg("v2",flt))),
    2198             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",flt))),
    2199             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",lng),arg("v2",flt))),
    2200             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",lng),arg("v2",flt))),
    2201             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",lng),arg("v2",flt))),
    2202             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",lng),arg("v2",flt))),
    2203             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",lng),arg("v2",flt))),
    2204             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",lng),arg("v2",flt))),
    2205             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",bte),arg("v2",flt))),
    2206             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",flt))),
    2207             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",sht),arg("v2",flt))),
    2208             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",flt))),
    2209             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",int),arg("v2",flt))),
    2210             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",flt))),
    2211             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",flt))),
    2212             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",flt))),
    2213             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",flt),arg("v2",bte))),
    2214             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",flt),arg("v2",bte))),
    2215             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",flt),arg("v2",sht))),
    2216             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",flt),arg("v2",sht))),
    2217             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",flt),arg("v2",bte))),
    2218             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",flt),arg("v2",bte))),
    2219             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",flt),arg("v2",sht))),
    2220             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",flt),arg("v2",sht))),
    2221             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",flt),arg("v2",int))),
    2222             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",flt),arg("v2",int))),
    2223             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",flt),arg("v2",int))),
    2224             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",flt),arg("v2",int))),
    2225             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",flt),arg("v2",bte))),
    2226             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",flt),arg("v2",bte))),
    2227             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",flt),arg("v2",sht))),
    2228             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",flt),arg("v2",sht))),
    2229             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",flt),arg("v2",int))),
    2230             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",flt),arg("v2",int))),
    2231             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",flt),arg("v2",lng))),
    2232             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",flt),arg("v2",lng))),
    2233             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",flt),arg("v2",lng))),
    2234             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",flt),arg("v2",lng))),
    2235             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",flt),arg("v2",lng))),
    2236             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",flt),arg("v2",lng))),
    2237             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",flt),arg("v2",bte))),
    2238             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",flt),arg("v2",bte))),
    2239             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",flt),arg("v2",sht))),
    2240             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",flt),arg("v2",sht))),
    2241             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",flt),arg("v2",int))),
    2242             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",flt),arg("v2",int))),
    2243             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",flt),arg("v2",lng))),
    2244             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",flt),arg("v2",lng))),
    2245             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",bte),arg("v2",dbl))),
    2246             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",dbl))),
    2247             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",sht),arg("v2",dbl))),
    2248             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",sht),arg("v2",dbl))),
    2249             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",bte),arg("v2",dbl))),
    2250             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",dbl))),
    2251             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",sht),arg("v2",dbl))),
    2252             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",dbl))),
    2253             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",int),arg("v2",dbl))),
    2254             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",int),arg("v2",dbl))),
    2255             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",int),arg("v2",dbl))),
    2256             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",int),arg("v2",dbl))),
    2257             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",bte),arg("v2",dbl))),
    2258             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",dbl))),
    2259             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",sht),arg("v2",dbl))),
    2260             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",dbl))),
    2261             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",int),arg("v2",dbl))),
    2262             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",dbl))),
    2263             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",lng),arg("v2",dbl))),
    2264             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",lng),arg("v2",dbl))),
    2265             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",lng),arg("v2",dbl))),
    2266             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",lng),arg("v2",dbl))),
    2267             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",lng),arg("v2",dbl))),
    2268             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",lng),arg("v2",dbl))),
    2269             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",bte),arg("v2",dbl))),
    2270             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",dbl))),
    2271             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",sht),arg("v2",dbl))),
    2272             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",dbl))),
    2273             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",int),arg("v2",dbl))),
    2274             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",dbl))),
    2275             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",lng),arg("v2",dbl))),
    2276             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",dbl))),
    2277             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",bte))),
    2278             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",bte))),
    2279             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",sht))),
    2280             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",sht))),
    2281             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",dbl),arg("v2",bte))),
    2282             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",dbl),arg("v2",bte))),
    2283             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",dbl),arg("v2",sht))),
    2284             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",dbl),arg("v2",sht))),
    2285             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",int))),
    2286             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",int))),
    2287             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",dbl),arg("v2",int))),
    2288             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",dbl),arg("v2",int))),
    2289             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",dbl),arg("v2",bte))),
    2290             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",dbl),arg("v2",bte))),
    2291             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",dbl),arg("v2",sht))),
    2292             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",dbl),arg("v2",sht))),
    2293             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",dbl),arg("v2",int))),
    2294             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",dbl),arg("v2",int))),
    2295             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",lng))),
    2296             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",lng))),
    2297             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",sht),arg("v1",dbl),arg("v2",lng))),
    2298             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",sht),arg("v1",dbl),arg("v2",lng))),
    2299             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",int),arg("v1",dbl),arg("v2",lng))),
    2300             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",int),arg("v1",dbl),arg("v2",lng))),
    2301             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",dbl),arg("v2",bte))),
    2302             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",dbl),arg("v2",bte))),
    2303             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",dbl),arg("v2",sht))),
    2304             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",dbl),arg("v2",sht))),
    2305             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",dbl),arg("v2",int))),
    2306             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",dbl),arg("v2",int))),
    2307             :  pattern("calc", "*", CMDvarMULsignal, false, "Return V1 * V2, signal error on overflow", args(1,3, arg("",lng),arg("v1",dbl),arg("v2",lng))),
    2308             :  pattern("calc", "mul_noerror", CMDvarMUL, false, "Return V1 * V2, overflow results in NIL value", args(1,3, arg("",lng),arg("v1",dbl),arg("v2",lng))),
    2309             :  command("calc", "+", CMDvarADDstr, false, "Concatenate LEFT and RIGHT", args(1,3, arg("",str),arg("v1",str),arg("v2",str))),
    2310             :  command("calc", "+", CMDvarADDstrint, false, "Concatenate LEFT and string representation of RIGHT", args(1,3, arg("",str),arg("v1",str),arg("i",int))),
    2311             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",bte))),
    2312             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",bte))),
    2313             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",bte),arg("v2",bte))),
    2314             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",bte),arg("v2",bte))),
    2315             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",bte),arg("v2",bte))),
    2316             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",bte))),
    2317             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",bte),arg("v2",bte))),
    2318             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",bte))),
    2319             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",bte),arg("v2",bte))),
    2320             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",bte))),
    2321             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2322             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2323             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",sht))),
    2324             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",sht))),
    2325             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",bte),arg("v2",sht))),
    2326             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",bte),arg("v2",sht))),
    2327             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",bte),arg("v2",sht))),
    2328             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",sht))),
    2329             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",bte),arg("v2",sht))),
    2330             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",sht))),
    2331             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",bte),arg("v2",sht))),
    2332             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",sht))),
    2333             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",bte),arg("v2",sht))),
    2334             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",sht))),
    2335             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",int))),
    2336             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",int))),
    2337             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",bte),arg("v2",int))),
    2338             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",bte),arg("v2",int))),
    2339             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",bte),arg("v2",int))),
    2340             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",int))),
    2341             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",bte),arg("v2",int))),
    2342             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",int))),
    2343             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",bte),arg("v2",int))),
    2344             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",int))),
    2345             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",bte),arg("v2",int))),
    2346             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",int))),
    2347             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",lng))),
    2348             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",lng))),
    2349             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",bte),arg("v2",lng))),
    2350             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",bte),arg("v2",lng))),
    2351             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",bte),arg("v2",lng))),
    2352             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",lng))),
    2353             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",bte),arg("v2",lng))),
    2354             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",lng))),
    2355             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",bte),arg("v2",lng))),
    2356             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",lng))),
    2357             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",bte),arg("v2",lng))),
    2358             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",lng))),
    2359             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",flt))),
    2360             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",flt))),
    2361             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",bte),arg("v2",flt))),
    2362             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",bte),arg("v2",flt))),
    2363             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",bte),arg("v2",flt))),
    2364             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",flt))),
    2365             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",bte),arg("v2",flt))),
    2366             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",flt))),
    2367             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",bte),arg("v2",flt))),
    2368             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",flt))),
    2369             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",bte),arg("v2",flt))),
    2370             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",flt))),
    2371             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",dbl))),
    2372             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",dbl))),
    2373             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",bte),arg("v2",dbl))),
    2374             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",bte),arg("v2",dbl))),
    2375             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",bte),arg("v2",dbl))),
    2376             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",dbl))),
    2377             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",bte),arg("v2",dbl))),
    2378             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",dbl))),
    2379             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",bte),arg("v2",dbl))),
    2380             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",dbl))),
    2381             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",bte),arg("v2",dbl))),
    2382             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",dbl))),
    2383             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",bte))),
    2384             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",bte))),
    2385             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",sht),arg("v2",bte))),
    2386             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",sht),arg("v2",bte))),
    2387             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",sht),arg("v2",bte))),
    2388             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",bte))),
    2389             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",sht),arg("v2",bte))),
    2390             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",bte))),
    2391             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    2392             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    2393             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",sht))),
    2394             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",sht))),
    2395             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",sht),arg("v2",sht))),
    2396             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",sht),arg("v2",sht))),
    2397             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",sht),arg("v2",sht))),
    2398             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",sht))),
    2399             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",sht),arg("v2",sht))),
    2400             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",sht))),
    2401             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2402             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2403             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",int))),
    2404             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",int))),
    2405             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",sht),arg("v2",int))),
    2406             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",sht),arg("v2",int))),
    2407             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",sht),arg("v2",int))),
    2408             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",int))),
    2409             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",sht),arg("v2",int))),
    2410             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",int))),
    2411             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",sht),arg("v2",int))),
    2412             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",int))),
    2413             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",lng))),
    2414             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",lng))),
    2415             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",sht),arg("v2",lng))),
    2416             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",sht),arg("v2",lng))),
    2417             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",sht),arg("v2",lng))),
    2418             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",lng))),
    2419             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",sht),arg("v2",lng))),
    2420             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",lng))),
    2421             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",sht),arg("v2",lng))),
    2422             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",lng))),
    2423             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",flt))),
    2424             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",flt))),
    2425             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",sht),arg("v2",flt))),
    2426             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",sht),arg("v2",flt))),
    2427             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",sht),arg("v2",flt))),
    2428             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",flt))),
    2429             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",sht),arg("v2",flt))),
    2430             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",flt))),
    2431             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",sht),arg("v2",flt))),
    2432             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",flt))),
    2433             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",dbl))),
    2434             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",dbl))),
    2435             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",sht),arg("v2",dbl))),
    2436             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",sht),arg("v2",dbl))),
    2437             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",sht),arg("v2",dbl))),
    2438             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",dbl))),
    2439             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",sht),arg("v2",dbl))),
    2440             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",dbl))),
    2441             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",sht),arg("v2",dbl))),
    2442             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",dbl))),
    2443             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",int),arg("v2",bte))),
    2444             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",int),arg("v2",bte))),
    2445             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",int),arg("v2",bte))),
    2446             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",int),arg("v2",bte))),
    2447             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",int),arg("v2",bte))),
    2448             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",bte))),
    2449             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    2450             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    2451             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",int),arg("v2",sht))),
    2452             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",int),arg("v2",sht))),
    2453             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",int),arg("v2",sht))),
    2454             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",int),arg("v2",sht))),
    2455             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",int),arg("v2",sht))),
    2456             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",sht))),
    2457             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    2458             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    2459             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",int),arg("v2",int))),
    2460             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",int),arg("v2",int))),
    2461             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",int),arg("v2",int))),
    2462             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",int),arg("v2",int))),
    2463             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",int),arg("v2",int))),
    2464             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",int))),
    2465             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2466             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2467             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",int),arg("v2",lng))),
    2468             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",int),arg("v2",lng))),
    2469             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",int),arg("v2",lng))),
    2470             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",int),arg("v2",lng))),
    2471             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",int),arg("v2",lng))),
    2472             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",lng))),
    2473             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",int),arg("v2",lng))),
    2474             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",lng))),
    2475             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",int),arg("v2",flt))),
    2476             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",int),arg("v2",flt))),
    2477             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",int),arg("v2",flt))),
    2478             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",int),arg("v2",flt))),
    2479             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",int),arg("v2",flt))),
    2480             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",flt))),
    2481             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",int),arg("v2",flt))),
    2482             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",flt))),
    2483             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",int),arg("v2",dbl))),
    2484             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",int),arg("v2",dbl))),
    2485             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",int),arg("v2",dbl))),
    2486             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",int),arg("v2",dbl))),
    2487             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",int),arg("v2",dbl))),
    2488             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",dbl))),
    2489             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",int),arg("v2",dbl))),
    2490             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",dbl))),
    2491             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",bte))),
    2492             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",bte))),
    2493             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",lng),arg("v2",bte))),
    2494             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",lng),arg("v2",bte))),
    2495             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    2496             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    2497             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",sht))),
    2498             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",sht))),
    2499             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",lng),arg("v2",sht))),
    2500             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",lng),arg("v2",sht))),
    2501             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    2502             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    2503             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",int))),
    2504             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",int))),
    2505             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",lng),arg("v2",int))),
    2506             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",lng),arg("v2",int))),
    2507             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    2508             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    2509             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",lng))),
    2510             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",lng))),
    2511             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",lng),arg("v2",lng))),
    2512             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",lng),arg("v2",lng))),
    2513             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2514             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2515             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",flt))),
    2516             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",flt))),
    2517             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",lng),arg("v2",flt))),
    2518             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",lng),arg("v2",flt))),
    2519             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",lng),arg("v2",flt))),
    2520             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",flt))),
    2521             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",dbl))),
    2522             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",dbl))),
    2523             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",lng),arg("v2",dbl))),
    2524             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",lng),arg("v2",dbl))),
    2525             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",lng),arg("v2",dbl))),
    2526             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",dbl))),
    2527             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",bte))),
    2528             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",bte))),
    2529             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",bte))),
    2530             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",bte))),
    2531             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",sht))),
    2532             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",sht))),
    2533             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",sht))),
    2534             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",sht))),
    2535             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",int))),
    2536             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",int))),
    2537             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",int))),
    2538             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",int))),
    2539             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",lng))),
    2540             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",lng))),
    2541             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",lng))),
    2542             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",lng))),
    2543             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",flt))),
    2544             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",flt))),
    2545             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",flt))),
    2546             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",flt))),
    2547             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",dbl))),
    2548             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",dbl))),
    2549             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",dbl))),
    2550             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",dbl))),
    2551             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",bte))),
    2552             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",bte))),
    2553             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",sht))),
    2554             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",sht))),
    2555             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",int))),
    2556             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",int))),
    2557             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",lng))),
    2558             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",lng))),
    2559             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",flt))),
    2560             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",flt))),
    2561             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",dbl))),
    2562             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",dbl))),
    2563             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",flt),arg("v2",bte))),
    2564             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",flt),arg("v2",bte))),
    2565             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",flt),arg("v2",sht))),
    2566             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",flt),arg("v2",sht))),
    2567             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",flt),arg("v2",int))),
    2568             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",flt),arg("v2",int))),
    2569             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",flt),arg("v2",lng))),
    2570             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",flt),arg("v2",lng))),
    2571             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",bte))),
    2572             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",bte))),
    2573             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",dbl),arg("v2",sht))),
    2574             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",dbl),arg("v2",sht))),
    2575             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",dbl),arg("v2",int))),
    2576             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",dbl),arg("v2",int))),
    2577             :  pattern("calc", "/", CMDvarDIVsignal, false, "Return V1 / V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",dbl),arg("v2",lng))),
    2578             :  pattern("calc", "div_noerror", CMDvarDIV, false, "Return V1 / V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",dbl),arg("v2",lng))),
    2579             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",bte),arg("v2",bte))),
    2580             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",bte))),
    2581             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",bte),arg("v2",bte))),
    2582             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",bte))),
    2583             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",bte),arg("v2",bte))),
    2584             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",bte))),
    2585             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2586             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2587             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",bte),arg("v2",sht))),
    2588             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",sht))),
    2589             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",bte),arg("v2",sht))),
    2590             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",sht))),
    2591             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",bte),arg("v2",sht))),
    2592             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",sht))),
    2593             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",bte),arg("v2",sht))),
    2594             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",sht))),
    2595             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",bte),arg("v2",int))),
    2596             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",int))),
    2597             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",bte),arg("v2",int))),
    2598             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",int))),
    2599             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",bte),arg("v2",int))),
    2600             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",int))),
    2601             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",bte),arg("v2",int))),
    2602             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",int))),
    2603             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",bte),arg("v2",lng))),
    2604             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",bte),arg("v2",lng))),
    2605             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",bte),arg("v2",lng))),
    2606             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",bte),arg("v2",lng))),
    2607             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",bte),arg("v2",lng))),
    2608             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",bte),arg("v2",lng))),
    2609             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",bte),arg("v2",lng))),
    2610             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",lng))),
    2611             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",bte),arg("v2",flt))),
    2612             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",bte),arg("v2",flt))),
    2613             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",dbl))),
    2614             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",bte),arg("v2",dbl))),
    2615             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",sht),arg("v2",bte))),
    2616             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",bte))),
    2617             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",sht),arg("v2",bte))),
    2618             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",bte))),
    2619             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    2620             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    2621             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",sht),arg("v2",bte))),
    2622             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",sht),arg("v2",bte))),
    2623             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",sht),arg("v2",sht))),
    2624             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",sht))),
    2625             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",sht),arg("v2",sht))),
    2626             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",sht))),
    2627             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2628             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2629             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",sht),arg("v2",int))),
    2630             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",int))),
    2631             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",sht),arg("v2",int))),
    2632             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",int))),
    2633             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",sht),arg("v2",int))),
    2634             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",int))),
    2635             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",sht),arg("v2",lng))),
    2636             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",sht),arg("v2",lng))),
    2637             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",sht),arg("v2",lng))),
    2638             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",sht),arg("v2",lng))),
    2639             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",sht),arg("v2",lng))),
    2640             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",lng))),
    2641             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",sht),arg("v2",flt))),
    2642             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",sht),arg("v2",flt))),
    2643             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",dbl))),
    2644             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",sht),arg("v2",dbl))),
    2645             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",int),arg("v2",bte))),
    2646             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",bte))),
    2647             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    2648             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    2649             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",int),arg("v2",bte))),
    2650             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",int),arg("v2",bte))),
    2651             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",int),arg("v2",bte))),
    2652             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",int),arg("v2",bte))),
    2653             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",int),arg("v2",sht))),
    2654             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",sht))),
    2655             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    2656             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    2657             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",int),arg("v2",sht))),
    2658             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",int),arg("v2",sht))),
    2659             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",int),arg("v2",int))),
    2660             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",int))),
    2661             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2662             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2663             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",int),arg("v2",lng))),
    2664             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",int),arg("v2",lng))),
    2665             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",int),arg("v2",lng))),
    2666             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",lng))),
    2667             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",int),arg("v2",flt))),
    2668             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",int),arg("v2",flt))),
    2669             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",int),arg("v2",dbl))),
    2670             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",int),arg("v2",dbl))),
    2671             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    2672             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    2673             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",lng),arg("v2",bte))),
    2674             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",lng),arg("v2",bte))),
    2675             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",lng),arg("v2",bte))),
    2676             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",lng),arg("v2",bte))),
    2677             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",bte),arg("v1",lng),arg("v2",bte))),
    2678             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",bte),arg("v1",lng),arg("v2",bte))),
    2679             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    2680             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    2681             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",lng),arg("v2",sht))),
    2682             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",lng),arg("v2",sht))),
    2683             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",sht),arg("v1",lng),arg("v2",sht))),
    2684             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",sht),arg("v1",lng),arg("v2",sht))),
    2685             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    2686             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    2687             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",int),arg("v1",lng),arg("v2",int))),
    2688             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",int),arg("v1",lng),arg("v2",int))),
    2689             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2690             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2691             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",lng),arg("v2",flt))),
    2692             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",lng),arg("v2",flt))),
    2693             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",dbl))),
    2694             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",lng),arg("v2",dbl))),
    2695             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",bte))),
    2696             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",bte))),
    2697             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",sht))),
    2698             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",sht))),
    2699             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",int))),
    2700             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",int))),
    2701             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",lng))),
    2702             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",lng))),
    2703             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",flt),arg("v1",flt),arg("v2",flt))),
    2704             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",flt),arg("v1",flt),arg("v2",flt))),
    2705             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",dbl))),
    2706             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",flt),arg("v2",dbl))),
    2707             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",bte))),
    2708             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",bte))),
    2709             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",sht))),
    2710             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",sht))),
    2711             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",int))),
    2712             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",int))),
    2713             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",lng))),
    2714             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",lng))),
    2715             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",flt))),
    2716             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",flt))),
    2717             :  pattern("calc", "%", CMDvarMODsignal, false, "Return V1 % V2, signal error on divide by zero", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",dbl))),
    2718             :  pattern("calc", "mod_noerror", CMDvarMOD, false, "Return V1 % V2, divide by zero results in NIL value", args(1,3, arg("",dbl),arg("v1",dbl),arg("v2",dbl))),
    2719             :  pattern("mmath", "fmod", CMDvarMODsignal, false, "", args(1,3, arg("",flt),arg("y",flt),arg("x",flt))),
    2720             :  pattern("mmath", "fmod", CMDvarMODsignal, false, "The fmod(x,y) function computes the remainder of dividing x by y.\nThe return value is x - n * y, where n is the quotient of x / y,\nrounded towards zero to an integer.", args(1,3, arg("",dbl),arg("y",dbl),arg("x",dbl))),
    2721             :  pattern("calc", "and", CMDvarAND, false, "Return V1 AND V2", args(1,3, arg("",bit),arg("v1",bit),arg("v2",bit))),
    2722             :  pattern("calc", "and", CMDvarAND, false, "Return V1 AND V2", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2723             :  pattern("calc", "and", CMDvarAND, false, "Return V1 AND V2", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2724             :  pattern("calc", "and", CMDvarAND, false, "Return V1 AND V2", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2725             :  pattern("calc", "and", CMDvarAND, false, "Return V1 AND V2", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2726             :  pattern("calc", "or", CMDvarOR, false, "Return V1 OR V2", args(1,3, arg("",bit),arg("v1",bit),arg("v2",bit))),
    2727             :  pattern("calc", "or", CMDvarOR, false, "Return V1 OR V2", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2728             :  pattern("calc", "or", CMDvarOR, false, "Return V1 OR V2", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2729             :  pattern("calc", "or", CMDvarOR, false, "Return V1 OR V2", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2730             :  pattern("calc", "or", CMDvarOR, false, "Return V1 OR V2", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2731             :  pattern("calc", "xor", CMDvarXOR, false, "Return V1 XOR V2", args(1,3, arg("",bit),arg("v1",bit),arg("v2",bit))),
    2732             :  pattern("calc", "xor", CMDvarXOR, false, "Return V1 XOR V2", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2733             :  pattern("calc", "xor", CMDvarXOR, false, "Return V1 XOR V2", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2734             :  pattern("calc", "xor", CMDvarXOR, false, "Return V1 XOR V2", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2735             :  pattern("calc", "xor", CMDvarXOR, false, "Return V1 XOR V2", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2736             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2737             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2738             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",bte),arg("v1",bte),arg("v2",sht))),
    2739             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",sht))),
    2740             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",bte),arg("v1",bte),arg("v2",int))),
    2741             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",int))),
    2742             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",bte),arg("v1",bte),arg("v2",lng))),
    2743             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",lng))),
    2744             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    2745             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    2746             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2747             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2748             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",sht),arg("v1",sht),arg("v2",int))),
    2749             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",int))),
    2750             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",sht),arg("v1",sht),arg("v2",lng))),
    2751             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",lng))),
    2752             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    2753             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    2754             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    2755             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    2756             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2757             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2758             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",int),arg("v1",int),arg("v2",lng))),
    2759             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",lng))),
    2760             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    2761             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    2762             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    2763             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    2764             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    2765             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    2766             :  pattern("calc", "<<", CMDvarLSHsignal, false, "Return V1 << V2, raise error on out of range second operand", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2767             :  pattern("calc", "lsh_noerror", CMDvarLSH, false, "Return V1 << V2, out of range second operand results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2768             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2769             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    2770             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",bte),arg("v1",bte),arg("v2",sht))),
    2771             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",sht))),
    2772             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",bte),arg("v1",bte),arg("v2",int))),
    2773             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",int))),
    2774             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",bte),arg("v1",bte),arg("v2",lng))),
    2775             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",bte),arg("v1",bte),arg("v2",lng))),
    2776             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    2777             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",bte))),
    2778             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2779             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",sht))),
    2780             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",sht),arg("v1",sht),arg("v2",int))),
    2781             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",int))),
    2782             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",sht),arg("v1",sht),arg("v2",lng))),
    2783             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",sht),arg("v1",sht),arg("v2",lng))),
    2784             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    2785             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",bte))),
    2786             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    2787             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",sht))),
    2788             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2789             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",int))),
    2790             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",int),arg("v1",int),arg("v2",lng))),
    2791             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",int),arg("v1",int),arg("v2",lng))),
    2792             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    2793             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",bte))),
    2794             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    2795             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",sht))),
    2796             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    2797             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",int))),
    2798             :  pattern("calc", ">>", CMDvarRSHsignal, false, "Return V1 >> V2, raise error on out of range second operand", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2799             :  pattern("calc", "rsh_noerror", CMDvarRSH, false, "Return V1 >> V2, out of range second operand results in NIL value", args(1,3, arg("",lng),arg("v1",lng),arg("v2",lng))),
    2800             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",bit),arg("v2",bit))),
    2801             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",str),arg("v2",str))),
    2802             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",blob),arg("v2",blob))),
    2803             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",oid),arg("v2",oid))),
    2804             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",bte))),
    2805             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",sht))),
    2806             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",int))),
    2807             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",lng))),
    2808             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",flt))),
    2809             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",dbl))),
    2810             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",bte))),
    2811             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",sht))),
    2812             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",int))),
    2813             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",lng))),
    2814             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",flt))),
    2815             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",dbl))),
    2816             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",bte))),
    2817             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",sht))),
    2818             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",int))),
    2819             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",lng))),
    2820             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",flt))),
    2821             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",dbl))),
    2822             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",bte))),
    2823             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",sht))),
    2824             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",int))),
    2825             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",lng))),
    2826             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",flt))),
    2827             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",dbl))),
    2828             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",bte))),
    2829             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",sht))),
    2830             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",int))),
    2831             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",lng))),
    2832             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",flt))),
    2833             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",dbl))),
    2834             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",bte))),
    2835             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",sht))),
    2836             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",int))),
    2837             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",lng))),
    2838             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",flt))),
    2839             :  pattern("calc", "<", CMDvarLT, false, "Return V1 < V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",dbl))),
    2840             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",bit),arg("v2",bit))),
    2841             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",str),arg("v2",str))),
    2842             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",blob),arg("v2",blob))),
    2843             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",oid),arg("v2",oid))),
    2844             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",bte))),
    2845             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",sht))),
    2846             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",int))),
    2847             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",lng))),
    2848             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",flt))),
    2849             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",dbl))),
    2850             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",bte))),
    2851             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",sht))),
    2852             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",int))),
    2853             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",lng))),
    2854             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",flt))),
    2855             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",dbl))),
    2856             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",bte))),
    2857             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",sht))),
    2858             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",int))),
    2859             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",lng))),
    2860             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",flt))),
    2861             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",dbl))),
    2862             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",bte))),
    2863             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",sht))),
    2864             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",int))),
    2865             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",lng))),
    2866             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",flt))),
    2867             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",dbl))),
    2868             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",bte))),
    2869             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",sht))),
    2870             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",int))),
    2871             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",lng))),
    2872             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",flt))),
    2873             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",dbl))),
    2874             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",bte))),
    2875             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",sht))),
    2876             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",int))),
    2877             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",lng))),
    2878             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",flt))),
    2879             :  pattern("calc", "<=", CMDvarLE, false, "Return V1 <= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",dbl))),
    2880             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",bit),arg("v2",bit))),
    2881             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",str),arg("v2",str))),
    2882             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",blob),arg("v2",blob))),
    2883             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",oid),arg("v2",oid))),
    2884             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",bte))),
    2885             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",sht))),
    2886             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",int))),
    2887             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",lng))),
    2888             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",flt))),
    2889             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",dbl))),
    2890             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",bte))),
    2891             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",sht))),
    2892             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",int))),
    2893             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",lng))),
    2894             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",flt))),
    2895             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",dbl))),
    2896             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",bte))),
    2897             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",sht))),
    2898             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",int))),
    2899             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",lng))),
    2900             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",flt))),
    2901             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",dbl))),
    2902             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",bte))),
    2903             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",sht))),
    2904             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",int))),
    2905             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",lng))),
    2906             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",flt))),
    2907             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",dbl))),
    2908             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",bte))),
    2909             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",sht))),
    2910             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",int))),
    2911             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",lng))),
    2912             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",flt))),
    2913             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",dbl))),
    2914             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",bte))),
    2915             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",sht))),
    2916             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",int))),
    2917             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",lng))),
    2918             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",flt))),
    2919             :  pattern("calc", ">", CMDvarGT, false, "Return V1 > V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",dbl))),
    2920             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",bit),arg("v2",bit))),
    2921             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",str),arg("v2",str))),
    2922             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",blob),arg("v2",blob))),
    2923             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",oid),arg("v2",oid))),
    2924             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",bte))),
    2925             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",sht))),
    2926             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",int))),
    2927             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",lng))),
    2928             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",flt))),
    2929             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",dbl))),
    2930             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",bte))),
    2931             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",sht))),
    2932             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",int))),
    2933             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",lng))),
    2934             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",flt))),
    2935             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",dbl))),
    2936             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",bte))),
    2937             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",sht))),
    2938             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",int))),
    2939             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",lng))),
    2940             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",flt))),
    2941             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",dbl))),
    2942             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",bte))),
    2943             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",sht))),
    2944             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",int))),
    2945             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",lng))),
    2946             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",flt))),
    2947             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",dbl))),
    2948             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",bte))),
    2949             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",sht))),
    2950             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",int))),
    2951             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",lng))),
    2952             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",flt))),
    2953             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",dbl))),
    2954             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",bte))),
    2955             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",sht))),
    2956             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",int))),
    2957             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",lng))),
    2958             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",flt))),
    2959             :  pattern("calc", ">=", CMDvarGE, false, "Return V1 >= V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",dbl))),
    2960             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",bit),arg("v2",bit))),
    2961             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",bit),arg("v2",bit),arg("nil_matches",bit))),
    2962             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",str),arg("v2",str))),
    2963             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",str),arg("v2",str),arg("nil_matches",bit))),
    2964             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",blob),arg("v2",blob))),
    2965             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",blob),arg("v2",blob),arg("nil_matches",bit))),
    2966             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",oid),arg("v2",oid))),
    2967             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",oid),arg("v2",oid),arg("nil_matches",bit))),
    2968             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",bte))),
    2969             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",bte),arg("nil_matches",bit))),
    2970             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",sht))),
    2971             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",sht),arg("nil_matches",bit))),
    2972             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",int))),
    2973             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",int),arg("nil_matches",bit))),
    2974             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",lng))),
    2975             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",lng),arg("nil_matches",bit))),
    2976             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",flt))),
    2977             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",flt),arg("nil_matches",bit))),
    2978             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",dbl))),
    2979             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",dbl),arg("nil_matches",bit))),
    2980             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",bte))),
    2981             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",bte),arg("nil_matches",bit))),
    2982             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",sht))),
    2983             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",sht),arg("nil_matches",bit))),
    2984             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",int))),
    2985             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",int),arg("nil_matches",bit))),
    2986             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",lng))),
    2987             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",lng),arg("nil_matches",bit))),
    2988             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",flt))),
    2989             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",flt),arg("nil_matches",bit))),
    2990             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",dbl))),
    2991             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",dbl),arg("nil_matches",bit))),
    2992             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",bte))),
    2993             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",bte),arg("nil_matches",bit))),
    2994             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",sht))),
    2995             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",sht),arg("nil_matches",bit))),
    2996             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",int))),
    2997             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",int),arg("nil_matches",bit))),
    2998             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",lng))),
    2999             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",lng),arg("nil_matches",bit))),
    3000             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",flt))),
    3001             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",flt),arg("nil_matches",bit))),
    3002             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",dbl))),
    3003             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",dbl),arg("nil_matches",bit))),
    3004             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",bte))),
    3005             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",bte),arg("nil_matches",bit))),
    3006             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",sht))),
    3007             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",sht),arg("nil_matches",bit))),
    3008             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",int))),
    3009             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",int),arg("nil_matches",bit))),
    3010             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",lng))),
    3011             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",lng),arg("nil_matches",bit))),
    3012             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",flt))),
    3013             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",flt),arg("nil_matches",bit))),
    3014             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",dbl))),
    3015             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",dbl),arg("nil_matches",bit))),
    3016             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",bte))),
    3017             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",bte),arg("nil_matches",bit))),
    3018             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",sht))),
    3019             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",sht),arg("nil_matches",bit))),
    3020             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",int))),
    3021             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",int),arg("nil_matches",bit))),
    3022             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",lng))),
    3023             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",lng),arg("nil_matches",bit))),
    3024             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",flt))),
    3025             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",flt),arg("nil_matches",bit))),
    3026             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",dbl))),
    3027             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",dbl),arg("nil_matches",bit))),
    3028             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",bte))),
    3029             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",bte),arg("nil_matches",bit))),
    3030             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",sht))),
    3031             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",sht),arg("nil_matches",bit))),
    3032             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",int))),
    3033             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",int),arg("nil_matches",bit))),
    3034             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",lng))),
    3035             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",lng),arg("nil_matches",bit))),
    3036             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",flt))),
    3037             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",flt),arg("nil_matches",bit))),
    3038             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",dbl))),
    3039             :  pattern("calc", "==", CMDvarEQ, false, "Return V1 == V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",dbl),arg("nil_matches",bit))),
    3040             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",bit),arg("v2",bit))),
    3041             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",bit),arg("v2",bit),arg("nil_matches",bit))),
    3042             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",str),arg("v2",str))),
    3043             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",str),arg("v2",str),arg("nil_matches",bit))),
    3044             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",blob),arg("v2",blob))),
    3045             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",blob),arg("v2",blob),arg("nil_matches",bit))),
    3046             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",oid),arg("v2",oid))),
    3047             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",oid),arg("v2",oid),arg("nil_matches",bit))),
    3048             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",bte))),
    3049             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",bte),arg("nil_matches",bit))),
    3050             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",sht))),
    3051             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",sht),arg("nil_matches",bit))),
    3052             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",int))),
    3053             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",int),arg("nil_matches",bit))),
    3054             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",lng))),
    3055             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",lng),arg("nil_matches",bit))),
    3056             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",flt))),
    3057             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",flt),arg("nil_matches",bit))),
    3058             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",bte),arg("v2",dbl))),
    3059             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",bte),arg("v2",dbl),arg("nil_matches",bit))),
    3060             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",bte))),
    3061             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",bte),arg("nil_matches",bit))),
    3062             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",sht))),
    3063             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",sht),arg("nil_matches",bit))),
    3064             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",int))),
    3065             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",int),arg("nil_matches",bit))),
    3066             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",lng))),
    3067             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",lng),arg("nil_matches",bit))),
    3068             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",flt))),
    3069             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",flt),arg("nil_matches",bit))),
    3070             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",sht),arg("v2",dbl))),
    3071             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",sht),arg("v2",dbl),arg("nil_matches",bit))),
    3072             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",bte))),
    3073             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",bte),arg("nil_matches",bit))),
    3074             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",sht))),
    3075             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",sht),arg("nil_matches",bit))),
    3076             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",int))),
    3077             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",int),arg("nil_matches",bit))),
    3078             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",lng))),
    3079             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",lng),arg("nil_matches",bit))),
    3080             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",flt))),
    3081             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",flt),arg("nil_matches",bit))),
    3082             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",int),arg("v2",dbl))),
    3083             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",int),arg("v2",dbl),arg("nil_matches",bit))),
    3084             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",bte))),
    3085             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",bte),arg("nil_matches",bit))),
    3086             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",sht))),
    3087             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",sht),arg("nil_matches",bit))),
    3088             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",int))),
    3089             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",int),arg("nil_matches",bit))),
    3090             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",lng))),
    3091             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",lng),arg("nil_matches",bit))),
    3092             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",flt))),
    3093             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",flt),arg("nil_matches",bit))),
    3094             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",lng),arg("v2",dbl))),
    3095             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",lng),arg("v2",dbl),arg("nil_matches",bit))),
    3096             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",bte))),
    3097             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",bte),arg("nil_matches",bit))),
    3098             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",sht))),
    3099             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",sht),arg("nil_matches",bit))),
    3100             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",int))),
    3101             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",int),arg("nil_matches",bit))),
    3102             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",lng))),
    3103             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",lng),arg("nil_matches",bit))),
    3104             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",flt))),
    3105             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",flt),arg("nil_matches",bit))),
    3106             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",flt),arg("v2",dbl))),
    3107             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",flt),arg("v2",dbl),arg("nil_matches",bit))),
    3108             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",bte))),
    3109             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",bte),arg("nil_matches",bit))),
    3110             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",sht))),
    3111             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",sht),arg("nil_matches",bit))),
    3112             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",int))),
    3113             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",int),arg("nil_matches",bit))),
    3114             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",lng))),
    3115             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",lng),arg("nil_matches",bit))),
    3116             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",flt))),
    3117             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",flt),arg("nil_matches",bit))),
    3118             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,3, arg("",bit),arg("v1",dbl),arg("v2",dbl))),
    3119             :  pattern("calc", "!=", CMDvarNE, false, "Return V1 != V2", args(1,4, arg("",bit),arg("v1",dbl),arg("v2",dbl),arg("nil_matches",bit))),
    3120             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",bit),arg("v2",bit))),
    3121             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",str),arg("v2",str))),
    3122             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",oid),arg("v2",oid))),
    3123             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",bte),arg("v2",bte))),
    3124             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",bte),arg("v2",sht))),
    3125             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",bte),arg("v2",int))),
    3126             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",bte),arg("v2",lng))),
    3127             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",bte),arg("v2",flt))),
    3128             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",bte),arg("v2",dbl))),
    3129             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",sht),arg("v2",bte))),
    3130             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",sht),arg("v2",sht))),
    3131             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",sht),arg("v2",int))),
    3132             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",sht),arg("v2",lng))),
    3133             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",sht),arg("v2",flt))),
    3134             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",sht),arg("v2",dbl))),
    3135             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",int),arg("v2",bte))),
    3136             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",int),arg("v2",sht))),
    3137             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",int),arg("v2",int))),
    3138             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",int),arg("v2",lng))),
    3139             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",int),arg("v2",flt))),
    3140             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",int),arg("v2",dbl))),
    3141             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",lng),arg("v2",bte))),
    3142             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",lng),arg("v2",sht))),
    3143             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",lng),arg("v2",int))),
    3144             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",lng),arg("v2",lng))),
    3145             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",lng),arg("v2",flt))),
    3146             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",lng),arg("v2",dbl))),
    3147             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",flt),arg("v2",bte))),
    3148             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",flt),arg("v2",sht))),
    3149             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",flt),arg("v2",int))),
    3150             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",flt),arg("v2",lng))),
    3151             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",flt),arg("v2",flt))),
    3152             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",flt),arg("v2",dbl))),
    3153             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",bte))),
    3154             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",sht))),
    3155             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",int))),
    3156             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",lng))),
    3157             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",flt))),
    3158             :  pattern("calc", "cmp", CMDvarCMP, false, "Return -1/0/1 if V1 </==/> V2", args(1,3, arg("",bte),arg("v1",dbl),arg("v2",dbl))),
    3159             :  pattern("calc", "between", CMDvarBETWEEN, false, "B between LO and HI inclusive", args(1,9, arg("",bit),argany("b",1),argany("lo",1),argany("hi",1),arg("sym",bit),arg("linc",bit),arg("hinc",bit),arg("nils_false",bit),arg("anti",bit))),
    3160             :  pattern("calc", "void", CMDvarCONVERT, false, "Cast VALUE to void", args(1,2, arg("",void),arg("v",void))),
    3161             :  pattern("calc", "void", CMDvarCONVERT, false, "Cast VALUE to void", args(1,2, arg("",void),arg("v",bit))),
    3162             :  pattern("calc", "void", CMDvarCONVERT, false, "Cast VALUE to void", args(1,2, arg("",void),arg("v",bte))),
    3163             :  pattern("calc", "void", CMDvarCONVERT, false, "Cast VALUE to void", args(1,2, arg("",void),arg("v",sht))),
    3164             :  pattern("calc", "void", CMDvarCONVERT, false, "Cast VALUE to void", args(1,2, arg("",void),arg("v",int))),
    3165             :  pattern("calc", "void", CMDvarCONVERT, false, "Cast VALUE to void", args(1,2, arg("",void),arg("v",lng))),
    3166             :  pattern("calc", "void", CMDvarCONVERT, false, "Cast VALUE to void", args(1,2, arg("",void),arg("v",flt))),
    3167             :  pattern("calc", "void", CMDvarCONVERT, false, "Cast VALUE to void", args(1,2, arg("",void),arg("v",dbl))),
    3168             :  pattern("calc", "void", CMDvarCONVERT, false, "Cast VALUE to void", args(1,2, arg("",void),arg("v",oid))),
    3169             :  pattern("calc", "void", CMDvarCONVERT, false, "Cast VALUE to void", args(1,2, arg("",void),arg("v",str))),
    3170             :  pattern("calc", "bit", CMDvarCONVERT, false, "Cast VALUE to bit", args(1,2, arg("",bit),arg("v",void))),
    3171             :  pattern("calc", "bit", CMDvarCONVERT, false, "Cast VALUE to bit", args(1,2, arg("",bit),arg("v",bit))),
    3172             :  pattern("calc", "bit", CMDvarCONVERT, false, "Cast VALUE to bit", args(1,2, arg("",bit),arg("v",bte))),
    3173             :  pattern("calc", "bit", CMDvarCONVERT, false, "Cast VALUE to bit", args(1,2, arg("",bit),arg("v",sht))),
    3174             :  pattern("calc", "bit", CMDvarCONVERT, false, "Cast VALUE to bit", args(1,2, arg("",bit),arg("v",int))),
    3175             :  pattern("calc", "bit", CMDvarCONVERT, false, "Cast VALUE to bit", args(1,2, arg("",bit),arg("v",lng))),
    3176             :  pattern("calc", "bit", CMDvarCONVERT, false, "Cast VALUE to bit", args(1,2, arg("",bit),arg("v",flt))),
    3177             :  pattern("calc", "bit", CMDvarCONVERT, false, "Cast VALUE to bit", args(1,2, arg("",bit),arg("v",dbl))),
    3178             :  pattern("calc", "bit", CMDvarCONVERT, false, "Cast VALUE to bit", args(1,2, arg("",bit),arg("v",oid))),
    3179             :  pattern("calc", "bit", CMDvarCONVERT, false, "Cast VALUE to bit", args(1,2, arg("",bit),arg("v",str))),
    3180             :  pattern("calc", "bte", CMDvarCONVERT, false, "Cast VALUE to bte", args(1,2, arg("",bte),arg("v",void))),
    3181             :  pattern("calc", "bte", CMDvarCONVERT, false, "Cast VALUE to bte", args(1,2, arg("",bte),arg("v",bit))),
    3182             :  pattern("calc", "bte", CMDvarCONVERT, false, "Cast VALUE to bte", args(1,2, arg("",bte),arg("v",bte))),
    3183             :  pattern("calc", "bte", CMDvarCONVERT, false, "Cast VALUE to bte", args(1,2, arg("",bte),arg("v",sht))),
    3184             :  pattern("calc", "bte", CMDvarCONVERT, false, "Cast VALUE to bte", args(1,2, arg("",bte),arg("v",int))),
    3185             :  pattern("calc", "bte", CMDvarCONVERT, false, "Cast VALUE to bte", args(1,2, arg("",bte),arg("v",lng))),
    3186             :  pattern("calc", "bte", CMDvarCONVERT, false, "Cast VALUE to bte", args(1,2, arg("",bte),arg("v",flt))),
    3187             :  pattern("calc", "bte", CMDvarCONVERT, false, "Cast VALUE to bte", args(1,2, arg("",bte),arg("v",dbl))),
    3188             :  pattern("calc", "bte", CMDvarCONVERT, false, "Cast VALUE to bte", args(1,2, arg("",bte),arg("v",oid))),
    3189             :  pattern("calc", "bte", CMDvarCONVERT, false, "Cast VALUE to bte", args(1,2, arg("",bte),arg("v",str))),
    3190             :  pattern("calc", "sht", CMDvarCONVERT, false, "Cast VALUE to sht", args(1,2, arg("",sht),arg("v",void))),
    3191             :  pattern("calc", "sht", CMDvarCONVERT, false, "Cast VALUE to sht", args(1,2, arg("",sht),arg("v",bit))),
    3192             :  pattern("calc", "sht", CMDvarCONVERT, false, "Cast VALUE to sht", args(1,2, arg("",sht),arg("v",bte))),
    3193             :  pattern("calc", "sht", CMDvarCONVERT, false, "Cast VALUE to sht", args(1,2, arg("",sht),arg("v",sht))),
    3194             :  pattern("calc", "sht", CMDvarCONVERT, false, "Cast VALUE to sht", args(1,2, arg("",sht),arg("v",int))),
    3195             :  pattern("calc", "sht", CMDvarCONVERT, false, "Cast VALUE to sht", args(1,2, arg("",sht),arg("v",lng))),
    3196             :  pattern("calc", "sht", CMDvarCONVERT, false, "Cast VALUE to sht", args(1,2, arg("",sht),arg("v",flt))),
    3197             :  pattern("calc", "sht", CMDvarCONVERT, false, "Cast VALUE to sht", args(1,2, arg("",sht),arg("v",dbl))),
    3198             :  pattern("calc", "sht", CMDvarCONVERT, false, "Cast VALUE to sht", args(1,2, arg("",sht),arg("v",oid))),
    3199             :  pattern("calc", "sht", CMDvarCONVERT, false, "Cast VALUE to sht", args(1,2, arg("",sht),arg("v",str))),
    3200             :  pattern("calc", "int", CMDvarCONVERT, false, "Cast VALUE to int", args(1,2, arg("",int),arg("v",void))),
    3201             :  pattern("calc", "int", CMDvarCONVERT, false, "Cast VALUE to int", args(1,2, arg("",int),arg("v",bit))),
    3202             :  pattern("calc", "int", CMDvarCONVERT, false, "Cast VALUE to int", args(1,2, arg("",int),arg("v",bte))),
    3203             :  pattern("calc", "int", CMDvarCONVERT, false, "Cast VALUE to int", args(1,2, arg("",int),arg("v",sht))),
    3204             :  pattern("calc", "int", CMDvarCONVERT, false, "Cast VALUE to int", args(1,2, arg("",int),arg("v",int))),
    3205             :  pattern("calc", "int", CMDvarCONVERT, false, "Cast VALUE to int", args(1,2, arg("",int),arg("v",lng))),
    3206             :  pattern("calc", "int", CMDvarCONVERT, false, "Cast VALUE to int", args(1,2, arg("",int),arg("v",flt))),
    3207             :  pattern("calc", "int", CMDvarCONVERT, false, "Cast VALUE to int", args(1,2, arg("",int),arg("v",dbl))),
    3208             :  pattern("calc", "int", CMDvarCONVERT, false, "Cast VALUE to int", args(1,2, arg("",int),arg("v",oid))),
    3209             :  pattern("calc", "int", CMDvarCONVERT, false, "Cast VALUE to int", args(1,2, arg("",int),arg("v",str))),
    3210             :  pattern("calc", "lng", CMDvarCONVERT, false, "Cast VALUE to lng", args(1,2, arg("",lng),arg("v",void))),
    3211             :  pattern("calc", "lng", CMDvarCONVERT, false, "Cast VALUE to lng", args(1,2, arg("",lng),arg("v",bit))),
    3212             :  pattern("calc", "lng", CMDvarCONVERT, false, "Cast VALUE to lng", args(1,2, arg("",lng),arg("v",bte))),
    3213             :  pattern("calc", "lng", CMDvarCONVERT, false, "Cast VALUE to lng", args(1,2, arg("",lng),arg("v",sht))),
    3214             :  pattern("calc", "lng", CMDvarCONVERT, false, "Cast VALUE to lng", args(1,2, arg("",lng),arg("v",int))),
    3215             :  pattern("calc", "lng", CMDvarCONVERT, false, "Cast VALUE to lng", args(1,2, arg("",lng),arg("v",lng))),
    3216             :  pattern("calc", "lng", CMDvarCONVERT, false, "Cast VALUE to lng", args(1,2, arg("",lng),arg("v",flt))),
    3217             :  pattern("calc", "lng", CMDvarCONVERT, false, "Cast VALUE to lng", args(1,2, arg("",lng),arg("v",dbl))),
    3218             :  pattern("calc", "lng", CMDvarCONVERT, false, "Cast VALUE to lng", args(1,2, arg("",lng),arg("v",oid))),
    3219             :  pattern("calc", "lng", CMDvarCONVERT, false, "Cast VALUE to lng", args(1,2, arg("",lng),arg("v",str))),
    3220             :  pattern("calc", "flt", CMDvarCONVERT, false, "Cast VALUE to flt", args(1,2, arg("",flt),arg("v",void))),
    3221             :  pattern("calc", "flt", CMDvarCONVERT, false, "Cast VALUE to flt", args(1,2, arg("",flt),arg("v",bit))),
    3222             :  pattern("calc", "flt", CMDvarCONVERT, false, "Cast VALUE to flt", args(1,2, arg("",flt),arg("v",bte))),
    3223             :  pattern("calc", "flt", CMDvarCONVERT, false, "Cast VALUE to flt", args(1,2, arg("",flt),arg("v",sht))),
    3224             :  pattern("calc", "flt", CMDvarCONVERT, false, "Cast VALUE to flt", args(1,2, arg("",flt),arg("v",int))),
    3225             :  pattern("calc", "flt", CMDvarCONVERT, false, "Cast VALUE to flt", args(1,2, arg("",flt),arg("v",lng))),
    3226             :  pattern("calc", "flt", CMDvarCONVERT, false, "Cast VALUE to flt", args(1,2, arg("",flt),arg("v",flt))),
    3227             :  pattern("calc", "flt", CMDvarCONVERT, false, "Cast VALUE to flt", args(1,2, arg("",flt),arg("v",dbl))),
    3228             :  pattern("calc", "flt", CMDvarCONVERT, false, "Cast VALUE to flt", args(1,2, arg("",flt),arg("v",oid))),
    3229             :  pattern("calc", "flt", CMDvarCONVERT, false, "Cast VALUE to flt", args(1,2, arg("",flt),arg("v",str))),
    3230             :  pattern("calc", "dbl", CMDvarCONVERT, false, "Cast VALUE to dbl", args(1,2, arg("",dbl),arg("v",void))),
    3231             :  pattern("calc", "dbl", CMDvarCONVERT, false, "Cast VALUE to dbl", args(1,2, arg("",dbl),arg("v",bit))),
    3232             :  pattern("calc", "dbl", CMDvarCONVERT, false, "Cast VALUE to dbl", args(1,2, arg("",dbl),arg("v",bte))),
    3233             :  pattern("calc", "dbl", CMDvarCONVERT, false, "Cast VALUE to dbl", args(1,2, arg("",dbl),arg("v",sht))),
    3234             :  pattern("calc", "dbl", CMDvarCONVERT, false, "Cast VALUE to dbl", args(1,2, arg("",dbl),arg("v",int))),
    3235             :  pattern("calc", "dbl", CMDvarCONVERT, false, "Cast VALUE to dbl", args(1,2, arg("",dbl),arg("v",lng))),
    3236             :  pattern("calc", "dbl", CMDvarCONVERT, false, "Cast VALUE to dbl", args(1,2, arg("",dbl),arg("v",flt))),
    3237             :  pattern("calc", "dbl", CMDvarCONVERT, false, "Cast VALUE to dbl", args(1,2, arg("",dbl),arg("v",dbl))),
    3238             :  pattern("calc", "dbl", CMDvarCONVERT, false, "Cast VALUE to dbl", args(1,2, arg("",dbl),arg("v",oid))),
    3239             :  pattern("calc", "dbl", CMDvarCONVERT, false, "Cast VALUE to dbl", args(1,2, arg("",dbl),arg("v",str))),
    3240             :  pattern("calc", "oid", CMDvarCONVERT, false, "Cast VALUE to oid", args(1,2, arg("",oid),arg("v",void))),
    3241             :  pattern("calc", "oid", CMDvarCONVERT, false, "Cast VALUE to oid", args(1,2, arg("",oid),arg("v",bit))),
    3242             :  pattern("calc", "oid", CMDvarCONVERT, false, "Cast VALUE to oid", args(1,2, arg("",oid),arg("v",bte))),
    3243             :  pattern("calc", "oid", CMDvarCONVERT, false, "Cast VALUE to oid", args(1,2, arg("",oid),arg("v",sht))),
    3244             :  pattern("calc", "oid", CMDvarCONVERT, false, "Cast VALUE to oid", args(1,2, arg("",oid),arg("v",int))),
    3245             :  pattern("calc", "oid", CMDvarCONVERT, false, "Cast VALUE to oid", args(1,2, arg("",oid),arg("v",lng))),
    3246             :  pattern("calc", "oid", CMDvarCONVERT, false, "Cast VALUE to oid", args(1,2, arg("",oid),arg("v",flt))),
    3247             :  pattern("calc", "oid", CMDvarCONVERT, false, "Cast VALUE to oid", args(1,2, arg("",oid),arg("v",dbl))),
    3248             :  pattern("calc", "oid", CMDvarCONVERT, false, "Cast VALUE to oid", args(1,2, arg("",oid),arg("v",oid))),
    3249             :  pattern("calc", "oid", CMDvarCONVERT, false, "Cast VALUE to oid", args(1,2, arg("",oid),arg("v",str))),
    3250             :  pattern("calc", "str", CMDvarCONVERT, false, "Cast VALUE to str", args(1,2, arg("",str),argany("v",0))),
    3251             :  pattern("calc", "min", CALCmin, false, "Return min of V1 and V2", args(1,3, argany("",1),argany("v1",1),argany("v2",1))),
    3252             :  pattern("calc", "min_no_nil", CALCmin_no_nil, false, "Return min of V1 and V2, ignoring nil values", args(1,3, argany("",1),argany("v1",1),argany("v2",1))),
    3253             :  pattern("calc", "max", CALCmax, false, "Return max of V1 and V2", args(1,3, argany("",1),argany("v1",1),argany("v2",1))),
    3254             :  pattern("calc", "max_no_nil", CALCmax_no_nil, false, "Return max of V1 and V2, ignoring nil values", args(1,3, argany("",1),argany("v1",1),argany("v2",1))),
    3255             :  command("calc", "ptr", CMDvarCONVERTptr, false, "Cast VALUE to ptr", args(1,2, arg("",ptr),arg("v",ptr))),
    3256             :  pattern("calc", "ifthenelse", CALCswitchbit, false, "If VALUE is true return MIDDLE else RIGHT", args(1,4, argany("",1),arg("b",bit),argany("t",1),argany("f",1))),
    3257             :  command("calc", "length", CMDstrlength, false, "Length of STRING", args(1,2, arg("",int),arg("s",str))),
    3258             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",bte),batarg("b",bte))),
    3259             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",bte),batarg("b",bte),arg("nil_if_empty",bit))),
    3260             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",bte),batarg("b",bte),batarg("s",oid))),
    3261             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",bte),batarg("b",bte),batarg("s",oid),arg("nil_if_empty",bit))),
    3262             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",sht),batarg("b",bte))),
    3263             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",sht),batarg("b",bte),arg("nil_if_empty",bit))),
    3264             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",sht),batarg("b",bte),batarg("s",oid))),
    3265             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",sht),batarg("b",bte),batarg("s",oid),arg("nil_if_empty",bit))),
    3266             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",int),batarg("b",bte))),
    3267             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",int),batarg("b",bte),arg("nil_if_empty",bit))),
    3268             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",int),batarg("b",bte),batarg("s",oid))),
    3269             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",int),batarg("b",bte),batarg("s",oid),arg("nil_if_empty",bit))),
    3270             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",lng),batarg("b",bte))),
    3271             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",lng),batarg("b",bte),arg("nil_if_empty",bit))),
    3272             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",lng),batarg("b",bte),batarg("s",oid))),
    3273             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",lng),batarg("b",bte),batarg("s",oid),arg("nil_if_empty",bit))),
    3274             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",dbl),batarg("b",bte))),
    3275             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",dbl),batarg("b",bte),arg("nil_if_empty",bit))),
    3276             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",dbl),batarg("b",bte),batarg("s",oid))),
    3277             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",dbl),batarg("b",bte),batarg("s",oid),arg("nil_if_empty",bit))),
    3278             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",sht),batarg("b",sht))),
    3279             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",sht),batarg("b",sht),arg("nil_if_empty",bit))),
    3280             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",sht),batarg("b",sht),batarg("s",oid))),
    3281             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",sht),batarg("b",sht),batarg("s",oid),arg("nil_if_empty",bit))),
    3282             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",int),batarg("b",sht))),
    3283             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",int),batarg("b",sht),arg("nil_if_empty",bit))),
    3284             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",int),batarg("b",sht),batarg("s",oid))),
    3285             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",int),batarg("b",sht),batarg("s",oid),arg("nil_if_empty",bit))),
    3286             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",lng),batarg("b",sht))),
    3287             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",lng),batarg("b",sht),arg("nil_if_empty",bit))),
    3288             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",lng),batarg("b",sht),batarg("s",oid))),
    3289             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",lng),batarg("b",sht),batarg("s",oid),arg("nil_if_empty",bit))),
    3290             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",dbl),batarg("b",sht))),
    3291             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",dbl),batarg("b",sht),arg("nil_if_empty",bit))),
    3292             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",dbl),batarg("b",sht),batarg("s",oid))),
    3293             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",dbl),batarg("b",sht),batarg("s",oid),arg("nil_if_empty",bit))),
    3294             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",int),batarg("b",int))),
    3295             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",int),batarg("b",int),arg("nil_if_empty",bit))),
    3296             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",int),batarg("b",int),batarg("s",oid))),
    3297             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",int),batarg("b",int),batarg("s",oid),arg("nil_if_empty",bit))),
    3298             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",lng),batarg("b",int))),
    3299             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",lng),batarg("b",int),arg("nil_if_empty",bit))),
    3300             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",lng),batarg("b",int),batarg("s",oid))),
    3301             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",lng),batarg("b",int),batarg("s",oid),arg("nil_if_empty",bit))),
    3302             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",dbl),batarg("b",int))),
    3303             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",dbl),batarg("b",int),arg("nil_if_empty",bit))),
    3304             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",dbl),batarg("b",int),batarg("s",oid))),
    3305             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",dbl),batarg("b",int),batarg("s",oid),arg("nil_if_empty",bit))),
    3306             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",lng),batarg("b",lng))),
    3307             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",lng),batarg("b",lng),arg("nil_if_empty",bit))),
    3308             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",lng),batarg("b",lng),batarg("s",oid))),
    3309             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",lng),batarg("b",lng),batarg("s",oid),arg("nil_if_empty",bit))),
    3310             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",dbl),batarg("b",lng))),
    3311             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",dbl),batarg("b",lng),arg("nil_if_empty",bit))),
    3312             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",dbl),batarg("b",lng),batarg("s",oid))),
    3313             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",dbl),batarg("b",lng),batarg("s",oid),arg("nil_if_empty",bit))),
    3314             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",flt),batarg("b",flt))),
    3315             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",flt),batarg("b",flt),arg("nil_if_empty",bit))),
    3316             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",flt),batarg("b",flt),batarg("s",oid))),
    3317             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",flt),batarg("b",flt),batarg("s",oid),arg("nil_if_empty",bit))),
    3318             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",dbl),batarg("b",flt))),
    3319             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",dbl),batarg("b",flt),arg("nil_if_empty",bit))),
    3320             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",dbl),batarg("b",flt),batarg("s",oid))),
    3321             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",dbl),batarg("b",flt),batarg("s",oid),arg("nil_if_empty",bit))),
    3322             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,2, arg("",dbl),batarg("b",dbl))),
    3323             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B.", args(1,3, arg("",dbl),batarg("b",dbl),arg("nil_if_empty",bit))),
    3324             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,3, arg("",dbl),batarg("b",dbl),batarg("s",oid))),
    3325             :  pattern("aggr", "sum", CMDBATsum, false, "Calculate aggregate sum of B with candidate list.", args(1,4, arg("",dbl),batarg("b",dbl),batarg("s",oid),arg("nil_if_empty",bit))),
    3326             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",bte),batarg("b",bte))),
    3327             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",bte),batarg("b",bte),arg("nil_if_empty",bit))),
    3328             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",bte),batarg("b",bte),batarg("s",oid))),
    3329             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",bte),batarg("b",bte),batarg("s",oid),arg("nil_if_empty",bit))),
    3330             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",sht),batarg("b",bte))),
    3331             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",sht),batarg("b",bte),arg("nil_if_empty",bit))),
    3332             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",sht),batarg("b",bte),batarg("s",oid))),
    3333             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",sht),batarg("b",bte),batarg("s",oid),arg("nil_if_empty",bit))),
    3334             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",int),batarg("b",bte))),
    3335             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",int),batarg("b",bte),arg("nil_if_empty",bit))),
    3336             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",int),batarg("b",bte),batarg("s",oid))),
    3337             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",int),batarg("b",bte),batarg("s",oid),arg("nil_if_empty",bit))),
    3338             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",lng),batarg("b",bte))),
    3339             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",lng),batarg("b",bte),arg("nil_if_empty",bit))),
    3340             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",lng),batarg("b",bte),batarg("s",oid))),
    3341             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",lng),batarg("b",bte),batarg("s",oid),arg("nil_if_empty",bit))),
    3342             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",dbl),batarg("b",bte))),
    3343             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",dbl),batarg("b",bte),arg("nil_if_empty",bit))),
    3344             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",dbl),batarg("b",bte),batarg("s",oid))),
    3345             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",dbl),batarg("b",bte),batarg("s",oid),arg("nil_if_empty",bit))),
    3346             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",sht),batarg("b",sht))),
    3347             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",sht),batarg("b",sht),arg("nil_if_empty",bit))),
    3348             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",sht),batarg("b",sht),batarg("s",oid))),
    3349             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",sht),batarg("b",sht),batarg("s",oid),arg("nil_if_empty",bit))),
    3350             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",int),batarg("b",sht))),
    3351             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",int),batarg("b",sht),arg("nil_if_empty",bit))),
    3352             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",int),batarg("b",sht),batarg("s",oid))),
    3353             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",int),batarg("b",sht),batarg("s",oid),arg("nil_if_empty",bit))),
    3354             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",lng),batarg("b",sht))),
    3355             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",lng),batarg("b",sht),arg("nil_if_empty",bit))),
    3356             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",lng),batarg("b",sht),batarg("s",oid))),
    3357             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",lng),batarg("b",sht),batarg("s",oid),arg("nil_if_empty",bit))),
    3358             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",dbl),batarg("b",sht))),
    3359             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",dbl),batarg("b",sht),arg("nil_if_empty",bit))),
    3360             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",dbl),batarg("b",sht),batarg("s",oid))),
    3361             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",dbl),batarg("b",sht),batarg("s",oid),arg("nil_if_empty",bit))),
    3362             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",int),batarg("b",int))),
    3363             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",int),batarg("b",int),arg("nil_if_empty",bit))),
    3364             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",int),batarg("b",int),batarg("s",oid))),
    3365             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",int),batarg("b",int),batarg("s",oid),arg("nil_if_empty",bit))),
    3366             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",lng),batarg("b",int))),
    3367             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",lng),batarg("b",int),arg("nil_if_empty",bit))),
    3368             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",lng),batarg("b",int),batarg("s",oid))),
    3369             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",lng),batarg("b",int),batarg("s",oid),arg("nil_if_empty",bit))),
    3370             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",dbl),batarg("b",int))),
    3371             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",dbl),batarg("b",int),arg("nil_if_empty",bit))),
    3372             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",dbl),batarg("b",int),batarg("s",oid))),
    3373             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",dbl),batarg("b",int),batarg("s",oid),arg("nil_if_empty",bit))),
    3374             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",lng),batarg("b",lng))),
    3375             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",lng),batarg("b",lng),arg("nil_if_empty",bit))),
    3376             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",lng),batarg("b",lng),batarg("s",oid))),
    3377             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",lng),batarg("b",lng),batarg("s",oid),arg("nil_if_empty",bit))),
    3378             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",dbl),batarg("b",lng))),
    3379             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",dbl),batarg("b",lng),arg("nil_if_empty",bit))),
    3380             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",dbl),batarg("b",lng),batarg("s",oid))),
    3381             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",dbl),batarg("b",lng),batarg("s",oid),arg("nil_if_empty",bit))),
    3382             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",flt),batarg("b",flt))),
    3383             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",flt),batarg("b",flt),arg("nil_if_empty",bit))),
    3384             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",flt),batarg("b",flt),batarg("s",oid))),
    3385             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",flt),batarg("b",flt),batarg("s",oid),arg("nil_if_empty",bit))),
    3386             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",dbl),batarg("b",flt))),
    3387             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",dbl),batarg("b",flt),arg("nil_if_empty",bit))),
    3388             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",dbl),batarg("b",flt),batarg("s",oid))),
    3389             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",dbl),batarg("b",flt),batarg("s",oid),arg("nil_if_empty",bit))),
    3390             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,2, arg("",dbl),batarg("b",dbl))),
    3391             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B.", args(1,3, arg("",dbl),batarg("b",dbl),arg("nil_if_empty",bit))),
    3392             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,3, arg("",dbl),batarg("b",dbl),batarg("s",oid))),
    3393             :  pattern("aggr", "prod", CMDBATprod, false, "Calculate aggregate product of B with candidate list.", args(1,4, arg("",dbl),batarg("b",dbl),batarg("s",oid),arg("nil_if_empty",bit))),
    3394             :  pattern("aggr", "str_group_concat", CMDBATstr_group_concat, false, "Calculate aggregate string concatenate of B.", args(1,2, arg("",str),batarg("b",str))),
    3395             :  pattern("aggr", "str_group_concat", CMDBATstr_group_concat, false, "Calculate aggregate string concatenate of B.", args(1,3, arg("",str),batarg("b",str),arg("nil_if_empty",bit))),
    3396             :  pattern("aggr", "str_group_concat", CMDBATstr_group_concat, false, "Calculate aggregate string concatenate of B with candidate list.", args(1,3, arg("",str),batarg("b",str),batarg("s",oid))),
    3397             :  pattern("aggr", "str_group_concat", CMDBATstr_group_concat, false, "Calculate aggregate string concatenate of B with candidate list.", args(1,4, arg("",str),batarg("b",str),batarg("s",oid),arg("nil_if_empty",bit))),
    3398             :  pattern("aggr", "str_group_concat", CMDBATstr_group_concat, false, "Calculate aggregate string concatenate of B with separator SEP.", args(1,3, arg("",str),batarg("b",str),batarg("sep",str))),
    3399             :  pattern("aggr", "str_group_concat", CMDBATstr_group_concat, false, "Calculate aggregate string concatenate of B with separator SEP.", args(1,4, arg("",str),batarg("b",str),batarg("sep",str),arg("nil_if_empty",bit))),
    3400             :  pattern("aggr", "str_group_concat", CMDBATstr_group_concat, false, "Calculate aggregate string concatenate of B with candidate list and separator SEP.", args(1,4, arg("",str),batarg("b",str),batarg("sep",str),batarg("s",oid))),
    3401             :  pattern("aggr", "str_group_concat", CMDBATstr_group_concat, false, "Calculate aggregate string concatenate of B with candidate list and separator SEP.", args(1,5, arg("",str),batarg("b",str),batarg("sep",str),batarg("s",oid),arg("nil_if_empty",bit))),
    3402             :  //from sql
    3403             :  pattern("aggr", "anyequal", CMDvarEQ, false, "", args(1,3, arg("",bit),argany("l",1),argany("r",1))),
    3404             :  pattern("aggr", "not_anyequal", CMDvarNE, false, "", args(1,3, arg("",bit),argany("l",1),argany("r",1))),
    3405             :  { .imp=NULL }
    3406             : };
    3407             : #include "mal_import.h"
    3408             : #ifdef _MSC_VER
    3409             : #undef read
    3410             : #pragma section(".CRT$XCU",read)
    3411             : #endif
    3412         255 : LIB_STARTUP_FUNC(init_calc_mal)
    3413         255 : { mal_module("calc", NULL, calc_init_funcs); }

Generated by: LCOV version 1.14