new file mode 100644
--- /dev/null
+++ b/a.c
@@ -0,0 +1,163 @@
+/* Copyright 1990-2011, Jsoftware Inc.  All rights reserved. */
+/* License in license.txt.                                   */
+/*                                                                         */
+/* Adverbs                                                                 */
+
+#include "j.h"
+
+
+static DF1(swap1){DECLF; R jt->rank?irs2(w,w,fs,jt->rank[1],jt->rank[1],f2):CALL2(f2,w,w,fs);}
+static DF2(swap2){DECLF; R jt->rank?irs2(w,a,fs,jt->rank[1],jt->rank[0],f2):CALL2(f2,w,a,fs);}
+
+F1(jtswap){A y;C*s;I n;
+ RZ(w); 
+ if(VERB&AT(w))R ADERIV(CTILDE,swap1,swap2,RMAX,rr(w),lr(w));
+ else{
+  if(C2T&AT(w))RZ(w=cvt(LIT,w)) else ASSERT(LIT&AT(w),EVDOMAIN);
+  ASSERT(1>=AR(w),EVRANK);
+  n=AN(w); s=CAV(w); 
+  ASSERT(vnm(n,s),EVILNAME); 
+  RZ(y=nfs(AN(w),CAV(w)));
+  R nameref(y);
+}}
+
+
+static B booltab[64]={
+ 0,0,0,0, 0,0,0,1, 0,0,1,0, 0,0,1,1,  0,1,0,0, 0,1,0,1, 0,1,1,0, 0,1,1,1,
+ 1,0,0,0, 1,0,0,1, 1,0,1,0, 1,0,1,1,  1,1,0,0, 1,1,0,1, 1,1,1,0, 1,1,1,1,
+};
+
+static DF2(jtbdot2){R from(plus(duble(cvt(B01,a)),cvt(B01,w)),VAV(self)->h);}
+
+static DF1(jtbdot1){R bdot2(zero,w,self);}
+
+static DF1(jtbasis1){DECLF;A z;D*x;I j;V*v;
+ PREF1(jtbasis1);
+ RZ(w=vi(w));
+ switch(*AV(w)){
+  case 0:
+   GA(z,FL,3,1,0); x=DAV(z); v=VAV(fs);
+   j=v->mr; x[0]=j<=-RMAX?-inf:j>=RMAX?inf:j;
+   j=v->lr; x[1]=j<=-RMAX?-inf:j>=RMAX?inf:j;
+   j=v->rr; x[2]=j<=-RMAX?-inf:j>=RMAX?inf:j;
+   R pcvt(INT,z);
+  case -1: R lrep(inv (fs));
+  case  1: R lrep(iden(fs));
+  default: ASSERT(0,EVDOMAIN);
+}}
+
+F1(jtbdot){A b,h=0;I j,n,*v;
+ RZ(w);
+ if(VERB&AT(w))R ADERIV(CBDOT, jtbasis1,0L, 0,0,0);
+ RZ(w=vi(w));
+ n=AN(w); v=AV(w);
+ if(1==n){j=*v; ASSERT(-16<=j&&j<=34,EVINDEX);}
+ else DO(n, j=*v++; ASSERT(-16<=j&&j<16,EVINDEX););
+ if(1!=n||j<16){
+  GA(b,B01,64,2,0); *AS(b)=16; *(1+AS(b))=4; MC(AV(b),booltab,64L);
+  RZ(h=cant2(IX(AR(w)),from(w,b)));
+  R fdef(CBDOT,VERB, jtbdot1,jtbdot2, w,0L,h, 0L, RMAX,0L,0L);
+ }else switch(j){
+  default: ASSERT(0,EVNONCE);
+  case 16: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise0000, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 17: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise0001, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 18: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise0010, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 19: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise0011, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 20: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise0100, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 21: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise0101, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 22: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise0110, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 23: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise0111, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 24: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise1000, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 25: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise1001, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 26: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise1010, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 27: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise1011, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 28: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise1100, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 29: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise1101, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 30: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise1110, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 31: R fdef(CBDOT,VERB, jtbitwise1,jtbitwise1111, w,0L,0L, VIRS2, 0L,0L,0L);
+  case 32: R ADERIV(CBDOT,jtbitwise1,jtbitwiserotate,0,0,0);
+  case 33: R ADERIV(CBDOT,jtbitwise1,jtbitwiseshift, 0,0,0);
+  case 34: R ADERIV(CBDOT,jtbitwise1,jtbitwiseshifta,0,0,0);
+}}
+
+
+/* The h parameter in self for u M.                 */
+/* 3 elememt boxed list                             */
+/* 0 - integer atom of # of entries in hash table   */
+/* 1 - 2-column integer table of arguments          */
+/*     arguments are machine word integers          */
+/*     column 1 is right arg; column 1 is left arg  */
+/*     column 0 is IMIN for monad                   */
+/* 2 - box list of results corresp. to arguments    */
+/*     unused entries are set to 0                  */
+
+#if SY_64
+#define HIC(x,y)  ((UI)x+10495464745870458733U*(UI)y)
+#else
+#define HIC(x,y)  ((UI)x+2838338383U*(UI)y)
+#endif
+
+static A jtmemoget(J jt,I x,I y,A self){A h,*hv,q;I*jv,k,m,*v;
+ h=VAV(self)->h; hv=AAV(h); 
+ q=hv[1]; jv=AV(q); m=*AS(q);
+ k=HIC(x,y)%m; v=jv+2*k; while(IMIN!=*v&&!(y==*v&&x==v[1])){v+=2; if(v==jv+2*m)v=jv;}
+ R*(AAV(hv[2])+(v-jv)/2);
+}
+
+static A jtmemoput(J jt,I x,I y,A self,A z){A*cv,h,*hv,q;I c,*jv,k,m,*mv,*v;
+ RZ(z);
+ c=AC(self); h=VAV(self)->h; hv=AAV(h);
+ q=hv[0]; mv= AV(q);
+ q=hv[1]; jv= AV(q);
+ q=hv[2]; cv=AAV(q); m=AN(q);
+ if(m<=2**mv){A cc,*cu=cv,jj;I i,*ju=jv,n=m,*u;
+  v=ptab; while(m>=*v)++v; m=*v;
+  RZ(jj=reshape(v2(m,2L),sc(IMIN))); jv= AV(jj);
+  GA(cc,BOX,m,1,0);                  cv=AAV(cc);
+  for(i=0,u=ju;i<n;++i,u+=2)if(IMIN!=*u){
+   k=HIC(x,y)%m; v=jv+2*k; while(IMIN!=*v){v+=2; if(v==jv+2*m)v=jv;}
+   cv[(v-jv)/2]=cu[i]; cu[i]=0; v[0]=u[0]; v[1]=u[1];
+  }
+  q=hv[1]; AC(q)=1; fa(q); AC(jj)+=c; hv[1]=jj;
+  q=hv[2]; AC(q)=1; fa(q); AC(cc)+=c; hv[2]=cc;
+ }
+ ++*mv;
+ k=HIC(x,y)%m; v=jv+2*k; while(IMIN!=*v){v+=2; if(v==jv+2*m)v=jv;}
+ cv[(v-jv)/2]=raa(c,z); v[0]=y; v[1]=x; 
+ R z;
+}
+
+static I jtint0(J jt,A w){A x;
+ if(AR(w))R IMIN;
+ if(NUMERIC&AT(w))switch(AT(w)){
+  case B01: R (I)*BAV(w);
+  case INT: R *AV(w);
+ }
+ x=pcvt(INT,w); 
+ R x&&INT&AT(x)?*AV(x):IMIN; 
+}
+
+DF1(jtmemo1){DECLF;A z;I x,y;
+ RZ(w);
+ x=IMIN; y=int0(w);
+ if(y==IMIN)R CALL1(f1,w,fs);
+ R (z=memoget(x,y,self))?z:memoput(x,y,self,CALL1(f1,w,fs));
+}
+
+DF2(jtmemo2){DECLF;A z;I x,y; 
+ RZ(a&&w);
+ x=int0(a); y=int0(w);
+ if(x==IMIN||y==IMIN)R CALL2(f2,a,w,fs);
+ R (z=memoget(x,y,self))?z:memoput(x,y,self,CALL2(f2,a,w,fs));
+}
+
+F1(jtmemo){A h,*hv,q;I m;V*v;
+ RZ(w);
+ ASSERT(VERB&AT(w),EVDOMAIN);
+ v=VAV(w); m=ptab[1];
+ GA(h,BOX,3,1,0); hv=AAV(h);
+ RZ(q=sc(0L));                     hv[0]=q;
+ RZ(q=reshape(v2(m,2L),sc(IMIN))); hv[1]=q;
+ GA(q,BOX,m,1,0);                  hv[2]=q;
+ R fdef(CMCAP,VERB,jtmemo1,jtmemo2,w,0L,h,0L,v->mr,v->lr,v->rr);
+}

new file mode 100644
--- /dev/null
+++ b/a.h
@@ -0,0 +1,48 @@
+/* Copyright 1990-2011, Jsoftware Inc.  All rights reserved. */
+/* License in license.txt.                                   */
+/*                                                                         */
+/* Adverbs: Macros and Defined-Constants (for Adverbs and Conjunctions)    */
+
+
+#define GAPPEND         (I)0
+#define GINSERT         (I)3
+#define GTRAIN          (I)6
+
+#define COMPOSE(c)  ((c)==CAT||(c)==CATCO||(c)==CAMP||(c)==CAMPCO) 
+
+#define CONJCASE(a,w)   (2*!(VERB&AT(a))+!(VERB&AT(w)))
+#define NN              3               /* NOUN NOUN                       */
+#define NV              2               /* NOUN VERB                       */
+#define VN              1               /* VERB NOUN                       */
+#define VV              0               /* VERB VERB                       */
+
+#define DECLF           V*sv=VAV(self);A fs=sv->f;  \
+                        AF f1=fs?VAV(fs)->f1:0,f2=fs?VAV(fs)->f2:0
+
+#define DECLG           V*sv=VAV(self);A gs=sv->g;  \
+                        AF g1=gs?VAV(gs)->f1:0,g2=gs?VAV(gs)->f2:0
+
+#define DECLFG          DECLF;         A gs=sv->g;  \
+                        AF g1=gs?VAV(gs)->f1:0,g2=gs?VAV(gs)->f2:0
+
+#define DECLFGH         DECLFG;        A hs=sv->h;  \
+                        AF h1=hs?VAV(hs)->f1:0,h2=hs?VAV(hs)->f2:0
+
+#define PREF1(f)        {I m=mr(self);            F1RANK(  m,f,self);}
+#define PREF2(f)        {I l=lr(self),r=rr(self); F2RANK(l,r,f,self);}
+
+#define AS1(f,exp)      DF1(f){PROLOG;DECLF ;A z; PREF1(f); z=(exp); EPILOG(z);}
+#define AS2(f,exp)      DF2(f){PROLOG;DECLF ;A z; PREF2(f); z=(exp); EPILOG(z);}
+#define CS1(f,exp)      DF1(f){PROLOG;DECLFG;A z; PREF1(f); z=(exp); EPILOG(z);}
+#define CS2(f,exp)      DF2(f){PROLOG;DECLFG;A z; PREF2(f); z=(exp); EPILOG(z);}
+
+#define ADERIV(id,f1,f2,m,l,r)  fdef(id,VERB,(AF)(f1),(AF)(f2),w,0L,0L,0L,(I)(m),(I)(l),(I)(r))
+#define CDERIV(id,f1,f2,m,l,r)  fdef(id,VERB,(AF)(f1),(AF)(f2),a,w ,0L,0L,(I)(m),(I)(l),(I)(r))
+
+#define ASSERTVV(a,w)   RZ(a&&w); ASSERT(VERB&AT(a)&&VERB&AT(w),EVDOMAIN)
+#define ASSERTVN(a,w)   RZ(a&&w); ASSERT(VERB&AT(a)&&NOUN&AT(w),EVDOMAIN)
+#define ASSERTNN(a,w)   RZ(a&&w); ASSERT(NOUN&AT(a)&&NOUN&AT(w),EVDOMAIN)
+
+#define SCALARFN(id,w)  (id==ID(w)&&!lr(w)&&!rr(w))
+
+#define FIT0(c,v)       (CFIT==v->id&&c==ID(v->f)&&equ(zero,v->g))

