X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=hachu.c;h=11e5710c70f5b9dac7134aef71dcafe6d0c9f9b8;hb=f72cb2001c9dfc2e44c9c453b61c96835836fcb5;hp=e660aa9e4361e3249a17bce7d4f721f8a0023c82;hpb=6ac33b8f72e0a0bfa6ed2c8f4965171a198adb20;p=hachu.git

diff --git a/hachu.c b/hachu.c
index e660aa9..11e5710 100644
--- a/hachu.c
+++ b/hachu.c
@@ -10,9 +10,9 @@
 // promotions by pieces with Lion power stepping in & out the zone in same turn
 // promotion on capture
 
-#define VERSION "0.16 k+ky"
+#define VERSION "0.20"
 
-//define PATH level==0 /*|| path[0] == 0x3490a &&  (level==1 || path[1] == 0x285b3 && (level == 2 || path[2] == 0x8710f && (level == 3 /*|| path[3] == 0x3e865 && (level == 4 || path[4] == 0x4b865 && (level == 5)))))*/
+//define PATH level==0 || path[0] == 0x590cb &&  (level==1 || path[1] == 0x4c0c9 && (level == 2 || path[2] == 0x8598ca && (level == 3 /*|| path[3] == 0x3e865 && (level == 4 || path[4] == 0x4b865 && (level == 5))*/)))
 #define PATH 0
 
 #define HASH
@@ -21,11 +21,12 @@
 #define CHECKEXT
 #define LMR 4
 #define LIONTRAP
-#define WINGS
+#define XWINGS
 #define KINGSAFETY
 #define KSHIELD
-#define XFORTRESS
+#define FORTRESS
 #define PAWNBLOCK
+#define TANDEM 100 /* bonus for pairs of attacking light steppers */
 #define KYLIN 100 /* extra end-game value of Kylin for promotability */
 #define PROMO 0 /* extra bonus for 'vertical' piece when it actually promotes (diagonal pieces get half) */
 
@@ -71,7 +72,7 @@
 #define BSIZE BWMAX*BHMAX
 #define ZONE  zone
 
-#define ONE (currentVariant == V_SHO || currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK || currentVariant == V_LION)
+#define ONE 1 /* currently no variants with 10-deep board */
 
 #define BLACK      0
 #define WHITE      1
@@ -88,6 +89,7 @@
 #define PROMOTE (1<<2*SQLEN+1)     /* promotion bit in move   */
 #define SPECIAL  1400              /* start of special moves  */
 #define BURN    (SPECIAL + 96)     /* start of burn encodings */
+#define CASTLE  (SPECIAL + 100)    /* castling encodings      */
 #define STEP(X,Y) (BW*(X)+ (Y))
 #define SORTKEY(X) 0
 
@@ -102,12 +104,31 @@
 #define P_WHITE     0x0F
 #define P_BLACK     0xF0
 
+// Piece-Square Tables
+#define PST_NEUTRAL 0
+#define PST_STEPPER BH
+#define PST_WJUMPER (BW*BH)
+#define PST_SLIDER  (BW*BH+BH)
+#define PST_TRAP    (2*BW*BH)
+#define PST_CENTER  (2*BW*BH+BH)
+#define PST_WPPROM  (3*BW*BH)
+#define PST_BPPROM  (3*BW*BH+BH)
+#define PST_BJUMPER (4*BW*BH)
+#define PST_ZONDIST (4*BW*BH+BH)
+#define PST_ADVANCE (5*BW*BH)
+#define PST_RETRACT (5*BW*BH+BH)
+#define PST_WFLYER  (6*BW*BH)
+#define PST_BFLYER  (6*BW*BH+BH)
+#define PST_LANCE   (7*BW*BH)
+#define PST_END     (8*BW*BH)
+
 typedef unsigned int Move;
 
 char *MoveToText(Move move, int m);     // from WB driver
 void pmap(int *m, int col);
 void pboard(int *b);
 void pbytes(unsigned char *b);
