ja.h

/* Copyright 1990-2011, Jsoftware Inc.  All rights reserved. */
/* License in license.txt.                                   */
/*                                                                         */
/* Aliases for jt                                                          */


#define BfromD(x,y)                 jtBfromD(jt,(x),(y))
#define BfromI(x,y)                 jtBfromI(jt,(x),(y))
#define BfromX(x,y)                 jtBfromX(jt,(x),(y))
#define C1fromC2(x,y)               jtC1fromC2(jt,(x),(y))
#define C2fromC1(x,y)               jtC2fromC1(jt,(x),(y))
#define DfromQ(x,y)                 jtDfromQ(jt,(x),(y))
#define DfromX(x,y)                 jtDfromX(jt,(x),(y))
#define DfromZ(x,y)                 jtDfromZ(jt,(x),(y))
#define DXfI(x,y,z)                 jtDXfI(jt,(x),(y),(z))
#define IfromD(x,y)                 jtIfromD(jt,(x),(y))
#define IfromX(x,y)                 jtIfromX(jt,(x),(y))
#define QfromD(x,y)                 jtQfromD(jt,(x),(y))
#define QfromX(x,y)                 jtQfromX(jt,(x),(y))
#define XfromB(x,y)                 jtXfromB(jt,(x),(y))
#define XfromD(x,y)                 jtXfromD(jt,(x),(y))
#define XfromI(x,y)                 jtXfromI(jt,(x),(y))
#define XfromQ(x,y)                 jtXfromQ(jt,(x),(y))
#define aaxis(x0,x1,x2,x3,x4,x5,x6,x7)              jtaaxis(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7))
#define abase2(x,y)                 jtabase2(jt,(x),(y))
#define ac2(x)                      jtac2(jt,(x))
#define add2(x,y,z)                 jtadd2(jt,(x),(y),(z))
#define afi(x,y)                    jtafi(jt,(x),(y))
#define afrom(x,y)                  jtafrom(jt,(x),(y))
#define afrom2(x0,x1,x2,x3)         jtafrom2(jt,(x0),(x1),(x2),(x3))
#define afzrndID(x,y)               jtafzrndID(jt,(x),(y))
#define aii(x)                      jtaii(jt,(x))
#define aindex(x0,x1,x2,x3)         jtaindex(jt,(x0),(x1),(x2),(x3))
#define aindex1(x0,x1,x2,x3)        jtaindex1(jt,(x0),(x1),(x2),(x3))
#define am1a(x0,x1,x2,x3)           jtam1a(jt,(x0),(x1),(x2),(x3))
#define am1e(x0,x1,x2,x3)           jtam1e(jt,(x0),(x1),(x2),(x3))
#define am1sp(x0,x1,x2,x3)          jtam1sp(jt,(x0),(x1),(x2),(x3))
#define amend(x,y)                  jtamend(jt,(x),(y))
#define amendn2(x0,x1,x2,x3)        jtamendn2(jt,(x0),(x1),(x2),(x3))
#define amna(x0,x1,x2,x3)           jtamna(jt,(x0),(x1),(x2),(x3))
#define amne(x0,x1,x2,x3)           jtamne(jt,(x0),(x1),(x2),(x3))
#define amnsp(x0,x1,x2,x3)          jtamnsp(jt,(x0),(x1),(x2),(x3))
#define amp(x,y)                    jtamp(jt,(x),(y))
#define ampco(x,y)                  jtampco(jt,(x),(y))
#define apipx(x,y)                  jtapipx(jt,(x),(y))
#define applystr(x,y)               jtapplystr(jt,(x),(y))
#define apv(x,y,z)                  jtapv(jt,(x),(y),(z))
#define arep(x)                     jtarep(jt,(x))
#define aro(x)                      jtaro(jt,(x))
#define ascan(x,y)                  jtascan(jt,(x),(y))
#define aslash(x,y)                 jtaslash(jt,(x),(y))
#define aslash1(x,y)                jtaslash1(jt,(x),(y))
#define astd1(x,y,z)                jtastd1(jt,(x),(y),(z))
#define astdn(x,y,z)                jtastdn(jt,(x),(y),(z))
#define atab(x,y,z)                 jtatab(jt,(x),(y),(z))
#define atco(x,y)                   jtatco(jt,(x),(y))
#define atcompf(x,y,z)              jtatcompf(jt,(x),(y),(z))
#define atomic(x,y)                 jtatomic(jt,(x),(y))
#define atop(x,y)                   jtatop(jt,(x),(y))
#define attu(x)                     jtattu(jt,(x))
#define attv(x)                     jtattv(jt,(x))
#define axbytes(x,y)                jtaxbytes(jt,(x),(y))
#define axbytes1(x0,x1,x2,x3,x4)    jtaxbytes1(jt,(x0),(x1),(x2),(x3),(x4))
#define axtally(x,y)                jtaxtally(jt,(x),(y))
#define b0(x)                       jtb0(jt,(x))
#define baddson(x,y,z)              jtbaddson(jt,(x),(y),(z))
#define badjust(x,y)                jtbadjust(jt,(x),(y))
#define base2(x,y)                  jtbase2(jt,(x),(y))
#define bcvt(x,y)                   jtbcvt(jt,(x),(y))
#define bdot(x)                     jtbdot(jt,(x))
#define bdot2(x,y,z)                jtbdot2(jt,(x),(y),(z))
#define behead(x)                   jtbehead(jt,(x))
#define bfi(x,y,z)                  jtbfi(jt,(x),(y),(z))
#define bfind(x,y,z)                jtbfind(jt,(x),(y),(z))
#define bfrom(x,y)                  jtbfrom(jt,(x),(y))
#define bigdeal(x,y)                jtbigdeal(jt,(x),(y))
#define bindd(x,y)                  jtbindd(jt,(x),(y))
#define binrep1(x)                  jtbinrep1(jt,(x))
#define binrep2(x,y)                jtbinrep2(jt,(x),(y))
#define binsert(x,y,z)              jtbinsert(jt,(x),(y),(z))
#define binzz(x,y)                  jtbinzz(jt,(x),(y))
#define bitmatch(x,y)               jtbitmatch(jt,(x),(y))
#define bitwise0000(x,y)            jtbitwise0000(jt,(x),(y))
#define bitwise0001(x,y)            jtbitwise0001(jt,(x),(y))
#define bitwise0010(x,y)            jtbitwise0010(jt,(x),(y))
#define bitwise0011(x,y)            jtbitwise0011(jt,(x),(y))
#define bitwise0100(x,y)            jtbitwise0100(jt,(x),(y))
#define bitwise0101(x,y)            jtbitwise0101(jt,(x),(y))
#define bitwise0110(x,y)            jtbitwise0110(jt,(x),(y))
#define bitwise0111(x,y)            jtbitwise0111(jt,(x),(y))
#define bitwise1000(x,y)            jtbitwise1000(jt,(x),(y))
#define bitwise1001(x,y)            jtbitwise1001(jt,(x),(y))
#define bitwise1010(x,y)            jtbitwise1010(jt,(x),(y))
#define bitwise1011(x,y)            jtbitwise1011(jt,(x),(y))
#define bitwise1100(x,y)            jtbitwise1100(jt,(x),(y))
#define bitwise1101(x,y)            jtbitwise1101(jt,(x),(y))
#define bitwise1110(x,y)            jtbitwise1110(jt,(x),(y))
#define bitwise1111(x,y)            jtbitwise1111(jt,(x),(y))
#define bitwisecharamp(x0,x1,x2,x3) jtbitwisecharamp(jt,(x0),(x1),(x2),(x3))
#define box(x)                      jtbox(jt,(x))
#define box0(x)                     jtbox0(jt,(x))
#define boxatop(x)                  jtboxatop(jt,(x))
#define boxopen(x)                  jtboxopen(jt,(x))   
#define bput(x,y,z)                 jtbput(jt,(x),(y),(z))
#define brep(x,y,z)                 jtbrep(jt,(x),(y),(z))
#define brephdr(x0,x1,x2,x3)        jtbrephdr(jt,(x0),(x1),(x2),(x3))
#define breps(x,y,z)                jtbreps(jt,(x),(y),(z))
#define bsdot(x)                    jtbsdot(jt,(x))
#define bslash(x)                   jtbslash(jt,(x))
#define c2fi(x)                     jtc2fi(jt,(x))
#define c2j(x,y,z)                  jtc2j(jt,(x),(y),(z))
#define ca(x)                       jtca(jt,(x))
#define cancel(x,y)                 jtcancel(jt,(x),(y))
#define cant1(x)                    jtcant1(jt,(x))
#define cant2(x,y)                  jtcant2(jt,(x),(y)) 
#define canta(x,y)                  jtcanta(jt,(x),(y))
#define cants(x,y,z)                jtcants(jt,(x),(y),(z)) 
#define cap(x)                      jtcap(jt,(x))
#define car(x)                      jtcar(jt,(x))
#define case1a(x,y)                 jtcase1a(jt,(x),(y))
#define casev(x)                    jtcasev(jt,(x))
#define catalog(x)                  jtcatalog(jt,(x)) 
#define ccvt(x,y,z)                 jtccvt(jt,(x),(y),(z))
#define cdexec1(x0,x1,x2,x3,x4,x5)  jtcdexec1(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define cdgahash(x)                 jtcdgahash(jt,(x))   
#define cdinit()                    jtcdinit(jt)   
#define cdinsert(x,y)               jtcdinsert(jt,(x),(y))   
#define cdload(x,y,z)               jtcdload(jt,(x),(y),(z))
#define cdlookup(x)                 jtcdlookup(jt,(x))   
#define cdlookupl(x)                jtcdlookupl(jt,(x))   
#define cdot1(x)                    jtcdot1(jt,(x))   
#define cdot2(x,y)                  jtcdot2(jt,(x),(y))  
#define cdparse(x)                  jtcdparse(jt,(x))
#define ceil1(x)                    jtceil1(jt,(x))
#define center(x0,x1,x2,x3)         jtcenter(jt,(x0),(x1),(x2),(x3))
#define cex(x,y)                    jtcex(jt,(x),(y))
#define cfd(x)                      jtcfd(jt,(x))
#define cfn(x)                      jtcfn(jt,(x))
#define cfr(x)                      jtcfr(jt,(x))
#define cfrd(x,y)                   jtcfrd(jt,(x),(y))
#define cfrq(x,y)                   jtcfrq(jt,(x),(y))
#define cfrx(x,y)                   jtcfrx(jt,(x),(y))
#define cfrz(x,y)                   jtcfrz(jt,(x),(y))
#define charmap(x,y,z)              jtcharmap(jt,(x),(y),(z))
#define checkmf()                   jtcheckmf(jt)
#define checksi()                   jtchecksi(jt)
#define cirx(x0,x1,x2,x3)           jtcirx(jt,(x0),(x1),(x2),(x3)) 
#define coeff(x)                    jtcoeff(jt,(x))
#define coerce2(x,y,z)              jtcoerce2(jt,(x),(y),(z))
#define colon(x,y)                  jtcolon(jt,(x),(y))
#define colon0(x)                   jtcolon0(jt,(x))
#define compare(x,y)                jtcompare(jt,(x),(y))
#define conall(x,y)                 jtconall(jt,(x),(y))
#define congoto(x,y,z)              jtcongoto(jt,(x),(y),(z))
#define congotoblk(x,y)             jtcongotoblk(jt,(x),(y))
#define congotochk(x,y,z)           jtcongotochk(jt,(x),(y),(z))
#define conjug(x)                   jtconjug(jt,(x))
#define connum(x,y)                 jtconnum(jt,(x),(y))
#define consinit()                  jtconsinit(jt)
#define constr(x,y)                 jtconstr(jt,(x),(y))
#define convert0(x0,x1,x2,x3)       jtconvert0(jt,(x0),(x1),(x2),(x3)) 
#define conword(x,y)                jtconword(jt,(x),(y))
#define cpa(x,y)                    jtcpa(jt,(x),(y))
#define cps(x)                      jtcps(jt,(x))
#define crc2(x,y)                   jtcrc2(jt,(x),(y))
#define crccompile(x)               jtcrccompile(jt,(x))
#define crcvalidate(x)              jtcrcvalidate(jt,(x))
#define csize(x,y)                  jtcsize(jt,(x),(y))
#define cstr(x)                     jtcstr(jt,(x))
#define curtail(x)                  jtcurtail(jt,(x))
#define cut(x,y)                    jtcut(jt,(x),(y))
#define cut02(x,y,z)                jtcut02(jt,(x),(y),(z))
#define cut02m(x,y)                 jtcut02m(jt,(x),(y))
#define cut02v(x,y)                 jtcut02v(jt,(x),(y))
#define cut2(x,y,z)                 jtcut2(jt,(x),(y),(z))
#define cut2bx(x,y,z)               jtcut2bx(jt,(x),(y),(z))
#define cut2sx(x,y,z)               jtcut2sx(jt,(x),(y),(z))
#define cvt(x,y)                    jtcvt(jt,(x),(y))
#define cvt0(x)                     jtcvt0(jt,(x))
#define cvt2bit(x,y)                jtcvt2bit(jt,(x),(y))
#define cvz(x,y)                    jtcvz(jt,(x),(y))
#define daxis(x,y)                  jtdaxis(jt,(x),(y))
#define db1b2(x,y)                  jtdb1b2(jt,(x),(y))
#define dbcall(x)                   jtdbcall(jt,(x))
#define dbin(x,y)                   jtdbin(jt,(x),(y))
#define dbincancel(x0,x1,x2,x3,x4)  jtdbincancel(jt,(x0),(x1),(x2),(x3),(x4))
#define dbjump(x)                   jtdbjump(jt,(x))
#define dbrr(x,y)                   jtdbrr(jt,(x),(y))
#define dbstack(x)                  jtdbstack(jt,(x))
#define dbstop(x,y)                 jtdbstop(jt,(x),(y))
#define dbsig(x,y)                  jtdbsig(jt,(x),(y))
#define dbunquote(x,y,z)            jtdbunquote(jt,(x),(y),(z))
#define dcapco(x,y)                 jtdcapco(jt,(x),(y))
#define dcase(x,y)                  jtdcase(jt,(x),(y))
#define dcube(x,y)                  jtdcube(jt,(x),(y))
#define ddot(x,y)                   jtddot(jt,(x),(y))   
#define deal(x,y)                   jtdeal(jt,(x),(y))
#define deba(x0,x1,x2,x3)           jtdeba(jt,(x0),(x1),(x2),(x3))
#define debdisp(x)                  jtdebdisp(jt,(x))
#define debsi1(x)                   jtdebsi1(jt,(x))
#define debug()                     jtdebug(jt)
#define debz()                      jtdebz(jt)
#define decrem(x)                   jtdecrem(jt,(x))
#define deflate(x0,x1,x2,x3)        jtdeflate(jt,(x0),(x1),(x2),(x3))
#define deflateq(x0,x1,x2,x3)       jtdeflateq(jt,(x0),(x1),(x2),(x3))
#define denseit(x)                  jtdenseit(jt,(x))
#define det(x,y)                    jtdet(jt,(x),(y))
#define detd(x)                     jtdetd(jt,(x))
#define detmr(x)                    jtdetmr(jt,(x))
#define detr(x)                     jtdetr(jt,(x))
#define detxm(x,y)                  jtdetxm(jt,(x),(y))
#define detz(x)                     jtdetz(jt,(x))
#define df1(x,y)                    jtdf1(jt,(x),(y))  
#define df2(x,y,z)                  jtdf2(jt,(x),(y),(z))  
#define dfc(x,y)                    jtdfc(jt,(x),(y))
#define dfr(x)                      jtdfr(jt,(x))
#define dfrep(x)                    jtdfrep(jt,(x))
#define dfs1(x,y)                   jtdfs1(jt,(x),(y)) 
#define dfs2(x,y,z)                 jtdfs2(jt,(x),(y),(z)) 
#define dgamma(x)                   jtdgamma(jt,(x))
#define dgcd(x,y)                   jtdgcd(jt,(x),(y))
#define dgrade1(x)                  jtdgrade1(jt,(x)) 
#define dgrade2(x,y)                jtdgrade2(jt,(x),(y))
#define dhead(x,y)                  jtdhead(jt,(x),(y))
#define diag(x,y)                   jtdiag(jt,(x),(y))
#define diff(x)                     jtdiff(jt,(x))
#define diff0(x)                    jtdiff0(jt,(x))
#define diffamp(x)                  jtdiffamp(jt,(x))
#define diffamp0(x)                 jtdiffamp0(jt,(x))
#define dir1(x)                     jtdir1(jt,(x))
#define disp(x)                     jtdisp(jt,(x))
#define divide(x,y)                 jtdivide(jt,(x),(y)) 
#define dlcm(x,y)                   jtdlcm(jt,(x),(y))
#define dllsymaddr(x,y)             jtdllsymaddr(jt,(x),(y)) 
#define dloc(x)                     jtdloc(jt,(x))
#define dolock(x0,x1,x2,x3)         jtdolock(jt,(x0),(x1),(x2),(x3))
#define dot(x,y)                    jtdot(jt,(x),(y))  
#define dotprod(x,y,z)              jtdotprod(jt,(x),(y),(z))  
#define dpoly(x)                    jtdpoly(jt,(x))
#define dpone(x,y)                  jtdpone(jt,(x),(y))
#define drep(x)                     jtdrep(jt,(x))
#define drop(x,y)                   jtdrop(jt,(x),(y))   
#define dropr(x,y)                  jtdropr(jt,(x),(y)) 
#define drow(x,y,z)                 jtdrow(jt,(x),(y),(z))
#define drr(x)                      jtdrr(jt,(x))  
#define dspell(x,y)                 jtdspell(jt,(x),(y))
#define dtab(x,y)                   jtdtab(jt,(x),(y))
#define duble(x)                    jtduble(jt,(x))   
#define dx_init(x)                  jtdx_init(jt,(x))
#define dx_next()                   jtdx_next(jt)
#define dx_next30()                 jtdx_next30(jt)
#define dxplus(x,y)                 jtdxplus(jt,(x),(y))
#define eachl(x,y,z)                jteachl(jt,(x),(y),(z))
#define ebar(x,y)                   jtebar(jt,(x),(y))   
#define ebarmat(x,y)                jtebarmat(jt,(x),(y))
#define ebarprep(x0,x1,x2,x3,x4)    jtebarprep(jt,(x0),(x1),(x2),(x3),(x4))
#define ebarvec(x,y)                jtebarvec(jt,(x),(y))
#define eca(x0,x1,x2,x3,x4,x5)      jteca(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define ecd(x0,x1,x2,x3,x4)         jtecd(jt,(x0),(x1),(x2),(x3),(x4))
#define ecm(x0,x1,x2,x3,x4,x5)      jtecm(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define ecm_s1(x0,x1,x2,x3,x4,x5)   jtecm_s1(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define ecm_s2(x0,x1,x2,x3,x4,x5,x6)                jtecm_s2(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6))
#define ecvt(x0,x1,x2,x3,x4)        jtecvt(jt,(x0),(x1),(x2),(x3),(x4))
#define efflev(x,y,z)               jtefflev(jt,(x),(y),(z))
#define efmt(x,y)                   jtefmt(jt,(x),(y))
#define enframe(x)                  jtenframe(jt,(x))
#define enqueue(x,y)                jtenqueue(jt,(x),(y))
#define ep(x,y)                     jtep(jt,(x),(y))
#define eps(x,y)                    jteps(jt,(x),(y))    
#define eputc(x)                    jteputc(jt,(x))
#define eputl(x)                    jteputl(jt,(x))
#define eputq(x)                    jteputq(jt,(x))
#define eputs(x)                    jteputs(jt,(x))
#define eputv(x)                    jteputv(jt,(x))
#define eq(x,y)                     jteq(jt,(x),(y))     
#define eqa(x0,x1,x2,x3,x4)         jteqa(jt,(x0),(x1),(x2),(x3),(x4))
#define eqd(x,y,z)                  jteqd(jt,(x),(y),(z))
#define eqf(x,y)                    jteqf(jt,(x),(y))
#define eqq(x,y,z)                  jteqq(jt,(x),(y),(z))
#define eqx(x,y,z)                  jteqx(jt,(x),(y),(z))
#define equ(x,y)                    jtequ(jt,(x),(y))
#define eqz(x,y,z)                  jteqz(jt,(x),(y),(z))
#define errcap()                    jterrcap(jt)
#define etc(x)                      jtetc(jt,(x))
#define ev1(x,y)                    jtev1(jt,(x),(y))
#define ev2(x,y,z)                  jtev2(jt,(x),(y),(z))
#define eva(x,y)                    jteva(jt,(x),(y))
#define eval(x)                     jteval(jt,(x))
#define evc(x,y,z)                  jtevc(jt,(x),(y),(z))
#define even(x,y)                   jteven(jt,(x),(y))  
#define every(x,y,z)                jtevery(jt,(x),(y),(z)) 
#define every2(x0,x1,x2,x3)         jtevery2(jt,(x0),(x1),(x2),(x3)) 
#define everysp(x,y,z)              jteverysp(jt,(x),(y),(z))
#define evger(x,y)                  jtevger(jt,(x),(y))
#define evinit()                    jtevinit(jt)
#define ex(x)                       jtex(jt,(x))  
#define exec1(x)                    jtexec1(jt,(x))   
#define exec2(x,y)                  jtexec2(jt,(x),(y))   
#define exec2q(x0,x1,x2,x3,x4)      jtexec2q(jt,(x0),(x1),(x2),(x3),(x4)) 
#define exec2r(x0,x1,x2,x3,x4)      jtexec2r(jt,(x0),(x1),(x2),(x3),(x4)) 
#define exec2x(x0,x1,x2,x3,x4)      jtexec2x(jt,(x0),(x1),(x2),(x3),(x4)) 
#define exec2z(x0,x1,x2,x3,x4)      jtexec2z(jt,(x0),(x1),(x2),(x3),(x4))
#define exg(x)                      jtexg(jt,(x))
#define expand(x,y)                 jtexpand(jt,(x),(y))
#define expn1(x)                    jtexpn1(jt,(x))   
#define expn2(x,y)                  jtexpn2(jt,(x),(y))  
#define exprndID(x,y)               jtexprndID(jt,(x),(y))  
#define ext(x,y)                    jtext(jt,(x),(y))
#define exta(x0,x1,x2,x3)           jtexta(jt,(x0),(x1),(x2),(x3))
#define fa(x)                       jtfa(jt,(x))     
#define fac_ecm(x)                  jtfac_ecm(jt,(x))
#define facit(x)                    jtfacit(jt,(x))
#define fact(x)                     jtfact(jt,(x))    
#define factor(x)                   jtfactor(jt,(x))  
#define fdef(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10)     jtfdef(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8),(x9),(x10))
#define fdep(x)                     jtfdep(jt,(x))
#define fdepger(x)                  jtfdepger(jt,(x))
#define fh(x)                       jtfh(jt,(x))
#define filler(x)                   jtfiller(jt,(x))  
#define fit(x,y)                    jtfit(jt,(x),(y))
#define fitct(x,y)                  jtfitct(jt,(x),(y)) 
#define fix(x)                      jtfix(jt,(x))     
#define fixa(x,y)                   jtfixa(jt,(x),(y))
#define fixrecursive(x,y)           jtfixrecursive(jt,(x),(y))
#define floor1(x)                   jtfloor1(jt,(x))
#define fmfill(x0,x1,x2,x3,x4,x5,x6)                jtfmfill(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6))
#define fminit(x0,x1,x2,x3,x4,x5)   jtfminit(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define fminus(x,y)                 jtfminus(jt,(x),(y))
#define fmt02(x,y)                  jtfmt02(jt,(x),(y))
#define fmt1(x0,x1,x2,x3,x4,x5)     jtfmt1(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define fmt12(x,y)                  jtfmt12(jt,(x),(y))
#define fmt22(x,y)                  jtfmt22(jt,(x),(y))
#define fmtallcol(x,y,z)            jtfmtallcol(jt,(x),(y),(z))
#define fmtbfc(x)                   jtfmtbfc(jt,(x))
#define fmtcomma(x0,x1,x2,x3)       jtfmtcomma(jt,(x0),(x1),(x2),(x3))
#define fmtD(x,y)                   jtfmtD(jt,(x),(y))
#define fmtex(x0,x1,x2,x3,x4,x5,x6,x7)              jtfmtex(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7))
#define fmtprecomp(x,y)             jtfmtprecomp(jt,(x),(y))
#define fmtq(x0,x1,x2,x3,x4,x5)     jtfmtq(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define fmtx(x0,x1,x2,x3,x4,x5)     jtfmtx(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define fmtxi(x0,x1,x2,x3)          jtfmtxi(jt,(x0),(x1),(x2),(x3))
#define fname(x)                    jtfname(jt,(x))
#define fnegate(x)                  jtfnegate(jt,(x))
#define fnum(x)                     jtfnum(jt,(x))
#define folk(x,y,z)                 jtfolk(jt,(x),(y),(z))
#define fong(x,y)                   jtfong(jt,(x),(y))
#define foreign(x,y)                jtforeign(jt,(x),(y))
#define foreignextra(x,y)           jtforeignextra(jt,(x),(y))
#define forinit(x,y)                jtforinit(jt,(x),(y))
#define fplus(x,y)                  jtfplus(jt,(x),(y))
#define fpoly(x,y)                  jtfpoly(jt,(x),(y))
#define fpolyc(x)                   jtfpolyc(jt,(x))
#define fr(x)                       jtfr(jt,(x))
#define fram(x0,x1,x2,x3)           jtfram(jt,(x0),(x1),(x2),(x3))   
#define from(x,y)                   jtfrom(jt,(x),(y))   
#define frombs(x,y)                 jtfrombs(jt,(x),(y))
#define frombs1(x,y,z)              jtfrombs1(jt,(x),(y),(z))
#define frombsn(x,y,z)              jtfrombsn(jt,(x),(y),(z))
#define frombu(x,y,z)               jtfrombu(jt,(x),(y),(z))
#define fromis(x,y)                 jtfromis(jt,(x),(y))
#define fromis1(x0,x1,x2,x3)        jtfromis1(jt,(x0),(x1),(x2),(x3))
#define fromr(x,y)                  jtfromr(jt,(x),(y))
#define fromsd(x,y)                 jtfromsd(jt,(x),(y))
#define fromss(x,y)                 jtfromss(jt,(x),(y))
#define fslashatg(x,y,z)            jtfslashatg(jt,(x),(y),(z))
#define fsm0(x,y,z)                 jtfsm0(jt,(x),(y),(z))
#define fsmdo(x0,x1,x2,x3,x4,x5)    jtfsmdo(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define fsmvfya(x)                  jtfsmvfya(jt,(x))
#define ftymes(x,y)                 jtftymes(jt,(x),(y))
#define fullname(x)                 jtfullname(jt,(x))
#define fx(x)                       jtfx(jt,(x)) 
#define fxchar(x)                   jtfxchar(jt,(x))
#define fxeach(x)                   jtfxeach(jt,(x))
#define fxeachv(x,y)                jtfxeachv(jt,(x),(y))
#define ga(x0,x1,x2,x3)             jtga(jt,(x0),(x1),(x2),(x3))
#define gadv(x,y)                   jtgadv(jt,(x),(y))
#define gah(x,y)                    jtgah(jt,(x),(y))
#define gaussdet(x)                 jtgaussdet(jt,(x))
#define gausselm(x)                 jtgausselm(jt,(x))
#define gb_flip_cycle()             jtgb_flip_cycle(jt)
#define gb_init(x)                  jtgb_init(jt,(x))
#define gb_next()                   jtgb_next(jt)
#define gb_unif_rand(x)             jtgb_unif_rand(jt,(x))
#define gc(x,y)                     jtgc(jt,(x),(y))
#define gc3(x0,x1,x2,x3)            jtgc3(jt,(x0),(x1),(x2),(x3))
#define gcd(x,y)                    jtgcd(jt,(x),(y)) 
#define gconj(x,y,z)                jtgconj(jt,(x),(y),(z))   
#define ge(x,y)                     jtge(jt,(x),(y))  
#define gerfrom(x,y)                jtgerfrom(jt,(x),(y))
#define getsen(x)                   jtgetsen(jt,(x))
#define gjoin(x,y,z)                jtgjoin(jt,(x),(y),(z))   
#define gr1(x)                      jtgr1(jt,(x))
#define gr2(x,y)                    jtgr2(jt,(x),(y))
#define grade1(x)                   jtgrade1(jt,(x))
#define grade1p(x,y)                jtgrade1p(jt,(x),(y))
#define grade2(x,y)                 jtgrade2(jt,(x),(y))
#define graft(x)                    jtgraft(jt,(x))
#define grb(x0,x1,x2,x3,x4)         jtgrb(jt,(x0),(x1),(x2),(x3),(x4))
#define grc(x0,x1,x2,x3,x4)         jtgrc(jt,(x0),(x1),(x2),(x3),(x4))
#define grd(x0,x1,x2,x3,x4)         jtgrd(jt,(x0),(x1),(x2),(x3),(x4))
#define grd1sp(x)                   jtgrd1sp(jt,(x))
#define grd1spdd(x,y,z)             jtgrd1spdd(jt,(x),(y),(z))
#define grd1spds(x,y,z)             jtgrd1spds(jt,(x),(y),(z))
#define grd1spsd(x,y,z)             jtgrd1spsd(jt,(x),(y),(z))
#define grd1spss(x,y,z)             jtgrd1spss(jt,(x),(y),(z))
#define grd1spz(x,y,z)              jtgrd1spz(jt,(x),(y),(z))
#define grd2sp(x,y)                 jtgrd2sp(jt,(x),(y))
#define grd2spsd(x,y,z)             jtgrd2spsd(jt,(x),(y),(z))
#define grd2spss(x,y,z)             jtgrd2spss(jt,(x),(y),(z))
#define gri(x0,x1,x2,x3,x4)         jtgri(jt,(x0),(x1),(x2),(x3),(x4))
#define gri1(x0,x1,x2,x3,x4)        jtgri1(jt,(x0),(x1),(x2),(x3),(x4))
#define group(x)                    jtgroup(jt,(x))
#define grs(x0,x1,x2,x3,x4)         jtgrs(jt,(x0),(x1),(x2),(x3),(x4))
#define grx(x0,x1,x2,x3,x4)         jtgrx(jt,(x0),(x1),(x2),(x3),(x4))
#define gt(x,y)                     jtgt(jt,(x),(y))     
#define halve(x)                    jthalve(jt,(x))
#define head(x)                     jthead(jt,(x))
#define hgcoeff(x,y)                jthgcoeff(jt,(x),(y))
#define hgd(x0,x1,x2,x3,x4)         jthgd(jt,(x0),(x1),(x2),(x3),(x4))
#define hgdiff(x)                   jthgdiff(jt,(x))
#define hgeom(x,y)                  jthgeom(jt,(x),(y)) 
#define hgeom2(x,y,z)               jthgeom2(jt,(x),(y),(z))
#define hgv(x0,x1,x2,x3)            jthgv(jt,(x0),(x1),(x2),(x3))
#define hia(x,y)                    jthia(jt,(x),(y))
#define hiau(x)                     jthiau(jt,(x))
#define hid(x)                      jthid(jt,(x))
#define hook(x,y)                   jthook(jt,(x),(y))
#define hook1(x,y)                  jthook1(jt,(x),(y))
#define hostio(x)                   jthostio(jt,(x))
#define hparm(x,y,z)                jthparm(jt,(x),(y),(z))
#define hrep(x,y,z)                 jthrep(jt,(x),(y),(z))
#define i0(x)                       jti0(jt,(x))
#define iaddr(x0,x1,x2,x3)          jtiaddr(jt,(x0),(x1),(x2),(x3))
#define icap(x)                     jticap(jt,(x))
#define icor(x,y)                   jticor(jt,(x),(y))  
#define icube(x)                    jticube(jt,(x))
#define icvt(x)                     jticvt(jt,(x))    
#define iden(x)                     jtiden(jt,(x)) 
#define idenv0(x0,x1,x2,x3,x4)      jtidenv0(jt,(x0),(x1),(x2),(x3),(x4)) 
#define ifb(x,y)                    jtifb(jt,(x),(y))
#define ifc2(x)                     jtifc2(jt,(x))
#define ifdz(x)                     jtifdz(jt,(x))
#define ifrom(x,y)                  jtifrom(jt,(x),(y))
#define ifxi(x,y)                   jtifxi(jt,(x),(y))   
#define igcd(x,y)                   jtigcd(jt,(x),(y))   
#define iindx(x,y)                  jtiindx(jt,(x),(y))
#define iixBX(x0,x1,x2,x3,x4)       jtiixBX(jt,(x0),(x1),(x2),(x3),(x4)) 
#define iixI(x0,x1,x2,x3,x4)        jtiixI(jt,(x0),(x1),(x2),(x3),(x4)) 
#define ilcm(x,y)                   jtilcm(jt,(x),(y))   
#define immea(x)                    jtimmea(jt,(x))
#define immex(x)                    jtimmex(jt,(x))
#define increm(x)                   jtincrem(jt,(x))  
#define indexof(x,y)                jtindexof(jt,(x),(y))
#define indexofprehashed(x,y,z)     jtindexofprehashed(jt,(x),(y),(z))
#define indexofss(x,y,z)            jtindexofss(jt,(x),(y),(z))
#define indexofsub(x,y,z)           jtindexofsub(jt,(x),(y),(z))
#define indexofxx(x,y,z)            jtindexofxx(jt,(x),(y),(z))
#define infix(x,y,z)                jtinfix(jt,(x),(y),(z))
#define infix2(x,y,z)               jtinfix2(jt,(x),(y),(z))
#define inpl(x,y,z)                 jtinpl(jt,(x),(y),(z))
#define int0(x)                     jtint0(jt,(x))
#define intdiv(x,y)                 jtintdiv(jt,(x),(y))
#define intg(x)                     jtintg(jt,(x))
#define intg0(x)                    jtintg0(jt,(x))
#define intgamp0(x)                 jtintgamp0(jt,(x))
#define intgatop(x,y)               jtintgatop(jt,(x),(y))
#define intgtymes(x,y)              jtintgtymes(jt,(x),(y))
#define intmod2(x)                  jtintmod2(jt,(x))
#define intpow(x,y)                 jtintpow(jt,(x),(y))
#define inv(x)                      jtinv(jt,(x))
#define invamp(x)                   jtinvamp(jt,(x))
#define invfork(x)                  jtinvfork(jt,(x))
#define iocol(x,y,z)                jtiocol(jt,(x),(y),(z))
#define ioe(x,y)                    jtioe(jt,(x),(y))
#define ioi(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12)  jtioi(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8),(x9),(x10),(x11),(x12))
#define iopart(x0,x1,x2,x3,x4,x5,x6)                jtiopart(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6))
#define ioresparse(x,y,z)           jtioresparse(jt,(x),(y),(z))
#define ioev(x,y)                   jtioev(jt,(x),(y))
#define iovsd(x,y,z)                jtiovsd(jt,(x),(y),(z))
#define iovxs(x,y,z)                jtiovxs(jt,(x),(y),(z))
#define iota(x)                     jtiota(jt,(x))  
#define ipart(x0,x1,x2,x3)          jtipart(jt,(x0),(x1),(x2),(x3))  
#define ipbx(x0,x1,x2,x3)           jtipbx(jt,(x0),(x1),(x2),(x3))  
#define ipoly(x)                    jtipoly(jt,(x))
#define ipprep(x0,x1,x2,x3,x4,x5)   jtipprep(jt,(x0),(x1),(x2),(x3),(x4),(x5)) 
#define iprimetest(x)               jtiprimetest(jt,(x)) 
#define irs1(x0,x1,x2,x3)           jtirs1(jt,(x0),(x1),(x2),(x3))
#define irs2(x0,x1,x2,x3,x4,x5)     jtirs2(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define iscons(x)                   jtiscons(jt,(x))
#define isnanq(x)                   jtisnanq(jt,(x))
#define ispoly(x)                   jtispoly(jt,(x))
#define istd1(x,y)                  jtistd1(jt,(x),(y))
#define ixf(x)                      jtixf(jt,(x))
#define ixin(x0,x1,x2,x3)           jtixin(jt,(x0),(x1),(x2),(x3))
#define jclose(x)                   jtjclose(jt,(x))
#define jdot1(x)                    jtjdot1(jt,(x))   
#define jdot2(x,y)                  jtjdot2(jt,(x),(y)) 
#define jerrno()                    jtjerrno(jt)
#define jfread(x)                   jtjfread(jt,(x))
#define jfwrite(x,y)                jtjfwrite(jt,(x),(y))
#define jgetenv(x)                  jtjgetenv(jt,(x))
#define jgets(x)                    jtjgets(jt,(x))
#define jico2(x,y)                  jtjico2(jt,(x),(y))  
#define jinit3()                    jtjinit3(jt)
#define joff(x)                     jtjoff(jt,(x))  
#define joi(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12)  jtjoi(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8),(x9),(x10),(x11),(x12))
#define jope(x,y)                   jtjope(jt,(x),(y))
#define jpr(x)                      jtjpr(jt,(x))
#define jpr1(x)                     jtjpr1(jt,(x))
#define jprx(x0,x1,x2,x3,x4)        jtjprx(jt,(x0),(x1),(x2),(x3),(x4))
#define jset(x,y)                   jtjset(jt,(x),(y))
#define jsig(x,y)                   jtjsig(jt,(x),(y))
#define jsigd(x)                    jtjsigd(jt,(x))
#define jsignal(x)                  jtjsignal(jt,(x))
#define jsignal3(x,y,z)             jtjsignal3(jt,(x),(y),(z))
#define jsigstr(x,y,z)              jtjsigstr(jt,(x),(y),(z))
#define jstd(x,y)                   jtjstd(jt,(x),(y))
#define key(x,y,z)                  jtkey(jt,(x),(y),(z))
#define keyi(x,y,z)                 jtkeyi(jt,(x),(y),(z))
#define keysp(x,y,z)                jtkeysp(jt,(x),(y),(z))
#define keyrs(x,y,z)                jtkeyrs(jt,(x),(y),(z))
#define keytally(x,y,z)             jtkeytally(jt,(x),(y),(z))
#define keytallysp(x)               jtkeytallysp(jt,(x))
#define laguerre(x,y,z)             jtlaguerre(jt,(x),(y),(z))
#define lamin1(x)                   jtlamin1(jt,(x))  
#define lamin2(x,y)                 jtlamin2(jt,(x),(y)) 
#define lbox(x)                     jtlbox(jt,(x))
#define lchar(x)                    jtlchar(jt,(x))
#define lcm(x,y)                    jtlcm(jt,(x),(y))    
#define lcolon(x)                   jtlcolon(jt,(x)) 
#define lcpx(x)                     jtlcpx(jt,(x))
#define le(x,y)                     jtle(jt,(x),(y))     
#define less(x,y)                   jtless(jt,(x),(y))   
#define lev1(x,y)                   jtlev1(jt,(x),(y))
#define lev2(x,y,z)                 jtlev2(jt,(x),(y),(z))
#define level1(x)                   jtlevel1(jt,(x))
#define levs1(x,y)                  jtlevs1(jt,(x),(y))
#define levs2(x,y,z)                jtlevs2(jt,(x),(y),(z))
#define line(x0,x1,x2,x3)           jtline(jt,(x0),(x1),(x2),(x3))
#define lineit(x)                   jtlineit(jt,(x))
#define linf(x0,x1,x2,x3)           jtlinf(jt,(x0),(x1),(x2),(x3))
#define link(x,y)                   jtlink(jt,(x),(y))  
#define linsert(x,y)                jtlinsert(jt,(x),(y)) 
#define lnoun(x)                    jtlnoun(jt,(x))
#define lnoun0(x)                   jtlnoun0(jt,(x))
#define lnum(x)                     jtlnum(jt,(x))
#define lnum1(x)                    jtlnum1(jt,(x))
#define locale(x,y)                 jtlocale(jt,(x),(y))
#define loccrenum(x)                jtloccrenum(jt,(x))
#define locdestroy(x)               jtlocdestroy(jt,(x))
#define locindirect(x,y)            jtlocindirect(jt,(x),(y))
#define lock1(x)                    jtlock1(jt,(x))
#define lock2(x,y)                  jtlock2(jt,(x),(y))
#define locmap1(x)                  jtlocmap1(jt,(x))
#define locname(x)                  jtlocname(jt,(x))
#define locnlx(x)                   jtlocnlx(jt,(x))
#define logar1(x)                   jtlogar1(jt,(x))  
#define lp(x)                       jtlp(jt,(x))
#define lr2(x,y,z)                  jtlr2(jt,(x),(y),(z))
#define lrep(x)                     jtlrep(jt,(x))
#define lrr(x)                      jtlrr(jt,(x))
#define lsh(x)                      jtlsh(jt,(x))
#define lshape(x)                   jtlshape(jt,(x))
#define lsparse(x)                  jtlsparse(jt,(x))
#define lsub(x,y,z)                 jtlsub(jt,(x),(y),(z))
#define lsymb(x,y)                  jtlsymb(jt,(x),(y))
#define lt(x,y)                     jtlt(jt,(x),(y))  
#define ltie(x)                     jtltie(jt,(x))
#define ma(x)                       jtma(jt,(x))
#define mag(x)                      jtmag(jt,(x))     
#define makename(x)                 jtmakename(jt,(x))  
#define map(x)                      jtmap(jt,(x))  
#define mapx(x,y)                   jtmapx(jt,(x),(y))  
#define mat(x)                      jtmat(jt,(x))   
#define match(x,y)                  jtmatch(jt,(x),(y))  
#define matchs(x,y)                 jtmatchs(jt,(x),(y))  
#define matchsub(x0,x1,x2,x3,x4,x5,x6,x7,x8)  jtmatchsub(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8))
#define matth1(x)                   jtmatth1(jt,(x))
#define maxdenom(x,y)               jtmaxdenom(jt,(x),(y))
#define maximum(x,y)                jtmaximum(jt,(x),(y))
#define maxtype(x,y)                jtmaxtype(jt,(x),(y))
#define mdiv(x,y)                   jtmdiv(jt,(x),(y))   
#define mdivsp(x,y)                 jtmdivsp(jt,(x),(y))
#define meanD(x0,x1,x2,x3,x4)       jtmeanD(jt,(x0),(x1),(x2),(x3),(x4))
#define meanI(x0,x1,x2,x3,x4)       jtmeanI(jt,(x0),(x1),(x2),(x3),(x4))
#define meminit()                   jtmeminit(jt)
#define memoget(x,y,z)              jtmemoget(jt,(x),(y),(z))
#define memoput(x0,x1,x2,x3)        jtmemoput(jt,(x0),(x1),(x2),(x3))
#define merge1(x,y)                 jtmerge1(jt,(x),(y))
#define merge2(x0,x1,x2,x3)         jtmerge2(jt,(x0),(x1),(x2),(x3))
#define minimum(x,y)                jtminimum(jt,(x),(y))
#define minors(x)                   jtminors(jt,(x))
#define minus(x,y)                  jtminus(jt,(x),(y))  
#define minv(x)                     jtminv(jt,(x))  
#define mkdir1(x)                   jtmkdir1(jt,(x))
#define mmharvest(x0,x1,x2,x3,x4,x5,x6) jtmmharvest(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6))
#define mmprep(x0,x1,x2,x3,x4,x5)   jtmmprep(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define mnomx(x,y)                  jtmnomx(jt,(x),(y))
#define modpow2(x,y,z)              jtmodpow2(jt,(x),(y),(z))
#define move(x,y,z)                 jtmove(jt,(x),(y),(z))
#define movandor(x0,x1,x2,x3)       jtmovandor(jt,(x0),(x1),(x2),(x3))
#define movbwneeq(x0,x1,x2,x3)      jtmovbwneeq(jt,(x0),(x1),(x2),(x3))
#define movfslash(x,y,z)            jtmovfslash(jt,(x),(y),(z))
#define movminmax(x0,x1,x2,x3)      jtmovminmax(jt,(x0),(x1),(x2),(x3))
#define movneeq(x0,x1,x2,x3)        jtmovneeq(jt,(x0),(x1),(x2),(x3))
#define movsumavg(x0,x1,x2,x3)      jtmovsumavg(jt,(x0),(x1),(x2),(x3))
#define movsumavg1(x0,x1,x2,x3)     jtmovsumavg1(jt,(x0),(x1),(x2),(x3))
#define mr_init(x)                  jtmr_init(jt,(x))
#define mr_next()                   jtmr_next(jt)
#define mr_next31()                 jtmr_next31(jt)
#define msmerge(x,y,z)              jtmsmerge(jt,(x),(y),(z))
#define msort(x,y,z)                jtmsort(jt,(x),(y),(z))
#define mt_init_by_array(x,y)       jtmt_init_by_array(jt,(x),(y))
#define mt_init(x)                  jtmt_init(jt,(x))
#define mt_next()                   jtmt_next(jt)
#define mult(x,y)                   jtmult(jt,(x),(y))
#define multiple(x,y)               jtmultiple(jt,(x),(y))
#define mvw(x0,x1,x2,x3,x4,x5,x6)   jtmvw(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6))
#define nameref(x)                  jtnameref(jt,(x)) 
#define namerefop(x,y)              jtnamerefop(jt,(x),(y)) 
#define nch1(x0,x1,x2,x3)           jtnch1(jt,(x0),(x1),(x2),(x3))   
#define ne(x,y)                     jtne(jt,(x),(y))  
#define negate(x)                   jtnegate(jt,(x))
#define neutral(x)                  jtneutral(jt,(x))
#define newt(x0,x1,x2,x3)           jtnewt(jt,(x0),(x1),(x2),(x3))
#define nextprime(x)                jtnextprime(jt,(x))
#define nfb(x)                      jtnfb(jt,(x))
#define nfs(x,y)                    jtnfs(jt,(x),(y))  
#define nlsym(x)                    jtnlsym(jt,(x))
#define nlx(x)                      jtnlx(jt,(x))
#define nlxxx(x)                    jtnlxxx(jt,(x))
#define nodupgrade(x0,x1,x2,x3,x4,x5,x6,x7,x8)      jtnodupgrade(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8))
#define nor(x,y)                    jtnor(jt,(x),(y))  
#define norm(x)                     jtnorm(jt,(x))  
#define not(x)                      jtnot(jt,(x))
#define nub(x)                      jtnub(jt,(x))     
#define nubi(x)                     jtnubi(jt,(x))     
#define nubsieve(x)                 jtnubsieve(jt,(x))
#define nubsievesp(x)               jtnubsievesp(jt,(x))
#define numb(x0,x1,x2,x3)           jtnumb(jt,(x0),(x1),(x2),(x3))
#define numbpx(x,y,z)               jtnumbpx(jt,(x),(y),(z))
#define numcase(x0,x1,x2,x3,x4,x5,x6)               jtnumcase(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6))
#define numd(x,y,z)                 jtnumd(jt,(x),(y),(z))
#define nume(x,y,z)                 jtnume(jt,(x),(y),(z))
#define numi(x,y,z)                 jtnumi(jt,(x),(y),(z))
#define numj(x,y,z)                 jtnumj(jt,(x),(y),(z))
#define numq(x,y,z)                 jtnumq(jt,(x),(y),(z))
#define numr(x,y,z)                 jtnumr(jt,(x),(y),(z))
#define numx(x,y,z)                 jtnumx(jt,(x),(y),(z))
#define nvrpop(x)                   jtnvrpop(jt,(x))
#define nvrpush(x)                  jtnvrpush(jt,(x))
#define nvrredef(x)                 jtnvrredef(jt,(x))
#define oblique(x,y)                jtoblique(jt,(x),(y))
#define obqfslash(x,y)              jtobqfslash(jt,(x),(y))
#define obverse(x,y)                jtobverse(jt,(x),(y))
#define odom(x,y,z)                 jtodom(jt,(x),(y),(z))
#define ofxassoc(x,y,z)             jtofxassoc(jt,(x),(y),(z))
#define oind(x)                     jtoind(jt,(x))
#define omask(x,y)                  jtomask(jt,(x),(y))
#define onf1(x,y)                   jtonf1(jt,(x),(y))
#define onm(x)                      jtonm(jt,(x))     
#define ope(x)                      jtope(jt,(x)) 
#define opes(x,y,z)                 jtopes(jt,(x),(y),(z))
#define opes1(x0,x1,x2,x3,x4,x5)    jtopes1(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define opes2(x0,x1,x2,x3,x4,x5,x6) jtopes2(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6))
#define ord(x)                      jtord(jt,(x))
#define ordstat(x,y)                jtordstat(jt,(x),(y))
#define osub(x,y)                   jtosub(jt,(x),(y))
#define outfix(x,y,z)               jtoutfix(jt,(x),(y),(z))
#define over(x,y)                   jtover(jt,(x),(y))
#define ovgmove(x0,x1,x2,x3,x4,x5,x6)               jtovgmove(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6))
#define ovs(x,y)                    jtovs(jt,(x),(y))
#define ovs0(x0,x1,x2,x3)           jtovs0(jt,(x0),(x1),(x2),(x3))
#define ovv(x,y)                    jtovv(jt,(x),(y))
#define pad(x,y,z)                  jtpad(jt,(x),(y),(z))
#define parse(x)                    jtparse(jt,(x))
#define parsea(x)                   jtparsea(jt,(x))
#define parseas(x,y)                jtparseas(jt,(x),(y))
#define parseinit()                 jtparseinit(jt)
#define parsex(x0,x1,x2,x3)         jtparsex(jt,(x0),(x1),(x2),(x3))
#define partfscan(x0,x1,x2,x3,x4,x5)                jtpartfscan(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define pathit(x)                   jtpathit(jt,(x))
#define paxis(x,y)                  jtpaxis(jt,(x),(y))
#define pcvt(x,y)                   jtpcvt(jt,(x),(y))
#define pdef(x0,x1,x2,x3,x4,x5,x6)  jtpdef(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6))
#define pdt(x,y)                    jtpdt(jt,(x),(y))
#define pdtby(x,y)                  jtpdtby(jt,(x),(y))
#define pdtsp(x,y)                  jtpdtsp(jt,(x),(y))
#define pdtspmv(x,y)                jtpdtspmv(jt,(x),(y))
#define pdtspmm(x,y)                jtpdtspmm(jt,(x),(y))
#define pdtspmm0(x,y)               jtpdtspmm0(jt,(x),(y))
#define pdtspmm1(x,y)               jtpdtspmm1(jt,(x),(y))
#define pdtspmm01(x,y)              jtpdtspmm01(jt,(x),(y))
#define pdtspvm(x,y)                jtpdtspvm(jt,(x),(y))
#define pdtspvmmv01(x,y)            jtpdtspvmmv01(jt,(x),(y))
#define pdtspvmmv0or1(x,y)          jtpdtspvmmv0or1(jt,(x),(y))
#define pdtspvv(x,y)                jtpdtspvv(jt,(x),(y))
#define pfill(x,y)                  jtpfill(jt,(x),(y))
#define piev(x,y)                   jtpiev(jt,(x),(y))
#define pind(x,y)                   jtpind(jt,(x),(y))
#define pinit()                     jtpinit(jt)
#define pinv(x)                     jtpinv(jt,(x))
#define pix(x)                      jtpix(jt,(x))
#define plt(x)                      jtplt(jt,(x))
#define plus(x,y)                   jtplus(jt,(x),(y))   
#define ply1(x,y)                   jtply1(jt,(x),(y))
#define pmarea2(x,y)                jtpmarea2(jt,(x),(y))
#define pmfree(x)                   jtpmfree(jt,(x))
#define pmrecord(x0,x1,x2,x3)       jtpmrecord(jt,(x0),(x1),(x2),(x3))
#define pollard_p_1(x)              jtpollard_p_1(jt,(x))
#define pollard_rho(x)              jtpollard_rho(jt,(x))
#define poly1(x)                    jtpoly1(jt,(x))   
#define poly2(x,y)                  jtpoly2(jt,(x),(y))
#define poly2a(x,y)                 jtpoly2a(jt,(x),(y))
#define polymult(x,y,z)             jtpolymult(jt,(x),(y),(z))
#define pospow(x,y)                 jtpospow(jt,(x),(y))
#define powop(x,y)                  jtpowop(jt,(x),(y)) 
#define powseqlim(x,y)              jtpowseqlim(jt,(x),(y)) 
#define prefix(x,y)                 jtprefix(jt,(x),(y))
#define prep(x)                     jtprep(jt,(x))
#define preparse(x,y,z)             jtpreparse(jt,(x),(y),(z))
#define prevprime(x)                jtprevprime(jt,(x))   
#define prime(x)                    jtprime(jt,(x))   
#define prime1(x)                   jtprime1(jt,(x)) 
#define prime1d(x)                  jtprime1d(jt,(x)) 
#define primetest(x)                jtprimetest(jt,(x)) 
#define primitive(x)                jtprimitive(jt,(x))
#define probe(x,y)                  jtprobe(jt,(x),(y))
#define probeis(x,y)                jtprobeis(jt,(x),(y))
#define probenum(x)                 jtprobenum(jt,(x))  
#define prod(x,y)                   jtprod(jt,(x),(y))
#define pscan(x,y)                  jtpscan(jt,(x),(y))
#define pscangt(x0,x1,x2,x3,x4,x5,x6,x7,x8)         jtpscangt(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8))
#define pscanlt(x0,x1,x2,x3,x4,x5)  jtpscanlt(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define qbin(x,y)                   jtqbin(jt,(x),(y))
#define qco2(x,y)                   jtqco2(jt,(x),(y))
#define qco2x(x,y)                  jtqco2x(jt,(x),(y))
#define qcompare(x,y)               jtqcompare(jt,(x),(y))
#define qdiv(x,y)                   jtqdiv(jt,(x),(y))
#define qgcd(x,y)                   jtqgcd(jt,(x),(y))
#define qlcm(x,y)                   jtqlcm(jt,(x),(y))
#define qlogd1(x)                   jtqlogd1(jt,(x))
#define qlogz1(x)                   jtqlogz1(jt,(x))
#define qminus(x,y)                 jtqminus(jt,(x),(y))
#define qplus(x,y)                  jtqplus(jt,(x),(y))
#define qpow(x,y)                   jtqpow(jt,(x),(y))
#define qq(x,y)                     jtqq(jt,(x),(y)) 
#define qr(x)                       jtqr(jt,(x))  
#define qrem(x,y)                   jtqrem(jt,(x),(y))
#define qrr(x)                      jtqrr(jt,(x))  
#define qstd(x)                     jtqstd(jt,(x))
#define qtymes(x,y)                 jtqtymes(jt,(x),(y))
#define ra(x)                       jtra(jt,(x))
#define ra1(x)                      jtra1(jt,(x))
#define raa(x,y)                    jtraa(jt,(x),(y))
#define ranec(x0,x1,x2,x3,x4,x5)    jtranec(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define rank1ex(x0,x1,x2,x3)        jtrank1ex(jt,(x0),(x1),(x2),(x3))
#define rank2ex(x0,x1,x2,x3,x4,x5)  jtrank2ex(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define rankingb(x0,x1,x2,x3,x4,x5) jtrankingb(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define rat(x)                      jtrat(jt,(x))
#define ravel(x)                    jtravel(jt,(x))   
#define raze(x)                     jtraze(jt,(x))    
#define razecut2(x,y,z)             jtrazecut2(jt,(x),(y),(z))    
#define razeg(x0,x1,x2,x3,x4,x5)    jtrazeg(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define razeh(x)                    jtrazeh(jt,(x))    
#define rc(x,y,z)                   jtrc(jt,(x),(y),(z)) 
#define rca(x)                      jtrca(jt,(x))
#define rd(x,y,z)                   jtrd(jt,(x),(y),(z)) 
#define rdns(x)                     jtrdns(jt,(x))   
#define rdot1(x)                    jtrdot1(jt,(x))   
#define reaxis(x,y)                 jtreaxis(jt,(x),(y))
#define recip(x)                    jtrecip(jt,(x))   
#define rect(x)                     jtrect(jt,(x))
#define red0(x,y)                   jtred0(jt,(x),(y))
#define redcatsp(x,y,z)             jtredcatsp(jt,(x),(y),(z))
#define redef(x,y)                  jtredef(jt,(x),(y))
#define redefg(x)                   jtredefg(jt,(x))
#define redg(x,y)                   jtredg(jt,(x),(y))
#define redsp1(x0,x1,x2,x3,x4,x5,x6,x7)             jtredsp1(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7))
#define redsp1a(x0,x1,x2,x3,x4,x5)                  jtredsp1a(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define redspd(x0,x1,x2,x3,x4,x5,x6,x7)             jtredspd(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7))
#define redsps(x0,x1,x2,x3,x4,x5,x6,x7)             jtredsps(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7))
#define redspse(x0,x1,x2,x3,x4,x5,x6,x7)            jtredspse(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7))
#define redspsprep(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12)  jtredspsprep(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8),(x9),(x10),(x11),(x12))
#define reduce(x,y)                 jtreduce(jt,(x),(y))
#define reduce2(x0,x1,x2,x3,x4)     jtreduce2(jt,(x0),(x1),(x2),(x3),(x4))
#define reducesp(x,y)               jtreducesp(jt,(x),(y))
#define reitem(x,y)                 jtreitem(jt,(x),(y)) 
#define remdd(x,y)                  jtremdd(jt,(x),(y))
#define remid(x,y)                  jtremid(jt,(x),(y))
#define rep1d(x0,x1,x2,x3)          jtrep1d(jt,(x0),(x1),(x2),(x3))
#define rep1s(x0,x1,x2,x3)          jtrep1s(jt,(x0),(x1),(x2),(x3))
#define rep1sa(x,y,z)               jtrep1sa(jt,(x),(y),(z))
#define repbdx(x0,x1,x2,x3)         jtrepbdx(jt,(x0),(x1),(x2),(x3))
#define repbsx(x0,x1,x2,x3)         jtrepbsx(jt,(x0),(x1),(x2),(x3))
#define repeat(x,y)                 jtrepeat(jt,(x),(y)) 
#define repeatr(x,y)                jtrepeatr(jt,(x),(y))
#define repidx(x0,x1,x2,x3)         jtrepidx(jt,(x0),(x1),(x2),(x3))
#define repisx(x0,x1,x2,x3)         jtrepisx(jt,(x0),(x1),(x2),(x3))
#define repzdx(x0,x1,x2,x3)         jtrepzdx(jt,(x0),(x1),(x2),(x3))
#define repzsx(x0,x1,x2,x3)         jtrepzsx(jt,(x0),(x1),(x2),(x3))
#define reshape(x,y)                jtreshape(jt,(x),(y))
#define reshapesp(x0,x1,x2,x3)      jtreshapesp(jt,(x0),(x1),(x2),(x3))
#define reshapesp0(x0,x1,x2,x3)     jtreshapesp0(jt,(x0),(x1),(x2),(x3))
#define residue(x,y)                jtresidue(jt,(x),(y))
#define reverse(x)                  jtreverse(jt,(x)) 
#define revsp(x)                    jtrevsp(jt,(x)) 
#define rezero(x,y)                 jtrezero(jt,(x),(y))
#define rfc(x)                      jtrfc(jt,(x))
#define rfcq(x0,x1,x2,x3)           jtrfcq(jt,(x0),(x1),(x2),(x3))
#define rfcz(x,y)                   jtrfcz(jt,(x),(y))
#define rfd(x)                      jtrfd(jt,(x))
#define rinv(x)                     jtrinv(jt,(x))
#define rmdir1(x)                   jtrmdir1(jt,(x))
#define rngga(x,y)                  jtrngga(jt,(x),(y))
#define rnginit()                   jtrnginit(jt)
#define rngseeds(x)                 jtrngseeds(jt,(x))
#define rngselects(x)               jtrngselects(jt,(x))
#define rngstates1(x0,x1,x2,x3,x4,x5,x6)         jtrngstates1(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6))
#define roll(x)                     jtroll(jt,(x))
#define roll2(x,y)                  jtroll2(jt,(x),(y))
#define rollany(x,y)                jtrollany(jt,(x),(y))
#define rollbool(x)                 jtrollbool(jt,(x))
#define rollk(x,y,z)                jtrollk(jt,(x),(y),(z))    
#define rollksub(x,y)               jtrollksub(jt,(x),(y))    
#define rollnot0(x,y)               jtrollnot0(jt,(x),(y))
#define rollxnum(x)                 jtrollxnum(jt,(x))
#define root(x,y)                   jtroot(jt,(x),(y)) 
#define rot(x0,x1,x2,x3,x4,x5,x6,x7)                jtrot(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7))  
#define rotate(x,y)                 jtrotate(jt,(x),(y)) 
#define rotsp(x,y)                  jtrotsp(jt,(x),(y))
#define roundID(x,y)                jtroundID(jt,(x),(y))
#define rsh0(x)                     jtrsh0(jt,(x))
#define rsort(x)                    jtrsort(jt,(x))
#define sb2(x,y)                    jtsb2(jt,(x),(y))
#define sbbox(x)                    jtsbbox(jt,(x))
#define sbcheck(x)                  jtsbcheck(jt,(x))
#define sbcheck1(x0,x1,x2,x3,x4,x5,x6,x7)           jtsbcheck1(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7))
#define sbextend(x0,x1,x2,x3)       jtsbextend(jt,(x0),(x1),(x2),(x3))
#define sbgetdata(x)                jtsbgetdata(jt,(x))
#define sbhashstat(x)               jtsbhashstat(jt,(x))
#define sbinsert(x0,x1,x2,x3,x4)    jtsbinsert(jt,(x0),(x1),(x2),(x3),(x4))
#define sblit(x,y)                  jtsblit(jt,(x),(y))
#define sborder(x)                  jtsborder(jt,(x))
#define sbprobe(x,y,z)              jtsbprobe(jt,(x),(y),(z))
#define sbsetdata(x)                jtsbsetdata(jt,(x))
#define sbstr(x,y)                  jtsbstr(jt,(x),(y))
#define sbtypeinit()                jtsbtypeinit(jt)
#define sbunbox(x)                  jtsbunbox(jt,(x))
#define sbunind(x)                  jtsbunind(jt,(x))
#define sbunlit(x,y)                jtsbunlit(jt,(x),(y))
#define sbunstr(x,y)                jtsbunstr(jt,(x),(y))
#define sc(x)                       jtsc(jt,(x))
#define sc4(x,y)                    jtsc4(jt,(x),(y))
#define scansp(x,y,z)               jtscansp(jt,(x),(y),(z))
#define scb(x)                      jtscb(jt,(x))
#define scc(x)                      jtscc(jt,(x))
#define scf(x)                      jtscf(jt,(x))
#define scfn(x)                     jtscfn(jt,(x))
#define scheck(x)                   jtscheck(jt,(x))
#define scind(x)                    jtscind(jt,(x))
#define scuba(x,y,z)                jtscuba(jt,(x),(y),(z))
#define scubb(x,y)                  jtscubb(jt,(x),(y))
#define scubc(x,y,z)                jtscubc(jt,(x),(y),(z))
#define scube(x,y,z)                jtscube(jt,(x),(y),(z))
#define scx(x)                      jtscx(jt,(x))
#define seecall(x)                  jtseecall(jt,(x))
#define seeparse(x)                 jtseeparse(jt,(x))
#define seg(x,y)                    jtseg(jt,(x),(y))   
#define selfq(x)                    jtselfq(jt,(x))
#define selm(x)                     jtselm(jt,(x))
#define selx(x,y,z)                 jtselx(jt,(x),(y),(z))
#define sely(x0,x1,x2,x3)           jtsely(jt,(x0),(x1),(x2),(x3))
#define sent12b(x,y,z)              jtsent12b(jt,(x),(y),(z))
#define sent12c(x,y,z)              jtsent12c(jt,(x),(y),(z))
#define sesminit()                  jtsesminit(jt)
#define setfv(x,y)                  jtsetfv(jt,(x),(y))
#define sfn(x,y)                    jtsfn(jt,(x),(y))
#define shape(x)                    jtshape(jt,(x))   
#define shift1(x)                   jtshift1(jt,(x))
#define shift10(x,y)                jtshift10(jt,(x),(y))
#define showerr()                   jtshowerr(jt)
#define signum(x)                   jtsignum(jt,(x))  
#define slash(x)                    jtslash(jt,(x))   
#define sldot(x)                    jtsldot(jt,(x))
#define sm_init(x)                  jtsm_init(jt,(x))
#define smallprimes(x0,x1,x2,x3)    jtsmallprimes(jt,(x0),(x1),(x2),(x3))
#define smma(x,y)                   jtsmma(jt,(x),(y))
#define smmblkf(x)                  jtsmmblkf(jt,(x))
#define smmblku(x)                  jtsmmblku(jt,(x))
#define smmcar(x,y)                 jtsmmcar(jt,(x),(y))
#define smmga(x0,x1,x2,x3,x4)       jtsmmga(jt,(x0),(x1),(x2),(x3),(x4))
#define smmin(x,y)                  jtsmmin(jt,(x),(y))
#define smminit(x)                  jtsmminit(jt,(x))
#define smmis(x,y)                  jtsmmis(jt,(x),(y))
#define smmjoin(x,y)                jtsmmjoin(jt,(x),(y))
#define snl(x)                      jtsnl(jt,(x))
#define sortb(x0,x1,x2,x3)          jtsortb(jt,(x0),(x1),(x2),(x3))
#define sortb2(x0,x1,x2,x3)         jtsortb2(jt,(x0),(x1),(x2),(x3))
#define sortb4(x0,x1,x2,x3)         jtsortb4(jt,(x0),(x1),(x2),(x3))
#define sortc(x0,x1,x2,x3)          jtsortc(jt,(x0),(x1),(x2),(x3))
#define sortc2(x0,x1,x2,x3)         jtsortc2(jt,(x0),(x1),(x2),(x3))
#define sortd(x0,x1,x2,x3)          jtsortd(jt,(x0),(x1),(x2),(x3))
#define sorti(x0,x1,x2,x3)          jtsorti(jt,(x0),(x1),(x2),(x3))
#define sorti1(x0,x1,x2,x3)         jtsorti1(jt,(x0),(x1),(x2),(x3))
#define sp(x)                       jtsp(jt,(x))
#define sparse1(x)                  jtsparse1(jt,(x)) 
#define sparse1a(x0,x1,x2,x3,x4)    jtsparse1a(jt,(x0),(x1),(x2),(x3),(x4))
#define sparseit(x,y,z)             jtsparseit(jt,(x),(y),(z))
#define sparsen1(x)                 jtsparsen1(jt,(x))
#define sparsep1(x)                 jtsparsep1(jt,(x))
#define spc()                       jtspc(jt)
#define spdscell(x0,x1,x2,x3,x4)    jtspdscell(jt,(x0),(x1),(x2),(x3),(x4))
#define spella(x)                   jtspella(jt,(x))
#define spellcon(x)                 jtspellcon(jt,(x))
#define spellout(x)                 jtspellout(jt,(x))
#define spfor1(x)                   jtspfor1(jt,(x))
#define spfree()                    jtspfree(jt)
#define splitij(x,y,z)              jtsplitij(jt,(x),(y),(z))
#define spmult(x0,x1,x2,x3,x4,x5,x6,x7)             jtspmult(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7))
#define spmultdo(x0,x1,x2,x3)       jtspmultdo(jt,(x0),(x1),(x2),(x3))
#define spradv(x0,x1,x2,x3,x4,x5,x6)                jtspradv(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6))
#define sprank1(x0,x1,x2,x3)        jtsprank1(jt,(x0),(x1),(x2),(x3))
#define sprank2(x0,x1,x2,x3,x4,x5)  jtsprank2(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define sprank2_0w(x0,x1,x2,x3,x4,x5)               jtsprank2_0w(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define sprank2_a0(x0,x1,x2,x3,x4,x5)               jtsprank2_a0(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define sprarg(x,y)                 jtsprarg(jt,(x),(y)) 
#define spredge(x,y,z)              jtspredge(jt,(x),(y),(z))  
#define sprinit(x0,x1,x2,x3,x4)     jtsprinit(jt,(x0),(x1),(x2),(x3),(x4))
#define sprintfeD(x0,x1,x2,x3,x4)   jtsprintfeD(jt,(x0),(x1),(x2),(x3),(x4))
#define sprintfnD(x0,x1,x2,x3,x4)   jtsprintfnD(jt,(x0),(x1),(x2),(x3),(x4))
#define sprintfI(x0,x1,x2,x3,x4)    jtsprintfI(jt,(x0),(x1),(x2),(x3),(x4))
#define sprz(x0,x1,x2,x3,x4)        jtsprz(jt,(x0),(x1),(x2),(x3),(x4))
#define spspd(x0,x1,x2,x3)          jtspspd(jt,(x0),(x1),(x2),(x3))
#define spspi(x0,x1,x2,x3)          jtspspi(jt,(x0),(x1),(x2),(x3))
#define spspx(x0,x1,x2,x3)          jtspspx(jt,(x0),(x1),(x2),(x3))
#define spsscell(x0,x1,x2,x3,x4)    jtspsscell(jt,(x0),(x1),(x2),(x3),(x4))
#define sqroot(x)                   jtsqroot(jt,(x))  
#define square(x)                   jtsquare(jt,(x))  
#define sscan(x,y)                  jtsscan(jt,(x),(y))
#define ssdo(x,y,z)                 jtssdo(jt,(x),(y),(z))
#define ssel(x,y)                   jtssel(jt,(x),(y))
#define ssg(x,y)                    jtssg(jt,(x),(y))
#define ssgu(x,y)                   jtssgu(jt,(x),(y))
#define sslope(x,y,z)               jtsslope(jt,(x),(y),(z))
#define ssnext(x,y)                 jtssnext(jt,(x),(y))
#define stcreate(x0,x1,x2,x3)       jtstcreate(jt,(x0),(x1),(x2),(x3))
#define stdf(x)                     jtstdf(jt,(x))
#define stdnm(x)                    jtstdnm(jt,(x))
#define stfind(x,y,z)               jtstfind(jt,(x),(y),(z))
#define stfindnum(x,y)              jtstfindnum(jt,(x),(y))
#define stitch(x,y)                 jtstitch(jt,(x),(y)) 
#define stitchsp2(x,y)              jtstitchsp2(jt,(x),(y)) 
#define str(x,y)                    jtstr(jt,(x),(y))
#define str0(x)                     jtstr0(jt,(x))
#define suffix(x,y)                 jtsuffix(jt,(x),(y))
#define sumatgbool(x,y,z)           jtsumatgbool(jt,(x),(y),(z))
#define sumattymes(x,y,z)           jtsumattymes(jt,(x),(y),(z))
#define summag(x)                   jtsummag(jt,(x))
#define sup(x,y)                    jtsup(jt,(x),(y))
#define suq(x,y)                    jtsuq(jt,(x),(y))
#define susp()                      jtsusp(jt)
#define swap(x)                     jtswap(jt,(x)) 
#define swapc(x)                    jtswapc(jt,(x)) 
#define symbinit()                  jtsymbinit(jt)
#define symbis(x,y,z)               jtsymbis(jt,(x),(y),(z))
#define symbrd(x)                   jtsymbrd(jt,(x))
#define symbrdlock(x)               jtsymbrdlock(jt,(x))
#define symext(x)                   jtsymext(jt,(x))
#define symfree(x)                  jtsymfree(jt,(x))
#define symfreeh(x,y)               jtsymfreeh(jt,(x),(y))
#define symfreeha(x)                jtsymfreeha(jt,(x))
#define symnew(x)                   jtsymnew(jt,(x))
#define sympoola(x)                 jtsympoola(jt,(x))
#define syrd(x,y)                   jtsyrd(jt,(x),(y))
#define syrd1(x,y,z)                jtsyrd1(jt,(x),(y),(z))
#define table(x)                    jttable(jt,(x))   
#define tail(x)                     jttail(jt,(x))    
#define take(x,y)                   jttake(jt,(x),(y))   
#define taker(x,y)                  jttaker(jt,(x),(y))   
#define tally(x)                    jttally(jt,(x))   
#define tayamp(x0,x1,x2,x3)         jttayamp(jt,(x0),(x1),(x2),(x3))
#define tayatop(x)                  jttayatop(jt,(x))
#define tayfolk(x)                  jttayfolk(jt,(x))
#define tayinv(x,y)                 jttayinv(jt,(x),(y))
#define taysum(x)                   jttaysum(jt,(x))
#define tcap(x,y)                   jttcap(jt,(x),(y))   
#define tceil(x)                    jttceil(jt,(x)) 
#define tclosure(x,y)               jttclosure(jt,(x),(y))   
#define tco(x)                      jttco(jt,(x))     
#define tcoamp(x0,x1,x2,x3)         jttcoamp(jt,(x0),(x1),(x2),(x3))
#define tconnect(x)                 jttconnect(jt,(x))
#define tdot(x)                     jttdot(jt,(x))   
#define teq(x,y)                    jtteq(jt,(x),(y))
#define tesa(x,y)                   jttesa(jt,(x),(y))
#define tesmat(x0,x1,x2,x3,x4)      jttesmat(jt,(x0),(x1),(x2),(x3),(x4))
#define tesmatu(x0,x1,x2,x3,x4)     jttesmatu(jt,(x0),(x1),(x2),(x3),(x4))
#define tesos(x,y,z)                jttesos(jt,(x),(y),(z))
#define tess2(x,y,z)                jttess2(jt,(x),(y),(z))
#define tf()                        jttf(jt)
#define tfloor(x)                   jttfloor(jt,(x)) 
#define tg()                        jttg(jt)
#define th2a(x0,x1,x2,x3,x4,x5,x6,x7,x8)            jtth2a(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8))
#define th2box(x,y)                 jtth2box(jt,(x),(y))
#define th2c(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9)         jtth2c(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8),(x9))
#define th2ctrl(x0,x1,x2,x3,x4,x5)  jtth2ctrl(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define thbit(x)                    jtthbit(jt,(x))
#define thb(x)                      jtthb(jt,(x))
#define thbox(x)                    jtthbox(jt,(x))
#define thdx1(x)                    jtthdx1(jt,(x))
#define thn(x)                      jtthn(jt,(x))
#define thorn1(x)                   jtthorn1(jt,(x))  
#define thq1(x)                     jtthq1(jt,(x))
#define ths(x)                      jtths(jt,(x))
#define thsb(x)                     jtthsb(jt,(x))
#define thv(x,y,z)                  jtthv(jt,(x),(y),(z))
#define thx1(x)                     jtthx1(jt,(x))
#define thxqe(x)                    jtthxqe(jt,(x))
#define tie(x,y)                    jttie(jt,(x),(y))
#define tine(x)                     jttine(jt,(x))
#define tk(x,y)                     jttk(jt,(x),(y)) 
#define tk0(x,y,z)                  jttk0(jt,(x),(y),(z)) 
#define tks(x,y)                    jttks(jt,(x),(y)) 
#define tleaf(x)                    jttleaf(jt,(x))
#define tlt(x,y)                    jttlt(jt,(x),(y))
#define toc1(x,y)                   jttoc1(jt,(x),(y))
#define toc2(x)                     jttoc2(jt,(x))
#define toc2e(x)                    jttoc2e(jt,(x))
#define tokens(x)                   jttokens(jt,(x))
#define totient(x)                  jttotient(jt,(x))
#define toutf8(x)                   jttoutf8(jt,(x))
#define toutf16(x)                  jttoutf16(jt,(x))
#define toutf16x(x)                 jttoutf16x(jt,(x))
#define tparse(x)                   jttparse(jt,(x))
#define tpoly(x)                    jttpoly(jt,(x))
#define tpop(x)                     jttpop(jt,(x))  
#define tpush(x)                    jttpush(jt,(x))
#define traverse(x,y)               jttraverse(jt,(x),(y))
#define trc(x)                      jttrc(jt,(x))     
#define treach(x)                   jttreach(jt,(x))
#define trep(x)                     jttrep(jt,(x))
#define tridiag(x,y,z)              jttridiag(jt,(x),(y),(z))
#define troot(x,y)                  jttroot(jt,(x),(y))
#define trr(x)                      jttrr(jt,(x))
#define tryinit(x,y,z)              jttryinit(jt,(x),(y),(z))
#define ts(x)                       jtts(jt,(x))
#define tsit2(x,y)                  jttsit2(jt,(x),(y))
#define tymes(x,y)                  jttymes(jt,(x),(y))
#define uco1(x)                     jtuco1(jt,(x))
#define uco2(x,y)                   jtuco2(jt,(x),(y))
#define unbinr(x0,x1,x2,x3,x4)      jtunbinr(jt,(x0),(x1),(x2),(x3),(x4))
#define under(x,y)                  jtunder(jt,(x),(y))  
#define unh(x)                      jtunh(jt,(x))
#define unhex(x)                    jtunhex(jt,(x))
#define unlj(x)                     jtunlj(jt,(x))
#define unlk(x)                     jtunlk(jt,(x))
#define unlock1(x)                  jtunlock1(jt,(x))
#define unlock2(x,y)                jtunlock2(jt,(x),(y))
#define unname(x)                   jtunname(jt,(x))
#define unparse(x)                  jtunparse(jt,(x))
#define unparse1(x0,x1,x2,x3)       jtunparse1(jt,(x0),(x1),(x2),(x3))
#define unparse1a(x,y,z)            jtunparse1a(jt,(x),(y),(z))
#define unparsem(x,y)               jtunparsem(jt,(x),(y))
#define unquote(x,y,z)              jtunquote(jt,(x),(y),(z))
#define unstackcv(x)                jtunstackcv(jt,(x))
#define unzero(x)                   jtunzero(jt,(x))
#define upon2(x,y,z)                jtupon2(jt,(x),(y),(z))
#define uponf2(x,y,z)               jtuponf2(jt,(x),(y),(z))
#define usebs(x,y,z)                jtusebs(jt,(x),(y),(z))
#define utype(x,y)                  jtutype(jt,(x),(y))
#define v2(x,y)                     jtv2(jt,(x),(y))
#define va1(x,y)                    jtva1(jt,(x),(y))
#define va1s(x0,x1,x2,x3)           jtva1s(jt,(x0),(x1),(x2),(x3))
#define va2(x,y,z)                  jtva2(jt,(x),(y),(z))
#define vaid(x)                     jtvaid(jt,(x))
#define vains(x0,x1,x2,x3)          jtvains(jt,(x0),(x1),(x2),(x3))
#define vapfx(x0,x1,x2,x3)          jtvapfx(jt,(x0),(x1),(x2),(x3))
#define var(x0,x1,x2,x3,x4,x5,x6)   jtvar(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6))
#define vasfx(x0,x1,x2,x3)          jtvasfx(jt,(x0),(x1),(x2),(x3))
#define vasp(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12)     jtvasp(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8),(x9),(x10),(x11),(x12))
#define vasp0(x0,x1,x2,x3,x4,x5)                            jtvasp0(jt,(x0),(x1),(x2),(x3),(x4),(x5))
#define vaspc(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12)    jtvaspc(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8),(x9),(x10),(x11),(x12))
#define vaspeq(x0,x1,x2,x3,x4,x5,x6,x7,x8)                  jtvaspeq(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8))
#define vaspeqprep(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11)   jtvaspeqprep(jt,(x0),(x1),(x2),(x3),(x4),(x5),(x6),(x7),(x8),(x9),(x10),(x11))
#define vaspz(x)                    jtvaspz(jt,(x))
#define vaxis(x,y)                  jtvaxis(jt,(x),(y))
#define vc1(x,y)                    jtvc1(jt,(x),(y))
#define vci(x)                      jtvci(jt,(x))
#define vec(x,y,z)                  jtvec(jt,(x),(y),(z))
#define vfinal(x)                   jtvfinal(jt,(x))
#define vfn(x)                      jtvfn(jt,(x))
#define vger2(x,y,z)                jtvger2(jt,(x),(y),(z))
#define vi(x)                       jtvi(jt,(x))
#define vib(x)                      jtvib(jt,(x))
#define vip(x)                      jtvip(jt,(x))
#define vlocnl(x,y)                 jtvlocnl(jt,(x),(y))
#define vmove(x,y,z)                jtvmove(jt,(x),(y),(z))
#define vnm(x,y)                    jtvnm(jt,(x),(y))
#define vs(x)                       jtvs(jt,(x))
#define vtokens(x)                  jtvtokens(jt,(x))
#define vtrans(x)                   jtvtrans(jt,(x))
#define wa(x,y,z)                   jtwa(jt,(x),(y),(z))
#define weight(x,y)                 jtweight(jt,(x),(y)) 
#define widthdp(x,y,z)              jtwidthdp(jt,(x),(y),(z)) 
#define wordil(x)                   jtwordil(jt,(x))
#define words(x)                    jtwords(jt,(x)) 
#define x10(x)                      jtx10(jt,(x))
#define xbin(x,y)                   jtxbin(jt,(x),(y))
#define xbinp(x,y)                  jtxbinp(jt,(x),(y))
#define xc(x)                       jtxc(jt,(x))
#define xco1(x)                     jtxco1(jt,(x))    
#define xco2(x,y)                   jtxco2(jt,(x),(y))
#define xcompare(x,y)               jtxcompare(jt,(x),(y))
#define xcvt(x,y)                   jtxcvt(jt,(x),(y)) 
#define xdefn(x,y,z)                jtxdefn(jt,(x),(y),(z))
#define xd1(x)                      jtxd1(jt,(x))
#define xdiv(x,y,z)                 jtxdiv(jt,(x),(y),(z))
#define xdivrem(x0,x1,x2,x3)        jtxdivrem(jt,(x0),(x1),(x2),(x3))
#define xev1(x,y)                   jtxev1(jt,(x),(y))
#define xev2(x,y,z)                 jtxev2(jt,(x),(y),(z))
#define xexp(x,y)                   jtxexp(jt,(x),(y))
#define xfact(x)                    jtxfact(jt,(x))
#define xfactor(x)                  jtxfactor(jt,(x))
#define xgcd(x,y)                   jtxgcd(jt,(x),(y))
#define xint(x)                     jtxint(jt,(x))
#define xlcm(x,y)                   jtxlcm(jt,(x),(y))
#define xlinit()                    jtxlinit(jt)
#define xlog1(x)                    jtxlog1(jt,(x))
#define xlog2(x,y)                  jtxlog2(jt,(x),(y))
#define xlog2sub(x,y)               jtxlog2sub(jt,(x),(y))
#define xlogabs(x)                  jtxlogabs(jt,(x))
#define xlogd1(x)                   jtxlogd1(jt,(x))
#define xlogz1(x)                   jtxlogz1(jt,(x))
#define xminus(x,y)                 jtxminus(jt,(x),(y))
#define xmodpow(x,y,z)              jtxmodpow(jt,(x),(y),(z))
#define xoinit()                    jtxoinit(jt)
#define xop(x)                      jtxop(jt,(x))
#define xopcall(x)                  jtxopcall(jt,(x))
#define xpi(x)                      jtxpi(jt,(x))
#define xplus(x,y)                  jtxplus(jt,(x),(y))
#define xpow(x,y)                   jtxpow(jt,(x),(y))
#define xprimeq(x,y)                jtxprimeq(jt,(x),(y)) 
#define xprimetest(x)               jtxprimetest(jt,(x))
#define xrand(x)                    jtxrand(jt,(x))
#define xrem(x,y)                   jtxrem(jt,(x),(y))
#define xrep(x,y)                   jtxrep(jt,(x),(y))
#define xroot(x,y)                  jtxroot(jt,(x),(y))
#define xsgn(x)                     jtxsgn(jt,(x))
#define xsinit()                    jtxsinit(jt)
#define xsq(x)                      jtxsq(jt,(x))
#define xsqrt(x)                    jtxsqrt(jt,(x))
#define xstd(x)                     jtxstd(jt,(x))
#define xtymes(x,y)                 jtxtymes(jt,(x),(y))
#define zacos(x)                    jtzacos(jt,(x))
#define zacosh(x)                   jtzacosh(jt,(x))
#define zarc(x)                     jtzarc(jt,(x))
#define zasin(x)                    jtzasin(jt,(x))
#define zasinh(x)                   jtzasinh(jt,(x))
#define zatan(x)                    jtzatan(jt,(x))
#define zatanh(x)                   jtzatanh(jt,(x))
#define zbin(x,y)                   jtzbin(jt,(x),(y))
#define zceil(x)                    jtzceil(jt,(x))
#define zcir(x,y)                   jtzcir(jt,(x),(y))
#define zconjug(x)                  jtzconjug(jt,(x))
#define zcos(x)                     jtzcos(jt,(x))
#define zcosh(x)                    jtzcosh(jt,(x))
#define zdiv(x,y)                   jtzdiv(jt,(x),(y))
#define zeq(x,y)                    jtzeq(jt,(x),(y))
#define zexp(x)                     jtzexp(jt,(x))
#define zfloor(x)                   jtzfloor(jt,(x))
#define zgamma(x)                   jtzgamma(jt,(x))
#define zgauss(x,y)                 jtzgauss(jt,(x),(y))
#define zgcd(x,y)                   jtzgcd(jt,(x),(y))
#define zgps(x)                     jtzgps(jt,(x))
#define zgrecur(x)                  jtzgrecur(jt,(x))
#define zhorner(x,y,z)              jtzhorner(jt,(x),(y),(z))
#define zjx(x)                      jtzjx(jt,(x))
#define zlcm(x,y)                   jtzlcm(jt,(x),(y))
#define zlog(x)                     jtzlog(jt,(x))
#define zm4(x)                      jtzm4(jt,(x))
#define zminus(x,y)                 jtzminus(jt,(x),(y))
#define zmj(x)                      jtzmj(jt,(x))
#define znegate(x)                  jtznegate(jt,(x))
#define zp4(x)                      jtzp4(jt,(x))
#define zp8(x)                      jtzp8(jt,(x))
#define zpad1(x,y,z)                jtzpad1(jt,(x),(y),(z))
#define zpadn(x,y,z)                jtzpadn(jt,(x),(y),(z))
#define zplus(x,y)                  jtzplus(jt,(x),(y))
#define zpow(x,y)                   jtzpow(jt,(x),(y))
#define zrem(x,y)                   jtzrem(jt,(x),(y))
#define zsin(x)                     jtzsin(jt,(x))
#define zsinh(x)                    jtzsinh(jt,(x))
#define zsqrt(x)                    jtzsqrt(jt,(x))
#define zstirling(x)                jtzstirling(jt,(x))
#define ztan(x)                     jtztan(jt,(x))
#define ztanh(x)                    jtztanh(jt,(x))
#define ztrend(x)                   jtztrend(jt,(x))
#define ztridiag(x,y,z)             jtztridiag(jt,(x),(y),(z))
#define ztymes(x,y)                 jtztymes(jt,(x),(y))