new file mode 100644
--- /dev/null
+++ b/ab.c
@@ -0,0 +1,182 @@
+/* Copyright 1990-2011, Jsoftware Inc.  All rights reserved. */
+/* License in license.txt.                                   */
+/*                                                                         */
+/* Adverbs: b. bitwise functions                                           */
+
+#include "j.h"
+#include "ve.h"
+#include "ar.h"
+
+
+APFX(bw0000II, UI,UI,UI, BW0000)       static APFX(bw0000CC, UC,UC,UC, BW0000)
+APFX(bw0001II, UI,UI,UI, BW0001)       static APFX(bw0001CC, UC,UC,UC, BW0001)
+APFX(bw0010II, UI,UI,UI, BW0010)       static APFX(bw0010CC, UC,UC,UC, BW0010)
+APFX(bw0011II, UI,UI,UI, BW0011)       static APFX(bw0011CC, UC,UC,UC, BW0011)
+APFX(bw0100II, UI,UI,UI, BW0100)       static APFX(bw0100CC, UC,UC,UC, BW0100)
+APFX(bw0101II, UI,UI,UI, BW0101)       static APFX(bw0101CC, UC,UC,UC, BW0101)
+APFX(bw0110II, UI,UI,UI, BW0110)       static APFX(bw0110CC, UC,UC,UC, BW0110)
+APFX(bw0111II, UI,UI,UI, BW0111)       static APFX(bw0111CC, UC,UC,UC, BW0111)
+APFX(bw1000II, UI,UI,UI, BW1000)       static APFX(bw1000CC, UC,UC,UC, BW1000)
+APFX(bw1001II, UI,UI,UI, BW1001)       static APFX(bw1001CC, UC,UC,UC, BW1001)
+APFX(bw1010II, UI,UI,UI, BW1010)       static APFX(bw1010CC, UC,UC,UC, BW1010)
+APFX(bw1011II, UI,UI,UI, BW1011)       static APFX(bw1011CC, UC,UC,UC, BW1011)
+APFX(bw1100II, UI,UI,UI, BW1100)       static APFX(bw1100CC, UC,UC,UC, BW1100)
+APFX(bw1101II, UI,UI,UI, BW1101)       static APFX(bw1101CC, UC,UC,UC, BW1101)
+APFX(bw1110II, UI,UI,UI, BW1110)       static APFX(bw1110CC, UC,UC,UC, BW1110)
+APFX(bw1111II, UI,UI,UI, BW1111)       static APFX(bw1111CC, UC,UC,UC, BW1111)
+
+/* see below */                        /* see below */
+REDUCEPFX(bw0001insI, UI,UI, BW0001)   static REDUCEPFX(bw0001insC, UC,UC, BW0001)
+REDUCEPFX(bw0010insI, UI,UI, BW0010)   static REDUCEPFX(bw0010insC, UC,UC, BW0010)
+/* see below */                        /* see below */
+REDUCEPFX(bw0100insI, UI,UI, BW0100)   static REDUCEPFX(bw0100insC, UC,UC, BW0100)  
+/* see below */                        /* see below */
+REDUCEPFX(bw0110insI, UI,UI, BW0110)   static REDUCEPFX(bw0110insC, UC,UC, BW0110)
+REDUCEPFX(bw0111insI, UI,UI, BW0111)   static REDUCEPFX(bw0111insC, UC,UC, BW0111)
+REDUCEPFX(bw1000insI, UI,UI, BW1000)   static REDUCEPFX(bw1000insC, UC,UC, BW1000)
+REDUCEPFX(bw1001insI, UI,UI, BW1001)   static REDUCEPFX(bw1001insC, UC,UC, BW1001)
+/* see below */                        /* see below */
+REDUCEPFX(bw1011insI, UI,UI, BW1011)   static REDUCEPFX(bw1011insC, UC,UC, BW1011)
+/* see below */                        /* see below */
+REDUCEPFX(bw1101insI, UI,UI, BW1101)   static REDUCEPFX(bw1101insC, UC,UC, BW1101)
+REDUCEPFX(bw1110insI, UI,UI, BW1110)   static REDUCEPFX(bw1110insC, UC,UC, BW1110)
+/* see below */                        /* see below */
+
+       AHDRR(bw0000insI,UI,UI){I k=SZI*m*c/n; if(1<n)memset(z,C0 ,k); else MC(z,x,k);}
+static AHDRR(bw0000insC,UC,UC){I k=    m*c/n; if(1<n)memset(z,C0 ,k); else MC(z,x,k);}
+
+       AHDRR(bw1111insI,UI,UI){I k=SZI*m*c/n; if(1<n)memset(z,CFF,k); else MC(z,x,k);}
+static AHDRR(bw1111insC,UC,UC){I k=    m*c/n; if(1<n)memset(z,CFF,k); else MC(z,x,k);}
+
+       AHDRR(bw0011insI,UI,UI){I d=c/n,k=c-d;                        DO(m, DO(d, *z++=  *x++;); x+=k;);}
+static AHDRR(bw0011insC,UC,UC){I d=c/n,k=c-d;                        DO(m, DO(d, *z++=  *x++;); x+=k;);}
+
+       AHDRR(bw1100insI,UI,UI){I d=c/n,k=c-d;                 if(1<n)DO(m, DO(d, *z++= ~*x++;); x+=k;) else MC(z,x,SZI*m*c/n);}
+static AHDRR(bw1100insC,UC,UC){I d=c/n,k=c-d;                 if(1<n)DO(m, DO(d, *z++= ~*x++;); x+=k;) else MC(z,x,    m*c/n);}
+
+       AHDRR(bw0101insI,UI,UI){I d=c/n,k=c-d;                  x+=k; DO(m, DO(d, *z++=  *x++;); x+=k;);}
+static AHDRR(bw0101insC,UC,UC){I d=c/n,k=c-d;                  x+=k; DO(m, DO(d, *z++=  *x++;); x+=k;);}
+
+       AHDRR(bw1010insI,UI,UI){I d=c/n,k=c-d;UI t=     n%2-1 ; x+=k; DO(m, DO(d, *z++=t^*x++;); x+=k;);}
+static AHDRR(bw1010insC,UC,UC){I d=c/n,k=c-d;UC t=(UC)(n%2-1); x+=k; DO(m, DO(d, *z++=t^*x++;); x+=k;);}
+
+
+
+#define BITWISE(f,T,op)  \
+ F2(f){A z;B b;I an,ar,*as,*av,k=0,wn,wr,*ws,x;T*wv,y,*zv;             \
+  RZ(a&&w);                                                            \
+  if(!(INT&AT(a)))RZ(a=cvt(INT,a));                                    \
+  if(!(INT&AT(w)))RZ(w=cvt(INT,w));                                    \
+  an=AN(a); ar=AR(a); as=AS(a); av=(I*)AV(a);                          \
+  wn=AN(w); wr=AR(w); ws=AS(w); wv=(T*)AV(w); b=ar>wr;                 \
+  DO(MIN(ar,wr), ASSERT(as[i]==ws[i],EVLENGTH););                      \
+  GA(z,INT,b?an:wn,MAX(ar,wr),b?as:ws); zv=(T*)AV(z);                  \
+  if(!AN(z))R z;                                                       \
+  if     (ar==wr)DO(an, x=*av++;           y=*wv++; *zv++=op(x,y);  )  \
+  else if(ar< wr)DO(an, x=*av++; DO(wn/an, y=*wv++; *zv++=op(x,y););)  \
+  else           DO(wn, y=*wv++; DO(an/wn, x=*av++; *zv++=op(x,y););); \
+  RE(0); R z;                                                          \
+ }
+
+#if SY_64
+#define WLEN    64
+#else
+#define WLEN    32
+#endif
+
+#define BWROT(x,y)      (0>x ? (y>>(-x%WLEN))|(y<<(WLEN+(x%WLEN))) : (y<<(x%WLEN))|(y>>(WLEN-(x%WLEN))) )
+#define BWSHIFT(x,y)    (0>x ? (x<=-WLEN?0:y>>-x)           : (x>=WLEN?0:y<<x)            )
+#define BWSHIFTA(x,y)   (0>x ? (x<=-WLEN?(y<0?-1:0):y>>-x)  : (x>=WLEN?0:y<<x)            )
+
+BITWISE(jtbitwiserotate,UI,BWROT   )
+BITWISE(jtbitwiseshift, UI,BWSHIFT )
+BITWISE(jtbitwiseshifta,I, BWSHIFTA)
+
+DF1(jtbitwise1){R CALL2(VAV(self)->f2,zero,w,self);}
+
+
+static VF bwC[16]={bw0000CC,bw0001CC,bw0010CC,bw0011CC, bw0100CC,bw0101CC,bw0110CC,bw0111CC,
+                   bw1000CC,bw1001CC,bw1010CC,bw1011CC, bw1100CC,bw1101CC,bw1110CC,bw1111CC};
+
+static VF bwI[16]={bw0000II,bw0001II,bw0010II,bw0011II, bw0100II,bw0101II,bw0110II,bw0111II,
+                   bw1000II,bw1001II,bw1010II,bw1011II, bw1100II,bw1101II,bw1110II,bw1111II};
+
+/* a m b.&.(a.&i.) w */
+/* a m b.&.(a.i.]) w */
+/* m e. 16+i.16      */
+
+DF2(jtbitwisechar){DECLFG;A*p,x,y,z;B b;I an,ar,*as,at,d,j,m,n,wn,wr,*ws,wt,zn;VF f;
+ RZ(a&&w);
+ d=SZI;
+ x=a; an=AN(a); ar=AR(a); as=AS(a); at=AT(a);
+ y=w; wn=AN(w); wr=AR(w); ws=AS(w); wt=AT(a);
+ if(!(an&&wn&&at&LIT&&wt&LIT))R from(df2(indexof(alp,a),indexof(alp,w),fs),alp);
+ b=ar<=wr; zn=b?wn:an; m=b?an:wn; n=zn/m;
+ ASSERT(!ICMP(as,ws,MIN(ar,wr)),EVLENGTH);
+ j=i0(VAV(fs)->f)-16;
+ GA(z,d==SZI?LIT:C2T,zn,MAX(ar,wr),b?ws:as); 
+ if(1==n)                 {f=bwI[j]; m=(m+d-1)/d;}
+ else if(!ar||!wr||0==n%d){f=bwI[j]; n=(n+d-1)/d; p=b?&x:&y; RZ(*p=irs2(sc(d),*p,0L,0L,0L,jtrepeat));}
+ else                      f=bwC[j];
+ f(jt,b,m,n,AV(z),AV(x),AV(y)); 
+ *(zn+CAV(z))=0;
+ R z;
+}
+
+/* compute z=: t{~ a.i.w if t=: c&(m b.) a.                             */
+/* http://www.jsoftware.com/jwiki/Essays/Bitwise_Functions_on_Charcters */
+
+B jtbitwisecharamp(J jt,UC*t,I n,UC*wv,UC*zv){I p;UC c,i,j,*pv,s[256];VF f;
+ i=t[0]; j=t[255];
+ if     (i==0    ){c=j; f=bw0001II;}
+ else if(j==i    ){c=i; f=bw0011II;}
+ else if(j==255  ){c=i; f=bw0111II;}
+ else if(j==255-i){c=i; f=bw0110II;}
+ else if(j==0    ){c=i; f=bw0010II;}
+ else if(i==255  ){c=j; f=bw1011II;}
+ else R 0;
+ pv=(UC*)&p; DO(SZI, pv[i]=c;);
+ f(jt,1,1L,256L/SZI,s,pv,AV(alp)); if(memcmp(s,t,256L))R 0;
+ f(jt,1,1L,(n+SZI-1)/SZI,zv,pv,wv); zv[n]=0;
+ R 1;
+}
+
+
+static VF bwinsC[16]={bw0000insC,bw0001insC,bw0010insC,bw0011insC, bw0100insC,bw0101insC,bw0110insC,bw0111insC,
+                      bw1000insC,bw1001insC,bw1010insC,bw1011insC, bw1100insC,bw1101insC,bw1110insC,bw1111insC};
+
+static VF bwinsI[16]={bw0000insI,bw0001insI,bw0010insI,bw0011insI, bw0100insI,bw0101insI,bw0110insI,bw0111insI,
+                      bw1000insI,bw1001insI,bw1010insI,bw1011insI, bw1100insI,bw1101insI,bw1110insI,bw1111insI};
+
+/* m b./&.(a.&i.) w */
+/* m b./&.(a.i.]) w */
+/* m e. 16+i.16     */
+
+DF1(jtbitwiseinsertchar){A fs,z;I c,d=SZI,j,m,n,r,wn,wr;UC*u,*v,*wv,x,*zv;VF f;
+ RZ(w&&self);
+ wr=AR(w); c=wn=AN(w); n=wr?*AS(w):1; z=VAV(self)->f; fs=VAV(z)->f;
+ if(!(wn&&d<n&&LIT&AT(w)))R from(df1(indexof(alp,w),fs),alp);
+ m=wn/n; wv=CAV(w); j=i0(VAV(fs)->f)-16; f=bwinsC[j];
+ if(1==wr)switch(j){
+  case  0: R scc(0);
+  case  3: R scc(*wv);
+  case  5: R scc(*(wv+wn-1));
+  case 10: x=*(wv+wn-1); R scc((UC)(wn%2?x:~x));
+  case 12: R scc((UC)~*wv);
+  case 15: R scc((UC)255);
+  case  1: case 6: case 7: case 9: f=bwinsI[j]; c=n=n/d;
+ }else if(0==m%d){f=bwinsI[j]; c/=d;}
+ GA(z,LIT,m,wr-1,1+AS(w)); zv=CAV(z);
+ f(jt,1L,c,n,zv,wv);
+ if(1==wr){
+  r=wn-n*d; u=wv+n*d; x=*zv; v=1+zv; 
+  switch(j){
+   case 1: DO(d-1, x=BW0001(x,*v); ++v;); DO(r, x=BW0001(x,*u); ++u;); break;
+   case 6: DO(d-1, x=BW0110(x,*v); ++v;); DO(r, x=BW0110(x,*u); ++u;); break;
+   case 7: DO(d-1, x=BW0111(x,*v); ++v;); DO(r, x=BW0111(x,*u); ++u;); break;
+   case 9: DO(d-1, x=BW1001(x,*v); ++v;); DO(r, x=BW1001(x,*u); ++u;); break;
+  }
+  *(I*)zv=0; *zv=x;
+ }
+ R z;
+}

new file mode 100644
--- /dev/null
+++ b/af.c
@@ -0,0 +1,99 @@
+/* Copyright 1990-2011, Jsoftware Inc.  All rights reserved. */
+/* License in license.txt.                                   */
+/*                                                                         */
+/* Adverbs: Fix                                                            */
+
+#include "j.h"
+
+
+F1(jtunname){A x;V*v;
+ RZ(w); 
+ v=VAV(w);
+ if(CTILDE==v->id&&!jt->glock&&!(VLOCK&v->flag)){x=v->f; if(NAME&AT(x))R symbrd(x);}
+ R w;
+}
+
+static B jtselfq(J jt,A w){A hs,*u;V*v;
+ RZ(w);
+ if(AT(w)&NOUN+NAME)R 0;
+ v=VAV(w);
+ switch(v->id){
+  case CSELF:  
+   R 1;
+  case CATDOT:
+  case CGRCO:
+   if(hs=v->h){u=AAV(hs); DO(AN(hs), if(selfq(u[i]))R 1;);}
+   R 0;
+  default:     
+   if(v->f&&selfq(v->f))R 1;
+   if(v->g&&selfq(v->g))R 1;
+   if(v->h&&selfq(v->h))R 1;
+ }
+ R 0;
+}    /* 1 iff w contains $: */
+
+static F2(jtfixa){A aa,f,g,h,wf,x,y,z=w;V*v;
+ RZ(a&&w);
+ if(NOUN&AT(w)||VFIX&VAV(w)->flag)R w;
+ v=VAV(w); f=v->f; g=v->g; h=v->h; wf=ds(v->id); aa=a==zero?num[3]:a;
+ if(!(f||g))R w;
+ switch(v->id){
+  case CSLASH: 
+   R df1(fixa(num[2],f),wf);
+  case CSLDOT: case CBSLASH: case CBSDOT:
+   R df1(fixa(one,f),wf);
+  case CAT: case CATCO: case CCUT:
+   R df2(fixa(one,f),fixa(aa,g),wf);
+  case CAMP: case CAMPCO: case CUNDER: case CUNDCO:
+   R df2(fixa(aa,f),fixa(one,g),wf);
+  case CCOLON:
+   R df2(fixa(one,f),fixa(num[2],g),wf);
+  case CADVF:
+   R hook(fixa(num[3],f),fixa(num[3],g));
+  case CHOOK:
+   R hook(fixa(num[2],f),fixa(one,g));
+  case CFORK:
+   f=fixa(aa,f); g=fixa(num[ID(f)==CCAP?1:2],g); h=fixa(aa,h); R folk(f,g,h);
+  case CATDOT:
+  case CGRCO:
+   RZ(f=every(every2(aa,h,0L,jtfixa),0L,jtaro)); 
+   RZ(g=fixa(aa,g));
+   R df2(f,g,wf);
+  case CIBEAM:
+   if(f)RZ(f=fixa(aa,f));
+   if(g)RZ(g=fixa(aa,g));
+   R f&&g ? (VDDOP&v->flag?df2(f,g,df2(head(h),tail(h),wf)):df2(f,g,wf)) : 
+            (VDDOP&v->flag?df1(f,  df2(head(h),tail(h),wf)):df1(f,  wf)) ;
+  case CTILDE:
+   if(f&&NAME&AT(f)){
+    RZ(y=sfn(0,f));
+    if(all1(eps(box(y),jt->fxpath)))R w;
+    ASSERT(jt->fxi,EVLIMIT);
+    jt->fxpv[--jt->fxi]=y; 
+    if(x=symbrdlock(f)){
+     RZ(z=fixa(aa,x));
+     if(a!=zero&&selfq(x))RZ(z=fixrecursive(a,z));
+    }
+    jt->fxpv[jt->fxi++]=mtv;
+    RE(z);
+    ASSERT(AT(w)==AT(z)||AT(w)&NOUN&&AT(z)&NOUN,EVDOMAIN);
+    R z;
+   }else R df1(fixa(num[2],f),wf);
+  default:
+   if(f)RZ(f=fixa(aa,f));
+   if(g)RZ(g=fixa(aa,g));
+   R f&&g?df2(f,g,wf):f?df1(f,wf):w;
+}}   /* 0=a if fix names; 1=a if fix names only if does not contain $: */
+
+
+F1(jtfix){PROLOG;A z;I*rv=jt->rank;
+ RZ(w);
+ jt->rank=0;
+ RZ(jt->fxpath=reshape(sc(jt->fxi=(I)255),ace)); jt->fxpv=AAV(jt->fxpath);
+ if(LIT&AT(w)){ASSERT(1>=AR(w),EVRANK); RZ(w=nfs(AN(w),CAV(w)));}
+ ASSERT(AT(w)&NAME+VERB,EVDOMAIN);
+ RZ(z=fixa(zero,AT(w)&VERB?w:symbrdlock(w)));
+ if(AT(z)&VERB+ADV+CONJ){V*v=VAV(z); if(v->f){v->flag|=VFIX+VNAMED; v->flag^=VNAMED;}}
+ jt->rank=rv; jt->fxpath=0;
+ EPILOG(z);
+}