+int myRandom();
 
 typedef struct {
   int lock[5];
@@ -134,19 +155,20 @@ typedef struct {
 } PieceDesc;
 
 typedef struct {
-  int from, to, piece, victim, new, booty, epSquare, epVictim[8], ep2Square, revMoveCount;
+  int from, to, piece, victim, new, booty, epSquare, epVictim[9], ep2Square, revMoveCount;
   int savKeyL, savKeyH, gain, loss, filling, saveDelta;
   char fireMask;
 } UndoInfo;
 
 char *array, fenArray[4000], startPos[4000], *reason, checkStack[300];
-int bWidth, bHeight, bsize, zone, currentVariant, chuFlag, tenFlag, chessFlag, repDraws, tsume, pvCuts, allowRep, entryProm;
+int bWidth, bHeight, bsize, zone, currentVariant, chuFlag, tenFlag, chessFlag, repDraws, stalemate;
+int tsume, pvCuts, allowRep, entryProm, okazaki, pVal;
 int stm, xstm, hashKeyH=1, hashKeyL=1, framePtr, msp, nonCapts, rootEval, filling, promoDelta;
 int retMSP, retFirst, retDep, pvPtr, level, cnt50, mobilityScore;
 int ll, lr, ul, ur; // corner squares
 int nodes, startTime, lastRootMove, lastRootIter, tlim1, tlim2, tlim3, repCnt, comp, abortFlag;
 Move ponderMove;
-Move retMove, moveStack[10000], path[100], repStack[300], pv[1000], repeatMove[300], killer[100][2];
+Move retMove, moveStack[20000], path[100], repStack[300], pv[1000], repeatMove[300], killer[100][2];
 
       int maxDepth;                            // used by search
 
@@ -369,23 +391,23 @@ PieceDesc taikyokuPieces[] = {
 };
 
 PieceDesc chessPieces[] = {
-  {"Q", "",  950, { X,X,X,X,X,X,X,X } },
+  {"FK", "", 950, { X,X,X,X,X,X,X,X } },
   {"R", "",  500, { X,0,X,0,X,0,X,0 } },
   {"B", "",  320, { 0,X,0,X,0,X,0,X } },
   {"N", "",  300, { N,N,N,N,N,N,N,N } },
   {"K", "",  280, { 1,1,1,1,1,1,1,1 } },
-  {"P", "Q",  80, { M,C,0,0,0,0,0,C } },
+  {"P", "FK", 80, { M,C,0,0,0,0,0,C } },
   { NULL }  // sentinel
 };
 
 PieceDesc lionPieces[] = {
   {"LN","", LVAL, { L,L,L,L,L,L,L,L } },
-  {"Q", "",  600, { X,X,X,X,X,X,X,X } },
+  {"FK", "", 600, { X,X,X,X,X,X,X,X } },
   {"R", "",  300, { X,0,X,0,X,0,X,0 } },
   {"K", "",  280, { 1,1,1,1,1,1,1,1 } },
   {"B", "",  190, { 0,X,0,X,0,X,0,X } },
   {"N", "",  180, { N,N,N,N,N,N,N,N } },
-  {"P", "Q",  50, { M,C,0,0,0,0,0,C } },
+  {"P", "FK", 50, { M,C,0,0,0,0,0,C } },
   { NULL }  // sentinel
 };
 
@@ -421,10 +443,10 @@ char tenArray[] = "LN:FLICSGK:DEGSCI:FLNL/:RV.:CS:CS.:BT:KN:LN:FK:PH:BT.:CS:CS.:
 		  "....d......d..../pppppppppppppppp/:sm:vmr:hf:se:bg:rg:vg:gg:rg:bg:se:hfr:vm:sm/"
 		  ":ss:vsb:dh:dk:wb:fi:fe:lh:fi:wb:dk:dhb:vs:ss/:rv.:cs:cs.:bt:ph:fk:ln:kn:bt.:cs:cs.:rv/ln:flicsg:dekgsci:flnl";
 char shoArray[] = "LNSGKGSNL/.B..:DE..R./PPPPPPPPP/........./........./........./ppppppppp/.r..:de..b./lnsgkgsnl";
-char chessArray[] = "RNBQKBNR/PPPPPPPP/......../......../......../......../pppppppp/rnbqkbnr";
-char lionArray[]  = "R:LNBQKBNR/PPPPPPPP/......../......../......../......../pppppppp/r:lnbqkbnr";
+char chessArray[] = "RNB:FKKBNR/PPPPPPPP/......../......../......../......../pppppppp/rnb:fkkbnr";
+char lionArray[]  = "R:LNB:FKKBNR/PPPPPPPP/......../......../......../......../pppppppp/r:lnb:fkkbnr";
 char shatArray[]= "RNBK:FKBNR/PPPPPPPP/......../......../......../......../pppppppp/rnbk:fkbnr";
-char thaiArray[]= "RNSK:SMSNR/......../PPPPPPPP/......../......../pppppppp/......../rnsk:smsnr";
+char thaiArray[]= "RNSK:SMSNR/......../PPPPPPPP/......../......../pppppppp/......../rns:smksnr";
 
 typedef struct {
   int boardWidth, boardFiles, boardRanks, zoneDepth, varNr; // board sizes
@@ -434,11 +456,13 @@ typedef struct {
 
 typedef enum { V_CHESS, V_SHO, V_CHU, V_DAI, V_DADA, V_MAKA, V_TAI, V_KYOKU, V_TENJIKU, V_SHATRANJ, V_MAKRUK, V_LION } Variant;
 
+#define SAME (-1)
+
 VariantDesc variants[] = {
-  { 16,  8,  8, 1, V_CHESS,  "normal", chessArray }, // FIDE
+  { 24, 12, 12, 4, V_CHU,     "chu",     chuArray }, // Chu
+  { 16,  8,  8, 1, V_CHESS,  "nocastle", chessArray }, // FIDE
   { 18,  9,  9, 3, V_SHO, "9x9+0_shogi", shoArray }, // Sho
   { 18,  9,  9, 3, V_SHO,     "sho",     shoArray }, // Sho duplicat
-  { 24, 12, 12, 4, V_CHU,     "chu",     chuArray }, // Chu
   { 30, 15, 15, 5, V_DAI,     "dai",     daiArray }, // Dai
   { 32, 16, 16, 5, V_TENJIKU, "tenjiku", tenArray }, // Tenjiku
   { 16,  8,  8, 1, V_SHATRANJ,"shatranj",shatArray}, // Shatranj
@@ -476,7 +500,7 @@ Vector direction[] = { // clockwise!
   { 2,-1}
 };
 
-int epList[96], ep2List[96], toList[96], reverse[96];  // decoding tables for double and triple moves
+int epList[104], ep2List[104], toList[104], reverse[104];  // decoding tables for double and triple moves
 int kingStep[10], knightStep[10];         // raw tables for step vectors (indexed as -1 .. 8)
 int neighbors[9];   // similar to kingStep, but starts with null-step
 char fireFlags[10]; // flags for Fire-Demon presence (last two are dummies, which stay 0, for compactify)
@@ -598,8 +622,8 @@ int rawBoard[BSIZE + 11*BHMAX + 6];
 int attackMaps[200*BSIZE], *attacks = attackMaps;
 char distance[2*BSIZE]; // distance table
 char promoBoard[BSIZE]; // flags to indicate promotion zones
-char rawFire[BSIZE+2*BWMAX]; // flags to indicate squares controlled by Fire Demons
-signed char PST[5*BSIZE];
+unsigned char rawFire[BSIZE+2*BWMAX]; // flags to indicate squares controlled by Fire Demons
+signed char PST[7*BSIZE];
 
 #define board     (rawBoard + 6*BHMAX + 3)
 #define fireBoard (rawFire + BWMAX + 1)
@@ -685,7 +709,6 @@ Lance (signed char *r)
 int
 EasyProm (signed char *r)
 {
-  int i;
   if(r[0] == X) return 30 + PROMO*((unsigned int)(r[1] | r[2] | r[3] | r[5] | r[6] | r[7]) <= 1);
   if(r[1] == X || r[7] == X) return 30 + PROMO/2;
   return 0;
@@ -715,7 +738,7 @@ Range (signed char *r)
   int i, m=0;
   for(i=0; i<8; i++) {
     int d = r[i];
-    if(r[i] < 0) d == r[i] >= L ? 2 : 36;
+    if(r[i] < 0) d = r[i] >= L ? 2 : 36;
     if(d > m) m = d;
   }
   return m;
@@ -740,7 +763,7 @@ StackMultis (int col)
 void
 Compactify (int stm)
 { // remove pieces that are permanently gone (captured or promoted) from one side's piece list
-  int i, j, k;
+  int i, k;
   for(i=stm+2; i<=last[stm]; i+=2) { // first pass: unpromoted pieces
     if((k = p[i].promo) >= 0 && p[i].pos == ABSENT) { // unpromoted piece no longer there
       p[k].promo = -2; // orphan promoted version
@@ -768,9 +791,9 @@ AddPiece (int stm, PieceDesc *list)
   p[i].value = v = list->value;
   for(j=0; j<8; j++) p[i].range[j] = list->range[j^4*(WHITE-stm)];
   switch(Range(p[i].range)) {
-    case 1:  p[i].pst = BH; break;
-    case 2:  p[i].pst = bsize; break;
-    default: p[i].pst = bsize + BH; break;
+    case 1:  p[i].pst = PST_STEPPER; break;
+    case 2:  p[i].pst = PST_WJUMPER; break;
+    default: p[i].pst = PST_SLIDER;  break;
   }
   key = (stm == WHITE ? &list->whiteKey : &list->blackKey);
   if(!*key) *key = ~(myRandom()*myRandom());
@@ -780,7 +803,7 @@ AddPiece (int stm, PieceDesc *list)
   p[i].bulk = list->bulk;
   p[i].mobWeight = v > 600 ? 0 : v >= 400 ? 1 : v >= 300 ? 2 : v > 150 ? 3 : v >= 100 ? 2 : 0;
   if(Lance(list->range))
-    p[i].mobWeight = 5 + 3*(list->range[4]==X), p[i].pst = 0; // clear path but don't move forward
+    p[i].mobWeight = 0, p[i].pst = list->range[4] ? PST_NEUTRAL : PST_LANCE; // keep back
   for(j=stm+2; j<= last[stm]; j+=2) {
     if(p[j].promo >= i) p[j].promo += 2;
   }
@@ -792,12 +815,13 @@ AddPiece (int stm, PieceDesc *list)
 }
 
 void
-SetUp(char *array, int var)
+SetUp (char *array, int var)
 {
-  int i, j, n, m, nr, color;
-  char c, *q, name[3], prince = 0;
+  int i, j, n, m, color;
+  char c, name[3], prince = 0;
   PieceDesc *p1, *p2;
   last[WHITE] = 1; last[BLACK] = 0;
+  royal[WHITE] = royal[BLACK] = 0;
   for(i=0; ; i++) {
 //printf("next rank: %s\n", array);
     for(j = BW*i; ; j++) {
@@ -814,7 +838,7 @@ SetUp(char *array, int var)
 	name[0] += 'A' - 'a';
 	if(name[1]) name[1] += 'A' - 'a';
       } else color = WHITE;
-      if(!strcmp(name, "CP")) prince |= color+1; // remember if we added Crown Prince
+      if(!strcmp(name, "CP") || pflag && !strcmp(name, "DE")) prince |= color+1; // remember if we added Crown Prince
       p1 = LookUp(name, var);
       if(!p1) printf("tellusererror Unknown piece '%s' in setup\n", name), exit(-1);
       if(pflag && p1->promoted) p1 = LookUp(p1->promoted, var); // use promoted piece instead
@@ -838,6 +862,9 @@ SetUp(char *array, int var)
     }
   }
  eos:
+  // add dummy Kings if not yet added (needed to set royal[] to valid value!)
+  if(!royal[WHITE]) p[AddPiece(WHITE, LookUp("K", V_CHU))].pos = ABSENT;
+  if(!royal[BLACK]) p[AddPiece(BLACK, LookUp("K", V_CHU))].pos = ABSENT;
   // add dummy Crown Princes if not yet added
   if(!(prince & WHITE+1)) p[AddPiece(WHITE, LookUp("CP", V_CHU))].pos = ABSENT;
   if(!(prince & BLACK+1)) p[AddPiece(BLACK, LookUp("CP", V_CHU))].pos = ABSENT;
@@ -851,11 +878,14 @@ SetUp(char *array, int var)
   for(i=0; i<BH; i++) for(j=0; j<BH; j++) board[BW*i+j] = EMPTY;
   for(i=WHITE+2; i<=last[WHITE]; i+=2) if(p[i].pos != ABSENT) {
     int g = p[i].promoGain;
+    if(i == kylin[WHITE]) p[i].promoGain = 1.25*KYLIN, p[i].value += KYLIN;
+//    if(j > 0 && p[i].pst == PST_STEPPER) p[i].pst = PST_WPPROM; // use white pre-prom bonus
+    if(j > 0 && p[i].pst == PST_STEPPER && p[i].value >= 100)
+	p[i].pst = p[i].value <= 150 ? PST_ADVANCE : PST_WPPROM;  // light steppers advance
+    if(j > 0 && p[i].bulk == 6) p[i].pst = PST_WFLYER, p[i].mobWeight = 4; // SM defends zone
     if((j = p[i].promo) > 0 && g)
-      p[i].promoGain = (p[j].value - p[i].value - g)*1.25, p[i].value = p[j].value - g;
+      p[i].promoGain = (p[j].value - p[i].value - g)*0.9, p[i].value = p[j].value - g;
     else p[i].promoGain = 0;
-    if(i == kylin[WHITE]) p[i].promoGain = 1.25*KYLIN, p[i].value += KYLIN;
-    if(j > 0 && p[i].pst == BH) p[i].pst = 3*BW*BH;      // use white pre-prom bonus
     board[p[i].pos] = i;
     rootEval += p[i].value + PST[p[i].pst + p[i].pos];
     promoDelta += p[i].promoGain;
@@ -863,12 +893,15 @@ SetUp(char *array, int var)
   } else p[i].promoGain = 0;
   for(i=BLACK+2; i<=last[BLACK]; i+=2) if(p[i].pos != ABSENT) {
     int g = p[i].promoGain;
+//    if(j > 0 && p[i].pst == PST_STEPPER) p[i].pst = PST_BPPROM; // use black pre-prom bonus
+    if(j > 0 && p[i].pst == PST_STEPPER && p[i].value >= 100)
+	p[i].pst = p[i].value <= 150 ? PST_RETRACT : PST_BPPROM;  // light steppers advance
+    if(j > 0 && p[i].pst == PST_WJUMPER) p[i].pst = PST_BJUMPER;  // use black pre-prom bonus
+    if(j > 0 && p[i].bulk == 6) p[i].pst = PST_BFLYER, p[i].mobWeight = 4; // SM defends zone
     if((j = p[i].promo) > 0 && g)
-      p[i].promoGain = (p[j].value - p[i].value - g)*1.25, p[i].value = p[j].value - g;
+      p[i].promoGain = (p[j].value - p[i].value - g)*0.9, p[i].value = p[j].value - g;
     else p[i].promoGain = 0;
     if(i == kylin[BLACK]) p[i].promoGain = 1.25*KYLIN, p[i].value += KYLIN;
-    if(j > 0 && p[i].pst == BH) p[i].pst = 3*BW*BH + BH; // use black pre-prom bonus
-    if(j > 0 && p[i].pst == bsize) p[i].pst = 4*BW*BH;      // use white pre-prom bonus
     board[p[i].pos] = i;
     rootEval -= p[i].value + PST[p[i].pst + p[i].pos];
     promoDelta -= p[i].promoGain;
@@ -888,18 +921,23 @@ void
 Init (int var)
 {
   int i, j, k;
+  PieceDesc *pawn;
 
+  if(var != SAME) { // the following should be already set if we stay in same variant (for TakeBack)
   currentVariant = variants[var].varNr;
   bWidth  = variants[var].boardWidth;
   bHeight = variants[var].boardRanks;
   zone    = variants[var].zoneDepth;
   array   = variants[var].array;
+  }
   bsize = bWidth*bHeight;
   chuFlag = (currentVariant == V_CHU || currentVariant == V_LION);
   tenFlag = (currentVariant == V_TENJIKU);
   chessFlag = (currentVariant == V_CHESS || currentVariant == V_LION);
-  repDraws  = (currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK || currentVariant == V_LION);
+  stalemate = (currentVariant == V_CHESS || currentVariant == V_MAKRUK || currentVariant == V_LION);
+  repDraws  = (stalemate || currentVariant == V_SHATRANJ);
   ll = 0; lr = bHeight - 1; ul = (bHeight - 1)*bWidth; ur = ul + bHeight - 1;
+  pawn = LookUp("P", currentVariant); pVal = pawn ? pawn->value : 0; // get Pawn value
 
   for(i= -1; i<9; i++) { // board steps in linear coordinates
     kStep[i] = STEP(direction[i&7].x,   direction[i&7].y);       // King
@@ -922,6 +960,11 @@ Init (int var)
     toList[88+i] =   kStep[i]; epList[88+i] = 2*kStep[i];
   }
 
+  toList[100]   = BH - 2; epList[100]   = BH - 1; ep2List[100]   = BH - 3;
+  toList[100+1] =      2; epList[100+1] =      0; ep2List[100+1] =      3;
+  toList[100+2] = bsize - BH - 2; epList[100+2] = bsize - BH - 1; ep2List[100+2] = bsize - BH - 3;
+  toList[100+3] = bsize - BW + 2; epList[100+3] = bsize - BW;     ep2List[100+3] = bsize - BW + 3;
+
   // fill distance table
   for(i=0; i<2*BSIZE; i++) {
     distance[i] = 0;
@@ -954,22 +997,31 @@ Init (int var)
   for(j=0; j<BH; j++) {
    for(i=0; i<BH; i++) {
     int s = BW*i + j, d = BH*(BH-2) - abs(2*i - BH + 1)*(BH-1) - (2*j - BH + 1)*(2*j - BH + 1);
-    PST[s] = 2*(i==0 | i==BH-1) + (i==1 | i==BH-2);      // last-rank markers in null table
-    PST[BH+s] = d/4 - (i < 2 || i > BH-3 ? 3 : 0) - (j == 0 || j == BH-1 ? 5 : 0)
-                    + 3*(i==zone || i==BH-zone-1);       // stepper centralization
-    PST[BH*BW+s] = d/6;                                  // double-stepper centralization
-    PST[BH*BW+BH+s] = d/12 - 5*(i==BH/2 || i==(BH-1)/2); // slider centralization
-    PST[2*BH*BW+s] = j < 3 || j > BH-4 ? (i < 3 ? 7 : i == 3 ? 4 : i == 4 ? 2 : 0) : 0;
-    PST[2*BH*BW+BH+s] = ((BH-1)*(BH-1) - (2*i - BH + 1)*(2*i - BH + 1) - (2*j - BH + 1)*(2*j - BH + 1))/6;
-    PST[3*BH*BW+s] = PST[3*BH*BW+BH+s] = PST[BH+s];      // as stepper, but with pre-promotion bonus W/B
-    PST[4*BH*BW+s] = PST[BW*BH+s];                       // as jumper, but with pre-promotion bonus B
-    PST[4*BH*BW+BH+s] = BW*(zone - 1 - i);               // board step to enter promo zone black
+    PST[s] = 2*(i==0 | i==BH-1) + (i==1 | i==BH-2);         // last-rank markers in null table
+    PST[PST_STEPPER+s] = d/4 - (i < 2 || i > BH-3 ? 3 : 0) - (j == 0 || j == BH-1 ? 5 : 0)
+                    + 3*(i==zone || i==BH-zone-1);          // stepper centralization
+    PST[PST_WJUMPER+s] = d/6;                               // double-stepper centralization
+    PST[PST_SLIDER +s] = d/12 - 15*(i==BH/2 || i==(BH-1)/2);// slider centralization
+    PST[PST_TRAP  +s] = j < 3 || j > BH-4 ? (i < 3 ? 7 : i == 3 ? 4 : i == 4 ? 2 : 0) : 0;
+    PST[PST_CENTER+s] = ((BH-1)*(BH-1) - (2*i - BH + 1)*(2*i - BH + 1) - (2*j - BH + 1)*(2*j - BH + 1))/6;
+    PST[PST_WPPROM+s] = PST[PST_BPPROM+s] = PST[PST_STEPPER+s]; // as stepper, but with pre-promotion bonus W/B
+    PST[PST_BJUMPER+s] = PST[PST_WJUMPER+s];                // as jumper, but with pre-promotion bonus B
+    PST[PST_ZONDIST+s] = BW*(zone - 1 - i);                 // board step to enter promo zone black
+    PST[PST_ADVANCE+s] = PST[PST_WFLYER-s-1] = 2*(5*i+i*i) - (i >= zone)*6*(i-zone+1)*(i-zone+1)
+	- (2*j - BH + 1)*(2*j - BH + 1)/BH + BH/2
+	- 50 - 35*(j==0 || j == BH-1) - 15*(j == 1 || BH-2); // advance-encouraging table
+    PST[PST_WFLYER +s] = PST[PST_LANCE-s-1] = (i == zone-1)*40 + (i == zone-2)*20 - 20;
+    PST[PST_LANCE  +s] = (PST[PST_STEPPER+j] - PST[PST_STEPPER+s])/2; 
    }
-   if(zone > 0) PST[3*BW*BH+BW*(BH-1-zone) + j] += 10, PST[3*BW*BH+BH + BW*zone + j] += 10;
+   if(zone > 0) PST[PST_WPPROM+BW*(BH-1-zone) + j] += 10, PST[PST_BPPROM + BW*zone + j] += 10;
+   if(j > (BH-1)/2 - 3 && j < BH/2 + 3)
+	PST[PST_WPPROM + j] += 4, PST[PST_BPPROM + BW*(BH-1) + j] += 4; // fortress
+   if(j > (BH-1)/2 - 2 && j < BH/2 + 2)
+	PST[PST_WPPROM + BW + j] += 2, PST[PST_BPPROM + BW*(BH-2) + j] += 2; // fortress
 #if KYLIN
    // pre-promotion bonuses for jumpers
-   if(zone > 0) PST[BW*BH + BW*(BH-2-zone) + j] = PST[4*BW*BH + BW*(zone+1) + j] = 100,
-                PST[BW*BH + BW*(BH-1-zone) + j] = PST[4*BW*BH + BW*zone + j] = 200;
+   if(zone > 0) PST[PST_WJUMPER + BW*(BH-2-zone) + j] = PST[PST_BJUMPER + BW*(zone+1) + j] = 100,
+                PST[PST_WJUMPER + BW*(BH-1-zone) + j] = PST[PST_BJUMPER + BW*zone + j] = 200;
 #endif
   }
 
@@ -1011,8 +1063,8 @@ NewNonCapture (int x, int y, int promoFlags)
 {
   if(board[y] != EMPTY) return 1; // edge, capture or own piece
 //if(flag) printf("# add %c%d%c%d, pf=%d\n", x%BW+'a',x/BW,y%BW+'a',y/BW, promoFlags);
-  if( (promoBoard[x] | promoBoard[y]) & promoFlags &&
-      (!entryProm || promoBoard[y] & ~promoBoard[x] & CAN_PROMOTE )){ // piece can promote with this move
+  if( (entryProm ? promoBoard[y] & ~promoBoard[x] & CAN_PROMOTE
+                 : promoBoard[y] |  promoBoard[x]       ) & promoFlags ){ // piece can promote with this move
     moveStack[msp++] = moveStack[nonCapts];           // create space for promotion
     moveStack[nonCapts++] = x<<SQLEN | y | PROMOTE;   // push promotion
     if((promoFlags & promoBoard[y] & (CANT_DEFER | DONT_DEFER | LAST_RANK)) == 0) { // deferral could be a better alternative
@@ -1048,7 +1100,7 @@ char mapStep[] = { 7, 8, 1, -6, -7, -8, -1, 6 };
 char rowMask[] = { 0100, 0140, 0160, 070, 034, 016, 07, 03, 01 };
 char rows[9];
 
-int
+void
 AreaStep (int from, int x, int flags, int n, int d)
 {
   int i;
@@ -1062,7 +1114,7 @@ AreaStep (int from, int x, int flags, int n, int d)
   }
 }
 
-int
+void
 AreaMoves (int from, int piece, int range)
 {
   int i;
@@ -1089,6 +1141,17 @@ MarkBurns (int x)
   for(r=b; r<=t-2; r++) rows[r] |= rows[r+1] | rows[r+2]; // smear vertically
 }
 
+void
+GenCastlings ()
+{ // castings for Lion Chess. Assumes board width = 8 and Kings on e-file, and K/R value = 280/300!
+    int f = BH>>1, t = CASTLE;
+    if(stm != WHITE) f += bsize - BW, t += 2;
+    if(p[board[f]].value = 280) {
+      if(p[board[f-4]].value == 300 && board[f-3] == EMPTY && board[f-2] == EMPTY && board[f-1] == EMPTY) moveStack[msp++] = f<<SQLEN | t+1;
+      if(p[board[f+3]].value == 300 && board[f+1] == EMPTY && board[f+2] == EMPTY) moveStack[msp++] = f<<SQLEN | t;
+    }
+}
+
 int
 GenNonCapts (int promoSuppress)
 {
@@ -1115,7 +1178,7 @@ GenNonCapts (int promoSuppress)
 	  }
 	} else
 	if(r == M) { // FIDE Pawn; check double-move
-	  if(!NewNonCapture(x, x+v, pFlag) && chessFlag && promoBoard[x-v])
+	  if(!NewNonCapture(x, x+v, pFlag) && chessFlag && promoBoard[x-v] & LAST_RANK)
 	    NewNonCapture(x, x+2*v, pFlag), moveStack[msp-1] |= DEFER; // use promoSuppress flag as e.p. flag
 	}
 	continue;
@@ -1136,7 +1199,7 @@ report (int x, int y, int i)
 int
 MapOneColor (int start, int last, int *map)
 {
-  int i, j, k, totMob = 0;
+  int i, j, totMob = 0;
   for(i=start+2; i<=last; i+=2) {
     int mob = 0;
     if(p[i].pos == ABSENT) continue;
@@ -1263,6 +1326,21 @@ MakeMove(Move m, UndoInfo *u)
   } else u->new = u->piece;
 
   if(u->to >= SPECIAL) { // two-step Lion move
+   if(u->to >= CASTLE) { // move Rook, faking it was an e.p. victim so that UnMake works automatically
+    u->epSquare  = epList[u->to - SPECIAL];
+    u->ep2Square = ep2List[u->to - SPECIAL];
+    u->epVictim[0] = board[u->epSquare];  // kludgy: fake that King e.p. captured the Rook!
+    u->epVictim[1] = board[u->ep2Square]; // should be EMPTY (but you never know, so save as well).
+    board[u->ep2Square] = u->epVictim[0]; // but put Rook back
+    board[u->epSquare]  = EMPTY;
+    p[u->epVictim[0]].pos = u->ep2Square;
+    p[u->epVictim[1]].pos = ABSENT;
+    u->to       = toList[u->to - SPECIAL];
+    hashKeyL ^= p[u->epVictim[0]].pieceKey * squareKey[u->epSquare];
+    hashKeyH ^= p[u->epVictim[0]].pieceKey * squareKey[u->epSquare+BH];
+    hashKeyL ^= p[u->epVictim[0]].pieceKey * squareKey[u->ep2Square];
+    hashKeyH ^= p[u->epVictim[0]].pieceKey * squareKey[u->ep2Square+BH];
+   } else {
     // take care of first e.p. victim
     u->epSquare = u->from + epList[u->to - SPECIAL]; // decode
     u->epVictim[0] = board[u->epSquare]; // remember for takeback
@@ -1289,6 +1367,7 @@ MakeMove(Move m, UndoInfo *u)
     hashKeyH ^= p[u->epVictim[1]].pieceKey * squareKey[u->ep2Square+BH];
     if(p[u->piece].value != LVAL && p[u->epVictim[0]].value == LVAL) deferred |= PROMOTE; // flag non-Lion x Lion
     cnt50 = 0; // double capture irreversible
+   }
   }
 
   if(u->fireMask & fireBoard[u->to]) { // we moved next to enemy Fire Demon (must be done after SPECIAL, to decode to-sqr)
@@ -1385,13 +1464,13 @@ UnMake(UndoInfo *u)
 }
 	
 void
-GenCapts(int sqr, int victimValue)
+GenCapts (int sqr, int victimValue)
 { // generate all moves that capture the piece on the given square
-  int i, range, att = attacks[2*sqr + stm];
+  int i, att = attacks[2*sqr + stm];
 //printf("GenCapts(%c%d,%d) %08x\n",sqr%BW+'a',sqr/BW,victimValue,att);
   if(!att) return; // no attackers at all!
   for(i=0; i<8; i++) {               // try all rays
-    int x, v, jumper, jcapt=0;
+    int x, v, jcapt=0;
     if(att & attackMask[i]) {        // attacked by move in this direction
       v = -kStep[i]; x = sqr;
       while( board[x+=v] == EMPTY ); // scan towards source until we encounter a 'stop'
@@ -1522,10 +1601,27 @@ Guard (int sqr)
 int
 Fortress (int forward, int king, int lion)
 { // penalty for lack of Lion-proof fortress
-  int rank = PST[king], anchor, r, l, q;
-  if(!rank) return -300;
+  int rank = PST[king], anchor, r, l, q, res = 0;
+  if(rank != 2) return 25*(rank-2);
   anchor = king + forward*(rank-1);
 
+  q = Guard(anchor); l = Guard(anchor-1); r = Guard(anchor+1);
+  if(!q) return l > 1 || r > 1 ? 0 : -25;
+  if(q == 1) res = 40*(l > 1 && r > 1);           // TGT, EGT or TGE get 40
+  else { // T or E in front of King
+    if(l > 1) res = 30 + (r > 1)*(20 + 5*(q==2)); // TT., ET. or TE. (30), TET (50), TTE (55)
+    else if(r > 1) res = 30;                      // .TT, .ET or .TE (30)
+  }
+  q = 0;
+  if(filling > 32) {
+    if(r > 1 && Guard(king+2) == 1) q += 10;
+    if(l > 1 && Guard(king-2) == 1) q += 10; 
+    q += 5*(Guard(king+1) == 1);
+    q += 5*(Guard(king-1) == 1);
+    if(filling < 96) q = q*(filling - 32)>>6;
+  }
+  return res + q;
+
   if(Guard(anchor) == 3 || Guard(anchor+1) == 3 || Guard(anchor-1) == 3) return 0;
   if(rank == 2 && Guard(king+1) == 3 || Guard(king-1) == 3) return -50;
   if(Guard(r=anchor) == 2 || Guard(r=anchor+1) == 2 || Guard(r=anchor-1) == 2)
@@ -1554,7 +1650,7 @@ Fortress (int forward, int king, int lion)
 }
 
 int
-Surround (int stm, int king, int start)
+Surround (int stm, int king, int start, int max)
 {
   int i, s=0;
   for(i=start; i<9; i++) {
@@ -1564,7 +1660,7 @@ Surround (int stm, int king, int start)
     v = p[piece].value;
     s += -(v > 70) & v;
   }
-  return (s > 512 ? 512 : s);
+  return (s > max ? max : s);
 }
 
 int
@@ -1580,7 +1676,9 @@ Ftest (int side)
 int
 Evaluate (int difEval)
 {
-  int wLion = ABSENT, bLion = ABSENT, wKing, bKing, score=mobilityScore, f, i, j;
+  int wLion = ABSENT, bLion = ABSENT, wKing, bKing, score=mobilityScore, f, i, j, max=512;
+
+  if(tsume) return difEval;
 
   if(p[WHITE+2].value == LVAL) wLion = p[WHITE+2].pos;
   if(p[BLACK+2].value == LVAL) bLion = p[BLACK+2].pos;
@@ -1588,7 +1686,7 @@ Evaluate (int difEval)
   if(bLion == ABSENT && p[BLACK+4].value == LVAL) bLion = p[BLACK+4].pos;
 
 #ifdef LIONTRAP
-# define lionTrap (PST + 2*BH*BW)
+# define lionTrap (PST + PST_TRAP)
   // penalty for Lion in enemy corner, when enemy Lion is nearby
   if(wLion != ABSENT && bLion != ABSENT) { // both have a Lion
       static int distFac[36] = { 0, 0, 10, 9, 8, 7, 5, 3, 1 };
@@ -1615,24 +1713,25 @@ Evaluate (int difEval)
 
 #ifdef KINGSAFETY
   // basic centralization in end-game (also facilitates bare-King mating)
-  wKing = p[royal[WHITE]].pos; if(wKing == ABSENT) wKing = p[royal[WHITE]+1].pos;
-  bKing = p[royal[BLACK]].pos; if(bKing == ABSENT) bKing = p[royal[BLACK]+1].pos;
+  wKing = p[royal[WHITE]].pos; if(wKing == ABSENT) wKing = p[royal[WHITE]+2].pos;
+  bKing = p[royal[BLACK]].pos; if(bKing == ABSENT) bKing = p[royal[BLACK]+2].pos;
   if(filling < 32) {
     int lead = (stm == WHITE ? difEval : -difEval);
-    score += (PST[3*BW*BH+wKing] - PST[3*BW*BH+bKing])*(32 - filling) >> 7;
-    if(lead  > 100) score -= PST[3*BW*BH+bKing]*(32 - filling) >> 3; // white leads, drive black K to corner
-    if(lead < -100) score += PST[3*BW*BH+wKing]*(32 - filling) >> 3; // black leads, drive white K to corner
+    score += (PST[PST_CENTER+wKing] - PST[PST_CENTER+bKing])*(32 - filling) >> 7;
+    if(lead  > 100) score -= PST[PST_CENTER+bKing]*(32 - filling) >> 3; // white leads, drive black K to corner
+    if(lead < -100) score += PST[PST_CENTER+wKing]*(32 - filling) >> 3; // black leads, drive white K to corner
+    max = 16*filling;
   }
 
 # ifdef FORTRESS
   f = 0;
   if(bLion != ABSENT) f += Fortress( BW, wKing, bLion);
   if(wLion != ABSENT) f -= Fortress(-BW, bKing, wLion);
-  score += (filling < 96 ? f : f*(224 - filling) >> 7); // build up slowly
+  score += (filling < 192 ? f : f*(224 - filling) >> 5); // build up slowly
 # endif
 
 # ifdef KSHIELD
-  score += Surround(WHITE, wKing, 1) - Surround(BLACK, bKing, 1) >> 3;
+  score += Surround(WHITE, wKing, 1, max) - Surround(BLACK, bKing, 1, max) >> 3;
 # endif
 
 #endif
@@ -1643,18 +1742,18 @@ Evaluate (int difEval)
   if(filling < 128) {
     int sq;
     if((wLion = kylin[WHITE]) && (sq = p[wLion].pos) != ABSENT) {
-      int anchor = sq - PST[5*BW*BH - 1 - sq];
-      score += (512 - Surround(BLACK, anchor, 0))*(128 - filling)*PST[p[wLion].pst + sq] >> 15;
+      int anchor = sq - PST[5*BW*BH - 1 - sq]; // FIXME: PST_ZONDIST indexed backwards
+      score += (512 - Surround(BLACK, anchor, 0, 512))*(128 - filling)*PST[p[wLion].pst + sq] >> 15;
     }
     if((bLion = kylin[BLACK]) && (sq = p[bLion].pos) != ABSENT) {
-      int anchor = sq + PST[4*BW*BH + BH + sq];
-      score -= (512 - Surround(WHITE, anchor, 0))*(128 - filling)*PST[p[bLion].pst + sq] >> 15;
+      int anchor = sq + PST[PST_ZONDIST + sq];
+      score -= (512 - Surround(WHITE, anchor, 0, 512))*(128 - filling)*PST[p[bLion].pst + sq] >> 15;
     }
   }
 #endif
 
 #ifdef PAWNBLOCK
-  // penalty for blocking own P or GB: 20 by slider, 10 by other, but 50 if only retreat mode is straight back
+  // penalty for blocking own P or GB: 20 by slider, 10 by other, but 50 if only RETRACT mode is straight back
   for(i=last[WHITE]; i > 1 && p[i].value<=50; i-=2) {
     if((f = p[i].pos) != ABSENT) { // P present,
       if((j = board[f + BW])&1) // square before it white (odd) piece
@@ -1673,7 +1772,26 @@ Evaluate (int difEval)
   }
 #endif
 
-  return difEval - (filling*filling*promoDelta >> 16) + (stm ? score : -score);
+#ifdef TANDEM
+    if(zone > 0) {
+      int rw = BW*(BH-1-zone), rb = BW*zone, h=0;
+      for(f=0; f<BH; f++) {
+	if(p[board[rw+f]].pst == PST_ADVANCE) {
+	  h += (p[board[rw+f-BW]].pst == PST_ADVANCE);
+	  if(f > 0)    h += (p[board[rw+f-BW-1]].pst == PST_ADVANCE);
+	  if(f+1 < BH) h += (p[board[rw+f-BW+1]].pst == PST_ADVANCE);
+	}
+	if(p[board[rb+f]].pst == PST_ADVANCE) {
+	  h -= (p[board[rb+f+BW]].pst == PST_RETRACT);
+	  if(f > 0)    h -= (p[board[rb+f+BW-1]].pst == PST_RETRACT);
+	  if(f+1 < BH) h -= (p[board[rb+f+BW+1]].pst == PST_RETRACT);
+	}
+      }
+      score += h*TANDEM;
+    }
+#endif
+
+  return difEval - (filling*promoDelta >> 8) + (stm ? score : -score);
 }
 
 inline void
@@ -1691,7 +1809,7 @@ void TerminationCheck();
 int
 Search (int alpha, int beta, int difEval, int depth, int lmr, int oldPromo, int promoSuppress, int threshold)
 {
-  int i, j, k, phase, king, nextVictim, to, defer, autoFail=0, inCheck = 0, late=100000;
+  int i, j, k, phase, king, nextVictim, to, defer, autoFail=0, inCheck = 0, late=100000, ep;
   int firstMove, oldMSP = msp, curMove, sorted, bad, dubious, bestMoveNr;
   int resDep, iterDep, ext;
   int myPV = pvPtr;
@@ -1708,8 +1826,15 @@ if(PATH) /*pboard(board),pmap(attacks, BLACK),*/printf("search(%d) {%d,%d} eval=
   // in-check test and TSUME filter
   {
     k = p[king=royal[stm]].pos;
-    if( k == ABSENT) k = p[king + 2].pos;
-    else if(p[king + 2].pos != ABSENT) k = ABSENT; // two kings is no king...
+    if( k == ABSENT) {
+      if((k = p[king + 2].pos) == ABSENT && (!tsume || tsume & stm+1))
+        return -INF;   // lose when no King (in tsume only for side to be mated)
+    } else if(p[king + 2].pos != ABSENT) {
+      if(tsume && tsume & stm+1) {
+	retDep = 60; return INF; // we win when not in check
+      }
+      k = ABSENT; // two kings is no king...
+    }
     if( k != ABSENT) { // check is possible
       if(!attacks[2*k + xstm]) {
 	if(tsume && tsume & stm+1) {
@@ -1731,7 +1856,7 @@ if(!level) {for(i=0; i<5; i++)printf("# %d %08x, %d\n", i, repStack[200-i], chec
     }
   } else { // he has no king! Test for attacks on Crown Prince
     k = p[king + 2].pos;
-    if(attacks[2*k + stm]) return INF; // we have attack on Crown Prince
+    if(k == ABSENT ? !tsume : attacks[2*k + stm]) return INF; // we have attack on Crown Prince
   }
 //printf("King safe\n");fflush(stdout);
   // EVALUATION & WINDOW SHIFT
@@ -1826,7 +1951,11 @@ if(PATH) printf("%d:%2d:%2d next victim %d/%d\n",level,depth,iterDep,curMove,msp
 	      if(to == ABSENT) continue;              // ignore if absent
 	      if(!attacks[2*to + stm]) continue;      // skip if not attacked
 	      group = p[nextVictim].value;            // remember value of this found victim
-	      if(iterDep <= QSdepth + 1 && 2*group + curEval + 30 < alpha) { resDep = QSdepth + 1; goto cutoff; }
+	      if(iterDep <= QSdepth + 1 && 2*group + curEval + 30 < alpha) {
+		resDep = QSdepth + 1; nextVictim -= 2;
+		if(bestScore < 2*group + curEval + 30) bestScore = 2*group + curEval + 30;
+		goto cutoff;
+	      }
 if(PATH) printf("%d:%2d:%2d group=%d, to=%c%d\n",level,depth,iterDep,group,to%BW+'a',to/BW+ONE);
 	      GenCapts(to, 0);
 if(PATH) printf("%d:%2d:%2d first=%d msp=%d\n",level,depth,iterDep,firstMove,msp);
@@ -1847,11 +1976,11 @@ if(PATH) printf("# autofail end (%d-%d)\n", firstMove, msp);
 	      autoFail = 0; curMove = firstMove - 1; continue; // release stashed moves for search
 	    }
 	    phase = 4; // out of victims: all captures generated
-	    if(chessFlag && promoSuppress != ABSENT) { // e.p. rights. Create e.p. captures as Lion moves
-		int n = board[promoSuppress-1], old = msp; // a-side neighbor of pushed pawn
-		if( n != EMPTY && (n&TYPE) == stm && p[n].value == 80 ) NewCapture(promoSuppress-1, SPECIAL + 20 - 4*stm, 0);
-		n = board[promoSuppress+1];      // h-side neighbor of pushed pawn
-		if( n != EMPTY && (n&TYPE) == stm && p[n].value == 80 ) NewCapture(promoSuppress+1, SPECIAL + 52 - 4*stm, 0);
+	    if(chessFlag && (ep = promoSuppress & SQUARE) != ABSENT) { // e.p. rights. Create e.p. captures as Lion moves
+		int n = board[ep-1], old = msp; // a-side neighbor of pushed pawn
+		if( n != EMPTY && (n&TYPE) == stm && p[n].value == pVal ) NewCapture(ep-1, SPECIAL + 20 - 4*stm, 0);
+		n = board[ep+1];      // h-side neighbor of pushed pawn
+		if( n != EMPTY && (n&TYPE) == stm && p[n].value == pVal ) NewCapture(ep+1, SPECIAL + 52 - 4*stm, 0);
 		if(msp != old) goto extractMove; // one or more e.p. capture were generated
 	    }
 	  case 4: // dubious captures
@@ -1867,6 +1996,7 @@ if(PATH) printf("# autofail end (%d-%d)\n", firstMove, msp);
 	  case 6: // non-captures
 	    nonCapts = msp;
 	    nullMove = GenNonCapts(oldPromo);
+	    if(msp == nonCapts) goto cutoff;
 #ifdef KILLERS
 	    { // swap killers to front
 	      Move h = killer[level][0]; int j = curMove;
@@ -1930,6 +2060,7 @@ if(flag & depth >= 0) printf("%2d:%d found %d/%d %08x %s\n", depth, iterDep, cur
 
 if(flag & depth >= 0) printf("%2d:%d made %d/%d %s\n", depth, iterDep, curMove, msp, MoveToText(moveStack[curMove], 0));
       for(i=2; i<=cnt50; i+=2) if(repStack[level-i+200] == hashKeyH) {
+	retDep = iterDep;
 	if(repDraws) { score = 0; goto repetition; }
 	if(!allowRep) {
 	  moveStack[curMove] = 0;         // erase forbidden move
@@ -1956,7 +2087,9 @@ MapFromScratch(attacks); // for as long as incremental update does not work.
 	  if(dist[tb.from-tb.to] != 1 && attacks[2*tb.to + stm] && p[tb.epVictim[0]].value <= 50)
 	    score = -INF;                           // our Lion is indeed made vulnerable and can be recaptured
 	} else {                                    // other x Ln
-	  if(promoSuppress & PROMOTE) score = -INF; // non-Lion captures Lion after opponent did same
+	  if(promoSuppress & PROMOTE) {             // non-Lion captures Lion after opponent did same
+	    if(!okazaki || attacks[2*tb.to + stm]) score = -INF;
+	  }
 	  defer |= PROMOTE;                         // if we started, flag  he cannot do it in reply
 	}
         if(score == -INF) {
@@ -1969,6 +2102,7 @@ MapFromScratch(attacks); // for as long as incremental update does not work.
       score = -Search(-beta, -iterAlpha, -difEval - tb.booty, iterDep-1+ext,
                        curMove >= late && iterDep > QSdepth + LMR,
                                                       promoSuppress & ~PROMOTE, defer, depth ? INF : tb.gain);
+
 #else
       score = 0;
 #endif
@@ -2042,10 +2176,11 @@ if(PATH) printf("%d:%2d:%d %3d %6x %-10s %6d %6d  (%d)\n", level, depth, iterDep
     if(lmr && bestScore <= alpha && iterDep == depth)
       depth++, lmr--; // self-deepen on fail-low reply to late move by lowering reduction
 #endif
+    if(stalemate && bestScore == -INF && !inCheck) bestScore = 0; // stalemate
 #ifdef HASH
     // hash store
     hashTable[index].lock[hit]  = hashKeyH;
-    hashTable[index].depth[hit] = iterDep;
+    hashTable[index].depth[hit] = resDep;
     hashTable[index].score[hit] = bestScore;
     hashTable[index].flag[hit]  = (bestScore < beta) * H_UPPER;
     if(bestScore > alpha) {
@@ -2070,7 +2205,7 @@ pplist()
 {
   int i, j;
   for(i=0; i<182; i++) {
-	printf("%3d. %3d %3d %4d   %02x %d %d %x %3d ", i, p[i].value, p[i].promo, p[i].pos, p[i].promoFlag&255, p[i].mobWeight, p[i].qval, p[i].bulk, p[i].promoGain);
+	printf("%3d. %3d %3d %4d   %02x %d %d %x %3d %4d ", i, p[i].value, p[i].promo, p[i].pos, p[i].promoFlag&255, p[i].mobWeight, p[i].qval, p[i].bulk, p[i].promoGain, p[i].pst);
 	for(j=0; j<8; j++) printf("  %2d", p[i].range[j]);
 	if(i<2 || i>11) printf("\n"); else printf("  %02x\n", fireFlags[i-2]&255);
   }
@@ -2137,7 +2272,7 @@ pmoves(int start, int end)
 
     // some parameter of your engine
     #define MAXMOVES 2000 /* maximum game length  */
-    #define MAXPLY   30   /* maximum search depth */
+    #define MAXPLY   60   /* maximum search depth */
 
     #define OFF 0
     #define ON  1
@@ -2231,8 +2366,10 @@ Convert (char *fen)
         *p++ = table[2* (*fen - 'A' - n)+1] + n;
       }
     } else *p++ = *fen;
+    if(!*fen) break;
     fen++;
   }
+  *p = '\0';
   printf("# converted FEN '%s'\n", fenArray);
   return fenArray;
 }
@@ -2251,7 +2388,7 @@ Setup2 (char *fen)
   SetUp(array, currentVariant);
   strcpy(startPos, array);
   sup0 = sup1 = sup2 = ABSENT;
-  hashKeyH = hashKeyL = 87620895*currentVariant;
+  hashKeyH = hashKeyL = 87620895*currentVariant + !!fen;
   return stm;
 }
 
@@ -2280,7 +2417,8 @@ MoveToText (MOVE move, int multiLine)
   char *promoChar = "";
   if(f == t) { sprintf(buf, "@@@@"); return buf; } // null-move notation in WB protocol
   buf[0] = '\0';
-  if(t >= SPECIAL) { // kludgy! Print as side effect non-standard WB command to remove victims from double-capture (breaks hint command!)
+  if(t >= SPECIAL) {
+   if(t < CASTLE) { // castling is printed as a single move, implying its side effects
     int e = f + epList[t - SPECIAL];
 //    printf("take %c%d\n", e%BW+'a', e/BW+ONE);
     sprintf(buf, "%c%d%c%d,", f%BW+'a', f/BW+ONE, e%BW+'a', e/BW+ONE); f = e;
@@ -2291,6 +2429,7 @@ MoveToText (MOVE move, int multiLine)
       sprintf(buf+strlen(buf), "%c%d%c%d,", f%BW+'a', f/BW+ONE, e%BW+'a', e/BW+ONE); f = e;
     if(multiLine) printf("move %s\n", buf), buf[0] = '\0';
     }
+   }
     t = g + toList[t - SPECIAL];
   }
   if(move & PROMOTE) promoChar = currentVariant == V_MAKRUK ? "m" : repDraws ? "q" : "+";
@@ -2301,7 +2440,7 @@ MoveToText (MOVE move, int multiLine)
 int
 ReadSquare (char *p, int *sqr)
 {
-  int i=0, f, r;
+  int f, r;
   f = p[0] - 'a';
   r = atoi(p + 1) - ONE;
   *sqr = r*BW + f;
@@ -2321,7 +2460,8 @@ MapFromScratch(attacks);
   Search(-INF-1, INF+1, 0, QSdepth+1, 0, sup1 & ~PROMOTE, sup2, INF);
   postThinking++;
 
-  listStart = retFirst; listEnd = msp = retMSP;
+  listStart = retFirst; msp = retMSP;
+  if(currentVariant == V_LION) GenCastlings(); listEnd = msp;
 }
 
 MOVE
@@ -2342,11 +2482,16 @@ ParseMove (char *moveText)
     for(j=0; j<8; j++) if(e + kStep[j] == t) break;
     if(j >= 8) return INVALID; // this rejects Lion Dog 1+2 moves!
     t2 = SPECIAL + 8*i + j;
-  } else if(chessFlag && board[f] != EMPTY && p[board[f]].value == 80 && board[t] == EMPTY) { // Pawn to empty, could be e.p.
+  } else if(chessFlag && board[f] != EMPTY && p[board[f]].value == pVal && board[t] == EMPTY) { // Pawn to empty, could be e.p.
       if(t == f + BW + 1) t2 = SPECIAL + 16; else
       if(t == f + BW - 1) t2 = SPECIAL + 48; else
       if(t == f - BW + 1) t2 = SPECIAL + 20; else
       if(t == f - BW - 1) t2 = SPECIAL + 52; // fake double-move
+  } else if(currentVariant == V_LION && board[f] != EMPTY && p[board[f]].value == 280 && (t-f == 2 || f-t == 2)) { // castling
+      if(t == f+2 && f < BW) t2 = CASTLE;     else
+      if(t == f-2 && f < BW) t2 = CASTLE + 1; else
+      if(t == f+2 && f > BW) t2 = CASTLE + 2; else
+      if(t == f-2 && f > BW) t2 = CASTLE + 3;
   }
   ret = f<<SQLEN | t2;
   if(*moveText != '\n' && *moveText != '=') ret |= PROMOTE;
@@ -2396,6 +2541,7 @@ Highlight(char *coords)
   for(i=listStart; i<listEnd; i++) {
     if(sqr == (moveStack[i]>>SQLEN & SQUARE)) {
       int t = moveStack[i] & SQUARE;
+      if(t >= CASTLE) t = toList[t - SPECIAL]; else  // decode castling
       if(t >= SPECIAL) {
 	int e = sqr + epList[t - SPECIAL]; // decode
 	b[e] = 'C';
@@ -2461,14 +2607,14 @@ printf("# limits %d, %d, %d mode = %d\n", tlim1, tlim2, tlim3, abortFlag);
 int
 SearchBestMove (MOVE *move, MOVE *ponderMove)
 {
-  int score, i;
+  int score;
 printf("# SearchBestMove\n");
   startTime = GetTickCount();
   nodes = 0;
 printf("# s=%d\n", startTime);fflush(stdout);
 MapFromScratch(attacks);
   retMove = INVALID; repCnt = 0;
-  score = Search(-INF-1, INF+1, rootEval, maxDepth, 0, sup1, sup2, INF);
+  score = Search(-INF-1, INF+1, rootEval, maxDepth + QSdepth, 0, sup1, sup2, INF);
   *move = retMove;
   *ponderMove = pv[1];
 printf("# best=%s\n", MoveToText(pv[0],0));
@@ -2481,7 +2627,7 @@ printf("# ponder=%s\n", MoveToText(pv[1],0));
     { // reset the game and then replay it to the desired point
       int last, stm;
       last = moveNr - n; if(last < 0) last = 0;
-      Init(currentVariant); stm = Setup2(startPos);
+      Init(SAME); stm = Setup2(startPos);
 printf("# setup done");fflush(stdout);
       for(moveNr=0; moveNr<last; moveNr++) stm = MakeMove2(stm, gameMove[moveNr]),printf("make %2d: %x\n", moveNr, gameMove[moveNr]);
       return stm;
@@ -2498,6 +2644,7 @@ printf("# setup done");fflush(stdout);
 
     void GetLine(int root)
     {
+
       int i, c;
       while(1) {
         // wait for input, and read it until we have collected a complete line
@@ -2539,18 +2686,21 @@ printf("# ponder hit\n");
       }
     }
 
+    int
     main()
     {
-      int engineSide=NONE;                     // side played by engine
+      int engineSide=NONE;                // side played by engine
       MOVE move;
       int i, score, curVarNr;
 
-  Init(V_CHU); // Chu
+      setvbuf(stdin, NULL, _IOLBF, 1024); // buffering more than one line flaws test for pending input!
+
+      Init(V_CHU); // Chu
       seed = startTime = GetTickCount(); moveNr = 0; // initialize random
 
       while(1) { // infinite loop
 
-        fflush(stdout);                 // make sure everything is printed before we do something that might take time
+        fflush(stdout);                   // make sure everything is printed before we do something that might take time
         *inBuf = 0; if(moveNr >= 20) randomize = OFF;
 //if(moveNr >20) printf("resign\n");
 
@@ -2592,7 +2742,7 @@ pboard(board);
             PrintResult(stm, score);
           } else {
             MOVE f, pMove = move;
-            if((move & SQUARE) >= SPECIAL && p[board[f = move>>SQLEN & SQUARE]].value == 80) { // e.p. capture
+            if((move & SQUARE) >= SPECIAL && p[board[f = move>>SQLEN & SQUARE]].value == pVal) { // e.p. capture
               pMove = move & ~SQUARE | f + toList[(move & SQUARE) - SPECIAL]; // print as a single move
             }
             stm = MakeMove2(stm, move);  // assumes MakeMove returns new side to move
@@ -2634,6 +2784,7 @@ pboard(board);
           printf("feature option=\"Full analysis PV -check 1\"\n"); // example of an engine-defined option
           printf("feature option=\"Allow repeats -check 0\"\n");
           printf("feature option=\"Promote on entry -check 0\"\n");
+          printf("feature option=\"Okazaki rule -check 0\"\n");
           printf("feature option=\"Resign -check 0\"\n");           // 
           printf("feature option=\"Contempt -spin 0 -200 200\"\n"); // and another one
           printf("feature option=\"Tsume -combo no /// Sente mates /// Gote mates\"\n");
@@ -2645,6 +2796,7 @@ pboard(board);
           if(sscanf(inBuf+7, "Allow repeats=%d", &allowRep)  == 1) continue;
           if(sscanf(inBuf+7, "Resign=%d",   &resign)         == 1) continue;
           if(sscanf(inBuf+7, "Contempt=%d", &contemptFactor) == 1) continue;
+          if(sscanf(inBuf+7, "Okazaki rule=%d", &okazaki)    == 1) continue;
           if(sscanf(inBuf+7, "Promote on entry=%d", &entryProm) == 1) continue;
           if(sscanf(inBuf+7, "Tsume=%s", command) == 1) {
 	    if(!strcmp(command, "no"))    tsume = 0; else
@@ -2656,6 +2808,7 @@ pboard(board);
         }
         if(!strcmp(command, "sd"))      { sscanf(inBuf, "sd %d", &maxDepth);    continue; }
         if(!strcmp(command, "st"))      { sscanf(inBuf, "st %d", &timePerMove); continue; }
+
         if(!strcmp(command, "memory"))  { SetMemorySize(atoi(inBuf+7)); continue; }
         if(!strcmp(command, "ping"))    { printf("pong%s", inBuf+4); continue; }
     //  if(!strcmp(command, ""))        { sscanf(inBuf, " %d", &); continue; }
@@ -2719,5 +2872,6 @@ pboard(board);
         if(!strcmp(command, "remove"))  { stm = TakeBack(2); continue; }
         printf("Error: unknown command\n");
       }
+      return 0;
     }