new file mode 100644
--- /dev/null
+++ b/ai.c
@@ -0,0 +1,381 @@
+/* Copyright 1990-2011, Jsoftware Inc.  All rights reserved. */
+/* License in license.txt.                                   */
+/*                                                                         */
+/* Adverbs: Inverse & Identity Functions                                   */
+
+#include "j.h"
+
+
+static F1(jtinvamp);
+
+static B ip(A w,C c,C d){A f,g;V*v;
+ v=VAV(w); f=v->f; g=v->g;
+ R CSLASH==ID(f)&&c==ID(VAV(f)->f)&&d==ID(g);
+}
+
+static B consf(A w){A f;C c;
+ c=ID(w);
+ if(c==CFCONS||c==CQQ&&(f=VAV(w)->f,NOUN&AT(f)))R 1;
+ R 0;
+}    /* 1 iff w is a constant function */
+
+static F2(jtfong){A f;C c;V*v;
+ RZ(a&&w);
+ v=VAV(a); c=v->id; f=v->f;
+ R c==CRIGHT ? w : c==CFORK&&(NOUN&AT(f)||CCAP==ID(f)) ? folk(f,v->g,fong(v->h,w)) : folk(ds(CCAP),a,w);
+}    /* [: f g  with simplifications */
+
+static F1(jtinvfork){A f,fi,g,gi,h,k;B b,c;V*v;
+ RZ(w);
+ v=VAV(w); RZ(f=unname(v->f)); g=v->g; RZ(h=unname(v->h));
+ if(CCAP==ID(f))R fong(inv(h),inv(g));
+ c=1&&NOUN&AT(f); b=c||consf(f);
+ ASSERT(b!=consf(h),EVDOMAIN);
+ RZ(k=c?f:df1(zero,b?f:h));
+ RZ(gi=inv(b?amp(k,g):amp(g,k)));
+ RZ(fi=inv(b?h:f));
+ if(CAMP==ID(gi)){
+  v=VAV(gi); 
+  if     (NOUN&AT(v->f))RZ(gi=folk(v->f,     v->g, ds(CRIGHT)))
+  else if(NOUN&AT(v->g))RZ(gi=folk(v->g,swap(v->f),ds(CRIGHT)));
+ }
+ R fong(fi,gi);
+}
+
+static DF1(jtexpandf){A f; RZ(w&&self); f=VAV(self)->f; R expand(VAV(f)->f,w);}
+
+static DF1(jtexpandg){A f,g,z;V*v;
+ RZ(w&&self);
+ f=VAV(self)->f; v=VAV(f); g=v->g;
+ jt->fill=VAV(g)->g; z=expand(v->f,w); jt->fill=0; 
+ R z;
+}
+
+static F2(jtdiag){I d,k,m,p,r,t,*v;
+ RZ(a&&w);
+ r=AR(w); t=AT(w); k=bp(t);
+ v=AS(w);   m=0;      DO(r, m=MIN(m,v[i]););
+ v=AS(w)+r; p=1; d=0; DO(r, d+=p; p*=*--v;);
+ if(t!=AT(a))RZ(a=cvt(t,a));
+ if(AR(a)){
+  ASSERT(m==AN(a),EVLENGTH);
+  ASSERT(0,EVNONCE);
+ }else{
+  ASSERT(0,EVNONCE);
+}}
+
+static F1(jtbminv){A*wv,x,z=w;I i,j,m,r,*s,t=0,*u,**v,*y,wn,wr,*ws,wd;
+ RZ(w);
+ ASSERT(0,EVNONCE);
+ ASSERT(BOX&AT(w),EVDOMAIN);
+ wn=AN(w); wr=AR(w); ws=AS(w); wv=AAV(w); wd=(I)w*ARELATIVE(w);
+ if(1>=wr)R raze(w);
+ if(!wn)R iota(reshape(sc(wr),zero));
+ GA(x,INT,wr,1,0); u=AV(x); memset(u,C0,wr*SZI);
+ GA(x,INT,wr,1,0); v=(I**)AV(x);
+ DO(wr, m=ws[i]; GA(x,INT,m,1,0); memset(v[i]=AV(x),CFF,m*SZI););
+ for(i=0;i<wn;++i){
+  x=WVR(i); r=AR(x); s=AS(x);
+  if(AN(x)){if(!t)t=AT(x); ASSERT(HOMO(t,AT(x)),EVDOMAIN);}
+  ASSERT(2>r||r==wr,EVRANK);
+  if(2>r)z=0;
+  else DO(wr, y=v[i]+u[i]; if(0>*y)*y=s[i]; else ASSERT(*y==s[i],EVLENGTH););
+  j=wr; while(1){--j; ++u[j]; if(ws[j]>u[j])break; u[j]=0;}
+ }
+ if(!z){A f,h,*zv;I*hv;
+  GA(z,BOX,wn,2,ws); zv=AAV(z);
+  GA(h,INT,wr,1,0); hv=AV(h);
+  GA(f,t,1,1,0); RZ(f=filler(f)); memset(u,C0,wr*SZI);
+  for(i=0;i<wn;++i){
+   zv[i]=x=WVR(i);
+   if(2>AR(x)){DO(wr, hv[i]=*(v[i]+u[i]);); RZ(zv[i]=diag(x,reshape(h,f)));}
+   j=wr-1; while(1){--j; ++u[j]; if(ws[j]>u[j])break; u[j]=0;}
+ }}
+ DO(wr, RZ(z=df1(z,slash(under(qq(ds(CCOMMA),sc(wr-i)),ds(COPE))))););
+ R ope(z);
+}    /* <;.1 or <;.2 inverse on matrix argument */
+
+
+static F1(jtinvamp){A f,ff,g,h,*q,x,y;B nf,ng;C c,d,*yv;I n;V*u,*v;
+ RZ(w);
+ v=VAV(w);
+ f=v->f; nf=!!(NOUN&AT(f));
+ g=v->g; ng=!!(NOUN&AT(g));
+ h=nf?g:f; x=nf?f:g; c=ID(h); u=VAV(h);   
+ switch(c){
+  case CPLUS:    R amp(negate(x),h);
+  case CSTAR:    R amp(recip(x), h);
+  case CMINUS:   R nf?w:amp(x,ds(CPLUS));
+  case CDIV:     R nf?w:amp(x,ds(CSTAR));
+  case CROOT:    R amp(ds(nf?CEXP:CLOG),x);
+  case CEXP:     R ng&&equ(x,num[2])?ds(CROOT):amp(x,ds(nf?CLOG:CROOT));
+  case CLOG:     R nf?amp(x,ds(CEXP)):amp(ds(CROOT),x);
+  case CJDOT:    R nf?atop(inv(ds(CJDOT)),amp(ds(CMINUS),x)):amp(ds(CMINUS),jdot1(x));
+  case CRDOT:    R nf?atop(inv(ds(CRDOT)),amp(ds(CDIV  ),x)):amp(ds(CDIV  ),rdot1(x));
+  case CLBRACE:  R nf?amp(pinv(x),h):amp(x,ds(CIOTA));
+  case COBVERSE: ff=VAV(h)->g; R amp(nf?x:ff,nf?ff:x);
+  case CPDERIV:  if(!AR(h))R ds(CPDERIV);
+  case CXCO:     RE(n=i0(x)); ASSERT(n&&-3<n&&n<3,EVDOMAIN);
+  case CROT:
+  case CCIRCLE:  
+  case CSPARSE:  if(nf)R amp(negate(x),h);   break;
+  case CABASE:   if(nf)R amp(x,ds(CBASE));   break;
+  case CIOTA:    if(nf)R amp(ds(CLBRACE),x); break;
+  case CTHORN:   if(nf)R ds(CEXEC);          break;
+  case CTILDE:   
+   if(ff=VAV(h)->f,VERB&AT(ff))R invamp(amp(nf?ff:x,nf?x:ff));
+   else{ff=unname(h); R invamp(amp(nf?x:ff,nf?ff:x));}
+  case CSCO:     
+   ASSERT(nf,EVDOMAIN); 
+   RE(n=i0(x)); ASSERT(n&&-6<=n&&n<=6,EVDOMAIN);
+   R amp(sc(-n),h);
+  case CUCO:
+   ASSERT(nf,EVDOMAIN); 
+   RE(n=i0(x)); ASSERT(1<=n&&n<=4||7<=n&&n<=8,EVDOMAIN);
+   R amp(sc(1==n?2L:2==n?1L:3==n?4L:4==n?3L:7==n?8L:7L),h);
+  case CCANT:    
+   ASSERT(nf,EVDOMAIN); 
+   R obverse(eva(x,"] |:~ x C.^:_1 i.@#@$"),w);
+  case CPCO:
+   if(nf){
+    RE(n=i0(x));
+    switch(n){
+     case -4: case 4: R amp(negate(x),h);
+     case -1:         R ds(CPCO);
+     case  2:         R obverse(eval("*/@(^/)\"2"),w);
+     case  3:         R eval("*/");
+   }}
+   break;
+  case CQCO:     
+   if(nf){
+    ASSERT(!AR(x),EVRANK);
+    R obverse(eval(all1(lt(x,zero))?"*/@(^/)\"2":"(p:@i.@# */ .^ ])\"1"),w);
+   }
+   break;
+  case CFIT:
+   ASSERT(nf&&(CPOUND==ID(VAV(g)->f)),EVDOMAIN);
+   ASSERT(1==AR(x),EVRANK);
+   R fdef(CPOWOP,VERB, jtexpandg,0L, w,num[-1],0L, 0L, RMAX,0L,0L);
+  case CPOUND:
+   ASSERT(nf,EVDOMAIN);
+   ASSERT(1==AR(x),EVRANK);
+   R fdef(CPOWOP,VERB, jtexpandf,0L, w,num[-1],0L, 0L, RMAX,0L,0L);
+   break;
+  case CPOWOP:
+   if(VGERL&u->flag){ff=*(1+AAV(u->h)); R amp(nf?x:ff,nf?ff:x);} 
+   break;
+  case CCOMMA:  
+   n=IC(x); 
+   R obverse(1==n?ds(nf?CDROP:CCTAIL):amp(sc(nf?n:-n),ds(CDROP)),w);
+  case CBASE:   
+   if(!nf)break;
+   R AR(x) ? amp(x,ds(CABASE)) : 
+    obverse(evc(x,mag(x),"$&x@>:@(y&(<.@^.))@(1&>.)@(>./)@:|@, #: ]"),w);
+  case CBANG:
+   ASSERT(!AR(x),EVRANK);
+   ASSERT(all1(lt(zero,x)),EVDOMAIN);
+   GA(y,BOX,9,1,0); q=AAV(y);
+   q[0]=cstr("3 :'(-("); q[1]=q[3]=lrep(w);
+   q[2]=cstr("-y\"_)%1e_3&* "); q[4]=cstr("\"0 D:1 ])^:_[");
+   h=lrep(x);
+   if(nf){q[5]=over(over(h,cstr("&<@|@{:}")),over(h,cstr(",:"))); q[6]=over(h,cstr("%:y*!")); q[7]=h;}
+   else  {q[5]=cstr("1>.{.@/:\"1|y-/(i.!])"); q[6]=h; q[7]=mtv;}
+   RE(q[8]=cstr("'")); RZ(y=raze(y));
+   R obverse(eval(CAV(y)),w);
+  case CATOMIC:
+   if(ng){ASSERT(equ(x,nub(x)),EVDOMAIN); R obverse(atop(f,amp(x,ds(CIOTA))),w);}
+  case CCYCLE:
+   if(nf&&AR(x)<=(c==CCYCLE))R obverse(eva(w,"/:@x@(i.@#) { ]"),w); break;
+  case CDROP:
+   if(!(nf&&1>=AR(x)))break;
+   RZ(x=cvt(INT,x));
+   RZ(y=eps(v2(-1L,1L),signum(x))); yv=CAV(y);
+   f=amp(mag(x),ds(CPLUS));
+   g=1==AN(x)?ds(CPOUND):atop(amp(tally(x),ds(CTAKE)),ds(CDOLLAR));
+   h=!yv[1]?f:atop(!yv[0]?ds(CMINUS):amp(negate(signum(x)),ds(CSTAR)),f);
+   R obverse(hook(swap(ds(CTAKE)),atop(h,g)),w);
+  case CDOMINO:
+   if(!(2==AR(x)&&*AS(x)==*(1+AS(x))))break;
+   ff=eval("+/ .*");
+   R nf?atop(h,amp(ff,minv(x))):amp(x,ff);
+  case CDOT:
+   if(ip(h,CPLUS,CSTAR)){
+    ASSERT(2==AR(x),EVRANK);
+    ASSERT(*AS(x)==*(1+AS(x)),EVLENGTH);
+    R nf?amp(ds(CDOMINO),x):amp(h,minv(x));
+   }
+   break;
+  case CQQ:
+   if(ng&&equ(x,one)&&equ(f,eval("i.\"1")))R hook(ds(CFROM),ds(CEQ));
+   break;
+  case CBSLASH:
+   if(nf&&(n=i0(x),0>n)&&(d=ID(u->f),d==CLEFT||d==CRIGHT))R slash(ds(CCOMMA));
+   break;
+  case CIBEAM:
+   x=VAV(h)->f; y=VAV(h)->g;
+   if(NOUN&AT(x)&&equ(x,num[3])&&NOUN&AT(y)){
+    RE(n=i0(f));
+    if(all1(eps(y,v2(4L,5L)))){ASSERT(n&&-2<=n&&n<=2,EVDOMAIN); R amp(sc(-n),g);}
+    if(all1(eps(y,v2(1L,3L)))){ASSERT(0==n||1==n||10==n||11==n,EVDOMAIN); R foreign(x,num[2]);}
+   }
+   break;
+  case CBDOT:
+   RE(n=i0(x));
+   switch(i0(VAV(h)->f)){
+    case 22: case 25:          R w;
+    case 19: case 28:          if(ng)R w; break;
+    case 21: case 26:          if(nf)R w; break;
+    case 32: case 33: case 34: ASSERT(nf,EVDOMAIN); R amp(negate(x),h);
+   }
+   break;
+  case CPOLY:
+   if(nf&&1==AR(x)&&2==AN(x)&&NUMERIC&AT(x)&&!equ(zero,tail(x))){
+    RZ(y=recip(tail(x)));
+    R amp(over(tymes(y,negate(head(x))),y),h);
+ }}
+ ASSERT(0,EVDOMAIN);
+}
+
+static C invf[2][29] = {
+ CDIV,   CPLUS,  CMINUS,  CLEFT,   CRIGHT,  CREV,    CCANT,   CPOLY, 
+ CNOT,   CGRADE, CCYCLE,  CDOMINO, COPE,    CBOX,    CLOG,    CEXP,
+ CGE,    CLE,    CHALVE,  CPLUSCO, CSQRT,   CSTARCO, CHEAD,   CLAMIN,
+ CABASE, CBASE,  CTHORN,  CEXEC,   0,
+ CDIV,   CPLUS,  CMINUS,  CLEFT,   CRIGHT,  CREV,    CCANT,   CPOLY,
+ CNOT,   CGRADE, CCYCLE,  CDOMINO, CBOX,    COPE,    CEXP,    CLOG,
+ CLE,    CGE,    CPLUSCO, CHALVE,  CSTARCO, CSQRT,   CLAMIN,  CHEAD,  
+ CBASE,  CABASE, CEXEC,   CTHORN,  0 
+};
+
+F1(jtinv){A f,ff,g;B b,nf,ng,vf,vg;C id,*s;I p,q;V*v;
+ RZ(w);
+ ASSERT(VERB&AT(w),EVDOMAIN); 
+ id=ID(w); v=VAV(w);
+ if(s=strchr(invf[0],id))R ds(invf[1][s-invf[0]]);
+ f=v->f; nf=f&&AT(f)&NOUN+NAME; vf=f&&!nf;
+ g=v->g; ng=g&&AT(g)&NOUN+NAME; vg=g&&!ng;
+ switch(id){
+  case CCIRCLE:  R eval("1p_1&*");
+  case CJDOT:    R eval("0j_1&*");
+  case CRDOT:    R eval("%&0j1@^.");
+  case CPLUSDOT: R eval("j./\"1\"_ :. +.");
+  case CSTARDOT: R eval("r./\"1\"_ :. *.");
+  case CDGRADE:  R eval("/:@|.");
+  case CWORDS:   R eval("}:@;@(,&' '&.>\"1) :. ;:");
+  case CBANG:    R eval("3 :'(-(!-y\"_)%1e_3&* !\"0 D:1 ])^:_ <.&170^:(-:+)^.y' :. !");
+  case CXCO:     R amp(num[-1],w);
+  case CSPARSE:  R fdef(CPOWOP,VERB,jtdenseit,0L, w,num[-1],0L, 0L, RMAX,RMAX,RMAX);
+  case CPCO:     R fdef(CPOWOP,VERB,jtplt,    0L, w,num[-1],0L, 0L, 0L,  0L,  0L  );
+  case CQCO:     R eval("*/");
+  case CUCO:     R amp(num[3],w);
+  case CUNDER:   R under(inv(f),g);
+  case CFORK:    R invfork(w);
+  case CAMP:     if(nf!=ng)R invamp(w);  /* fall thru */
+  case CAT:      if(vf&&vg)R atop(inv(g),inv(f));   break;
+  case CAMPCO:
+  case CATCO:    if(vf&&vg)R atco(inv(g),inv(f));   break;
+  case CSLASH:   if(CSTAR==ID(f))R ds(CQCO);        break;
+  case CQQ:      if(vf)R qq(inv(f),g);              break;
+  case COBVERSE: if(vf&&vg)R obverse(g,f);          break;
+  case CSCO:     R amp(num[5],w);
+  case CPOWOP:   
+   if(vf&&ng){RE(p=i0(g)); R -1==p?f:1==p?inv(f):powop(0>p?f:inv(f),sc(ABS(p)));}
+   if(VGERL&v->flag)R*(1+AAV(v->h));
+   break;
+  case CTILDE:
+   if(nf)R inv(symbrd(f));
+   switch(ID(f)){
+    case CPLUS:  R ds(CHALVE);
+    case CSTAR:  R ds(CSQRT);
+    case CJDOT:  R eval("0.5j_0.5&*");
+    case CLAMIN: R eval("{. :. (,:~)");
+    case CSEMICO:R eval(">@{. :. (;~)");
+    case CCOMMA: R eval("<.@-:@# {. ] :. (,~)");
+    case CEXP:   R eval("3 : '(- -&b@(*^.) % >:@^.)^:_ ]1>.b=.^.y' \" 0 :. (^~)");
+   }
+   break;
+  case CBSLASH:
+  case CBSDOT:
+   if(CSLASH==ID(f)&&(ff=VAV(f)->f,ff&&VERB&AT(ff))){
+    b=id==CBSDOT;
+    switch(ID(ff)){
+     case CPLUS: R obverse(eval(b?"- 1&(|.!.0)":" - |.!.0"),w);
+     case CSTAR: R obverse(eval(b?"% 1&(|.!.1)":" % |.!.1"),w);
+     case CEQ:   R obverse(eval(b?"= 1&(|.!.1)":" = |.!.1"),w);
+     case CNE:   R obverse(eval(b?"~:1&(|.!.0)":" ~:|.!.0"),w);
+     case CMINUS:R obverse(eval(b?"+ 1&(|.!.0)":"(- |.!.0) *\"_1 $&1 _1@#"),w);
+     case CDIV:  R obverse(eval(b?"* 1&(|.!.1)":"(% |.!.1) ^\"_1 $&1 _1@#"),w);
+   }}
+   break;
+  case CCUT:
+   if(CBOX==ID(f)&&ng&&(p=i0(g),1==p||2==p))R fdef(CPOWOP,VERB, jtbminv,0L, w,num[-1], 0L,0L, RMAX,RMAX,RMAX);
+   break;
+  case CIBEAM:
+   p=i0(f); q=i0(g);
+   if(3==p&&1==q)R foreign(f,num[2]);
+   if(3==p&&2==q)R foreign(f,one   );
+   if(3==p&&3==q)R foreign(f,num[2]);
+   break;
+  case CHOOK:
+   if(CFROM==ID(f)&&CEQ==ID(g))R eval("i.\"1&1");
+   break;
+ }
+ if(!nameless(w))R inv(fix(w));
+ ASSERT(0,EVDOMAIN);
+}
+
+static F1(jtneutral){A x,y;B b;V*v;
+ RZ(w);
+ v=VAV(w);
+ ASSERT(!v->lr&&!v->rr,EVDOMAIN);
+ RZ(y=v2(0L,1L));
+ RZ(x=scf(infm)); b=equ(y,CALL2(v->f2,x,y,w)); RESETERR; if(b)R x;
+ x=ainf;          b=equ(y,CALL2(v->f2,x,y,w)); RESETERR; if(b)R x;
+ x=zero;          b=equ(y,CALL2(v->f2,x,y,w)); RESETERR; if(b)R x; 
+ x=one;           b=equ(y,CALL2(v->f2,x,y,w)); RESETERR; if(b)R x;
+ RZ(x=scf(infm)); b=equ(y,CALL2(v->f2,y,x,w)); RESETERR; if(b)R x;
+ x=ainf;          b=equ(y,CALL2(v->f2,y,x,w)); RESETERR; if(b)R x;
+ x=zero;          b=equ(y,CALL2(v->f2,y,x,w)); RESETERR; if(b)R x;
+ x=one;           b=equ(y,CALL2(v->f2,y,x,w)); RESETERR; if(b)R x;
+ ASSERT(0,EVDOMAIN);
+}    /* neutral of arbitrary rank-0 function */
+
+F1(jtiden){A f,g,x=0;V*u,*v;
+ RZ(w=fix(w)); ASSERT(VERB&AT(w),EVDOMAIN);
+ v=VAV(w); f=v->f; g=v->g;
+ switch(v->id){
+  default:      RZ(x=neutral(w)); break;
+  case CCOMMA:  R eval("i.@(0&,)@(2&}.)@$");
+  case CDOT:    if(!(ip(w,CPLUS,CSTAR)||ip(w,CPLUSDOT,CSTARDOT)||ip(w,CNE,CSTARDOT)))break;
+  case CDOMINO: R atop(atop(ds(CEQ),ds(CGRADE)),ds(CHEAD));
+  case CCYCLE:
+  case CLBRACE: R atop(ds(CGRADE),ds(CHEAD));
+  case CSLASH:  if(VERB&AT(f))R atop(iden(f),ds(CPOUND)); break;
+  case CPLUS: case CMINUS: case CSTILE:   case CNE:
+  case CGT:   case CLT:    case CPLUSDOT: case CJDOT:   case CRDOT:
+                x=zero; break;
+  case CSTAR: case CDIV:   case CEXP:     case CROOT:   case CBANG:
+  case CEQ:   case CGE:    case CLE:      case CSTARDOT:
+                x=one; break;
+  case CMAX:    x=scf(infm); break;
+  case CMIN:    x=ainf; break;
+  case CUNDER:  x=df1(df1(mtv,iden(f)),inv(g)); break;
+  case CAT:
+   if(CAMP==ID(f)&&(u=VAV(f),NOUN&AT(u->f)&&!AR(u->f)&&CSTILE==ID(u->g)))switch(ID(g)){
+    case CSTAR: case CEXP: x=one;  break;
+    case CPLUS:            x=zero;
+   }
+   break;
+  case CBDOT:
+   switch(i0(f)){
+    case 25:    x=num[-1]; break;
+    case  2: case  4: case  5: case  6: case  7:
+    case 18: case 20: case 21: case 22: case 23:
+                x=zero; break;
+    case  1: case  9: case 11: case 13: case 17: 
+    case 27: case 29:
+                x=one;
+ }}
+ ASSERT(x,EVDOMAIN);
+ R folk(x,swap(ds(CDOLLAR)),atop(ds(CBEHEAD),ds(CDOLLAR)));
+}

new file mode 100644
--- /dev/null
+++ b/am.c
@@ -0,0 +1,217 @@
+/* Copyright 1990-2011, Jsoftware Inc.  All rights reserved. */
+/* License in license.txt.                                   */
+/*                                                                         */
+/* Adverbs: Amend                                                          */
+
+#include "j.h"
+
+
+/*
+static A jtmerge1(J jt,A w,A ind){PROLOG;A z;C*v,*x;I c,k,r,*s,t,*u;
+ RZ(w&&ind);
+ RZ(ind=pind(IC(w),ind));
+ r=MAX(0,AR(w)-1); s=1+AS(w); t=AT(w); c=aii(w);
+ ASSERT(!(t&SPARSE),EVNONCE);
+ ASSERT(r==AR(ind),EVRANK);
+ ASSERT(!ICMP(s,AS(ind),r),EVLENGTH);
+ GA(z,t,c,r,s); x=CAV(z); v=CAV(w); u=AV(ind); k=bp(t);
+ DO(c, MC(x+k*i,v+k*(i+c*u[i]),k););
+ EPILOG(z);
+}
+*/
+
+#define MCASE(t,k)  ((t)+16*(k))
+#define MINDEX        {j=*u++; if(0>j)j+=m; ASSERT(0<=j&&j<m,EVINDEX);}
+
+static A jtmerge1(J jt,A w,A ind){A z;B*b;C*wc,*zc;D*wd,*zd;I c,it,j,k,m,r,*s,t,*u,*wi,*zi;
+ RZ(w&&ind);
+ r=MAX(0,AR(w)-1); s=1+AS(w); t=AT(w); k=bp(t); m=IC(w); c=aii(w);
+ ASSERT(!(t&SPARSE),EVNONCE);
+ ASSERT(r==AR(ind),EVRANK);
+ ASSERT(!ICMP(s,AS(ind),r),EVLENGTH);
+ GA(z,t,c,r,s);
+ if(!(AT(ind)&B01+INT))RZ(ind=cvt(INT,ind));
+ it=AT(ind); u=AV(ind); b=(B*)u;
+ ASSERT(!c||1<m||!(it&B01),EVINDEX);
+ ASSERT(!c||1!=m||!memchr(b,C1,c),EVINDEX);
+ zi=AV(z); zc=(C*)zi; zd=(D*)zc;
+ wi=AV(w); wc=(C*)wi; wd=(D*)wc;
+ switch(MCASE(it,k)){
+  case MCASE(B01,sizeof(C)): DO(c,         *zc++=wc[*b++?i+c:i];); break;
+  case MCASE(B01,sizeof(I)): DO(c,         *zi++=wi[*b++?i+c:i];); break;
+#if !SY_64
+  case MCASE(B01,sizeof(D)): DO(c,         *zd++=wd[*b++?i+c:i];); break;
+#endif
+  case MCASE(INT,sizeof(C)): DO(c, MINDEX; *zc++=wc[i+c*j];); break;
+  case MCASE(INT,sizeof(I)): DO(c, MINDEX; *zi++=wi[i+c*j];); break;
+#if !SY_64
+  case MCASE(INT,sizeof(D)): DO(c, MINDEX; *zd++=wd[i+c*j];); break;
+#endif  
+  default: if(it&B01)DO(c,         MC(zc,wc+k*(*b++?i+c:i),k); zc+=k;)
+           else      DO(c, MINDEX; MC(zc,wc+k*(i+c*j     ),k); zc+=k;); break;
+ }
+ R RELOCATE(w,z);
+}
+
+#define CASE2Z(T)  {T*xv=(T*)AV(x),*yv=(T*)AV(y),*zv=(T*)AV(z); DO(n, zv[i]=bv[i]?yv[i]:xv[i];); R z;}
+#define CASE2X(T)  {T*xv=(T*)AV(x),*yv=(T*)AV(y);               DO(n, if( bv[i])xv[i]=yv[i];);   R x;}
+#define CASE2Y(T)  {T*xv=(T*)AV(x),*yv=(T*)AV(y);               DO(n, if(!bv[i])yv[i]=xv[i];);   R y;}
+#define CASENZ(T)  {T*zv=(T*)AV(z); DO(n, j=iv[i]; if(0>j){j+=m; ASSERT(0<=j,EVINDEX);}else ASSERT(j<m,EVINDEX);  \
+                       zv[i]=*(i+(T*)aa[j]);); R z;}
+
+F1(jtcasev){A b,*u,*v,w1,x,y,z;B*bv,p,q;I*aa,c,*iv,j,m,n,r,*s,t;
+ RZ(w);
+ RZ(w1=ca(w)); u=AAV(w1);
+ p=1; m=AN(w)-3; v=AAV(w); c=i0(v[m+1]);
+ DO(m+1, x=symbrd(v[i]); if(!x){p=0; RESETERR; break;} u[i]=x; p=p&&NOUN&AT(x););
+ if(p){
+  b=u[m]; n=AN(b); r=AR(b); s=AS(b); t=AT(*u);
+  p=t&B01+LIT+INT+FL+CMPX&&AT(b)&NUMERIC; 
+  if(p)DO(m, y=u[i]; if(!(t==AT(y)&&r==AR(y)&&!ICMP(s,AS(y),r))){p=0; break;});
+ }
+ if(!p)R parse(v[m+2]);
+ if(q=2==m&&B01&AT(b)){bv=BAV(b); x=u[0]; y=u[1];}
+ else{
+  if(!(INT&AT(b)))RZ(b=cvt(INT,b));
+  iv=AV(b); 
+  GA(x,INT,m,1,0); aa=AV(x); DO(m, aa[i]=(I)AV(u[i]););
+ }
+ if(p=!q||0>c||1<AC(u[c]))GA(z,t,n,r,s) else z=u[c];
+ switch((!q?12:p?0:c==0?4:8)+(t&B01+LIT?0:t&INT?1:t&FL?2:3)){
+  case  0: CASE2Z(C);  case  1: CASE2Z(I);  case  2: CASE2Z(D);  case  3: CASE2Z(Z);
+  case  4: CASE2X(C);  case  5: CASE2X(I);  case  6: CASE2X(D);  case  7: CASE2X(Z);
+  case  8: CASE2Y(C);  case  9: CASE2Y(I);  case 10: CASE2Y(D);  case 11: CASE2Y(Z);
+  case 12: CASENZ(C);  case 13: CASENZ(I);  case 14: CASENZ(D);  case 15: CASENZ(Z);
+  default: ASSERTSYS(0,"casev");
+}}   /* z=:b}x0,x1,x2,...,x(m-2),:x(m-1) */
+
+
+A jtmerge2(J jt,A a,A w,A ind,B ip){A z;I an,ar,*as,at,in,ir,*iv,k,t,wn,wt;
+ RZ(a&&w&&ind);
+ an=AN(a); at=AT(a); ar=AR(a); as=AS(a); 
+ wn=AN(w); wt=AT(w);
+ in=AN(ind); ir=AR(ind); iv=AV(ind);
+ ASSERT(!an||!wn||HOMO(at,wt),EVDOMAIN);
+ ASSERT(ar<=ir,EVRANK);
+ ASSERT(!ICMP(as,AS(ind)+ir-ar,ar),EVLENGTH);
+ if(!wn)R ca(w);
+ RE(t=an&&wn?maxtype(at,wt):wt);
+ if(an&&t!=at)RZ(a=cvt(t,a));
+ if(ip&&t==wt&&(!(t&BOX)||AFNJA&AFLAG(w))){ASSERT(!(AFRO&AFLAG(w)),EVRO); z=w;}
+ else{RZ(z=cvt(t,w)); if(ARELATIVE(w))RZ(z=relocate((I)w-(I)z,z));}
+ if(ip&&t&BOX&&AFNJA&AFLAG(w)){A*av,t,x,y;A1*zv;I ad,*tv;
+  ad=(I)a*ARELATIVE(a); av=AAV(a); zv=A1AV(z);
+  GA(t,INT,in,1,0); tv=AV(t); memset(tv,C0,in*SZI);
+  DO(in, y=smmcar(z,AVR(i%an)); if(!y)break; tv[i]=(I)y;);
+  if(!y){DO(in, if(!tv[i])break; smmfrr((A)tv[i]);); R 0;}
+  DO(in, x=(A)AABS(zv[iv[i]],z); zv[iv[i]]=AREL(tv[i],z); smmfrr(x););
+ }else{
+  if(ARELATIVE(a))RZ(a=rca(a));
+  if(ARELATIVE(z)){A*av=AAV(a),*zv=AAV(z);          DO(in, zv[iv[i]]=(A)AREL(av[i%an],z););}
+  else            {C*av=CAV(a),*zv=CAV(z); k=bp(t); DO(in, MC(zv+k*iv[i],av+k*(i%an),k); );}
+ }
+ R z;
+}
+
+A jtjstd(J jt,A w,A ind){A j=0,k,*v,x;B b;I d,i,id,n,r,*s,*u,wr,*ws;
+ wr=AR(w); ws=AS(w); b=AN(ind)&&BOX&AT(ind);
+ if(!wr)R from(ind,zero);
+ if(b&&AR(ind)){
+  RE(aindex(ind,w,0L,&j));
+  if(!j){
+   RZ(x=from(ind,increm(iota(shape(w))))); u=AV(x); 
+   DO(AN(x), ASSERT(*u,EVDOMAIN); --*u; ++u;); 
+   R x;
+  }
+  k=AAV0(ind); n=AN(k);
+  GA(x,INT,wr,1,0); u=wr+AV(x); s=wr+ws; d=1; DO(wr, *--u=d; d*=*--s;);
+  R n==wr?pdt(j,x):irs2(pdt(j,vec(INT,n,AV(x))),iota(vec(INT,wr-n,ws+n)),0L,0L,RMAX,jtplus);
+ }
+ if(!b){n=1; RZ(j=pind(*ws,ind));}
+ else{
+  ind=AAV0(ind); n=AN(ind); r=AR(ind);
+  ASSERT(!n&&1==r||AT(ind)&BOX+NUMERIC,EVINDEX);
+  if(n&&!(BOX&AT(ind)))RZ(ind=every(ind,0L,jtright1));
+  v=AAV(ind); id=(I)ind*ARELATIVE(ind);
+  ASSERT(1>=r,EVINDEX);
+  ASSERT(n<=wr,EVINDEX);
+  d=n; DO(n, --d; if(!equ(ace,AADR(id,v[d])))break;); if(n)++d; n=d;
+  j=zero;
+  for(i=0;i<n;++i){
+   x=AADR(id,v[i]); d=ws[i];
+   if(AN(x)&&BOX&AT(x)){
+    ASSERT(!AR(x),EVINDEX); 
+    x=AAV0(x); k=IX(d);
+    if(AN(x))k=less(k,pind(d,1<AR(x)?ravel(x):x));
+   }else k=pind(d,x);
+   RZ(j=irs2(tymes(j,sc(d)),k,0L,0L,RMAX,jtplus));
+ }}
+ R n==wr?j:irs2(tymes(j,sc(prod(wr-n,ws+n))),iota(vec(INT,wr-n,ws+n)),0L,0L,RMAX,jtplus);
+}    /* convert ind in a ind}w into integer positions */
+
+/* Reference count for w for amend in place */
+/* 1 jdo     tpop                           */
+/* 2 amendn2 EPILOG/gc                      */
+/* 1 jdo     tpop                           */
+
+static A jtamendn2(J jt,A a,A w,A ind,B ip){PROLOG;A e,z;B b,sa,sw;I at,ir,it,t,t1,wt;P*p;
+ RZ(a&&w&&ind);
+ at=AT(a); sa=1&&at&SPARSE; if(sa)at=DTYPE(at);
+ wt=AT(w); sw=1&&wt&SPARSE; if(sw)wt=DTYPE(wt);
+ it=AT(ind); ir=AR(ind);
+ ASSERT(it&NUMERIC+BOX||!AN(ind),EVDOMAIN);
+ ASSERT(it&DENSE,EVNONCE);
+ if(sw){
+  ASSERT(!(wt&BOX),EVNONCE); ASSERT(HOMO(at,wt),EVDOMAIN);
+  RE(t=maxtype(at,wt)); t1=STYPE(t); RZ(a=t==at?a:cvt(sa?t1:t,a));
+  if(ip=ip&&t==wt&&t1!=BOX){ASSERT(!(AFRO&AFLAG(w)),EVRO); z=w;}else RZ(z=cvt(t1,w));
+  p=PAV(z); e=SPA(p,e); b=!AR(a)&&equ(a,e);
+  p=PAV(a); if(sa&&!equ(e,SPA(p,e))){RZ(a=denseit(a)); sa=0;}
+  if(it&NUMERIC||!ir)z=(b?jtam1e:sa?jtam1sp:jtam1a)(jt,a,z,it&NUMERIC?box(ind):ope(ind),ip);
+  else{RE(aindex(ind,z,0L,&ind)); ASSERT(ind,EVNONCE); z=(b?jtamne:sa?jtamnsp:jtamna)(jt,a,z,ind,ip);}
+ }else z=merge2(sa?denseit(a):a,w,jstd(w,ind),ip);
+ EPILOG(z);
+}
+
+static DF2(amccn2){R amendn2(a,w,VAV(self)->f,0);}
+static DF2(amipn2){R amendn2(a,w,VAV(self)->f,(B)(!(AT(w)&RAT+XNUM)&&(1==AC(w)||AFNJA&AFLAG(w))));}
+
+static DF2(amccv2){DECLF; 
+ RZ(a&&w); 
+ ASSERT(DENSE&AT(w),EVNONCE);
+ R merge2(a,w,pind(AN(w),CALL2(f2,a,w,fs)),0);
+}
+
+static DF2(amipv2){DECLF; 
+ RZ(a&&w); 
+ ASSERT(DENSE&AT(w),EVNONCE);
+ R merge2(a,w,pind(AN(w),CALL2(f2,a,w,fs)),(B)(!(AT(w)&RAT+XNUM)&&(1==AC(w)||AFNJA&AFLAG(w))));
+}
+
+static DF1(mergn1){       R merge1(w,VAV(self)->f);}
+static DF1(mergv1){DECLF; R merge1(w,CALL1(f1,w,fs));}
+
+static B ger(A w){A*wv,x;I wd;
+ if(!(BOX&AT(w)))R 0;
+ wv=AAV(w); wd=(I)w*ARELATIVE(w);
+ DO(AN(w), x=WVR(i); if(BOX&AT(x)&&1==AR(x)&&2==AN(x))x=AAV0(x); if(!(LIT&AT(x)&&1>=AR(x)&&AN(x)))R 0;);
+ R 1;
+}    /* 0 if w is definitely not a gerund; 1 if possibly a gerund */
+
+static A jtamend(J jt,A w,B ip){
+ RZ(w);
+ if(VERB&AT(w)) R ADERIV(CRBRACE,mergv1,ip?amipv2:amccv2,RMAX,RMAX,RMAX);
+ else if(ger(w))R gadv(w,CRBRACE);
+ else           R ADERIV(CRBRACE,mergn1,ip?amipn2:amccn2,RMAX,RMAX,RMAX);
+}
+
+F1(jtrbrace){R amend(w,0);}
+F1(jtamip  ){R amend(w,1);}
+
+
+static DF2(jtamen2){ASSERT(0,EVNONCE);}
+
+F1(jtemend){
+ ASSERT(NOUN&AT(w),EVDOMAIN);
+ R ADERIV(CEMEND,0L,jtamen2,RMAX,RMAX,RMAX);
+}

new file mode 100644
--- /dev/null
+++ b/am1.c
@@ -0,0 +1,205 @@
+/* Copyright 1990-2011, Jsoftware Inc.  All rights reserved. */
+/* License in license.txt.                                   */
+/*                                                                         */
+/* Adverbs: a ind}z for sparse z & ind is box a0;a1;a2;... or integer      */
+
+/*  am1e    a is the sparse element                                        */
+/*  am1a    a is an arbitrary dense array                                  */
+/*  am1sp   a an arbitrary sparse array                                    */
+
+#include "j.h"
+
+
+static A jtistd1(J jt,A z,A ind){A*iv,j,*jv,x;I d,i,id,n,r,*s;
+ RZ(z&&ind);
+ ASSERT(1>=AR(ind),EVRANK);
+ if(AN(ind)&&!(BOX&AT(ind))){ASSERT(NUMERIC&AT(ind),EVINDEX); RZ(ind=every(ind,0L,jtright1));}
+ s=AS(z); n=AN(ind); iv=AAV(ind); id=(I)ind*ARELATIVE(ind);
+ ASSERT(n<=AR(z),EVINDEX);
+ d=n; DO(n, --d; x=IVR(d); if(!equ(x,ace))break;); n=n?1+d:d;
+ GA(j,BOX,n,1,0); jv=AAV(j);
+ for(i=0;i<n;++i){
+  x=IVR(i); d=s[i];
+  if(BOX&AT(x)){
+   ASSERT(!AR(x),EVINDEX); 
+   x=AAV0(x); r=AR(x);
+   RZ(jv[i]=!AN(x)&&1==r?ace:less(IX(d),pind(d,x)));
+  }else RZ(jv[i]=pind(d,x));
+ }
+ R j;
+}    /* convert index list ind into standard form */
+
+static A jtastd1(J jt,A a,A z,A ind){A*iv,q,r,s,s1,*sv,x;B b;I ar,*as,d,id,j,m,n,*rv,zr,*zs;P*zp;  I*s1v;
+ ar=AR(a); as=AS(a);
+ zr=AR(z); zs=AS(z); zp=PAV(z);
+ if(!ar)R a;
+ n=AN(ind); iv=AAV(ind); id=(I)ind*ARELATIVE(ind);
+ GA(r,INT,zr,1,0); rv= AV(r);
+ GA(s,BOX,zr,1,0); sv=AAV(s);
+ m=0; j=n;
+ DO(n, x=IVR(i); b=x==ace; m+=rv[i]=b?1:AR(x); RZ(sv[i]=b?sc(zs[i]):shape(x));); 
+ DO(zr-n, rv[j]=1; RZ(sv[j]=sc(zs[j])); ++j;);
+ d=m+zr-n; ASSERT(ar<=d,EVRANK);
+ RZ(s1=raze(s)); s1v=AV(s1);
+ ASSERT(!ICMP(as,AV(s1)+d-ar,ar),EVLENGTH);
+ if(ar<d)RZ(a=reshape(s1,a));
+ RZ(q=dgrade1(eps(repeat(r,IX(zr)),SPA(zp,a))));
+ R equ(q,IX(d))?a:cant2(q,a);
+}    /* convert replacement array a into standard form relative to index list ind */
+
+static A jtssel(J jt,A z,A ind){A a,*iv,p,q,x,y;B*b;I*av,c,i,id,j,m,n,*u,*v,*yv;P*zp;
+ zp=PAV(z);
+ y=SPA(zp,i); v=AS(y); m=v[0]; c=v[1]; yv=AV(y); 
+ a=SPA(zp,a); n=AN(a); av=AV(a); 
+ GA(p,B01,m,1,0); b=BAV(p); memset(b,C1,m);
+ GA(q,INT,m,1,0); v=AV(q); iv=AAV(ind); id=(I)ind*ARELATIVE(ind); 
+ for(i=0;i<n;++i){
+  j=av[i]; if(j>=AN(ind))break;
+  x=IVR(j);
+  if(x!=ace){
+   u=yv+i; DO(m, v[i]=b[i]?*u:-1; u+=c;);
+   RZ(p=eps(q,1<AR(x)?ravel(x):x)); b=BAV(p);
+ }}
+ R p;
+}    /* which rows of the index matrix of z are selected by index list ind? */
+
+static B jtipart(J jt,A z,A ind,A*i1,A*i2){A*iv,p,*pv,q,*qv,x;B*b;I c,d,id,n;P*zp;
+ n=AN(ind); iv=AAV(ind); id=(I)ind*ARELATIVE(ind); zp=PAV(z);
+ RZ(b=bfi(AR(z),SPA(zp,a),1));
+ c=0; DO(n, if(b[i])++c;); d=n-c;
+ GA(p,BOX,c,1,0); pv=AAV(p); *i1=p;
+ GA(q,BOX,d,1,0); qv=AAV(q); *i2=q;
+ DO(n, x=IVR(i); if(b[i])*pv++=x; else *qv++=x;);
+ R 1;
+}    /* partition index into sparse and dense parts */
+
+static A jtdcube(J jt,A z,A i2){A*iv,x,y;I i,id,m,n,*s;P*zp;
+ n=AN(i2); iv=AAV(i2); id=(I)i2*ARELATIVE(i2);
+ zp=PAV(z); x=SPA(zp,x); s=1+AS(x);
+ m=1; y=IVR(n-1); if(y==ace)RZ(y=IX(s[n-1]));
+ for(i=n-2;0<=i;--i){
+  m*=s[1+i]; x=IVR(i);
+  RZ(y=irs2(tymes(sc(m),x==ace?IX(s[i]):x),y,0L,0L,RMAX,jtplus));
+ }
+ R y;
+}    /* index cube relative to dense axes */
+
+static A jtscuba(J jt,A z,A i1,B u){A*iv,q=0,x;I c,d,id,j,n,*s,*v;P*zp;
+ n=AN(i1); 
+ if(!n)R mtm;
+ iv=AAV(i1); id=(I)i1*ARELATIVE(i1); s=AS(z); zp=PAV(z); x=SPA(zp,a); v=AV(x);
+ for(j=n-1;0<=j;--j){
+  x=IVR(j);
+  if(x==ace)RZ(x=IX(s[v[j]]))else{if(1<AR(x))RZ(x=ravel(x)); if(u)RZ(x=nub(x));}
+  c=AN(x); 
+  if(q){d=*AS(q); RZ(q=stitch(repeat(sc(d),x),reitem(sc(c*d),q)));}
+  else RZ(q=reshape(v2(c,1L),x));
+ }
+ R q;
+}    /* index cube relative to sparse axes; 1=u iff unique (remove duplicates) */
+
+static A jtscubb(J jt,A z,A i1){A a,q,x,y;I c,d,h,j,*s,*v,*xv;P*zp;
+ RZ(q=scuba(z,i1,1));
+ if(!*AS(q))R mtm;
+ s=AS(z); zp=PAV(z); y=SPA(zp,i); a=SPA(zp,a); v=AV(a);
+ c=*(1+AS(q)); d=*(1+AS(y)); h=d-c;
+ if(c==d)R less(q,y);
+ RZ(q=less(q,taker(c,y)));
+ GA(x,INT,h,1,0); xv=AV(x); j=c; DO(h, xv[i]=s[v[j++]];);
+ RZ(x=odom(2L,h,xv));
+ c=*AS(q); d=*AS(x);
+ R stitch(repeat(sc(d),q),reitem(sc(c*d),x));
+}    /* new rows for the index matrix of z for brand new cells */
+
+static A jtscubc(J jt,A z,A i1,A p){A a,q,s,y,y1;B*qv;I c,d,h,j=-1,m,n,*sv,*u,*v;P*zp;
+ zp=PAV(z); a=SPA(zp,a); n=AN(i1); h=AN(a)-n;
+ if(!h)R mtm;
+ GA(s,INT,h,1,0); sv=AV(s); 
+ d=1; u=AS(z); v=AV(a); DO(h, d*=sv[i]=u[v[n+i]];);
+ RZ(y=repeat(p,SPA(zp,i))); m=*AS(y);
+ RZ(y1=take(v2(m,n),y)); v=AV(y1);
+ GA(q,B01,m,1,0); qv=BAV(q);
+ if(m){memset(qv,C0,m); DO(m-1, if(ICMP(v,v+n,n)){if(d>i-j)qv[i]=1; j=i;} v+=n;); if(d>(m-1)-j)qv[m-1]=1;}
+ RZ(y1=repeat(q,y1)); c=*AS(y1);
+ if(!c)R mtm;
+ R less(stitch(repeat(sc(d),y1),reitem(sc(c*d),odom(2L,h,sv))),y);
+}    /* new rows for the index matrix of z for existing cells */
+
+static A jtscube(J jt,A z,A i1,A p){A a,y;P*zp;
+ zp=PAV(z); a=SPA(zp,a); y=SPA(zp,i);
+ R !AN(a)&&!*AS(y)?take(one,mtm):over(scubb(z,i1),scubc(z,i1,p));
+}    /* new rows for the index matrix of z */
+
+static A jtiindx(J jt,A z,A i1){A q,j,j1,y;I c,d,e,h,i,*jv,m,n,*qv,*v,*yv;P*zp;
+ c=AN(i1); zp=PAV(z); y=SPA(zp,i); 
+ if(c==*(1+AS(y)))R indexof(y,scuba(z,i1,0));
+ /* when y has excess columns, do progressive indexing */
+ RZ(y=taker(c,y)); 
+ RZ(j=indexof(y,scuba(z,i1,0)));  /* j: group indices           */
+ n= AN(j); jv=AV(j);
+ m=*AS(y); yv=AV(y);
+ GA(q,INT,n,1,0); qv=AV(q);          /* q: # members in each group */
+ for(i=h=0;i<n;++i){
+  e=1; d=jv[i]; v=yv+c*d;
+  DO(m-d-1, if(ICMP(v,v+c,c))break; ++e; v+=c;);
+  qv[i]=e; h+=e;
+ }
+ GA(j1,INT,h,1,0); v=AV(j1);
+ DO(n, e=qv[i]; d=jv[i]; DO(e, *v++=d++;););
+ R j1;
+}    /* index of index list in the index matrix of z */
+
+static A jtzpad1(J jt,A z,A t,B ip){A q,s,x,x0,y,y0;I m;P*zp;
+ RZ(z&&t);
+ if(m=*AS(t)){  /* new cells being added */
+  zp=PAV(z);  
+  y0=SPA(zp,i); RZ(y=over(y0,t)); RZ(q=grade1(y)); RZ(y=from(q,y));
+  x0=SPA(zp,x); RZ(s=shape(x0)); *AV(s)=m; RZ(x=from(q,over(x0,reshape(s,SPA(zp,e)))));
+  if(ip){ra(y); ra(x); fa(y0); fa(x0);}
+  SPB(zp,i,y); SPB(zp,x,x);
+ }
+ R z;
+}    /* pad z with new rows t for its index matrix */
+
+static B mtind(A ind){A*iv,x;I id;
+ iv=AAV(ind); id=(I)ind*ARELATIVE(ind);
+ DO(AN(ind), x=IVR(i); if(!AN(x))R 1;); 
+ R 0;
+}    /* 1 iff standardized index ind is an empty selection */
+
+A jtam1e(J jt,A a,A z,A ind,B ip){A e,i1,i2,p,x,y;B*pv;C*u,*v;I*iv,k,m,n,r,*s,vk,xk;P*zp;
+ RZ(a&&(ind=istd1(z,ind)));
+ r=AR(z); zp=PAV(z); x=SPA(zp,x); y=SPA(zp,i); e=SPA(zp,e);
+ RZ(p=ssel(z,ind)); pv=BAV(p);
+ RZ(ipart(z,ind,&i1,&i2));
+ m=AN(p); n=AN(i2); u=CAV(e); v=CAV(x);
+ r=AR(x); s=AS(x); k=bp(AT(x)); xk=k*prod(r-(n+1),s+(n+1)); vk=k*prod(r-1,s+1);
+ if(!n)DO(m, if(pv[i])mvc(xk,v,k,u); v+=vk;)
+ else{
+  RZ(i2=dcube(z,i2)); iv=AV(i2); n=AN(i2);
+  DO(m, if(pv[i])DO(n, mvc(xk,v+iv[i]*xk,k,u);); v+=vk;);
+ }
+ R z;
+}    /* a (<ind)}z; sparse z; ind is index list; sparse element a replacement */
+
+A jtam1a(J jt,A a,A z,A ind,B ip){A a0=a,a1,e,i1,i2,t,x,y;C*u,*v,*xv;I ar,c,*iv,*jv,k,m,n,r,*s,uk,vk,xk;P*zp;
+ RZ(a&&(ind=istd1(z,ind)));
+ RZ(a=astd1(a,z,ind));
+ if(mtind(ind))R z;
+ RZ(ipart(z,ind,&i1,&i2));
+ RZ(z=zpad1(z,scube(z,i1,ssel(z,ind)),ip));
+ zp=PAV(z); x=SPA(zp,x); y=SPA(zp,i); e=SPA(zp,e);
+ ar=AR(a); n=AN(i2); r=AR(x); s=AS(x);
+ k=bp(AT(x)); xk=k*prod(r-1-n,s+1+n); vk=k*prod(r-1,s+1); uk=!ar?k:n?xk:vk;
+ u=CAV(a); xv=v=CAV(x);
+ RZ(t=iindx(z,i1)); iv=AV(t); m=AN(t);
+ if(!n&&!m){a1=SPA(zp,a); R ar?sparseit(a0,a1,e):sparseit(reshape(shape(z),a),a1,a);}
+ if(n){RZ(t=dcube(z,i2)); jv=AV(t); c=AN(t); v=xv-vk;}
+ if(!n)    DO(m,                           mvc(vk,v+vk*iv[i],uk,u); if(ar)u+=uk;  )
+ else if(m)DO(m,      v=xv+vk*iv[i]; DO(c, mvc(xk,v+xk*jv[i],uk,u); if(ar)u+=uk;);)
+ else      DO(*AS(x), v+=vk;         DO(c, mvc(xk,v+xk*jv[i],uk,u); if(ar)u+=uk;););
+ R z;
+}    /* a (<ind)}z; sparse z; ind is index list; arbitrary dense array a replacement */
+
+A jtam1sp(J jt,A a,A z,A ind,B ip){R amnsp(a,z,ope(catalog(istd1(z,ind))),ip);}
+     /* a (<ind)}z; sparse z; ind is index list; arbitrary sparse array a replacement */

new file mode 100644
--- /dev/null
+++ b/amn.c
@@ -0,0 +1,139 @@
+/* Copyright 1990-2011, Jsoftware Inc.  All rights reserved. */
+/* License in license.txt.                                   */
+/*                                                                         */
+/* Adverbs: a ind}z where z is sparse and ind is <"1 integers              */
+
+/*  amne    a is the sparse element                                        */
+/*  amna    a is an arbitrary dense array                                  */
+/*  amnsp   a an arbitrary sparse array                                    */
+
+#include "j.h"
+
+
+static I jtcsize(J jt,A z,A ind){B*b;I h,j,m,r,*s;P*zp;
+ r=AR(z); s=AS(z); zp=PAV(z);
+ RZ(b=bfi(r,SPA(zp,a),0));
+ m=1; j=h=*(AR(ind)+AS(ind)-1); DO(r-h, if(b[j])m*=s[j]; ++j;);
+ R m;
+}    /* data cell size in z for each element of index array ind */
+
+static B jtiaddr(J jt,A z,A ind,A*i1,A*i2){A a,ai,as,ii,jj,q,t,x,y;I c,d,e,h,i,*iv,*jv,m,n,p,*qv,*s,*u,*v,*yv;P*zp;
+ zp=PAV(z); a=SPA(zp,a); x=SPA(zp,x); s=1+AS(x); 
+ h=*(AS(ind)+AR(ind)-1);                               /* # axes indexed              */
+ RZ(q=gt(sc(h),a)); 
+ y=SPA(zp,i); if(!all1(q))RZ(y=repeatr(q,y));          /* indexed cols of index mat   */
+ m=*AS(y); yv=AV(y);      
+ RZ(ai=IX(h));
+ RZ(as=less(IX(AR(z)),a)); u=AV(as); n=AN(as);         /* dense axes                  */
+ GA(t,INT,n,1,0); v=AV(t);                             /* shape of indexed dense axes */
+ e=0; d=1; DO(n, if(h>u[i])v[e++]=s[i]; else d*=s[i];);
+ RZ(*i2=jj=tymes(sc(d),base2(vec(INT,e,v),repeatr(eps(ai,as),ind))));
+ c=*(1+AS(y));
+ if(!c){
+  n=AN(jj);
+  RZ(*i1=repeat(sc(n),IX(m)));
+  RZ(*i2=reshape(sc(m*n),jj));
+  R 1;
+ }
+ RZ(*i1=ii=indexof(y,repeatr(eps(ai,a),ind)));         /* group indices in index mat  */
+ if(c==AN(a))R 1;
+ n=AN(ii); iv=AV(ii); jv=AV(jj);                       /* do progressive iota         */
+ GA(q,INT,n,1,0); qv=AV(q);                            /* group sizes                 */
+ for(i=h=0;i<n;++i){
+  e=1; d=iv[i]; v=yv+c*d;
+  DO(m-d-1, if(ICMP(v,v+c,c))break; ++e; v+=c;);
+  qv[i]=e; h+=e;                                       /* # elements in group i       */
+ }
+ GA(t,INT,h,1,0); u=AV(t); *i1=t;
+ GA(t,INT,h,1,0); v=AV(t); *i2=t;
+ DO(n, e=qv[i]; d=iv[i]; p=jv[i]; DO(e, *u++=d++; *v++=p;););
+ R 1;
+}    /* index i1 (in index matrix) and address i2 (in data array) from index array */
+
+static A jtzpadn(J jt,A z,A ind,B ip){A a,ai,i1,p,p1,q,t,x,x0,y,y0,y1;B*b;I c,d,h,m,n;P*zp;
+ zp=PAV(z); a=SPA(zp,a); x=x0=SPA(zp,x); y=y0=SPA(zp,i);
+ n=1; h=*(AS(ind)+AR(ind)-1);
+ RZ(ai=IX(h));
+ RZ(t=eps(ai,a)); b=BAV(t); d=0; DO(h, if(b[i])++d;);
+ RZ(i1=d<h?repeatr(t,ind):ind); if(2!=AR(ind))RZ(i1=d?reshape(v2(AN(i1)/d,d),i1):mtm);
+ RZ(t=gt(sc(h),a)); RZ(y1=all1(t)?y:repeatr(t,y));
+ RZ(p=nub(less(i1,y1)));
+ if(c=AN(a)-d){
+  RZ(t=from(less(a,ai),shape(z))); RZ(p1=odom(2L,c,AV(t))); n=*AS(p1);
+  if(m=*AS(p))RZ(p=stitch(repeat(sc(n),p),reshape(v2(n*m,c),p1)));
+  RZ(t=nub(repeat(eps(y1,i1),y1)));
+  RZ(t=stitch(repeat(sc(n),t),reshape(v2(n**AS(t),c),p1)));
+  RZ(t=less(t,y));
+  if(AN(t))RZ(p=over(p,t));
+ }
+ if(m=*AS(p)){  /* new cells being added */
+  RZ(y=over(y,p)); RZ(q=grade1(y)); RZ(y=from(q,y));
+  RZ(t=shape(x)); *AV(t)=m; RZ(x=from(q,over(x,reshape(t,SPA(zp,e))))); 
+  if(ip){ra(y); ra(x); fa(y0); fa(x0);}
+  SPB(zp,i,y); SPB(zp,x,x);
+ }
+ R z;
+}    /* create new indexed cells in z as necessary */
+
+static A jtastdn(J jt,A a,A z,A ind){A a1,q,r,s;B*b;I ar,*as,*av,d,ir,n,n1,*v,zr,*zs;P*zp;
+ ar=AR(a); as=AS(a);
+ zr=AR(z); zs=AS(z); 
+ if(!ar)R a;
+ ir=AR(ind); n=*(AS(ind)+ir-1); d=(ir-1)+(zr-n); ASSERT(ar<=d,EVRANK);
+ GA(s,INT,d,1,0); v=AV(s); ICPY(v,AS(ind),ir-1); ICPY(v+ir-1,zs+n,zr-n);
+ ASSERT(!ICMP(as,AV(s)+d-ar,ar),EVLENGTH);
+ if(ar<d)RZ(a=reshape(s,a));
+ zp=PAV(z); a1=SPA(zp,a); av=AV(a1); n1=n-1;
+ GA(s,B01,zr,1,0); b=BAV(s); 
+ memset(b,C0,zr); DO(AN(a1), b[av[i]]=1;); memset(b,!memchr(b,C1,n)?C0:C1,n);
+ GA(r,INT,zr-n1,1,0); v=AV(r); *v++=ar-(zr-n); DO(zr-n, *v++=1;);
+ RZ(q=dgrade1(repeat(r,vec(B01,zr-n1,b+n1))));
+ R equ(q,IX(ar))?a:cant2(q,a);
+}    /* convert replacement array a into standard form relative to index array ind */
+
+A jtamne(J jt,A a,A z,A ind,B ip){A i1,i2,x,y;C*u,*v;I*iv,*jv,k,m,n,vk,xk;P*zp;
+ RZ(a&&z&&ind);
+ RZ(iaddr(z,ind,&i1,&i2));
+ zp=PAV(z); x=SPA(zp,x); y=SPA(zp,i);
+ m=*AS(y); n=AN(i1);
+ k=bp(AT(x)); xk=k*aii(x); vk=k*csize(z,ind);
+ u=CAV(a); v=CAV(x); iv=AV(i1); jv=AV(i2);
+ DO(n, if(m>iv[i])mvc(vk,v+xk*iv[i]+k*jv[i],k,u););
+ R z;
+}    /* a (<"1 ind)}z, sparse z, integer array ind, sparse element a replacement */
+
+A jtamna(J jt,A a,A z,A ind,B ip){A i1,i2,x;C*u,*v;I*iv,*jv,k,n,vk,xk;P*zp;
+ RZ(a&&z&&ind);
+ RZ(z=zpadn(z,ind,ip));
+ RZ(a=astdn(a,z,ind));
+ RZ(iaddr(z,ind,&i1,&i2));
+ zp=PAV(z); x=SPA(zp,x); n=AN(i1);
+ k=bp(AT(x)); xk=k*aii(x); vk=k*csize(z,ind);
+ u=CAV(a); v=CAV(x); iv=AV(i1); jv=AV(i2); 
+ if(AR(a))DO(n, mvc(vk,v+xk*iv[i]+k*jv[i],vk,u); u+=vk;)
+ else     DO(n, mvc(vk,v+xk*iv[i]+k*jv[i],k,u););
+ R z;
+}    /* a (<"1 ind)}z, dense a,integer array ind, sparse z */
+
+A jtamnsp(J jt,A a,A z,A ind,B ip){A i1,i2,t;C*ev,*u,*v,*vv;I c,*dv,i,*iv,j,*jv,k,m,n,p,q,r,*s,*yv,zk;P*ap,*zp;
+ RZ(a&&z&&ind);
+ r=AR(a); ap=PAV(a); t=SPA(ap,a); if(r>AN(t))RZ(a=reaxis(IX(r),a));
+ RZ(a=astdn(a,z,ind));  ap=PAV(a);
+ RZ(z=zpadn(z,ind,ip)); zp=PAV(z);
+ RZ(iaddr(z,ind,&i1,&i2));
+ s=AS(a); n=AN(i1); c=csize(z,ind); iv=AV(i1); jv=AV(i2);
+ t=SPA(ap,i); yv= AV(t); m=*AS(t); p=0;
+ t=SPA(ap,e); ev=CAV(t);
+ t=SPA(ap,x); u =CAV(t);
+ t=SPA(zp,x); v =CAV(t); k=bp(AT(t)); zk=k*aii(t);
+ GA(t,INT,r,1,0); dv=AV(t); memset(dv,C0,SZI*r); dv[r-1]=-1;
+ for(i=0;i<n;++i){
+  vv=v+zk*iv[i]+k*jv[i];
+  for(j=0;j<c;++j){
+   q=r; DO(r, --q; ++dv[q]; if(dv[q]<s[q])break; dv[q]=0;);
+   q=1; while(p<m){DO(r, if(q=yv[i]-dv[i])break;); if(0<=q)break; ++p; yv+=r;}
+   MC(vv,q?ev:u+k*p,k); 
+   vv+=k;
+ }}
+ R z;
+}    /* a (<"1 ind)}z, sparse a, integer array ind, sparse z */

new file mode 100644
--- /dev/null
+++ b/ao.c
@@ -0,0 +1,492 @@
+/* Copyright 1990-2011, Jsoftware Inc.  All rights reserved. */
+/* License in license.txt.                                   */
+/*                                                                         */
+/* Adverbs: Oblique and Key                                                */
+
+#include "j.h"
+
+
+static DF1(jtoblique){A x,y;I m,n,r,*u,*v;
+ RZ(w);
+ r=AR(w);
+ RZ(y=gah(MAX(r-1,1),w));
+ u=AS(w); v=AS(y);
+ if(1>=r){*v=m=AN(w); n=1;}else{m=*u++; n=*u++; *v++=m*n; ICPY(v,u,r-2);}
+ RZ(x=irs2(IX(m),IX(n),0L,0L,1L,jtplus)); AR(x)=1; *AS(x)=AN(x);
+ R df2(x,y,sldot(VAV(self)->f));
+}
+
+
+#define OBQCASE(id,t)    ((id)+(256*(t)))
+
+#define OBQLOOP(Tw,Tz,zt,init,expr)  \
+ {Tw*u,*v,*ww=(Tw*)wv;Tz x,*zz;                  \
+  b=1; k=n1;                                     \
+  GA(z,zt,d*c,r-1,1+s); *AS(z)=d; zz=(Tz*)AV(z); \
+  DO(n,  v=ww+i;      u=v+n1*MIN(i,m1);     init; while(v<=(u-=n1))expr; *zz++=x;);  \
+  DO(m1, v=ww+(k+=n); u=v+n1*MIN(m-i-2,n1); init; while(v<=(u-=n1))expr; *zz++=x;);  \
+ }
+
+static DF1(jtobqfslash){A y,z;B b=0,p;C er,id,*wv;I c,d,k,m,m1,mn,n,n1,r,*s,wt;
+ RZ(w);
+ r=AR(w); s=AS(w); wt=AT(w); wv=CAV(w);
+ if(!(AN(w)&&1<r&&DENSE&wt))R oblique(w,self);
+ y=VAV(self)->f; y=VAV(y)->f; id=vaid(y);
+ m=s[0]; m1=m-1;
+ n=s[1]; n1=n-1; mn=m*n; d=m+n-1; c=prod(r-2,2+s);
+ if(1==m||1==n){GA(z,wt,AN(w),r-1,1+s); *AS(z)=d; MC(AV(z),wv,AN(w)*bp(wt)); R z;}
+ if(wt&FL+CMPX)NAN0;
+ if(1==c)switch(OBQCASE(wt,id)){
+  case OBQCASE(B01, CNE     ): OBQLOOP(B,B,wt,x=*u, x^=*u        ); break;
+  case OBQCASE(B01, CEQ     ): OBQLOOP(B,B,wt,x=*u, x=x==*u      ); break;
+  case OBQCASE(B01, CMAX    ):
+  case OBQCASE(B01, CPLUSDOT): OBQLOOP(B,B,wt,x=*u, x|=*u        ); break;
+  case OBQCASE(B01, CMIN    ):
+  case OBQCASE(B01, CSTAR   ):
+  case OBQCASE(B01, CSTARDOT): OBQLOOP(B,B,wt,x=*u, x&=*u        ); break;
+  case OBQCASE(B01, CLT     ): OBQLOOP(B,B,wt,x=*u, x=*u< x      ); break;
+  case OBQCASE(B01, CLE     ): OBQLOOP(B,B,wt,x=*u, x=*u<=x      ); break;
+  case OBQCASE(B01, CGT     ): OBQLOOP(B,B,wt,x=*u, x=*u> x      ); break;
+  case OBQCASE(B01, CGE     ): OBQLOOP(B,B,wt,x=*u, x=*u>=x      ); break;
+  case OBQCASE(B01, CPLUS   ): OBQLOOP(B,I,INT,x=*u, x+=*u        ); break;
+  case OBQCASE(FL,  CMAX    ): OBQLOOP(D,D,wt,x=*u, x=MAX(x,*u)  ); break;
+  case OBQCASE(FL,  CMIN    ): OBQLOOP(D,D,wt,x=*u, x=MIN(x,*u)  ); break;
+  case OBQCASE(FL,  CPLUS   ): OBQLOOP(D,D,wt,x=*u, x+=*u        ); break;
+  case OBQCASE(CMPX,CPLUS   ): OBQLOOP(Z,Z,wt,x=*u, x=zplus(x,*u)); break;
+  case OBQCASE(XNUM,CMAX    ): OBQLOOP(X,X,wt,x=*u, x=1==xcompare(x,*u)? x:*u); break;
+  case OBQCASE(XNUM,CMIN    ): OBQLOOP(X,X,wt,x=*u, x=1==xcompare(x,*u)?*u: x); break;
+  case OBQCASE(XNUM,CPLUS   ): OBQLOOP(X,X,wt,x=*u, x=xplus(x,*u)); break;
+  case OBQCASE(RAT, CMAX    ): OBQLOOP(Q,Q,wt,x=*u, x=1==QCOMP(x,*u)? x:*u); break;
+  case OBQCASE(RAT, CMIN    ): OBQLOOP(Q,Q,wt,x=*u, x=1==QCOMP(x,*u)?*u: x); break;
+  case OBQCASE(RAT, CPLUS   ): OBQLOOP(Q,Q,wt,x=*u, x=qplus(x,*u)); break;
+  case OBQCASE(INT, CBW0001 ): OBQLOOP(I,I,wt,x=*u, x&=*u        ); break;
+  case OBQCASE(INT, CBW0110 ): OBQLOOP(I,I,wt,x=*u, x^=*u        ); break;
+  case OBQCASE(INT, CBW0111 ): OBQLOOP(I,I,wt,x=*u, x|=*u        ); break;
+  case OBQCASE(INT, CMAX    ): OBQLOOP(I,I,wt,x=*u, x=MAX(x,*u)  ); break;
+  case OBQCASE(INT, CMIN    ): OBQLOOP(I,I,wt,x=*u, x=MIN(x,*u)  ); break;
+  case OBQCASE(INT, CPLUS   ): 
+   er=0; OBQLOOP(I,I,wt,x=*u, {p=0>x; x+=*u; BOV(p==0>*u&&p!=0>x);}); 
+   if(er==EWOV)OBQLOOP(I,D,FL,x=(D)*u, x+=*u);
+ }
+ if(wt&FL+CMPX)NAN1; RE(0);
+ R b?z:oblique(w,self);
+}    /* f//.y for atomic f */
+
+
+#if SY_64
+#define TYMESF(x)       {LD t=*u--*(LD)*v++; x=(I)t; BOV(t<IMIN||IMAX<t);}
+#else
+#define TYMESF(x)       {D  t=*u--*( D)*v++; x=(I)t; BOV(t<IMIN||IMAX<t);}
+#endif
+#define ACCUMF          {B p;I y; TYMESF(y); p=0>x; x+=y; BOV(p==0>y&&p!=0>x);}
+
+#define PMCASE(t,c,d)   (65536*(c)+256*(d)+(t))
+
+#define PMLOOP(Tw,Tz,zt,expr0,expr)  \
+ {Tw*aa=(Tw*)av,*u,*v,*ww=(Tw*)wv;Tz x,*zv;  \
+  b=1; GA(z,zt,zn,1,0); zv=(Tz*)AV(z);       \
+  for(i=0;i<zn;++i){                         \
+   j=MIN(i,m1); u=aa+j; v=ww+i-j;            \
+   p=MIN(1+i,zn-i); p=MIN(p,k);              \
+   expr0; DO(p-1, expr;); *zv++=x;           \
+ }}
+
+DF2(jtpolymult){A f,g,y,z;B b=0;C*av,c,d,*wv;I at,i,j,k,m,m1,n,p,t,wt,zn;V*v;
+ RZ(a&&w&&self);
+ m=AN(a); n=AN(w); m1=m-1; zn=m+n-1; k=MIN(m,n);
+ at=AT(a); wt=AT(w); t=maxtype(at,wt);
+ if(t!=at)RZ(a=cvt(t,a)); at=AT(a); av=CAV(a);
+ if(t!=wt)RZ(w=cvt(t,w)); wt=AT(w); wv=CAV(w);
+ v=VAV(self); 
+ f=v->f; y=VAV(f)->f; y=VAV(y)->f; c=vaid(y);
+ g=v->g; y=VAV(g)->f;              d=vaid(y);
+ if(!(m&&1==AR(a)&&n&&1==AR(w)))R obqfslash(df2(a,w,g),f);
+ if(t&FL+CMPX)NAN0;
+ switch(PMCASE(t,c,d)){
+  case PMCASE(B01, CNE,    CMAX    ): 
+  case PMCASE(B01, CNE,    CPLUSDOT): PMLOOP(B,B,B01,  x=*u--|*v++, x^=*u--|*v++); break;
+  case PMCASE(B01, CNE,    CSTAR   ): 
+  case PMCASE(B01, CNE,    CMIN    ): 
+  case PMCASE(B01, CNE,    CSTARDOT): PMLOOP(B,B,B01,  x=*u--&*v++, x^=*u--&*v++); break;
+  case PMCASE(B01, CPLUS,  CMAX    ): 
+  case PMCASE(B01, CPLUS,  CPLUSDOT): PMLOOP(B,I,INT,  x=*u--|*v++, x+=*u--|*v++); break;
+  case PMCASE(B01, CPLUS,  CSTAR   ): 
+  case PMCASE(B01, CPLUS,  CMIN    ): 
+  case PMCASE(B01, CPLUS,  CSTARDOT): PMLOOP(B,I,INT,  x=*u--&*v++, x+=*u--&*v++); break;
+  case PMCASE(FL,  CPLUS,  CSTAR   ): PMLOOP(D,D,FL,   x=*u--**v++, x+=*u--**v++); break;
+  case PMCASE(CMPX,CPLUS,  CSTAR   ): PMLOOP(Z,Z,CMPX, x=ztymes(*u--,*v++), x=zplus(x,ztymes(*u--,*v++))); break;
+  case PMCASE(XNUM,CPLUS,  CSTAR   ): PMLOOP(X,X,XNUM, x=xtymes(*u--,*v++), x=xplus(x,xtymes(*u--,*v++))); break;
+  case PMCASE(RAT, CPLUS,  CSTAR   ): PMLOOP(Q,Q,RAT,  x=qtymes(*u--,*v++), x=qplus(x,qtymes(*u--,*v++))); break;
+  case PMCASE(INT, CBW0110,CBW0001 ): PMLOOP(I,I,INT,  x=*u--&*v++, x^=*u--&*v++); break;
+  case PMCASE(INT, CPLUS,  CSTAR   ): 
+/*
+   er=0; PMLOOP(I,I,INT, TYMESF(x), ACCUMF);
+*/
+  {A a1,y;I*aa,i,*u,*ww=(I*)wv,*v,*yv,*zv;VF adotymes,adosum;
+   b=1;
+   RZ(var(CSTAR,a,w,at,wt,&adotymes,&i)); vains(CPLUS,wt,&adosum,&i);
+   GA(a1,INT,m,1,0); aa=AV(a1); u=m+(I*)av; DO(m, aa[i]=*--u;);
+   GA(y,INT,MIN(m,n),1,0); yv=AV(y);
+   GA(z,INT,zn,1,0); zv=AV(z);
+   for(i=0;i<zn;++i){
+    j=MIN(i,m1); u=aa+m1-j; v=ww+i-j;
+    p=MIN(1+i,zn-i); p=MIN(p,k);
+    adotymes(jt,1,p,1,yv,u,v); adosum(jt,1,p,p,zv,yv);
+    ++zv;
+   }
+   if(EWOV==jt->jerr){RESETERR; fa(z); PMLOOP(I,D,FL, x=*u--*(D)*v++, x+=*u--*(D)*v++);}
+ }}
+ if(t&FL+CMPX)NAN1; RE(0);
+ if(!b)R obqfslash(df2(a,w,g),f);
+ R z;
+}    /* f//.@(g/) for atomic f, g */
+
+
+static DF2(jtkey);
+
+static DF2(jtkeysp){PROLOG;A b,by,e,q,x,y,z;I j,k,n,*u,*v;P*p;
+ RZ(a&&w);
+ n=IC(a); 
+ RZ(q=indexof(a,a)); p=PAV(q); 
+ x=SPA(p,x); u=AV(x);
+ y=SPA(p,i); v=AV(y);
+ e=SPA(p,e); k=i0(e); 
+ j=0; DO(AN(x), if(k<=u[i])break; if(u[i]==v[i])++j;);
+ RZ(b=ne(e,x));
+ RZ(by=repeat(b,y));
+ RZ(x=key(repeat(b,x),from(ravel(by),w),self));
+ GA(q,SB01,1,1,0); *AS(q)=n;  /* q=: 0 by}1$.n;0;1 */
+ p=PAV(q); SPB(p,a,iv0); SPB(p,e,one); SPB(p,i,by); SPB(p,x,reshape(tally(by),zero));
+ RZ(z=over(df1(repeat(q,w),VAV(self)->f),x));
+ EPILOG(j?cdot2(box(IX(1+j)),z):z);
+}
+
+static DF2(jtkeyi){PROLOG;A j,p;B*pv;I*av,c,d=-1,n,*jv;
+ RZ(a&&w);
+ n=IC(a); av=AV(a);
+ RZ(j=grade1(a)); jv=AV(j);
+ GA(p,B01,n,1,0); pv=BAV(p);
+ DO(n, c=d; d=av[*jv++]; *pv++=c<d;);
+ EPILOG(df2(p,from(j,w),cut(VAV(self)->f,one)));
+}    /* a f/. w where a is i.~x for dense x & w */
+
+static DF2(jtkeybox){PROLOG;B b;I*wv;
+ RZ(a&&w);
+ ASSERT(IC(a)==IC(w),EVLENGTH);
+ if(SPARSE&AT(a))R keysp(a,w,self);
+ if(b=INT&AT(w)&&1==AR(w)){wv=AV(w); DO(AN(w), if(i!=*wv++){b=0; break;});}
+ if(b)R group(a);
+ EPILOG(keyi(indexof(a,a),w,self));
+}    /* a </. w */
+
+static DF2(jtkey){PROLOG;
+ RZ(a&&w);
+ ASSERT(IC(a)==IC(w),EVLENGTH);
+ if(SPARSE&AT(a))R keysp(a,w,self);
+ EPILOG(keyi(indexof(a,a),w,self));
+}    /* a f/. w */
+
+static I jtkeyrs(J jt,A a,I*zr,I*zs){I ac,at,r=0,s=0;
+ at=AT(a); ac=aii(a);
+ if(2>=ac)switch(at){
+  case C2T: if(1==ac)s=65536;                      break;
+  case B01: if(1==ac)s=2;   else{s=258;   at=C2T;} break;
+  case LIT: if(1==ac)s=256; else{s=65536; at=C2T;} break;
+  case INT: if(1==ac)irange(AN(a),AV(a),&r,&s);    break;
+  case SBT: if(1==ac){at=INT; s=jt->sbun; if(65536<s)irange(AN(a),AV(a),&r,&s);}
+ }
+ *zr=r; *zs=s;
+ R at;
+}
+
+#define KCASE(d,t)          (t+17*d)
+#define KACC1(F,Ta)  \
+ {Ta*u;                                                          \
+  if(1==c){                                                      \
+   u=(Ta*)av0; DO(n, v=qv+  *u++;       y=*wv++; *v=F;       );  \
+   u=(Ta*)av0; DO(n, if(bv[j=*u++]){*zv++=qv[j];                  bv[j]=0; if(s==++m)break;});  \
+  }else{                                                         \
+   u=(Ta*)av0; DO(n, v=qv+c**u++; DO(c, y=*wv++; *v=F; ++v;););  \
+   u=(Ta*)av0; DO(n, if(bv[j=*u++]){v=qv+c*j; DO(c, *zv++=*v++;); bv[j]=0; if(s==++m)break;});  \
+ }}
+#define KACC(F,Tz,Tw,v0)   \
+ {Tw*wv=(Tw*)wv0,y;Tz*qv=(Tz*)qv0,*v,*zv=(Tz*)zv0;               \
+  if(bb){                                                        \
+   m=0; v=qv; DO(AN(q), *v++=v0;); qv-=r*c;                      \
+   switch(at){                                                   \
+    case B01: KACC1(F,B ); break;                                \
+    case LIT: KACC1(F,UC); break;                                \
+    case C2T: KACC1(F,US); break;                                \
+    case INT: KACC1(F,I );                                       \
+  }}else{                                                        \
+   v=zv; DO(m*c, *v++=v0;);                                      \
+   if(1==c)DO(n, v=zv+  *xv++;       y=*wv++; *v=F;       )      \
+   else    DO(n, v=zv+c**xv++; DO(c, y=*wv++; *v=F; ++v;););     \
+ }}
+
+static DF2(jtkeyslash){PROLOG;A b,q,x,z=0;B bb,*bv,pp=0;C d;I at,*av0,c,n,j,m,*qv0,r,s,*u,wr,wt,*wv0,*xv,zt,*zv0;
+ RZ(a&&w);
+ at=AT(a); av0=AV(a); n=IC(a); 
+ wt=AT(w); wv0=AV(w); wr=AR(w);
+ ASSERT(n==IC(w),EVLENGTH);
+ x=VAV(self)->f; d=vaid(VAV(x)->f); if(B01&wt)d=d==CMAX?CPLUSDOT:d==CMIN||d==CSTAR?CSTARDOT:d;
+ if(!(AN(a)&&AN(w)&&at&DENSE&&
+     (wt&B01&&(d==CEQ||d==CPLUSDOT||d==CSTARDOT||d==CNE||d==CPLUS)||
+     wt&INT&&(17<=d&&d<=25)||
+     wt&INT+FL&&(d==CMIN||d==CMAX||d==CPLUS) )))R key(a,w,self);
+ at=keyrs(a,&r,&s); c=aii(w); m=s;
+ zt=d==CPLUS?(wt&B01?INT:wt&INT?FL:wt):wt; bb=s&&s<=MAX(2*n,65536);
+ if(bb){
+  GA(b,B01,s,  1,0); bv=BAV(b); memset(bv,C1,s); bv-=r;
+  GA(q,zt, s*c,1,0); qv0=AV(q);
+ }else{RZ(x=indexof(a,a)); xv=AV(x); m=0; u=xv; DO(n, *u=i==*u?m++:xv[*u]; ++u;);}
+ GA(z,zt,m*c,wr,AS(w)); *AS(z)=m; zv0=AV(z);
+ if(wt&FL)NAN0;
+ switch(KCASE(d,wt)){
+  case KCASE(CEQ,     B01): KACC(*v==y,    B, B, 1   ); break;
+  case KCASE(CPLUSDOT,B01): KACC(*v||y,    B, B, 0   ); break;
+  case KCASE(CSTARDOT,B01): KACC(*v&&y,    B, B, 1   ); break;
+  case KCASE(CNE,     B01): KACC(*v!=y,    B, B, 0   ); break;
+  case KCASE(CMIN,    INT): KACC(MIN(*v,y),I, I, IMAX); break;  
+  case KCASE(CMIN,    FL ): KACC(MIN(*v,y),D, D, inf ); break;
+  case KCASE(CMAX,    INT): KACC(MAX(*v,y),I, I, IMIN); break;
+  case KCASE(CMAX,    FL ): KACC(MAX(*v,y),D, D, infm); break;
+  case KCASE(CPLUS,   B01): KACC(*v+y,     I, B, 0   ); break;
+  case KCASE(CPLUS,   INT): KACC(*v+y,     D, I, 0.0 ); pp=1; break;
+  case KCASE(CPLUS,   FL ): KACC(*v+y,     D, D, 0.0 ); break;
+  case KCASE(17,      INT): KACC(*v&y,     UI,UI,-1  ); break;
+  case KCASE(22,      INT): KACC(*v^y,     UI,UI,0   ); break;
+  case KCASE(23,      INT): KACC(*v|y,     UI,UI,0   ); break;
+  case KCASE(25,      INT): KACC(~(*v^y),  UI,UI,-1  );
+ }
+ if(wt&FL)NAN1;
+ *AS(z)=m; AN(z)=m*c; if(pp)RZ(z=pcvt(INT,z));
+ EPILOG(z);
+}    /* x f//.y */
+
+
+#define KMCASE(ta,tw)  (ta+65536*tw)
+#define KMACC(Ta,Tw) \
+ {Ta*u=(Ta*)av;Tw*v=(Tw*)wv;                                        \
+  if(1==c)DO(n, ++pv[*u];                   qv[*u]+=*v++;   ++u;)   \
+  else    DO(n, ++pv[*u]; vv=qv+c**u; DO(c, *vv++ +=*v++;); ++u;);  \
+ }
+#define KMSET(Ta)    \
+ {Ta*u=(Ta*)av;                                                                                           \
+  if(1==c)DO(n, if(pv[j=*u++]){                             *zv++=qv[j]/pv[j]; pv[j]=0; if(s==++m)break;})   \
+  else    DO(n, if(pv[j=*u++]){vv=qv+c*j; d=(D)pv[j]; DO(c, *zv++=*vv++/d;);   pv[j]=0; if(s==++m)break;});  \
+ }
+#define KMFUN(Tw)    \
+ {Tw*v=(Tw*)wv;                                                      \
+  if(1==c)DO(n, j=*xv++; ++pv[j]; zv[j]+=*v++;)                      \
+  else    DO(n, j=*xv++; ++pv[j]; vv=zv+j*c; DO(c, *vv+++=*v++;););  \
+ }
+
+static DF2(jtkeymean){PROLOG;A p,q,x,z;D d,*qv,*vv,*zv;I at,*av,c,j,m=0,n,*pv,r,s,*u,wr,wt,*wv,*xv;
+ RZ(a&&w);
+ at=AT(a); av=AV(a); n=IC(a); 
+ wt=AT(w); wv=AV(w); wr=AR(w);
+ ASSERT(n==IC(w),EVLENGTH);
+ if(!(AN(a)&&AN(w)&&at&DENSE&&wt&B01+INT+FL))R df2(a,w,folk(sldot(slash(ds(CPLUS))),ds(CDIV),sldot(ds(CPOUND))));
+ at=keyrs(a,&r,&s); c=aii(w);
+ if(wt&FL)NAN0;
+ if(s&&s<=MAX(2*n,65536)){
+  GA(p,INT,s,  1, 0    ); pv= AV(p); memset(pv,C0,s*  SZI); pv-=r;
+  GA(q,FL, s*c,1, 0    ); qv=DAV(q); memset(qv,C0,s*c*SZD); qv-=r*c;
+  GA(z,FL, s*c,wr,AS(w)); zv=DAV(z);
+  switch(KMCASE(at,wt)){
+   case KMCASE(B01,B01): KMACC(B, B); break;
+   case KMCASE(B01,INT): KMACC(B, I); break;
+   case KMCASE(B01,FL ): KMACC(B, D); break;
+   case KMCASE(LIT,B01): KMACC(UC,B); break;
+   case KMCASE(LIT,INT): KMACC(UC,I); break;
+   case KMCASE(LIT,FL ): KMACC(UC,D); break;
+   case KMCASE(C2T,B01): KMACC(US,B); break;
+   case KMCASE(C2T,INT): KMACC(US,I); break;
+   case KMCASE(C2T,FL ): KMACC(US,D); break;
+   case KMCASE(INT,B01): KMACC(I ,B); break;
+   case KMCASE(INT,INT): KMACC(I ,I); break;
+   case KMCASE(INT,FL ): KMACC(I ,D);
+  }
+  switch(at){
+   case B01: KMSET(B ); break;
+   case LIT: KMSET(UC); break;
+   case C2T: KMSET(US); break;
+   case INT: KMSET(I );
+  }
+  *AS(z)=m; AN(z)=m*c;
+ }else{
+  RZ(x=indexof(a,a)); xv=AV(x); m=0; u=xv; DO(n, *u=i==*u?m++:xv[*u]; ++u;);
+  GA(p,INT,m,  1, 0    );           pv= AV(p); memset(pv,C0,m*  SZI);
+  GA(z,FL, m*c,wr,AS(w)); *AS(z)=m; zv=DAV(z); memset(zv,C0,m*c*SZD);
+  switch(wt){
+   case B01: KMFUN(B); break;
+   case INT: KMFUN(I); break;
+   case FL:  KMFUN(D);
+  }
+  if(1==c)DO(m, *zv++/=*pv++;) else DO(m, d=(D)*pv++; DO(c, *zv++/=d;););
+ }
+ if(wt&FL)NAN1;
+ EPILOG(z);
+}    /* x (+/%#)/.y */
+
+
+#define GRPCD(T)            {T*v=(T*)wv; DO(n, j=*v++; if(0<=dv[j])++cv[j]; else{dv[j]=i; cv[j]=1; ++zn;});}
+#define GRPIX(T,asgn,j,k)   {T*v=(T*)wv; DO(n, j=asgn; if(m>=j)*cu[k]++=i; \
+                                 else{GA(x,INT,cv[k],1,0); *zv++=x; u=AV(x); *u++=m=j; cu[k]=u;})}
+
+F1(jtgroup){PROLOG;A c,d,x,z,*zv;B b;I**cu,*cv,*dv,j,k,m,n,p,q,t,*u,*v,*wv,zn=0;
+ RZ(w);
+ if(SPARSE&AT(w))RZ(w=denseit(w));
+ n=IC(w); t=AT(w); p=q=0; b=0; k=n?aii(w)*bp(t):0;
+ if(!AN(w)){GA(z,BOX,n?1:0,1,0); if(n)RZ(*AAV(z)=IX(n)); R z;}
+ if(2>=k)q=t&B01?(1==k?2:258):t&LIT?(1==k?256:65536):t&C2T?65536:0;
+ if(k==SZI&&t&INT+SBT)irange(n,AV(w),&p,&q);
+ if(b=q&&(2>=k||q<=2*n)){
+  GA(c,INT,q,1,0); cv=AV(c)-p;  /* counts  */
+  GA(d,INT,q,1,0); dv=AV(d)-p;  /* indices */
+  wv=AV(w); v=dv+p; DO(q, *v++=-1;);
+  switch(k){
+   case 1:   GRPCD(UC); break;
+   case 2:   GRPCD(US); break;
+   case SZI: GRPCD(I);
+ }}else{
+  RZ(w=indexof(w,w)); wv=AV(w);
+  GA(c,INT,n,1,0); cv=AV(c);
+  m=-1; v=wv; DO(n, j=*v++; if(m>=j)++cv[j]; else{m=j; cv[j]=1; ++zn;});
+ }
+ GA(z,BOX,zn,1,0); zv=AAV(z);
+ m=-1; cu=(I**)cv;
+ switch(b*k){
+  case 1:   GRPIX(UC,dv[k=*v++],j,k); break;
+  case 2:   GRPIX(US,dv[k=*v++],j,k); break;
+  case SZI: GRPIX(I ,dv[k=*v++],j,k); break;
+  default:  GRPIX(I ,     *v++ ,j,j);
+ }
+ EPILOG(z);
+}    /* (</. i.@#) w */
+
+
+static DF2(jtkeytally);
+
+static F1(jtkeytallysp){PROLOG;A b,e,q,x,y,z;I c,d,j,k,*u,*v;P*p;
+ RZ(w);
+ RZ(q=indexof(w,w));
+ p=PAV(q); 
+ x=SPA(p,x); u=AV(x); c=AN(x);
+ y=SPA(p,i); v=AV(y);
+ e=SPA(p,e); k=i0(e); 
+ j=0; DO(c, if(k<=u[i])break; if(u[i]==v[i])++j;);
+ RZ(b=ne(e,x));
+ RZ(x=repeat(b,x)); RZ(x=keytally(x,x,mark)); u=AV(x); d=AN(x);
+ GA(z,INT,1+d,1,0); v=AV(z);
+ DO(j, *v++=*u++;); *v++=IC(w)-bsum(c,BAV(b)); DO(d-j, *v++=*u++;);
+ EPILOG(z);
+}    /* x #/.y , sparse x */
+
+#define KEYTALLY(T)     {T*u;                             \
+                         u=(T*)av; DO(n, ++*(qv+*u++););  \
+                         u=(T*)av; DO(n, v=qv+*u++; if(*v){*zv++=*v; *v=0; if(s==++j)break;});}
+
+static DF2(jtkeytally){PROLOG;A q;I at,*av,j=0,k,n,r=0,s=0,*qv,*u,*v;
+ RZ(a&&w);
+ n=IC(a); at=AT(a); av=AV(a);
+ ASSERT(n==IC(w),EVLENGTH);
+ if(!AN(a))R vec(INT,n?1:0,&n);
+ if(at&SPARSE)R keytallysp(a);
+ at=keyrs(a,&r,&s);
+ if(n&&at&B01&&1>=AR(a)){B*b=(B*)av; k=bsum(n,b); R !k||n==k?vci(k?k:n):v2(*b?k:n-k,*b?n-k:k);}
+ if(s&&s<=MAX(2*n,65536)){A z;I*zv;
+  GA(z,INT,s,1,0); zv=AV(z);
+  GA(q,INT,s,1,0); qv=AV(q)-r;
+  u=qv+r; DO(s, *u++=0;);
+  switch(at){
+   case LIT: KEYTALLY(UC); break;
+   case C2T: KEYTALLY(US); break;
+   case INT: KEYTALLY(I );
+  }
+  AN(z)=*AS(z)=j;
+  EPILOG(z);
+ }
+ RZ(q=indexof(a,a));
+ if(!AR(q))R iv1; 
+ v=qv=AV(q);
+ u=qv; DO(n, ++*(qv+*u++););
+ u=qv; DO(n, k=*u++; if(i<k){j+=*v++=k-i; if(n==j)break;});
+ *AS(q)=AN(q)=v-qv;
+ EPILOG(q);
+}    /* x #/.y main control & dense x */
+
+
+#define KEYHEADTALLY(Tz,Ta,Tw,exp0,exp1)  \
+ {Ta*u;Tw*wv=(Tw*)AV(w);Tz*zz=(Tz*)zv;    \
+  u=(Ta*)av; DO(n, ++*(qv+*u++););        \
+  u=(Ta*)av; DO(n, v=qv+*u++; if(*v){*zz++=exp0; *zz++=exp1; k+=*v; if(n==k)break; *v=0;}); \
+  AN(z)=zz-(Tz*)zv;                       \
+ }
+
+static DF2(jtkeyheadtally){PROLOG;A f,q,x,y,z;B b;I at,*av,k,n,r=0,s=0,*qv,*u,*v,wt,*zv;
+ RZ(a&&w);
+ n=IC(a); wt=AT(w);
+ ASSERT(n==IC(w),EVLENGTH);
+ ASSERT(!n||wt&NUMERIC,EVDOMAIN);
+ if(SPARSE&AT(a)||1<AR(w)||!n||!AN(a))R key(a,w,self);
+ at=keyrs(a,&r,&s); av=AV(a); 
+ f=VAV(self)->f; f=VAV(f)->f; b=CHEAD==ID(f);
+ if(at&B01&&1>=AR(a)){B*c,*d,*p=(B*)av;I i,j,m;
+  c=d=p;
+  if(*p){i=0; d=(B*)memchr(p,C0,n); j=d?d-p:0;}
+  else  {j=0; c=(B*)memchr(p,C1,n); i=c?c-p:0;}
+  k=bsum(n,p); m=c&&d?2:1;
+  GA(x,INT,m,1,0); v=AV(x); *v++=MIN(i,j);      if(c&&d)*v=MAX(i,j); 
+  GA(y,INT,m,1,0); v=AV(y); *v++=i<j||!d?k:n-k; if(c&&d)*v=i<j?n-k:k;
+  R stitch(b?from(x,w):y,b?y:from(x,w));
+ }
+ if(at&LIT+C2T+INT&&wt&B01+INT+FL&&s&&s<=MAX(2*n,65536)){
+  GA(z,wt&FL?FL:INT,2*s,2,0); zv=AV(z);
+  GA(q,INT,s,1,0); qv=AV(q)-r;
+  u=qv+r; DO(s, *u++=0;); k=0;
+  switch(9*b+(at&INT?6:at&C2T?3:0)+(wt&FL?2:wt&INT?1:0)){
+   case  0: KEYHEADTALLY(I,UC,B,*v,   wv[i]); break;
+   case  1: KEYHEADTALLY(I,UC,I,*v,   wv[i]); break;
+   case  2: KEYHEADTALLY(D,UC,D,(D)*v,wv[i]); break;
+   case  3: KEYHEADTALLY(I,US,B,*v,   wv[i]); break;
+   case  4: KEYHEADTALLY(I,US,I,*v,   wv[i]); break;
+   case  5: KEYHEADTALLY(D,US,D,(D)*v,wv[i]); break;
+   case  6: KEYHEADTALLY(I,I ,B,*v,   wv[i]); break;
+   case  7: KEYHEADTALLY(I,I ,I,*v,   wv[i]); break;
+   case  8: KEYHEADTALLY(D,I ,D,(D)*v,wv[i]); break;
+   case  9: KEYHEADTALLY(I,UC,B,wv[i],*v   ); break;
+   case 10: KEYHEADTALLY(I,UC,I,wv[i],*v   ); break;
+   case 11: KEYHEADTALLY(D,UC,D,wv[i],(D)*v); break;
+   case 12: KEYHEADTALLY(I,US,B,wv[i],*v   ); break;
+   case 13: KEYHEADTALLY(I,US,I,wv[i],*v   ); break;
+   case 14: KEYHEADTALLY(D,US,D,wv[i],(D)*v); break;
+   case 15: KEYHEADTALLY(I,I ,B,wv[i],*v   ); break;
+   case 16: KEYHEADTALLY(I,I ,I,wv[i],*v   ); break;
+   case 17: KEYHEADTALLY(D,I ,D,wv[i],(D)*v); break;
+  }
+  *AS(z)=AN(z)/2; *(1+AS(z))=2;
+ }else{
+  RZ(q=indexof(a,a));
+  x=repeat(eq(q,IX(n)),w); y=keytally(q,q,0L); z=stitch(b?x:y,b?y:x);
+ }
+ EPILOG(z);
+}    /* x ({.,#)/.y or x (#,{.)/.y */
+
+
+F1(jtsldot){A h=0;AF f1=jtoblique,f2=jtkey;C c,d,e;I flag=0;V*v;
+ RZ(w);
+ if(NOUN&AT(w)){flag=VGERL; RZ(h=fxeachv(1L,w));}
+ else{
+  v=VAV(w);
+  switch(ID(w)){
+   case CPOUND: f2=jtkeytally; break;
+   case CSLASH: f2=jtkeyslash; if(vaid(v->f))f1=jtobqfslash; break;
+   case CBOX:   f2=jtkeybox;   break;
+   case CFORK:  if(v->f1==(AF)jtmean){f2=jtkeymean; break;}
+                c=ID(v->f); d=ID(v->g); e=ID(v->h); 
+                if(d==CCOMMA&&(c==CHEAD&&e==CPOUND||c==CPOUND&&e==CHEAD))f2=jtkeyheadtally;
+ }}
+ R fdef(CSLDOT,VERB, f1,f2, w,0L,h, flag, RMAX,RMAX,RMAX);
+}