X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=hachu.c;h=aa37ab3f44b6648e853fe784e1e3426c0a784385;hb=c40c2b9d2eb9abc3cd530a1ff96aaf0e6fc91643;hp=2133ce97d8fb27ba50024e7504170a0f3df01bc7;hpb=bf370f90ab8ae2a240a4afb0b961c272b8da406b;p=hachu.git

diff --git a/hachu.c b/hachu.c
index 2133ce9..aa37ab3 100644
--- a/hachu.c
+++ b/hachu.c
@@ -8,37 +8,77 @@
 
 // TODO:
 // in GenCapts we do not generate jumps of more than two squares yet
-// Chu rules for Lion capture
 // promotions by pieces with Lion power stepping in & out the zone in same turn
 // promotion on capture
 
-#define VERSION 0.0
+#define VERSION "0.7beta"
 
-#define PATH level==0 || level==1 && path[0] == 0x55893
+#define PATH level==0 || path[0] == 0xc4028 &&  (level==1 /*|| path[1] == 0x75967 && (level == 2 || path[2] == 0x3400b && (level == 3))*/)
+//define PATH 0
+
+#define XHASH
+#define XKILLERS
+#define XNULLMOVE
 
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <time.h>
+#include <stdint.h>
+
+#ifdef WIN32 
+#    include <windows.h>
+     int InputWaiting()
+     {  // checks for waiting input in pipe
+	static int pipe, init;
+	static HANDLE inp;
+	DWORD cnt;
+
+	if(!init) inp = GetStdHandle(STD_INPUT_HANDLE);
+	if(!PeekNamedPipe(inp, NULL, 0, NULL, &cnt, NULL)) return 1;
+	return cnt;
+    }
+#else
+#    include <sys/time.h>
+#    include <sys/ioctl.h>
+     int InputWaiting()
+     {
+	int cnt;
+	if(ioctl(0, FIONREAD, &cnt)) return 1;
+	return cnt;
+     }
+     int GetTickCount() // with thanks to Tord
+     {	struct timeval t;
+	gettimeofday(&t, NULL);
+	return t.tv_sec*1000 + t.tv_usec/1000;
+     }
+#endif
 
-#define BW 24
-#define BH 12
-#define BSIZE BW*BH*2
-#define ZONE 4
+#define BW bWidth
+#define BH bHeight
+#define BHMAX 16
+#define BWMAX (2*BHMAX)
+#define BSIZE BWMAX*BHMAX
+#define ZONE  zone
 
-#define ONE 0
+#define ONE (currentVariant == V_SHO || currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK)
 
 #define BLACK      0
 #define WHITE      1
 #define EMPTY      0
 #define EDGE   (1<<11)
 #define TYPE   (WHITE|BLACK|EDGE)
-#define ABSENT  4095
+#define ABSENT  2047
 #define INF     8000
-#define NPIECES 2000               /* length of piece list    */
+#define NPIECES EDGE+1               /* length of piece list    */
 
 #define SQLEN    11                /* bits in square number   */
 #define SQUARE  ((1<<SQLEN) - 1)   /* mask for square in move */
 #define DEFER   (1<<2*SQLEN)       /* deferral on zone entry  */
 #define PROMOTE (1<<2*SQLEN+1)     /* promotion bit in move   */
-#define SPECIAL  1500              /* start of special moves  */
+#define SPECIAL  1400              /* start of special moves  */
+#define BURN    (SPECIAL + 96)     /* start of burn encodings */
 #define STEP(X,Y) (BW*(X)+ (Y))
 #define SORTKEY(X) 0
 
@@ -56,33 +96,65 @@
 typedef unsigned int Move;
 
 char *MoveToText(Move move, int m);     // from WB driver
-void pmap (int *m, int col);
+void pmap(int *m, int col);
+void pboard(int *b);
+void pbytes(unsigned char *b);
+
+typedef struct {
+  int lock[5];
+  int move[5];
+  short int score[5];
+  char depth[5];
+  char flag[5];
+  char age[4];
+} HashBucket;
+
+HashBucket *hashTable;
+int hashMask;
+
+#define H_UPPER 2
+#define H_LOWER 1
 
 typedef struct {
   char *name, *promoted;
   int value;
   signed char range[8];
+  char ranking;
+  int whiteKey, blackKey;
 } PieceDesc;
 
 typedef struct {
-  int from, to, piece, victim, new, booty, epSquare, epVictim, ep2Square, ep2Victim;
+  int from, to, piece, victim, new, booty, epSquare, epVictim[8], ep2Square, revMoveCount, savKeyL, savKeyH;
+  char fireMask;
 } UndoInfo;
 
-int stm, xstm, hashKeyH, hashKeyL, framePtr, msp, nonCapts, retMSP, retFirst, level, chuFlag=1;
-Move retMove, moveStack[10000], path[100];
+char *array, fenArray[4000], *reason;
+int bWidth, bHeight, bsize, zone, currentVariant, chuFlag, tenFlag, chessFlag, repDraws;
+int stm, xstm, hashKeyH, hashKeyL, framePtr, msp, nonCapts, rootEval, retMSP, retFirst, retDep, pvPtr, level, cnt50, mobilityScore;
+int nodes, startTime, tlim1, tlim2, tlim3, repCnt, comp, abortFlag;
+Move ponderMove;
+Move retMove, moveStack[10000], path[100], repStack[300], pv[1000], repeatMove[300], killer[100][2];
+
+      int maxDepth;                            // used by search
 
 #define X 36 /* slider              */
-#define J -1 /* jump                */
-#define N -2 /* Knight              */
+#define R 37 /* jump capture        */
+#define N -1 /* Knight              */
+#define J -2 /* jump                */
 #define D -3 /* linear double move  */
 #define T -4 /* linear triple move  */
 #define L -5 /* true Lion move      */
 #define F -6 /* Lion + 3-step       */
 #define S -7 /* Lion + range        */
 #define H -9 /* hook move           */
+#define C -10 /* capture only       */
+#define M -11 /* non-capture only   */
+
+#define LVAL 100 /* piece value of Lion. Used in chu for recognizing it to implement Lion-trade rules  */
+#define FVAL 500 /* piece value of Fire Demon. Used in code for recognizing moves with it and do burns */
 
 PieceDesc chuPieces[] = {
-  {"LN", "",  100, { L,L,L,L,L,L,L,L } }, // lion
+  {"LN", "", LVAL, { L,L,L,L,L,L,L,L } }, // lion
   {"FK", "",   60, { X,X,X,X,X,X,X,X } }, // free king
   {"SE", "",   55, { X,D,X,X,X,X,X,D } }, // soaring eagle
   {"HF", "",   50, { D,X,X,X,X,X,X,X } }, // horned falcon
@@ -94,8 +166,8 @@ PieceDesc chuPieces[] = {
   {"R",  "DK", 30, { X,0,X,0,X,0,X,0 } }, // rook
   {"FS", "",   30, { X,1,1,1,X,1,1,1 } }, // flying stag
   {"WL", "",   25, { X,0,0,X,X,X,0,0 } }, // whale
-  {"K",  "",   28, { 1,1,1,1,1,1,1,1 } }, // king
-  {"CP", "",   27, { 1,1,1,1,1,1,1,1 } }, // king
+  {"K",  "",   28, { 1,1,1,1,1,1,1,1 }, 4 }, // king
+  {"CP", "",   27, { 1,1,1,1,1,1,1,1 }, 4 }, // king
   {"B",  "DH", 25, { 0,X,0,X,0,X,0,X } }, // bishop
   {"VM", "FO", 20, { X,0,1,0,X,0,1,0 } }, // vertical mover
   {"SM", "FB", 20, { 1,0,X,0,1,0,X,0 } }, // side mover
@@ -114,6 +186,22 @@ PieceDesc chuPieces[] = {
   { NULL }  // sentinel
 };
 
+PieceDesc shoPieces[] = {
+  {"DK", "",   70, { X,1,X,1,X,1,X,1 } }, // dragon king
+  {"DH", "",   52, { 1,X,1,X,1,X,1,X } }, // dragon horse
+  {"R",  "DK", 50, { X,0,X,0,X,0,X,0 } }, // rook
+  {"B",  "DH", 32, { 0,X,0,X,0,X,0,X } }, // bishop
+  {"K",  "",   41, { 1,1,1,1,1,1,1,1 } }, // king
+  {"CP", "",   40, { 1,1,1,1,1,1,1,1 } }, // king
+  {"DE", "CP", 25, { 1,1,1,1,0,1,1,1 } }, // silver
+  {"G",  "",   22, { 1,1,1,0,1,0,1,1 } }, // gold
+  {"S",  "G",  20, { 1,1,0,1,0,1,0,1 } }, // silver
+  {"L",  "G",  15, { X,0,0,0,0,0,0,0 } }, // lance
+  {"N",  "G",  11, { N,0,0,0,0,0,0,N } }, // Knight
+  {"P",  "G",  8,  { 1,0,0,0,0,0,0,0 } }, // pawn
+  { NULL }  // sentinel
+};
+
 PieceDesc daiPieces[] = {
   {"FD", "G", 15, { 0,2,0,2,0,2,0,2 } }, // Flying Dragon
   {"VO", "G", 20, { 2,0,2,0,2,0,2,0 } }, // Violent Ox
@@ -131,10 +219,10 @@ PieceDesc ddPieces[] = {
   {"OK", "LO", 1, { 2,1,2,0,2,0,2,1 } }, // Old Kite
   {"PS", "HM", 1, { J,0,1,J,0,J,1,0 } }, // Poisonous Snake
   {"GE", "",   1, { 3,3,5,5,3,5,5,3 } }, // Great Elephant
-  {"WB", "LD", 1, { 1,1,2,0,1,0,2,1 } }, // Western Barbarian
+  {"WS", "LD", 1, { 1,1,2,0,1,0,2,1 } }, // Western Barbarian
   {"EA", "LN", 1, { 2,1,1,0,2,0,1,1 } }, // Eastern Barbarian
   {"NO", "FE", 1, { 0,2,1,1,0,1,1,2 } }, // Northern Barbarian
-  {"S)", "WE", 1, { 0,1,1,2,0,2,1,1 } }, // Southern Barbarian
+  {"SO", "WE", 1, { 0,1,1,2,0,2,1,1 } }, // Southern Barbarian
   {"FE", "",   1, { 2,X,2,2,2,2,2,X } }, // Fragrant Elephant
   {"WE", "",   1, { 2,2,2,X,2,X,2,2 } }, // White Elephant
   {"FT", "",   1, { X,X,5,0,X,0,5,X } }, // Free Dream-Eater
@@ -237,32 +325,103 @@ PieceDesc taiPieces[] = {
   { NULL }  // sentinel
 };
 
+PieceDesc tenjikuPieces[] = { // only those not in Chu, or different (because of different promotion)
+  {"FI", "", FVAL, { X,X,0,X,X,X,0,X } }, // Fire Demon
+  {"GG", "", 150, { R,R,R,R,R,R,R,R }, 3 }, // Great General
+  {"VG", "", 140, { 0,R,0,R,0,R,0,R }, 2 }, // Vice General
+  {"RG", "GG",120, { R,0,R,0,R,0,R,0 }, 1 }, // Rook General
+  {"BG", "VG",110, { 0,R,0,R,0,R,0,R }, 1 }, // Bishop General
+  {"SE", "RG", 1, { X,D,X,X,X,X,X,D } }, // Soaring Eagle
+  {"HF", "BG", 1, { D,X,X,X,X,X,X,X } }, // Horned Falcon
+  {"LH", "",   1, { L,S,L,S,L,S,L,S } }, // Lion-Hawk
+  {"LN", "LH", LVAL, { L,L,L,L,L,L,L,L } }, // Lion
+  {"FE", "",   1,   { X,X,X,X,X,X,X,X } }, // Free Eagle
+  {"FK", "FE",  60, { X,X,X,X,X,X,X,X } }, // Free King
+  {"HT", "",   1, { X,X,2,X,X,X,2,X } }, // Heavenly Tetrarchs
+  {"CS", "HT", 1, { X,X,2,X,X,X,2,X } }, // Chariot Soldier
+  {"WB", "FI", 1, { 2,X,X,X,2,X,X,X } }, // Water Buffalo
+  {"VS", "CS", 1, { X,0,2,0,1,0,2,0 } }, // Vertical Soldier
+  {"SS", "WB", 1, { 2,0,X,0,1,0,X,0 } }, // Side Soldier
+  {"I",  "VS", 1, { 1,1,0,0,0,0,0,1 } }, // Iron
+  {"N",  "SS", 1, { N,0,0,0,0,0,0,N } }, // Knight
+  {"MG", "",   1, { X,0,0,X,0,X,0,0 } }, // Multi-General
+  {"D",  "MG", 1, { 1,0,0,1,0,1,0,0 } }, // Dog
+  { NULL }  // sentinel
+};
+
 PieceDesc taikyokuPieces[] = {
   {"", "", 1, {  } }, // 
   { NULL }  // sentinel
 };
 
+PieceDesc chessPieces[] = {
+  {"Q", "",  95, { X,X,X,X,X,X,X,X } },
+  {"R", "",  50, { X,0,X,0,X,0,X,0 } },
+  {"B", "",  32, { 0,X,0,X,0,X,0,X } },
+  {"N", "",  30, { N,N,N,N,N,N,N,N } },
+  {"K", "",  28, { 1,1,1,1,1,1,1,1 } },
+  {"P", "Q",  8, { M,C,0,0,0,0,0,C } },
+  { NULL }  // sentinel
+};
+
+PieceDesc shatranjPieces[] = {
+  {"FK", "", 15, { 0,1,0,1,0,1,0,1 } },
+  {"R", "",  50, { X,0,X,0,X,0,X,0 } },
+  {"B", "",   9, { 0,J,0,J,0,J,0,J } },
+  {"N", "",  30, { N,N,N,N,N,N,N,N } },
+  {"K", "",  28, { 1,1,1,1,1,1,1,1 } },
+  {"P", "FK", 8, { M,C,0,0,0,0,0,C } },
+  { NULL }  // sentinel
+};
+
+PieceDesc makrukPieces[] = {
+  {"SM","",  15, { 0,1,0,1,0,1,0,1 } },
+  {"R", "",  50, { X,0,X,0,X,0,X,0 } },
+  {"S", "",  20, { 1,1,0,1,0,1,0,1 } }, // silver
+  {"N", "",  30, { N,N,N,N,N,N,N,N } },
+  {"K", "",  28, { 1,1,1,1,1,1,1,1 } },
+  {"P", "SM", 8, { M,C,0,0,0,0,0,C } },
+  { NULL }  // sentinel
+};
+
 char chuArray[] = "L:FLCSGK:DEGSC:FLL/:RV.B.:BT:KN:PH:BT.B.:RV/:SM:VMR:DH:DK:LN:FK:DK:DHR:VM:SM/PPPPPPPPPPPP/...:GB....:GB..."
 		  "/............/............/"
 		  "...:gb....:gb.../pppppppppppp/:sm:vmr:dh:dk:fk:ln:dk:dhr:vm:sm/:rv.b.:bt:ph:kn:bt.b.:rv/l:flcsg:dekgsc:fll";
 char daiArray[] = "LN:STICSGKGSCI:STNL/:RV.:CS.:FL.:BT:DE:BT.:FL.:CS.:RV/.:VO.:AB.:EW:KN:LN:PH:EW.:AB.:VO./R:FD:SM:VMB:DH:DK:FK:DK:DHB:VM:SM:FDR"
 		  "/PPPPPPPPPPPPPPP/....:GB.....:GB..../.............../.............../.............../....:gb.....:gb..../ppppppppppppppp/"
 		  "r:fd:sm:vmb:dh:dk:fk:dk:dhb:vm:sm:fdr/.:vo.:ab.:ew:ph:ln:kn:ew.:ab.:vo./:rv.:cs.:fl.:bt:de:bt.:fl.:cs.:rv/ln:sticsgkgsci:stnl";
+char tenArray[] = "LN:FLICSGK:DEGSCI:FLNL/:RV.:CS:CS.:BT:KN:LN:FK:PH:BT.:CS:CS.:RV/:SS:VSB:DH:DK:WB:FI:LH:FE:FI:WB:DK:DHB:VS:SS/"
+		  ":SM:VMR:HF:SE:BG:RG:GG:VG:RG:BG:SE:HFR:VM:SM/PPPPPPPPPPPPPPPP/....D......D..../"
+		  "................/................/................/................/"
+		  "....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 shatArray[]= "RNBK:FKBNR/PPPPPPPP/......../......../......../......../pppppppp/rnbk:fkbnr";
+char thaiArray[]= "RNSK:SMSNR/......../PPPPPPPP/......../......../pppppppp/......../rnsk:smsnr";
 
 typedef struct {
-  int boardWidth, boardFiles, zoneDepth, boardRanks; // board sizes
+  int boardWidth, boardFiles, boardRanks, zoneDepth, varNr; // board sizes
   char *name;  // WinBoard name
   char *array; // initial position
 } VariantDesc;
 
+typedef enum { V_CHESS, V_SHO, V_CHU, V_DAI, V_TENJIKU, V_DADA, V_MAKA, V_TAI, V_KYOKU, V_SHATRANJ, V_MAKRUK } Variant;
+
 VariantDesc variants[] = {
-  { 24, 12, 12, 4, "chu",     chuArray }, // Chu
-  { 30, 15, 15, 5, "dai",     daiArray }, // Dai
-  { 32, 16, 16, 5, "tenjiku", chuArray }, // Tenjiku
-  { 34, 17, 17, 0, "dada",    chuArray }, // Dai Dai
-  { 38, 19, 19, 0, "maka",    chuArray }, // Maka Dai Dai
-  { 50, 25, 25, 0, "tai",     chuArray }, // Tai
-  { 40, 36, 36, 0, "kyoku",   chuArray }  // Taikyoku
+  { 16,  8,  8, 1, V_CHESS,  "normal", chessArray }, // FIDE
+  { 18,  9,  9, 3, V_SHO, "9x9+0_shogi", shoArray }, // Sho
+  { 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
+  { 16,  8,  8, 3, V_MAKRUK,  "makruk",  thaiArray}, // Makruk
+
+//  { 0, 0, 0, 0, 0 }, // sentinel
+  { 34, 17, 17, 0, V_DADA,    "dada",    chuArray }, // Dai Dai
+  { 38, 19, 19, 0, V_MAKA,    "maka",    chuArray }, // Maka Dai Dai
+  { 50, 25, 25, 0, V_TAI,     "tai",     chuArray }, // Tai
+  { 40, 36, 36, 0, V_KYOKU,   "kyoku",   chuArray }  // Taikyoku
 };
 
 typedef struct {
@@ -291,6 +450,7 @@ Vector direction[] = { // clockwise!
 
 int epList[96], ep2List[96], toList[96], reverse[96];  // decoding tables for double and triple moves
 int kingStep[10], knightStep[10];         // raw tables for step vectors (indexed as -1 .. 8)
+char fireFlags[10]; // flags for Fire-Demon presence (last two are dummies, which stay 0, for compactify)
 #define kStep (kingStep+1)
 #define nStep (knightStep+1)
 
@@ -391,23 +551,58 @@ typedef struct {
   char age;
 } HashEntry; // hash-table entry
 
+    // Some global variables that control your engine's behavior
+    int ponder;
+    int randomize;
+    int postThinking;
+    int resign;         // engine-defined option
+    int contemptFactor; // likewise
+
 int squareKey[BSIZE];
 
-int rawBoard[BSIZE + 11*BW + 6];
+int rawBoard[BSIZE + 11*BHMAX + 6];
 //int attacks[2*BSIZE];   // attack map
 int attackMaps[200*BSIZE], *attacks = attackMaps;
 char distance[2*BSIZE]; // distance table
-char promoBoard[BSIZE];
+char promoBoard[BSIZE]; // flags to indicate promotion zones
+char rawFire[BSIZE+2*BWMAX]; // flags to indicate squares controlled by Fire Demons
 signed char PST[2*BSIZE];
 
-#define board (rawBoard + 6*BW + 3)
-#define dist  (distance + BSIZE)
+#define board     (rawBoard + 6*BHMAX + 3)
+#define fireBoard (rawFire + BWMAX + 1)
+#define dist      (distance + BSIZE)
 
-int LookUp(char *name, PieceDesc *list)
+PieceDesc *
+ListLookUp (char *name, PieceDesc *list)
 { // find piece of given name in list of descriptors
-  int i=0;
-  while(list->name && strcmp(name, list->name)) i++, list++;
-  return (list->name == NULL ? -1 : i);
+  while(list->name && strcmp(name, list->name)) list++;
+  return (list->name == NULL ? NULL : list);
+}
+
+PieceDesc *
+LookUp (char *name, int var)
+{ // search piece of given name in all lists relevant for given variant
+  PieceDesc *desc;
+  switch(var) {
+    case V_TENJIKU: // Tenjiku
+      desc = ListLookUp(name, tenjikuPieces);
+      if(desc) return desc;
+      return ListLookUp(name, chuPieces);
+    case V_SHO: // Sho
+      return ListLookUp(name, shoPieces);
+    case V_DAI: // Dai
+      desc = ListLookUp(name, daiPieces);
+      if(desc) return desc;
+    case V_CHU: // Chu
+      return ListLookUp(name, chuPieces);
+    case V_CHESS: // FIDE
+      return ListLookUp(name, chessPieces);
+    case V_SHATRANJ: // Shatranj
+      return ListLookUp(name, shatranjPieces);
+    case V_MAKRUK: // Makruk
+      return ListLookUp(name, makrukPieces);
+  }
+  return NULL;
 }
 
 void
@@ -419,6 +614,7 @@ SqueezeOut (int n)
   for(i=n; i<last[stm]; i+=2) {
     p[i] = p[i+2];
     if(i+2 == royal[stm]) royal[stm] -= 2; // NB: squeezing out the King moves up Crown Prince to royal[stm]
+    if(i < 10) fireFlags[i-2] = fireFlags[i];
   }
   last[stm] -= 2;
 }
@@ -472,6 +668,22 @@ Range (signed char *r)
   return m;
 }
 
+int multis[2], multiMovers[100];
+
+void
+StackMultis (int col)
+{
+  int i, j;
+  multis[col] = col;
+  for(i=col+2; i<last[col]; i+=2) { // scan piece list for multi-capturers
+    for(j=0; j<8; j++) if(p[i].range[j] < J && p[i].range[j] >= S || p[i].value == 10*FVAL) {
+      multiMovers[multis[col]] = i; // found one: put its piece number in list
+      multis[col] += 2;
+      break;
+    }
+  }
+}
+
 void
 Compactify (int stm)
 { // remove pieces that are permanently gone (captured or promoted) from one side's piece list
@@ -483,46 +695,56 @@ Compactify (int stm)
     }
   }
   for(i=stm+2; i<last[stm]; i+=2) { // second pass: promoted pieces
+
     if((k = p[i].promo) == -2 && p[i].pos == ABSENT) { // orphaned promoted piece not present
       SqueezeOut(i);
     }
   }
+  StackMultis(stm);
 }
 
 int
-AddPiece (int stm, int n, PieceDesc *list)
+AddPiece (int stm, PieceDesc *list)
 {
-  int i, j;
+  int i, j, *key, v;
   for(i=stm+2; i<=last[stm]; i += 2) {
-    if(p[i].value < 10*list[n].value || p[i].value == 10*list[n].value && (p[i].promo < 0)) break;
+    if(p[i].value < 10*list->value || p[i].value == 10*list->value && (p[i].promo < 0)) break;
   }
   last[stm] += 2;
   for(j=last[stm]; j>i; j-= 2) p[j] = p[j-2];
-  p[i].value = 10*list[n].value;
-  for(j=0; j<8; j++) p[i].range[j] = list[n].range[j^4*(WHITE-stm)];
+  p[i].value = v = 10*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 2:  p[i].pst = bsize; break;
+    default: p[i].pst = bsize + BH; break;
   }
+  key = (stm == WHITE ? &list->whiteKey : &list->blackKey);
+  if(!*key) *key = ~(myRandom()*myRandom());
+  p[i].pieceKey = *key;
   p[i].promoFlag = 0;
+  p[i].mobWeight = v > 600 ? 0 : v >= 400 ? 1 : v >= 300 ? 2 : v > 150 ? 3 : v >= 100 ? 2 : 0;
   for(j=stm+2; j<= last[stm]; j+=2) {
     if(p[j].promo >= i) p[j].promo += 2;
   }
   if(royal[stm] >= i) royal[stm] += 2;
-  if(p[i].value == 280) royal[stm] = i;
+  if(p[i].value == (currentVariant == V_SHO ? 410 : 280) ) royal[stm] = i, p[i].pst = 0;
+  p[i].qval = (currentVariant == V_TENJIKU ? list->ranking : 0); // jump-capture hierarchy
   return i;
 }
 
 void
-SetUp(char *array, PieceDesc *list)
+SetUp(char *array, int var)
 {
-  int i, j, k, k2, n, m, nr, color;
-  char c, *q, name[3];
+  int i, j, n, m, nr, color;
+  char c, *q, name[3], prince = 0;
+  PieceDesc *p1, *p2;
   last[WHITE] = 1; last[BLACK] = 0;
   for(i=0; ; i++) {
 //printf("next rank: %s\n", array);
     for(j = BW*i; ; j++) {
+      int pflag=0;
+      if(*array == '+') pflag++, array++;
       c = name[0] = *array++;
       if(!c) goto eos;
       if(c == '.') continue;
@@ -534,17 +756,21 @@ SetUp(char *array, PieceDesc *list)
 	name[0] += 'A' - 'a';
 	if(name[1]) name[1] += 'A' - 'a';
       } else color = WHITE;
-      k = LookUp(name, list);
-      n = AddPiece(color, k, list);
+      if(!strcmp(name, "CP")) 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
+      n = AddPiece(color, p1);
       p[n].pos = j;
-      if(list[k].promoted[0]) {
-	k2 = LookUp(list[k].promoted, list);
-        m = AddPiece(color, k2, list);
+      if(p1->promoted[0] && !pflag) {
+        if(!strcmp(p1->promoted, "CP")) prince |= color+1; // remember if we added Crown Prince
+	p2 = LookUp(p1->promoted, var);
+        m = AddPiece(color, p2);
 	if(m <= n) n += 2;
 	p[n].promo = m;
-	p[n].promoFlag = IsUpwardCompatible(list[k2].range, list[k].range) * DONT_DEFER + CAN_PROMOTE;
-	if(Forward(list[k].range)) p[n].promoFlag |= LAST_RANK; // Pieces that only move forward can't defer on last rank
-	if(!strcmp(list[k].name, "N")) p[n].promoFlag |= CANT_DEFER; // Knights can't defer on last 2 ranks
+	p[n].promoFlag = IsUpwardCompatible(p2->range, p1->range) * DONT_DEFER + CAN_PROMOTE;
+	if(Forward(p1->range)) p[n].promoFlag |= LAST_RANK; // Pieces that only move forward can't defer on last rank
+	if(!strcmp(p1->name, "N")) p[n].promoFlag |= CANT_DEFER; // Knights can't defer on last 2 ranks
 	p[n].promoFlag &= n&1 ? P_WHITE : P_BLACK;
 	p[m].promo = -1;
 	p[m].pos = ABSENT;
@@ -553,9 +779,21 @@ SetUp(char *array, PieceDesc *list)
     }
   }
  eos:
+  // 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;
+  for(i=0; i<8; i++)  fireFlags[i] = 0;
+  for(i=2, n=1; i<10; i++) if(p[i].value == 10*FVAL) {
+    int x = p[i].pos; // mark all burn zones
+    fireFlags[i-2] = n;
+    if(x != ABSENT) for(j=0; j<8; j++) fireBoard[x+kStep[j]] |= n;
+    n <<= 1;
+  }
   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) board[p[i].pos] = i;
   for(i=BLACK+2; i<=last[BLACK]; i+=2) board[p[i].pos] = i;
+  StackMultis(WHITE);
+  StackMultis(BLACK);
   stm = WHITE; xstm = BLACK;
 }
 
@@ -565,10 +803,21 @@ int myRandom()
 }
 
 void
-Init()
+Init (int var)
 {
   int i, j, k;
 
+  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);
+  tenFlag = (currentVariant == V_TENJIKU);
+  chessFlag = (currentVariant == V_CHESS);
+  repDraws  = (currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK);
+
   for(i= -1; i<9; i++) { // board steps in linear coordinates
     kStep[i] = STEP(direction[i&7].x,   direction[i&7].y);       // King
     nStep[i] = STEP(direction[(i&7)+8].x, direction[(i&7)+8].y); // Knight
@@ -590,27 +839,28 @@ Init()
   }
 
   // fill distance table
-  for(i=0; i<BSIZE; i++) {
+  for(i=0; i<2*BSIZE; i++) {
     distance[i] = 0;
   }
   for(i=0; i<8; i++)
     for(j=1; j<BH; j++)
       dist[j * kStep[i]] = j;
+  if(currentVariant == V_TENJIKU)
+    for(i=1-BH; i<BH; i++) for(j=1-BH; j<BH; j++) dist[BW*i+j] = abs(i) > abs(j) ? abs(i) : abs(j);
 
   // hash key tables
-  for(i=0; i<BSIZE; i++) squareKey[i] = ~(myRandom()*myRandom());
-  for(i=0; i<NPIECES; i++) p[i].pieceKey = ~(myRandom()*myRandom());
+  for(i=0; i<bsize; i++) squareKey[i] = ~(myRandom()*myRandom());
 
   // board edge
-  for(i=0; i<BSIZE + 11*BW + 6; i++) rawBoard[i] = EDGE;
+  for(i=0; i<BSIZE + 11*BHMAX + 6; i++) rawBoard[i] = EDGE;
 
   // promotion zones
   for(i=0; i<BH; i++) for(j=0; j<BH; j++) {
     char v = 0;
     if(i == 0)       v |= LAST_RANK & P_BLACK;
     if(i < 2)        v |= CANT_DEFER & P_BLACK;
-    if(i < ZONE)     v |= (CAN_PROMOTE | DONT_DEFER) & P_BLACK;
-    if(i >= BH-ZONE) v |= (CAN_PROMOTE | DONT_DEFER) & P_WHITE;
+    if(i < ZONE)     v |= (CAN_PROMOTE | DONT_DEFER) & P_BLACK; else v &= ~P_BLACK;
+    if(i >= BH-ZONE) v |= (CAN_PROMOTE | DONT_DEFER) & P_WHITE; else v &= ~P_WHITE;
     if(i >= BH-2)    v |= CANT_DEFER & P_WHITE;
     if(i == BH-1)    v |= LAST_RANK & P_WHITE;
     promoBoard[BW*i + j] = v;
@@ -618,50 +868,37 @@ Init()
 
   // piece-square tables
   for(i=0; i<BH; i++) for(j=0; j<BH; j++) {
-    int s = BW*i + j, d = BH*(BH-2) - (2*i - BH + 1)*(2*i - BH + 1) - (2*j - BH + 1)*(2*j - BH + 1);
+    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] = 0;
     PST[BH+s] = d/4 - (i == 0 || i == BH-1 ? 15 : 0) - (j == 0 || j == BH-1 ? 15 : 0);
-    PST[BSIZE+s] = d/6;
-    PST[BSIZE+BH+s] = d/12;
-  }  
+    PST[BH*BW+s] = d/6;
+    PST[BH*BW+BH+s] = d/12;
+  }
+
+  p[EDGE].qval = 5; // tenjiku jump-capturer sentinel
 }
 
-#if 0
-inline int
-AddMove (int i, int x, int y)
+int
+PSTest ()
 {
-  if(board[y] == EDGE) return 1;
-	if(board[y] == EMPTY) {           // non-capt
-	  if((flagBoard[x] | flagBoard[y]) & p[i].flags) { // promotion possible
-	    moveStack[msp++] = moveStack[nonCapts];
-	    moveStack[nonCapts++] |= PROMOTE | p[i].flags << 24;
-	    if(!(p[i].flags & ALWAYS_PROMOTE))
-	       moveStack[msp++] = x << SQLEN | y; // push deferral as well
-	  else moveStack[msp++] = x << SQLEN | y; // normal move
-	  }
-	} else { // capture
-	  if(((board[y] ^ i) & 1) return 1; // own
-	  moveStack[msp++] = moveStack[nonCapts];
-	  moveStack[nonCapts++] = moveStack[promotions];
-	  moveStack[promotions++] = x << SQLEN | y;
-	  if((flagBoard[x] | flagBoard[y]) & p[i].flags) { // promotion possible
-	    int p = promotions;
-	    if(!(p[i].flags & ALWAYS_PROMOTE)) {
-	      moveStack[msp++] = moveStack[nonCapts];
-	      moveStack[nonCapts++] = moveStack[promotions];
-	      moveStack[promotions++] = moveStack[p-1];
-	    }
-	    moveStack[p-1] += PROMOTE | p[i].flags<<24;
-	  }
-	  return 1; // capture ends ray scan
-	}
-	return 0;
+  int r, f, score, tot=0;
+  for(r=0; r<BH; r++) for(f=0; f<BH; f++) {
+    int s = BW*r+f;
+    int piece = board[s];
+    if(!piece) continue;
+    score = p[piece].value + PST[p[piece].pst + s];
+    if(piece & 1) tot += score; else tot -= score;
+  }
+  return tot;
 }
-#endif
+
+int flag;
 
 inline int
 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) { // piece can promote with this move
     moveStack[msp++] = moveStack[nonCapts];           // create space for promotion
     moveStack[nonCapts++] = x<<SQLEN | y | PROMOTE;   // push promotion
@@ -673,6 +910,7 @@ NewNonCapture (int x, int y, int promoFlags)
     }
   } else
     moveStack[msp++] = x<<SQLEN | y; // push normal move
+//if(flag) printf("msp=%d nc=%d\n", msp, nonCapts);	
   return 0;
 }
 
@@ -692,41 +930,51 @@ NewCapture (int x, int y, int promoFlags)
   return 0;
 }
 
-#if 0
-void
-GenAllMoves ()
+char map[49]; // 7x7 map for area movers
+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
+AreaStep (int from, int x, int flags, int n, int d)
 {
-  int i, j, k;
-  promotions = nonCapts = msp;
-  for(i=stm+2; i<=last[stm]; i+=2) {
-    int x = p[i].pos;
-    if(x == ABSENT) continue;
-    for(j=0; j<8; j++) {
-      int y, v = kStep[j], r = p[i].range[j];
-      if(r < 0) { // jumping piece, special treatment
-	if(r >= -3) { // in any case, do a jump of 2
-	  if(board[x + 2*v] == EMPTY)
-	    ADDMOVE(x, x+2*v);
-	  if(r < -1) { // Lion power, also single step
-	    if(board[x + v] == EMPTY)
-	      ADDMOVE(x, x+v);
-	    if(r == -3) { // true Lion, also Knight jump
-	      v = nStep[j];
-	      if(board[x + v] == EMPTY)
-		ADDMOVE(x, x+v);
-	    }
-	  }
-	}
-	continue;
-      }
-      y = x;
-      while(r-- > 0) {
-	if(board[y+=v] == GUARD) break;    // off board
-	if((board[y] + i & 1) == 0) break; // same color
+  int i;
+  for(i=0; i<8; i++) {
+    int to = x + kStep[i], m = n + mapStep[i];
+    if(board[to] == EDGE) continue; // off board
+    if(map[m] >= d) continue;   // already done
+    if(!map[m]) moveStack[msp++] = from<<SQLEN | to;
+    map[m] = d;
+    if(d > 1 && board[to] == EMPTY) AreaStep(from, to, flags, m, d-1);
+  }
+}
+
+int
+AreaMoves (int from, int piece, int range)
+{
+  int i;
+  for(i=0; i<49; i++) map[i] = 0;
+  map[3*7+7] = range;
+  AreaStep(from, from, p[piece].promoFlag, 3*7+3, range);
+}
+
+void
+MarkBurns (int x)
+{ // make bitmap of squares in FI (7x7) neighborhood where opponents can be captured or burned
+  int r=x>>5, f=x&15, top=8, bottom=0, b=0, t=8, left=0, right=8; // 9x9 area; assumes 32x16 board
+  if(r < 4) bottom = 4 - r, rows[b=bottom-1] = 0; else
+  if(r > 11) top   = 19 - r, rows[t=top+1] = 0; // adjust area to board edges
+  if(f < 4) left   = 4 - f; else if(f > 11) right = 19 - f;
+  for(r=bottom; r<=top; r++) {
+    int mask = 0, y = x + 16*r;
+    for(f=left; f <= right; f++) {
+      if(board[y + f - (4*16+4)] != EMPTY && (board[y + f - (4*16+4)] & TYPE) == xstm)
+	mask |= rowMask[f]; // on-rank attacks
     }
+    rows[r+2] = mask;
   }
+  for(r=b; r<=t-2; r++) rows[r] |= rows[r+1] | rows[r+2]; // smear vertically
 }
-#endif
 
 int
 GenNonCapts (int promoSuppress)
@@ -735,19 +983,27 @@ GenNonCapts (int promoSuppress)
   for(i=stm+2; i<=last[stm]; i+=2) {
     int x = p[i].pos, pFlag = p[i].promoFlag;
     if(x == ABSENT) continue;
-    if(x == promoSuppress) pFlag = 0;
+    if(x == promoSuppress && chuFlag) pFlag = 0;
     for(j=0; j<8; j++) {
       int y, v = kStep[j], r = p[i].range[j];
       if(r < 0) { // jumping piece, special treatment
+	if(r == N) { // pure Knightm do off-ray jump
+	  NewNonCapture(x, x + nStep[j], pFlag);
+	} else
 	if(r >= S) { // in any case, do a jump of 2
-	  NewNonCapture(x, x + 2*v, pFlag);
-	  if(r < N) { // Lion power, also single step
-	    if(!NewNonCapture(x, x + v, pFlag)) nullMove = x;
-	    if(r == L) { // true Lion, also Knight jump
+	  int occup = NewNonCapture(x, x + 2*v, pFlag);
+	  if(r < J) { // Lion power, also single step
+	    if(!NewNonCapture(x, x + v, pFlag)) nullMove = x; else occup = 1;
+	    if(r <= L) { // true Lion, also Knight jump
+	      if(!occup & r < L) for(y=x+2*v; !NewNonCapture(x, y+=v, pFlag) && r == S; ); // BS and FF moves
 	      v = nStep[j];
 	      NewNonCapture(x, x + v, pFlag);
 	    }
 	  }
+	} else
+	if(r == M) { // FIDE Pawn; check double-move
+	  if(!NewNonCapture(x, x+v, pFlag) && chessFlag && promoBoard[x-v])
+	    NewNonCapture(x, x+2*v, pFlag), moveStack[msp-1] |= DEFER; // use promoSuppress flag as e.p. flag
 	}
 	continue;
       }
@@ -764,18 +1020,24 @@ report (int x, int y, int i)
 {
 }
 
-void
+int
 MapOneColor (int start, int last, int *map)
 {
-  int i, j, k;
+  int i, j, k, totMob = 0;
   for(i=start+2; i<=last; i+=2) {
+    int mob = 0;
     if(p[i].pos == ABSENT) continue;
     for(j=0; j<8; j++) {
       int x = p[i].pos, v = kStep[j], r = p[i].range[j];
       if(r < 0) { // jumping piece, special treatment
+	if(r == N) {
+	  x += nStep[j];
+	  if(board[x] != EMPTY && board[x] != EDGE)
+	    map[2*x + start] += one[8];
+	} else
 	if(r >= S) { // in any case, do a jump of 2
 	  if(board[x + 2*v] != EMPTY && board[x + 2*v] != EDGE)
-	    map[2*(x + 2*v) + start] += one[j];
+	    map[2*(x + 2*v) + start] += one[j], mob += (board[x + 2*v] ^ start) & 1;
 	  if(r < J) { // Lion power, also single step
 	    if(board[x + v] != EMPTY && board[x + v] != EDGE)
 	      map[2*(x + v) + start] += one[j];
@@ -800,32 +1062,56 @@ MapOneColor (int start, int last, int *map)
 		map[2*(x + v) + start] += one[8];
 	    }
 	  }
+	} else
+	if(r == C) { // FIDE Pawn diagonal
+	  if(board[x + v] != EMPTY && board[x + v] != EDGE)
+	    map[2*(x + v) + start] += one[j];
 	}
 	continue;
       }
       while(r-- > 0) {
         if(board[x+=v] != EMPTY) {
-	  if(board[x] != EDGE) map[2*x + start] += one[j];
+	  mob += dist[x-v-p[i].pos];
+	  if(board[x] != EDGE) map[2*x + start] += one[j], mob += (board[x] ^ start) & 1;
+#if 1
+	  if(p[i].range[j] > X) { // jump capturer
+	    int c = p[i].qval;
+	    if(p[board[x]].qval < c) {
+	      x += v; // go behind directly captured piece, if jumpable
+	      while(p[board[x]].qval < c) { // kludge alert: EDGE has qval = 5, blocking everything
+		if(board[x] != EMPTY) {
+//		  int n = map[2*x + start] & attackMask[j];
+//		  map[2*x + start] += (n < 3*one[j] ? 3*one[j] : one[j]); // first jumper gets 2 extra (to ease incremental update)
+		  map[2*x + start] += one[j]; // for now use true count
+		}
+		x += v;
+	      }
+	    }
+	  }
+#endif
 	  break;
 	}
       }
     }
+    totMob += mob * p[i].mobWeight;
   }
+if(!level) printf("# mobility %d = %d\n", start, totMob);
+  return totMob;
 }
 
 void
 MapFromScratch (int *map)
 {
   int i;
-  for(i=0; i<2*BSIZE; i++) map[i] = 0;
-  MapOneColor(0, last[BLACK], map);
-  MapOneColor(1, last[WHITE], map);
+  for(i=0; i<2*bsize; i++) map[i] = 0;
+  mobilityScore  = MapOneColor(1, last[WHITE], map);
+  mobilityScore -= MapOneColor(0, last[BLACK], map);
 }
 
 void
 Connect (int sqr, int piece, int dir)
-{
-  int x, step = kStep[dir], r1 = p[piece].range[dir], r2 = p[piece].range[dir+1], piece1, piece2;
+{ // scan to both sides along ray to elongate attacks from there, and remove our own attacks on there, if needed
+  int x, step = kStep[dir], r1 = p[piece].range[dir], r2 = p[piece].range[dir+4], r3, r4, piece1, piece2;
   int d1, d2, r, y, c;
 
   if((attacks[2*sqr] + attacks[2*sqr+1]) & attackMask[dir]) {         // there are incoming attack(s) from 'behind'
@@ -840,19 +1126,32 @@ Connect (int sqr, int piece, int dir)
       d2 = dist[y-sqr]; piece2 = board[y];
       attacks[2*y+stm] -= -(d2 <= r1) & one[dir];                     // remove our attack on it if in-range
       // we have two pieces now shooting at each other. See how far they get.
-      if(d1 + d2 <= (r1 = p[piece1].range[dir])) {                    // 1 hits 2
+      if(d1 + d2 <= (r3 = p[piece1].range[dir])) {                    // 1 hits 2
 	attacks[2*y + (piece1 & WHITE)] += one[dir];                  // count attack
 	UPDATE_MOBILITY(piece1, d2);
-      } else UPDATE_MOBILITY(piece1, r1 - d1);                        // does not connect, but could still gain mobility
-      if(d1 + d2 <= (r2 = p[piece2].range[dir])) {                    // 2 hits 1
+      } else UPDATE_MOBILITY(piece1, r3 - d1);                        // does not connect, but could still gain mobility
+      if(d1 + d2 <= (r4 = p[piece2].range[dir+4])) {                  // 2 hits 1
 	attacks[2*x + (piece2 & WHITE)] += one[dir+4];                // count attack
 	UPDATE_MOBILITY(piece2, d1);
-      } else UPDATE_MOBILITY(piece2, r2 - d2);                        // does not connect, but could still gain mobility
+      } else UPDATE_MOBILITY(piece2, r4 - d2);                        // does not connect, but could still gain mobility
+      // if r1 or r2<0, moves typically jump, and thus cannot be unblocked. Exceptions are FF and BS distant moves.
+      // test for d1+d2 > 2 && rN == F && d== 3 or rN == S
+      if(d1 <= 2) { // could be jump interactions
+	if(d1 == 2) {
+	  if(r2 <= J) attacks[2*x + stm] -= one[dir+4];
+	  if(r1 <= J) attacks[2*y + stm] -= one[dir];
+	} else { // d1 == 1
+	  if(r2 < J) attacks[2*x + stm] -= one[dir+4];
+	  if(r1 < J) attacks[2*y + stm] -= one[dir];
+	  if(board[x-step] != EMPTY && board[x-step] != EDGE)
+	    attacks[2*(x-step) + stm] -= one[dir+4];
+	}
+      }
 
     } else { // we were only attacked from behind
 
       r = (r2 = p[piece1].range[dir]) - d1;
-      if(r < 0 || c > one[dir+1]) { // Oops! This was not our attacker, or not the only one. There must be a jump attack from even further behind!
+      if(r < 0 || c > one[dir+4]) { // Oops! This was not our attacker, or not the only one. There must be a jump attack from even further behind!
 	// for now, forget jumpers
       }
       y = sqr; 
@@ -868,7 +1167,7 @@ Connect (int sqr, int piece, int dir)
 	}
       // we hit nothing with the extended move of the attacker behind us.
       UPDATE_MOBILITY(piece1, r2 - d1);
-      r = r1 - r2;                                            // extra squares covered by mover
+      r = r1 - r2 + d1;                                       // extra squares covered by mover
       while(r-- > 0)
 	if(board[y+=step] != EMPTY) {
 	  d2 = dist[y-sqr]; piece2 = board[y];
@@ -878,6 +1177,7 @@ Connect (int sqr, int piece, int dir)
 	  return;
 	}
     }
+    // if r2<0 we should again test for F and S moves
 
   } else // no incoming attack from behind
   if(c = (attacks[2*sqr] + attacks[2*sqr+1]) & attackMask[dir+4]) { // but incoming attack(s) from 'ahead'
@@ -902,7 +1202,7 @@ Connect (int sqr, int piece, int dir)
 	}
       // we hit nothing with the extended move of the attacker behind us.
       UPDATE_MOBILITY(piece2, r2 - d1);
-      r = r2 - r1;                                                  // extra squares covered by mover
+      r = r2 - r1 + d2;                                             // extra squares covered by mover
       while(r-- > 0)
 	if(board[x-=step] != EMPTY) {
 	  d1 = dist[x-sqr]; piece1 = board[x];
@@ -931,25 +1231,64 @@ Connect (int sqr, int piece, int dir)
   }
 }
 
+inline int
+Hit (int r, int d)
+{ // test if move with range r reaches over (un-obstructed) distance d
+  if(r < 0) switch(r) {
+    case J: return (d == 2);
+    case D:
+    case L: return (d <= 2);
+    case T:
+    case F: return (d <= 3);
+    case S: return 1;
+    default: return 0;
+  } else return (d <= r);
+  return 0; // not reached
+}
+
 void
-Disconnect (int sqr, int dir)
+Disconnect (int sqr, int piece, int dir)
 {
-  int x = sqr, step = kStep[dir], piece1, piece2, y;
+  int x = sqr, step = kStep[dir], piece1, piece2, d1, d2, r1, r2, y;
   while( board[x+=step] == EMPTY );
-  if(board[x] != EDGE) { // x has hit a piece
-    piece1 = board[x];
+  piece1 = board[x];
+  if(piece1 != EDGE) { // x has hit a piece
+    d1 = dist[x-sqr];
+    r1 = p[piece1].range[dir+4];
     y = sqr; while( board[y-=step] == EMPTY );
-    if(board[y] != EDGE) { // both ends of the ray hit a piece
-      piece2 = board[y];
-      
+    piece2 = board[y];
+    if(piece2 != EDGE) { // both ends of the ray hit a piece
+      d2 = dist[y-sqr];
+      r2 = p[piece2].range[dir];
+      if(r1 >= d1) {      // piece1 hits us
+	attacks[2*sqr + (piece1 & WHITE)] += one[dir+4];
+	if(r1 >= d1 + d2) // was hitting piece2 before, now blocked
+	  attacks[2*y + (piece1 & WHITE)] -= one[dir+4];
+      }
+      if(r2 >= d2) {      // piece2 hits us
+	attacks[2*sqr + (piece2 & WHITE)] += one[dir];
+	if(r2 >= d1 + d2) // was hitting piece1 before, now blocked
+	  attacks[2*x + (piece2 & WHITE)] -= one[dir];
+      }
+      if( Hit(p[piece].range[dir], d1) )
+	attacks[2*sqr + stm] += one[dir];
+      if( Hit(p[piece].range[dir+4], d2) )
+	attacks[2*sqr + stm] += one[dir+4];
       return;
     }
   } else {
     x = sqr; while( board[x-=step] == EMPTY );
-    if(board[x] == EDGE) return; // ray empty on both sides
+    piece1 = board[x];
+    if(piece1 == EDGE) return; // ray empty on both sides
+    d1 = dist[x-sqr];
+    r1 = p[piece1].range[dir];
+    dir += 4;
   }
-  // we only get here if one side hits a 
-  
+  // we only get here if one side looks to the board edge
+  if(r1 >= d1) // piece1 hits us
+    attacks[2*sqr + (piece1 & WHITE)] += one[dir^4];
+  if( Hit(p[piece].range[dir], d1) )
+    attacks[2*sqr + stm] += one[dir];
 }
 
 void
@@ -957,7 +1296,7 @@ Occupy (int sqr)
 { // determines attacks on square and blocking when a piece lands on an empty square
   int i;
   for(i=0; i<4; i++) {
-    Disconnect(sqr, i);
+    Disconnect(sqr, board[sqr], i);
   }
 }
 
@@ -978,46 +1317,84 @@ MakeMove(Move m, UndoInfo *u)
   u->piece = board[u->from];
   board[u->from] = EMPTY;
   u->booty = 0;
+  u->revMoveCount = cnt50++;
+  u->savKeyL = hashKeyL;
+  u->savKeyH = hashKeyH;
+  u->epVictim[0] = EMPTY;
+
+  if(p[u->piece].promoFlag & LAST_RANK) cnt50 = 0; // forward piece: move is irreversible
+  // TODO: put in some test for forward moves of non-backward pieces?
+
+  if(p[u->piece].value == 10*FVAL) { // move with Fire Demon
+    int i, f=~fireFlags[u->piece-2];
+    for(i=0; i<8; i++) fireBoard[u->from + kStep[i]] &= f; // clear old burn zone
+  }
 
   if(m & (PROMOTE | DEFER)) {
-    if(m & DEFER) {
+    if(m & DEFER) { // essential deferral: inform caller, but nothing special
       deferred = u->to;
       u->new = u->piece;
     } else {
       p[u->piece].pos = ABSENT;
       u->new = p[u->piece].promo;
       u->booty = p[u->new].value - p[u->piece].value;
+      cnt50 = 0; // promotion irreversible
     }
   } else u->new = u->piece;
 
-  u->booty += PST[p[u->new].pst + u->to] - PST[p[u->piece].pst + u->from];
-
   if(u->to >= SPECIAL) { // two-step Lion move
     // take care of first e.p. victim
     u->epSquare = u->from + epList[u->to - SPECIAL]; // decode
-    u->epVictim = board[u->epSquare]; // remember for takeback
+    u->epVictim[0] = board[u->epSquare]; // remember for takeback
     board[u->epSquare] = EMPTY;       // and remove
-    p[u->epVictim].pos = ABSENT;
+    p[u->epVictim[0]].pos = ABSENT;
     // now take care of (optional) second e.p. victim
     u->ep2Square = u->from + ep2List[u->to - SPECIAL]; // This is the (already evacuated) from-square when there is none!
-    u->ep2Victim = board[u->ep2Square]; // remember
+    u->epVictim[1] = board[u->ep2Square]; // remember
     board[u->ep2Square] = EMPTY;        // and remove
-    p[u->ep2Victim].pos = ABSENT;
+    p[u->epVictim[1]].pos = ABSENT;
     // decode the true to-square, and correct difEval and hash key for the e.p. captures
     u->to       = u->from + toList[u->to - SPECIAL];
-    u->booty += p[u->ep2Victim].value + PST[p[u->ep2Victim].pst + u->ep2Square];
-    u->booty += p[u->epVictim].value + PST[p[u->epVictim].pst + u->epSquare];
-    hashKeyL ^= p[u->epVictim].pieceKey * squareKey[u->epSquare];
-    hashKeyH ^= p[u->epVictim].pieceKey * squareKey[u->epSquare+BH];
-    hashKeyL ^= p[u->ep2Victim].pieceKey * squareKey[u->ep2Square];
-    hashKeyH ^= p[u->ep2Victim].pieceKey * squareKey[u->ep2Square+BH];
-    if(p[u->piece].value != 1000 && p[u->epVictim].value == 1000) deferred |= PROMOTE; // flag non-Lion x Lion
-  } else u->epVictim = EMPTY;
+    u->booty += p[u->epVictim[1]].value + PST[p[u->epVictim[1]].pst + u->ep2Square];
+    u->booty += p[u->epVictim[0]].value + PST[p[u->epVictim[0]].pst + u->epSquare];
+    hashKeyL ^= p[u->epVictim[0]].pieceKey * squareKey[u->epSquare];
+    hashKeyH ^= p[u->epVictim[0]].pieceKey * squareKey[u->epSquare+BH];
+    hashKeyL ^= p[u->epVictim[1]].pieceKey * squareKey[u->ep2Square];
+    hashKeyH ^= p[u->epVictim[1]].pieceKey * squareKey[u->ep2Square+BH];
+    if(p[u->piece].value != 10*LVAL && p[u->epVictim[0]].value == 10*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)
+    p[u->piece].pos = ABSENT;          // this is suicide: implement as promotion to EMPTY
+    u->new = EMPTY;
+    u->booty -= p[u->piece].value;
+    cnt50 = 0;
+  } else
+  if(p[u->piece].value == 10*FVAL) { // move with Fire Demon that survives: burn
+    int i, f=fireFlags[u->piece-2];
+    for(i=0; i<8; i++) {
+	int x = u->to + kStep[i], burnVictim = board[x];
+	fireBoard[x] |= f;  // mark new burn zone
+	u->epVictim[i+1] = burnVictim; // remember all neighbors, just in case
+	if(burnVictim != EMPTY && (burnVictim & TYPE) == xstm) { // opponent => actual burn
+	  board[x] = EMPTY; // remove it
+	  p[burnVictim].pos = ABSENT;
+	  u->booty += p[burnVictim].value + PST[p[burnVictim].pst + x];
+	  hashKeyL ^= p[burnVictim].pieceKey * squareKey[x];
+	  hashKeyH ^= p[burnVictim].pieceKey * squareKey[x + BH];
+	  cnt50 = 0; // actually burning something makes the move irreversible
+	}
+    }
+    u->epVictim[0] = EDGE; // kludge to flag to UnMake this is special move
+  }
+
+  u->booty += PST[p[u->new].pst + u->to] - PST[p[u->piece].pst + u->from];
 
   u->victim = board[u->to];
   p[u->victim].pos = ABSENT;
   u->booty += p[u->victim].value + PST[p[u->victim].pst + u->to];
-//  if(p[u->victim].value == 1000 && p[u->piece].value != 1000) deferred |= PROMOTE; // flag non-Lion x Lion
+  if(u->victim != EMPTY) cnt50 = 0; // capture irreversible
 
   p[u->new].pos = u->to;
   board[u->to] = u->new;
@@ -1035,11 +1412,26 @@ MakeMove(Move m, UndoInfo *u)
 void
 UnMake(UndoInfo *u)
 {
-  if(u->epVictim) { // put Lion victim of first leg back
-    p[u->ep2Victim].pos = u->ep2Square;
-    board[u->ep2Square] = u->ep2Victim;
-    p[u->epVictim].pos = u->epSquare;
-    board[u->epSquare] = u->epVictim;
+  if(u->epVictim[0]) { // move with side effects
+    if(u->epVictim[0] == EDGE) { // fire-demon burn
+      int i, f=~fireFlags[u->piece-2];
+      for(i=0; i<8; i++) {
+	int x = u->to + kStep[i];
+	fireBoard[x] &= f;
+	board[x] = u->epVictim[i+1];
+	p[board[x]].pos = x; // even EDGE should have dummy entry in piece list
+      }
+    } else { // put Lion victim of first leg back
+      p[u->epVictim[1]].pos = u->ep2Square;
+      board[u->ep2Square] = u->epVictim[1];
+      p[u->epVictim[0]].pos = u->epSquare;
+      board[u->epSquare] = u->epVictim[0];
+    }
+  }
+
+  if(p[u->piece].value == 10*FVAL) {
+    int i, f=fireFlags[u->piece-2];
+    for(i=0; i<8; i++) fireBoard[u->from + kStep[i]] |= f; // restore old burn zone
   }
 
   p[u->victim].pos = u->to;
@@ -1048,18 +1440,23 @@ UnMake(UndoInfo *u)
   p[u->new].pos = ABSENT; 
   p[u->piece].pos = u->from; // this can be the same as above
   board[u->from] = u->piece;
+
+  cnt50 = u->revMoveCount;
+  hashKeyL = u->savKeyL;
+  hashKeyH = u->savKeyH;
 }
 	
 void
 GenCapts(int sqr, int victimValue)
 { // generate all moves that capture the piece on the given square
   int i, range, att = attacks[2*sqr + stm];
-//printf("GenCapts(%d,%d)\n",sqr,victimValue);
-  for(i=0; i<8; i++) {                             // try all rays
-    int x, v, jumper;
-    if(att & attackMask[i]) {                      // attacked by move in this direction
+//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;
+    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'
+      while( board[x+=v] == EMPTY ); // scan towards source until we encounter a 'stop'
 //printf("stop @ %c%d (dir %d)\n",x%BW+'a',x/BW,i);
       if((board[x] & TYPE) == stm) {               // stop is ours
 	int attacker = board[x], d = dist[x-sqr], r = p[attacker].range[i];
@@ -1067,14 +1464,24 @@ GenCapts(int sqr, int victimValue)
 	if(r >= d || r < L && (d > 3 && r == S || d == 3 && r >= S)) { // it has a plain move in our direction that hits us
 	  NewCapture(x, sqr + victimValue - SORTKEY(attacker), p[attacker].promoFlag);
 	  att -= one[i];
-	  if(!(att & attackMask[i])) continue;
-	} else if(r < 0) goto lions; // test for special-move attacks by thiis stop
+	  if(!(att & attackMask[i])) continue; // no more; next direction
+	  jcapt = p[board[x]].qval;   // jump-capturer hierarchy
+	  while(board[x+=v] == EMPTY);// one attack accounted for, but more to come, so skip to next stop
+	}
       }
-      // we get here when the first stop on the ray is an opponent, or a normal mover which did not range fare enough
-      while(board[x+=v] == EMPTY);   // next stop
-    lions:
-      if((board[x] & TYPE) == stm) {     // second stop is ours
+      // we get here when we are on a piece that dous not attack us through a (limited) ranging move,
+      // it can be our own or an enemy with not (enough) range, or which is blocked
+      do {
+//printf("scan %x-%x (%d) dir=%d d=%d r=%d att=%o jcapt=%d qval=%d\n", sqr, x, board[x], i, dist[x-sqr], p[board[x]].range[i], att, jcapt, p[board[x]].qval);
+      if((board[x] & TYPE) == stm) {   // stop is ours
 	int attacker = board[x], d = dist[x-sqr], r = p[attacker].range[i];
+	if(jcapt < p[attacker].qval) { // it is a range jumper that jumps over the barrier
+	  if(p[attacker].range[i] > 1) { // assumes all jump-captures are infinite range
+	    NewCapture(x, sqr, p[attacker].promoFlag);
+	    att -= one[i];
+	  }
+//if(board[x] == EDGE) { printf("edge hit %x-%x dir=%d att=%o\n", sqr, x, i, att); continue; }
+	} else
 	if(r < 0) { // stop has non-standard moves
 	  switch(p[attacker].range[i]) { // figure out what he can do (including multi-captures, which causes the complexity)
 	    case F: // Lion power + 3-step (as in FF)
@@ -1093,6 +1500,7 @@ GenCapts(int sqr, int victimValue)
 		    NewCapture(x, SPECIAL + 8*(i-1&7) + (i+1&7) + victimValue - SORTKEY(attacker), p[attacker].promoFlag);
 		  v = kStep[i+1];
 		  if((board[x+v] & TYPE) == xstm && board[x+v] > board[sqr])
+
 		    NewCapture(x, SPECIAL + 8*(i+1&7) + (i-1&7) + victimValue - SORTKEY(attacker), p[attacker].promoFlag);
 		}
 	      } else { // primary victim on first ring
@@ -1126,12 +1534,20 @@ GenCapts(int sqr, int victimValue)
 	      if(d != 2) break;
 	      NewCapture(x, sqr + victimValue - SORTKEY(attacker), p[attacker].promoFlag);
 	      att -= one[i];
+	      break;
+	    case C: // FIDE Pawn
+	      if(d != 1) break;
+	      NewCapture(x, sqr + victimValue - SORTKEY(attacker), p[attacker].promoFlag);
+	      att -= one[i];
 	  }
 	}
 //printf("mask[%d] = %o\n", i, att);
-	if((att & attackMask[i]) == 0) continue; // no other attackers, so done with this direction
+	if((att & attackMask[i]) == 0) break;
       }
-      // now we get to the hairy part: there are other attackers than the stop, apparently jumping over it
+      // more attacks to come; san for next stop
+      if(jcapt < p[board[x]].qval) jcapt = p[board[x]].qval; // raise barrier for range jumpers further upstream
+      while(board[x+=v] == EMPTY); // this should never run off-board, if the attack map is not corrupted
+      } while(1);
     }
   }
   // off-ray attacks
@@ -1139,7 +1555,7 @@ GenCapts(int sqr, int victimValue)
     for(i=0; i<8; i++) {    // scan all knight jumps to locate source
       int x = sqr - nStep[i], attacker = board[x];
       if(attacker == EMPTY || (attacker & TYPE) != stm) continue;
-      if(p[attacker].range[i] <= N && p[attacker].range[i] >= S) { // has Knight jump in our direction
+      if(p[attacker].range[i] <= L && p[attacker].range[i] >= S || p[attacker].range[i] == N) { // has Knight jump in our direction
 	NewCapture(x, sqr + victimValue, p[attacker].promoFlag);   // plain jump (as in N)
 	if(p[attacker].range[i] < N) { // Lion power; generate double captures over two possible intermediates
 	  int v = kStep[i]; // leftish path
@@ -1157,20 +1573,34 @@ GenCapts(int sqr, int victimValue)
 int
 Evaluate ()
 {
-  return 0;
+  return (stm ? mobilityScore : -mobilityScore);
 }
 
-int flag;
+inline void
+FireSet (UndoInfo *tb)
+{ // set fireFlags acording to remaining presene of Fire Demons
+  int i;
+  for(i=stm+2; p[i].value == 10*FVAL; i++) // Fire Demons are always leading pieces in list
+    if(p[i].pos != ABSENT) tb->fireMask |= fireFlags[i-2];
+}
+
+void TerminationCheck();
+
+#define QSdepth 0
 
 int
 Search (int alpha, int beta, int difEval, int depth, int oldPromo, int promoSuppress)
 {
   int i, j, k, firstMove, oldMSP = msp, curMove, sorted, bad, phase, king, iterDep, replyDep, nextVictim, to, defer, dubious, bestMoveNr;
-  int savHashL = hashKeyL, savHashH = hashKeyH;
-  int score, bestScore, curEval;
+  int resDep;
+  int myPV = pvPtr;
+  int score, bestScore, oldBest, curEval, iterAlpha;
   Move move, nullMove;
   UndoInfo tb;
-if(PATH) printf("search(%d) %d-%d eval=%d, stm=%d\n",depth,alpha,beta,difEval,stm),fflush(stdout);
+#ifdef HASH
+  Move hashMove; int index, nr, hit;
+#endif
+if(PATH) /*pboard(board),pmap(attacks, BLACK),*/printf("search(%d) {%d,%d} eval=%d, stm=%d\n",depth,alpha,beta,difEval,stm),fflush(stdout);
   xstm = stm ^ WHITE;
 //printf("map made\n");fflush(stdout);
   // KING CAPTURE
@@ -1189,11 +1619,32 @@ if(PATH) printf("search(%d) %d-%d eval=%d, stm=%d\n",depth,alpha,beta,difEval,st
   alpha -= (alpha < curEval);
   beta  -= (beta <= curEval);
 
-  firstMove = curMove = sorted = nonCapts = msp += 20; // leave 20 empty slots in front of move list
-  phase = 0; iterDep=1; replyDep = (depth < 1 ? depth : 1) - 1;
-  do {
+  if(!(nodes++ & 4095)) TerminationCheck();
+  pv[pvPtr++] = 0; // start empty PV, directly behind PV of parent
+
+
+  firstMove = curMove = sorted = msp += 50; // leave 50 empty slots in front of move list
+  iterDep = 0; tb.fireMask = phase = 0;
+
+#ifdef HASH
+  index = hashKeyL & hashMask; nr = hashKeyL >> 30; hit = -1;
+  if(hashTable[index].lock[nr] == hashKeyH) hit = nr; else
+  if(hashTable[index].lock[4]  == hashKeyH) hit = 4;
+  if(hit >= 0) {
+    bestScore = hashTable[index].score[hit];
+    if((bestScore <= alpha || hashTable[index].flag[hit] & H_LOWER) &&
+       (bestScore >= beta  || hashTable[index].flag[hit] & H_UPPER)   ) {
+      iterDep = hashTable[index].depth[hit];
+    }
+  } else { // decide on replacement
+    if(depth >= hashTable[index].depth[nr]) hit = nr; else hit = 4;
+  }
+#endif
+
+  replyDep = (depth < 1 ? depth-1 : iterDep);
+  while(++iterDep <= depth || iterDep == 1) {
 if(flag && depth>= 0) printf("iter %d:%d\n", depth,iterDep),fflush(stdout);
-    bestScore = -INF; bestMoveNr = 0;
+    iterAlpha = alpha; bestScore = -INF; bestMoveNr = 0; resDep = 60;
     for(curMove = firstMove; ; curMove++) { // loop over moves
 if(flag && depth>= 0) printf("phase=%d: first/curr/last = %d / %d / %d\n", phase, firstMove, curMove, msp);fflush(stdout);
       // MOVE SOURCE
@@ -1201,39 +1652,57 @@ if(flag && depth>= 0) printf("phase=%d: first/curr/last = %d / %d / %d\n", phase
 	switch(phase) {
 	  case 0: // null move
 	    if(depth <= 0) {
-	      bestScore = curEval;
+	      bestScore = curEval; resDep = QSdepth;
 	      if(bestScore >= beta || depth < -1) goto cutoff;
 	    }
-#if 0
-	    if(curEval >= beta) {
+#ifdef NULLMOVE
+	    else if(curEval >= beta) {
 	      stm ^= WHITE;
-	      score = -Search(-beta, -alpha, difEval, depth-3, promoSuppress & SQUARE, ABSENT);
+	      score = -Search(-beta, 1-beta, -difEval, depth > 3 ? depth-3 : 0, promoSuppress & SQUARE, ABSENT);
 	      stm ^= WHITE;
-	      if(score >= beta) { msp = oldMSP; return score + (score < curEval); }
+	      if(score >= beta) { msp = oldMSP; retDep += 3; return score + (score < curEval); }
 	    }
 #endif
+	    if(tenFlag) FireSet(&tb); // in tenjiku we must identify opposing Fire Demons to perform any moves
+//if(PATH) printf("mask=%x\n",tb.fireMask),pbytes(fireBoard);
 	    phase = 1;
 	  case 1: // hash move
+#ifdef HASH
+	    if(hashMove) {
+	      moveStack[sorted = msp++] = hashMove;
+	      goto extractMove;
+	    }
+#endif
 	    phase = 2;
 	  case 2: // capture-gen init
 	    nextVictim = xstm;
 	    phase = 3;
 	  case 3: // generate captures
-	    while(nextVictim < last[xstm]) {           // more victims exist
+if(PATH) printf("%d:%2d:%2d next victim %d/%d\n",level,depth,iterDep,curMove,msp);
+	    while(nextVictim < last[xstm]) {          // more victims exist
 	      int group, to = p[nextVictim += 2].pos; // take next
 	      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(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 msp=%d\n",level,depth,iterDep,msp);
 	      while(nextVictim < last[xstm] && p[nextVictim+2].value == group) { // more victims of same value exist
 		to = p[nextVictim += 2].pos;          // take next
 		if(to == ABSENT) continue;            // ignore if absent
 		if(!attacks[2*to + stm]) continue;    // skip if not attacked
+if(PATH) printf("%d:%2d:%2d p=%d, to=%c%d\n",level,depth,iterDep,nextVictim,to%BW+'a',to/BW+ONE);
 		GenCapts(to, 0);
+if(PATH) printf("%d:%2d:%2d msp=%d\n",level,depth,iterDep,msp);
 	      }
 //printf("captures on %d generated, msp=%d\n", nextVictim, msp);
 	      goto extractMove;
 	    }
+//	    if(currentVariant == V_CHESS && promoSuppress != ABSENT) { // e.p.
+//		int n = board[promoSuppress-1];
+//		if( n != EMPTY && (n&TYPE) == xstm && p[n].value == 8 ) 
+//	    }
 	    phase = 4; // out of victims: all captures generated
 	  case 4: // dubious captures
 #if 0
@@ -1243,15 +1712,29 @@ if(flag && depth>= 0) printf("phase=%d: first/curr/last = %d / %d / %d\n", phase
 #endif
 	    phase = 5;
 	  case 5: // killers
-	    if(depth <= 0) goto cutoff;
+	    if(depth <= QSdepth) { resDep = QSdepth; goto cutoff; }
 	    phase = 6;
 	  case 6: // non-captures
+	    nonCapts = msp;
 	    nullMove = GenNonCapts(oldPromo);
+#ifdef KILLERS
+	    { // swap killers to front
+	      Move h = killer[level][0]; int j = curMove;
+	      for(i=curMove; i<msp; i++) if(moveStack[i] == h) { moveStack[i] = moveStack[j]; moveStack[j++] = h; break; }
+	      h = killer[level][1];
+	      for(i=curMove; i<msp; i++) if(moveStack[i] == h) { moveStack[i] = moveStack[j]; moveStack[j++] = h; break; }
+	    }
+#endif
 	    phase = 7;
 	    sorted = msp; // do not sort noncapts
 	    break;
 	  case 7: // bad captures
 	  case 8: // PV null move
+	    phase = 9;
+	    if(nullMove != ABSENT) {
+	      moveStack[msp++] = nullMove + (nullMove << SQLEN) | DEFER; // kludge: setting DEFER guarantees != 0, and has no effect
+	    }
+//printf("# %d. sqr = %08x null = %08x\n", msp, nullMove, moveStack[msp-1]);
 	  case 9:
 	    goto cutoff;
 	}
@@ -1260,7 +1743,7 @@ if(flag && depth>= 0) printf("phase=%d: first/curr/last = %d / %d / %d\n", phase
       // MOVE EXTRACTION
     extractMove:
 if(flag & depth >= 0) printf("%2d:%d extract %d/%d\n", depth, iterDep, curMove, msp);
-      if(curMove < sorted) {
+      if(curMove > sorted) {
 	move = moveStack[sorted=j=curMove];
 	for(i=curMove+1; i<msp; i++)
 	  if(moveStack[i] > move) move = moveStack[j=i]; // search move with highest priority
@@ -1270,44 +1753,66 @@ if(flag & depth >= 0) printf("%2d:%d extract %d/%d\n", depth, iterDep, curMove,
 	move = moveStack[curMove];
 	if(move == 0) continue; // skip invalidated move
       }
-if(flag & depth >= 0) printf("%2d:%d found %d/%d\n", depth, iterDep, curMove, msp);
+if(flag & depth >= 0) printf("%2d:%d found %d/%d %08x %s\n", depth, iterDep, curMove, msp, moveStack[curMove], MoveToText(moveStack[curMove], 0));
+
       // RECURSION
       stm ^= WHITE;
-      defer = MakeMove(moveStack[curMove], &tb);
-path[level++] = moveStack[curMove];
-attacks += 2*BSIZE;
+      defer = MakeMove(move, &tb);
+
+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) {
+	if(repDraws) { score = 0; goto repetition; }
+	moveStack[curMove] = 0; // erase forbidden move
+	if(!level) repeatMove[repCnt++] = move & 0xFFFFFF; // remember outlawed move
+	score = -INF; moveStack[curMove] = 0; goto repetition;
+      }
+      repStack[level+200] = hashKeyH;
+
+if(PATH) printf("%d:%2d:%d %3d %6x %-10s %6d %6d\n", level, depth, iterDep, curMove, moveStack[curMove], MoveToText(moveStack[curMove], 0), score, bestScore);
+path[level++] = move;
+attacks += 2*bsize;
 MapFromScratch(attacks); // for as long as incremental update does not work.
-if(PATH) pmap(attacks, stm);
-      if(chuFlag && p[tb.victim].value == 1000) {    // verify legality of Lion capture in Chu Shogi
+//if(flag & depth >= 0) printf("%2d:%d mapped %d/%d %s\n", depth, iterDep, curMove, msp, MoveToText(moveStack[curMove], 0));
+//if(PATH) pmap(attacks, stm);
+      if(chuFlag && p[tb.victim].value == 10*LVAL) {// verify legality of Lion capture in Chu Shogi
 	score = 0;
-	if(p[tb.piece].value == 1000) {              // Ln x Ln: can make Ln 'vulnarable' (if distant and not through intemediate > GB)
-	  if(dist[tb.from-tb.to] != 1 && attacks[2*tb.to + stm] && p[tb.epVictim].value <= 50)
+	if(p[tb.piece].value == 10*LVAL) {          // Ln x Ln: can make Ln 'vulnerable' (if distant and not through intemediate > GB)
+	  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
 	  defer |= PROMOTE;                         // if we started, flag  he cannot do it in reply
 	}
-        if(score == -INF) { moveStack[curMove] = 0; goto abortMove; }
+        if(score == -INF) {
+          if(level == 1) repeatMove[repCnt++] = move & 0xFFFFFF | (p[tb.piece].value == 10*LVAL ? 3<<24 : 1 << 24);
+          moveStack[curMove] = 0; // zap illegal moves
+          goto abortMove;
+        }
       }
 #if 1
-      score = -Search(-beta, -alpha, -difEval - tb.booty, replyDep, promoSuppress & ~PROMOTE, defer);
+      score = -Search(-beta, -iterAlpha, -difEval - tb.booty, replyDep, promoSuppress & ~PROMOTE, defer);
 #else
       score = 0;
 #endif
     abortMove:
-attacks -= 2*BSIZE;
+attacks -= 2*bsize;
 level--;
+    repetition:
       UnMake(&tb);
-      hashKeyL = savHashL;
-      hashKeyH = savHashH;
       xstm = stm; stm ^= WHITE;
+      if(abortFlag > 0) { // unwind search
+printf("# abort (%d) @ %d\n", abortFlag, level);
+        if(curMove == firstMove) bestScore = oldBest, bestMoveNr = firstMove; // none searched yet
+        goto leave;
+      }
 #if 1
 if(PATH) printf("%d:%2d:%d %3d %6x %-10s %6d %6d\n", level, depth, iterDep, curMove, moveStack[curMove], MoveToText(moveStack[curMove], 0), score, bestScore);
+
       // ALPHA-BETA STUFF
       if(score > bestScore) {
 	bestScore = score; bestMoveNr = curMove;
-	if(score > alpha) {
-	  alpha = score;
+	if(score > iterAlpha) {
+	  iterAlpha = score;
 	  if(curMove < firstMove + 5) { // if not too much work, sort move to front
 	    int i;
 	    for(i=curMove; i>firstMove; i--) {
@@ -1320,22 +1825,58 @@ if(PATH) printf("%d:%2d:%d %3d %6x %-10s %6d %6d\n", level, depth, iterDep, curM
 	  }
 	  bestMoveNr = firstMove;
 	  if(score >= beta) { // beta cutoff
-	    // update killer
+#ifdef KILLERS
+	    if(iterDep == depth && move != killer[level][0]) {
+	      // update killer
+	      killer[level][1] = killer[level][0]; killer[level][0] = move;
+	    }
+#endif
+	    resDep = retDep;
 	    goto cutoff;
 	  }
+	  { int i=pvPtr;
+	    for(pvPtr = myPV+1; pv[pvPtr++] = pv[i++]; ); // copy daughter PV
+	    pv[myPV] = move;                              // behind our move (pvPtr left at end of copy)
+	  }
 	}
 
       }
+      if(retDep < resDep) resDep = retDep;
 #endif
     } // next move
   cutoff:
+    if(!level) { // root node
+      if(postThinking > 0) {
+        int i;   // WB thinking output
+	printf("%d %d %d %d", iterDep, bestScore, (GetTickCount() - startTime)/10, nodes);
+	for(i=0; pv[i]; i++) printf(" %s", MoveToText(pv[i], 0));
+        if(iterDep == 1) printf(" { root eval = %4.2f dif = %4.2f; abs = %4.2f}", curEval/100., difEval/100., PSTest()/100.);
+	printf("\n");
+        fflush(stdout);
+      }
+printf("# s=%d t=%d 1=%d 3=%d f=%d\n",startTime,GetTickCount(),tlim1,tlim3,abortFlag);
+      if(!(abortFlag & 1) && GetTickCount() - startTime > tlim1) break; // do not start iteration we can (most likely) not finish
+    }
     replyDep = iterDep;
-  } while(++iterDep <= depth); // next depth
+#ifdef HASH
+    // hash store
+    hashTable[index].lock[hit]  = hashKeyH;
+    hashTable[index].depth[hit] = iterDep;
+    hashTable[index].flag[hit]  = (bestScore < beta) * H_UPPER;
+    if(bestScore > alpha) {
+      hashTable[index].flag[hit] |= H_LOWER;
+      hashTable[index].move[hit]  = bestMoveNr ? moveStack[bestMoveNr] : 0;
+    } else hashTable[index].move[hit] = 0;
+#endif
+  } // next depth
+leave:
   retMSP = msp;
   retFirst = firstMove;
-  msp = oldMSP;
+  msp = oldMSP; // pop move list
+  pvPtr = myPV; // pop PV
   retMove = bestMoveNr ? moveStack[bestMoveNr] : 0;
-if(flag && depth >= 0) printf("return %d: %d %d\n", depth, bestScore, curEval);
+  retDep = resDep + 1;
+if(PATH) printf("return %d: %d %d\n", depth, bestScore, curEval);
   return bestScore + (bestScore < curEval);
 }
 
@@ -1344,9 +1885,9 @@ pplist()
 {
   int i, j;
   for(i=0; i<182; i++) {
-	printf("%3d. %3d %3d %4d   %02x   ", i, p[i].value, p[i].promo, p[i].pos, p[i].promoFlag&255);
+	printf("%3d. %3d %3d %4d   %02x %d  ", i, p[i].value, p[i].promo, p[i].pos, p[i].promoFlag&255, p[i].qval);
 	for(j=0; j<8; j++) printf("  %2d", p[i].range[j]);
-	printf("\n");
+	if(i<2 || i>11) printf("\n"); else printf("  %02x\n", fireFlags[i-2]&255);
   }
   printf("last: %d / %d\nroyal %d / %d\n", last[WHITE], last[BLACK], royal[WHITE], royal[BLACK]);
 }
@@ -1410,15 +1951,12 @@ pmoves(int start, int end)
     #define INVALID 0
 
     // some parameter of your engine
-    #define MAXMOVES 500  /* maximum game length  */
-    #define MAXPLY   60   /* maximum search depth */
+    #define MAXMOVES 2000 /* maximum game length  */
+    #define MAXPLY   20   /* maximum search depth */
 
     #define OFF 0
     #define ON  1
 
-#define ONE 0
-#define DEFAULT_FEN ""
-
 typedef Move MOVE;
 
     int moveNr;              // part of game state; incremented by MakeMove
@@ -1431,7 +1969,7 @@ typedef Move MOVE;
     void SetMemorySize(int n);              // if n is different from last time, resize all tables to make memory usage below n MB
     char *MoveToText(MOVE move, int m);     // converts the move from your internal format to text like e2e2, e1g1, a7a8q.
     MOVE ParseMove(char *moveText);         // converts a long-algebraic text move to your internal move format
-    int  SearchBestMove(int stm, int timeLeft, int mps, int timeControl, int inc, int timePerMove, MOVE *move, MOVE *ponderMove);
+    int  SearchBestMove(MOVE *move, MOVE *ponderMove);
     void PonderUntilInput(int stm);         // Search current position for stm, deepening forever until there is input.
 
 UndoInfo undoInfo;
@@ -1441,29 +1979,96 @@ int lastLift, lastPut;
 int
 MakeMove2 (int stm, MOVE move)
 {
+  int i;
+  FireSet(&undoInfo);
   sup0 = sup1; sup1 = sup2;
   sup2 = MakeMove(move, &undoInfo);
+  if(chuFlag && p[undoInfo.victim].value == 10*LVAL && p[undoInfo.piece].value != 10*LVAL) sup2 |= PROMOTE;
+  rootEval = -rootEval - undoInfo.booty;
+  for(i=0; i<200; i++) repStack[i] = repStack[i+1];
+  repStack[199] = hashKeyH;
+printf("# makemove %08x %c%d %c%d\n", move, sup1%BW+'a', sup1/BW, sup2%BW+'a', sup2/BW);
   return stm ^ WHITE;
 }
 
 void
 UnMake2 (MOVE move)
 {
+  int i;
+  rootEval = -rootEval - undoInfo.booty;
   UnMake(&undoInfo);
+  for(i=200; i>0; i--) repStack[i] = repStack[i-1];
   sup2 = sup1; sup1 = sup0;
 }
 
+char fenNames[] = "RV....DKDEFL..DHGB......SMLNKN..FK....BT..VM..PH...."; // pairs of char
+char fenPromo[] = "WLDHSMSECPB R HFDE....WHFB..LNG ..DKVMFS..FO..FK...."; // pairs of char
+
+char *
+Convert (char *fen)
+{
+  char *p = fenArray, *q, *rows[36], tmp[4000];
+  int n=0;
+  printf("# convert FEN '%s'\n", fen);
+  q = strchr(fen, ' '); if(q) *q = 0; q = fen;
+  do { rows[n++] = q; q = strchr(q, '/'); if(!q) break; *q++ = 0; } while(1);
+  *tmp = 0;
+  while(--n >= 0) { strcat(tmp, rows[n]); if(n) strcat(tmp, "/"); }
+  fen = tmp;
+  printf("# flipped FEN '%s'\n", fen);
+  while(*fen) {
+    if(*fen == ' ') { *p = 0; break; }
+    if(n=atoi(fen)) fen++; // digits read
+    if(n > 9) fen++; // double digit
+    while(n-- > 0) *p++ = '.'; // expand to empty squares
+    if(isalpha(*fen)) {
+      char *table = fenNames;
+      n = *fen > 'Z' ? 'a' - 'A' : 0;
+      if((currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK) && *fen - n == 'N' // In Chess N is Knight, not Lion
+           || table[2* (*fen - 'A' - n)] == '.') *p++ = *fen; else {
+        *p++ = ':';
+        *p++ = table[2* (*fen - 'A' - n)] + n;
+        *p++ = table[2* (*fen - 'A' - n)+1] + n;
+      }
+    } else *p++ = *fen;
+    fen++;
+  }
+  printf("# converted FEN '%s'\n", fenArray);
+  return fenArray;
+}
+
 int
 Setup2 (char *fen)
 {
-  SetUp(chuArray, chuPieces);
+  int stm = WHITE;
+  if(fen) {
+    char *q = strchr(fen, '\n');
+    if(q) *q = 0;
+    if(q = strchr(fen, ' ')) stm = (q[1] == 'b' ? BLACK : WHITE); // fen contains color field
+    if(strchr(fen, '.') || strchr(fen, ':')) array = fen; else array = Convert(fen);
+  }
+  SetUp(array, currentVariant);
   sup0 = sup1 = sup2 = ABSENT;
-  return WHITE;
+  rootEval = cnt50 = hashKeyH = hashKeyL = moveNr = 0;
+  return stm;
 }
 
 void
 SetMemorySize (int n)
 {
+#ifdef HASH
+  static HashBucket *realHash;
+  static int oldSize;
+  int m = 1;
+  intptr_t l;
+  if(n != oldSize) {
+    if(oldSize) free(realHash);
+    while(m*sizeof(HashBucket) <= n*512) m <<= 1;
+    m *= 1024; hashMask = m - 1;
+    realHash = calloc(m + 1, sizeof(HashBucket));
+    l = (intptr_t) realHash; hashTable = (HashBucket*) (l & ~63); // align with cache line
+  }
+#endif
 }
 
 char *
@@ -1471,6 +2076,8 @@ MoveToText (MOVE move, int multiLine)
 {
   static char buf[50];
   int f = move>>SQLEN & SQUARE, g = f, t = move & SQUARE;
+  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!)
     int e = f + epList[t - SPECIAL];
@@ -1485,7 +2092,8 @@ MoveToText (MOVE move, int multiLine)
     }
     t = g + toList[t - SPECIAL];
   }
-  sprintf(buf+strlen(buf), "%c%d%c%d%s", f%BW+'a', f/BW+ONE, t%BW+'a', t/BW+ONE, move & PROMOTE ? "+" : "");
+  if(move & PROMOTE) promoChar = currentVariant == V_MAKRUK ? "m" : repDraws ? "q" : "+";
+  sprintf(buf+strlen(buf), "%c%d%c%d%s", f%BW+'a', f/BW+ONE, t%BW+'a', t/BW+ONE,  promoChar);
   return buf;
 }
 
@@ -1496,13 +2104,29 @@ ReadSquare (char *p, int *sqr)
   f = p[0] - 'a';
   r = atoi(p + 1) - ONE;
   *sqr = r*BW + f;
-  return 2 + (r > 9);
+  return 2 + (r + ONE > 9);
+}
+
+int listStart, listEnd;
+char boardCopy[BSIZE];
+
+void
+ListMoves ()
+{ // create move list on move stack
+  int i;
+  for(i=0; i< BSIZE; i++) boardCopy[i] = !!board[i];
+MapFromScratch(attacks);
+  postThinking--; repCnt = 0; tlim1 = tlim2 = tlim3 = 1e8; abortFlag = msp = 0;
+  Search(-INF-1, INF+1, 0, 1, sup1 & ~PROMOTE, sup2);
+  postThinking++;
+  listStart = retFirst; listEnd = msp = retMSP;
 }
 
 MOVE
 ParseMove (char *moveText)
 {
   int i, j, f, t, t2, e, ret, deferred=0;
+  char c = moveText[0];
   moveText += ReadSquare(moveText, &f);
   moveText += ReadSquare(moveText, &t); t2 = t;
   if(*moveText == ',') {
@@ -1518,27 +2142,40 @@ ParseMove (char *moveText)
     t2 = SPECIAL + 8*i + j;
   }
   ret = f<<SQLEN | t2;
-  if(*moveText == '+') ret |= PROMOTE;
-MapFromScratch(attacks);
-  Search(-INF-1, INF+1, 0, 1, sup1, sup2);
-  for(i=retFirst; i<retMSP; i++) {
+  if(*moveText != '\n' && *moveText != '=') ret |= PROMOTE;
+printf("# suppress = %c%d\n", sup1%BW+'a', sup1/BW);
+//  ListMoves();
+  for(i=listStart; i<listEnd; i++) {
+    if(moveStack[i] == INVALID) continue;
+    if(c == '@' && (moveStack[i] & SQUARE) == (moveStack[i] >> SQLEN & SQUARE)) break; // any null move matches @@@@
     if((moveStack[i] & (PROMOTE | DEFER-1)) == ret) break;
     if((moveStack[i] & DEFER-1) == ret) deferred = i; // promoted version of entered non-promotion is legal
   }
-  if(i>=retMSP) {  // no exact match
+printf("# moveNr = %d in {%d,%d}\n", i, listStart, listEnd);
+  if(i>=listEnd) { // no exact match
     if(deferred) { // but maybe non-sensical deferral
       int flags = p[board[f]].promoFlag;
+printf("# deferral of %d\n", deferred);
       i = deferred; // in any case we take that move
       if(!(flags & promoBoard[t] & (CANT_DEFER | LAST_RANK))) { // but change it into a deferral if that is allowed
 	moveStack[i] &= ~PROMOTE;
 	if(p[board[f]].value == 40) p[board[f]].promoFlag &= LAST_RANK; else
-	if(!(flags & promoBoard[t])) moveStack[i] |= DEFER; // came from outside zone, so essential deferral
+	if(!(flags & promoBoard[f])) moveStack[i] |= DEFER; // came from outside zone, so essential deferral
       }
     }
-    if(i >= retMSP)
-      for(i=20; i<retMSP; i++) printf("# %d. %08x %08x %s\n", i-20, moveStack[i], ret, MoveToText(moveStack[i], 0));
+    if(i >= listEnd) {
+      for(i=listStart; i<listEnd; i++) printf("# %d. %08x %08x %s\n", i-50, moveStack[i], ret, MoveToText(moveStack[i], 0));
+      reason = NULL;
+      for(i=0; i<repCnt; i++) {if((repeatMove[i] & 0xFFFFFF) == ret) {
+        if(repeatMove[i] & 1<<24) reason = (repeatMove[i] & 1<<25 ? "Distant capture of protected Lion" : "Counterstrike against Lion");
+        else reason = "Repeats earlier position";
+        break;
+      }
+ printf("# %d. %08x %08x %s\n", i, repeatMove[i], ret, MoveToText(repeatMove[i], 0));
+}
+    }
   }
-  return (i >= retMSP ? INVALID : moveStack[i]);
+  return (i >= listEnd ? INVALID : moveStack[i]);
 }
 
 void
@@ -1546,30 +2183,27 @@ Highlight(char *coords)
 {
   int i, j, n, sqr, cnt=0;
   char b[BSIZE], buf[2000], *q;
-  for(i=0; i<BSIZE; i++) b[i] = 0;
+  for(i=0; i<bsize; i++) b[i] = 0;
   ReadSquare(coords, &sqr);
-MapFromScratch(attacks);
-flag=1;
-  Search(-INF-1, INF+1, 0, 1, sup1, sup2);
-flag=0;
-  for(i=retFirst; i<retMSP; i++) {
+//  ListMoves();
+  for(i=listStart; i<listEnd; i++) {
     if(sqr == (moveStack[i]>>SQLEN & SQUARE)) {
       int t = moveStack[i] & SQUARE;
       if(t >= SPECIAL) continue;
-      b[t] = (board[t] == EMPTY ? 'Y' : 'R'); cnt++;
+      b[t] = (!boardCopy[t] ? 'Y' : 'R'); cnt++;
     }
   }
   if(!cnt) { // no moves from given square
     if(sqr != lastPut) return; // refrain from sending empty FEN
     // we lifted a piece for second leg of move
-    for(i=20; i<retMSP; i++) {
+    for(i=listStart; i<listEnd; i++) {
       if(lastLift == (moveStack[i]>>SQLEN & SQUARE)) {
 	int e, t = moveStack[i] & SQUARE;
 	if(t < SPECIAL) continue; // only special moves
 	e = lastLift + epList[t - SPECIAL]; // decode
 	t = lastLift + toList[t - SPECIAL];
 	if(e != sqr) continue;
-	b[t] = (board[t] == EMPTY ? 'Y' : 'R'); cnt++;
+	b[t] = (!boardCopy[t] ? 'Y' : 'R'); cnt++;
       }
     }
     if(!cnt) return;
@@ -1594,33 +2228,50 @@ flag=0;
   printf("highlight %s\n", buf);
 }
 
+int timeLeft;                            // timeleft on engine's clock
+int mps, timeControl, inc, timePerMove;  // time-control parameters, to be used by Search
+char inBuf[8000], command[80], ponderMoveText[20];
+
+void
+SetSearchTimes (int timeLeft)
+{
+  int targetTime, movesLeft = BW*BH/4 + 20;
+  if(mps) movesLeft = mps - (moveNr>>1)%mps;
+  targetTime = (timeLeft - 1000*inc) / (movesLeft + 2) + 1000 * inc;
+  if(moveNr < 30) targetTime *= 0.5 + moveNr/60.; // speedup in opening
+  if(timePerMove > 0) targetTime = 0.5*timeLeft, movesLeft = 1;
+  tlim1 = 0.2*targetTime;
+  tlim2 = 1.9*targetTime;
+  tlim3 = 5*timeLeft / (movesLeft + 4.1);
+}
+
 int
-SearchBestMove (int stm, int timeLeft, int mps, int timeControl, int inc, int timePerMove, MOVE *move, MOVE *ponderMove)
+SearchBestMove (MOVE *move, MOVE *ponderMove)
 {
   int score;
+  startTime = GetTickCount();
+  nodes = 0;
 MapFromScratch(attacks);
-  score = Search(-INF-1, INF+1, 0, 3, sup1, sup2);
+  retMove = INVALID; repCnt = 0;
+  score = Search(-INF-1, INF+1, rootEval, maxDepth, sup1, sup2);
   *move = retMove;
-  *ponderMove = INVALID;
+  *ponderMove = pv[1];
   return score;
 }
 
+
 void
 PonderUntilInput (int stm)
 {
+MapFromScratch(attacks);
+  repCnt = 0; abortFlag = -1;
+  Search(-INF-1, INF+1, rootEval, maxDepth, sup1, sup2);
 }
-
-    // Some global variables that control your engine's behavior
-    int ponder;
-    int randomize;
-    int postThinking;
-    int resign;         // engine-defined option
-    int contemptFactor; // likewise
-
+ 
     int TakeBack(int n)
     { // reset the game and then replay it to the desired point
       int last, stm;
-      stm = Setup2(NULL);
+      Init(currentVariant); stm = Setup2(NULL);
 printf("# setup done");fflush(stdout);
       last = moveNr - n; if(last < 0) last = 0;
       for(moveNr=0; moveNr<last; moveNr++) stm = MakeMove2(stm, gameMove[moveNr]),printf("make %2d: %x\n", moveNr, gameMove[moveNr]);
@@ -1629,46 +2280,90 @@ printf("# setup done");fflush(stdout);
 
     void PrintResult(int stm, int score)
     {
-      if(score == 0) printf("1/2-1/2\n");
-      if(score > 0 && stm == WHITE || score < 0 && stm == BLACK) printf("1-0\n");
-      else printf("0-1\n");
+      char tail[100];
+      if(reason) sprintf(tail, " {%s}", reason); else *tail = 0;
+      if(score == 0) printf("1/2-1/2%s\n", tail);
+      if(score > 0 && stm == WHITE || score < 0 && stm == BLACK) printf("1-0%s\n", tail);
+      else printf("0-1%s\n", tail);
+    }
+
+    void GetLine(int root)
+    {
+      int i, c;
+      while(1) {
+        // wait for input, and read it until we have collected a complete line
+        for(i = 0; (inBuf[i] = c = getchar()) != '\n'; i++) if(c == EOF || i>7997) exit(0);
+        inBuf[i+1] = 0;
+
+        // extract the first word
+        sscanf(inBuf, "%s", command);
+printf("# in (mode = %d,%d): %s\n", root, abortFlag, command);
+        if(!strcmp(command, "otim"))    { continue; } // do not start pondering after receiving time commands, as move will follow immediately
+        if(!strcmp(command, "time"))    { sscanf(inBuf, "time %d", &timeLeft); continue; }
+        if(!strcmp(command, "put"))     { ReadSquare(inBuf+4, &lastPut); continue; }  // ditto
+        if(!strcmp(command, "."))       { inBuf[0] = 0; return; } // ignore for now
+        if(!strcmp(command, "lift"))    { inBuf[0] = 0; Highlight(inBuf+5); return; } // treat here
+        abortFlag = 1;
+        return;
+      }
+    }
+
+    void
+    TerminationCheck()
+    {
+      if(abortFlag < 0) { // check for input
+        if(InputWaiting()) GetLine(0); // read & examine input command
+      } else {        // check for time
+        if(GetTickCount() - startTime > tlim3) abortFlag = 2;
+      }
     }
 
     main()
     {
       int engineSide=NONE;                     // side played by engine
-      int timeLeft;                            // timeleft on engine's clock
-      int mps, timeControl, inc, timePerMove;  // time-control parameters, to be used by Search
-      int maxDepth;                            // used by search
-      MOVE move, ponderMove;
-      int i, score;
-      char inBuf[80], command[80];
-
-  Init();
-  SetUp(chuArray, chuPieces);
-//  pplist();
-//  pboard(board);
-//  pbytes(promoBoard);
-//  Search(-INF, INF, 0, 1, ABSENT, ABSENT);
-//  pmoves(20, retMSP);
-//MapFromScratch(attacks);
-//  MapOneColor(1, last[WHITE], attacks);
+      MOVE move;
+      int i, score, curVarNr;
+
+  Init(V_CHU); // Chu
+      listEnd = 1;
 
       while(1) { // infinite loop
 
         fflush(stdout);                 // make sure everything is printed before we do something that might take time
+        *inBuf = 0;
+
+        if(listEnd == 0) ListMoves();   // always maintain a list of legal moves in root position
 
+        abortFlag = 0;
         if(stm == engineSide) {         // if it is the engine's turn to move, set it thinking, and let it move
      
-          score = SearchBestMove(stm, timeLeft, mps, timeControl, inc, timePerMove, &move, &ponderMove);
+pboard(board);
+          SetSearchTimes(10*timeLeft);
+          score = SearchBestMove(&move, &ponderMove);
 
           if(move == INVALID) {         // game apparently ended
+            int kcapt = 0, xstm = stm ^ WHITE, king, k = p[king=royal[xstm]].pos;
+            if( k != ABSENT) { // test if King capture possible
+              if(attacks[2*k + stm]) {
+                if( p[king + 2].pos == ABSENT ) kcapt = 1; // we have an attack on his only King
+              }
+            } else { // he has no king! Test for attacks on Crown Prince
+              k = p[king + 2].pos;
+              if(attacks[2*k + stm]) kcapt = 1; // we have attack on Crown Prince
+            }
+            if(kcapt) { // print King capture before claiming
+              GenCapts(k, 0);
+              printf("move %s\n", MoveToText(moveStack[msp-1], 1));
+              reason = "king capture";
+            } else reason = "resign";
             engineSide = NONE;          // so stop playing
             PrintResult(stm, score);
           } else {
             stm = MakeMove2(stm, move);  // assumes MakeMove returns new side to move
             gameMove[moveNr++] = move;  // remember game
             printf("move %s\n", MoveToText(move, 1));
+            listEnd = 0;
+            continue;
           }
         }
 
@@ -1688,24 +2383,14 @@ printf("# setup done");fflush(stdout);
           }
         }
 
-      noPonder:
-        // wait for input, and read it until we have collected a complete line
-        for(i = 0; (inBuf[i] = getchar()) != '\n'; i++);
-        inBuf[i+1] = 0;
-pboard(board);
-pmoves(retFirst, retMSP);
-
-        // extract the first word
-        sscanf(inBuf, "%s", command);
-printf("in: %s\n", command);
+        fflush(stdout);         // make sure everything is printed before we do something that might take time
+        if(!*inBuf) GetLine(1); // takes care of time and otim commands
 
         // recognize the command,and execute it
         if(!strcmp(command, "quit"))    { break; } // breaks out of infinite loop
         if(!strcmp(command, "force"))   { engineSide = NONE;    continue; }
         if(!strcmp(command, "analyze")) { engineSide = ANALYZE; continue; }
         if(!strcmp(command, "exit"))    { engineSide = NONE;    continue; }
-        if(!strcmp(command, "otim"))    { goto noPonder; } // do not start pondering after receiving time commands, as move will follow immediately
-        if(!strcmp(command, "time"))    { sscanf(inBuf, "time %d", &timeLeft); goto noPonder; }
         if(!strcmp(command, "level"))   {
           int min, sec=0;
           sscanf(inBuf, "level %d %d %d", &mps, &min, &inc) == 3 ||  // if this does not work, it must be min:sec format
@@ -1714,9 +2399,9 @@ printf("in: %s\n", command);
           continue;
         }
         if(!strcmp(command, "protover")){
-          printf("feature ping=1 setboard=1 colors=0 usermove=1 memory=1 debug=1\n");
-          printf("feature variants=\"chu,12x12+0_fairy\"\n");
-          printf("feature highlight=1\n");
+          printf("feature ping=1 setboard=1 colors=0 usermove=1 memory=1 debug=1 sigint=0 sigterm=0\n");
+          printf("feature variants=\"normal,shatranj,makruk,chu,dai,tenjiku,12x12+0_fairy,9x9+0_shogi\"\n");
+          printf("feature myname=\"HaChu " VERSION "\" highlight=1\n");
           printf("feature option=\"Resign -check 0\"\n");           // example of an engine-defined option
           printf("feature option=\"Contempt -spin 0 -200 200\"\n"); // and another one
           printf("feature done=1\n");
@@ -1732,44 +2417,60 @@ printf("in: %s\n", command);
         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; }
-        if(!strcmp(command, "new"))     { engineSide = BLACK; stm = Setup2(DEFAULT_FEN); maxDepth = MAXPLY; randomize = OFF; continue; }
-        if(!strcmp(command, "setboard")){ engineSide = NONE;  stm = Setup2(inBuf+9); continue; }
         if(!strcmp(command, "easy"))    { ponder = OFF; continue; }
         if(!strcmp(command, "hard"))    { ponder = ON;  continue; }
-        if(!strcmp(command, "undo"))    { stm = TakeBack(1); continue; }
-        if(!strcmp(command, "remove"))  { stm = TakeBack(2); continue; }
         if(!strcmp(command, "go"))      { engineSide = stm;  continue; }
         if(!strcmp(command, "post"))    { postThinking = ON; continue; }
         if(!strcmp(command, "nopost"))  { postThinking = OFF;continue; }
         if(!strcmp(command, "random"))  { randomize = ON;    continue; }
         if(!strcmp(command, "hint"))    { if(ponderMove != INVALID) printf("Hint: %s\n", MoveToText(ponderMove, 0)); continue; }
-        if(!strcmp(command, "lift"))    { Highlight(inBuf+5); continue; }
-        if(!strcmp(command, "put"))     { ReadSquare(inBuf+4, &lastPut); continue; }
         if(!strcmp(command, "book"))    {  continue; }
-        if(!strcmp(command, "variant")) { continue; }
 	// non-standard commands
         if(!strcmp(command, "p"))       { pboard(board); continue; }
-        if(!strcmp(command, "w"))       { pmap(attacks, WHITE); continue; }
-        if(!strcmp(command, "b"))       { pmap(attacks, BLACK); continue; }
+        if(!strcmp(command, "f"))       { pbytes(fireBoard); continue; }
+        if(!strcmp(command, "w"))       { MapOneColor(WHITE, last[WHITE], attacks); pmap(attacks, WHITE); continue; }
+        if(!strcmp(command, "b"))       { MapOneColor(BLACK, last[BLACK], attacks); pmap(attacks, BLACK); continue; }
+        if(!strcmp(command, "l"))       { pplist(); continue; }
         // ignored commands:
         if(!strcmp(command, "xboard"))  { continue; }
-        if(!strcmp(command, "computer")){ continue; }
+        if(!strcmp(command, "computer")){ comp = 1; continue; }
         if(!strcmp(command, "name"))    { continue; }
         if(!strcmp(command, "ics"))     { continue; }
         if(!strcmp(command, "accepted")){ continue; }
         if(!strcmp(command, "rejected")){ continue; }
-        if(!strcmp(command, "hover"))   {  continue; }
+        if(!strcmp(command, "result"))  { continue; }
+        if(!strcmp(command, "hover"))   { continue; }
         if(!strcmp(command, ""))  {  continue; }
         if(!strcmp(command, "usermove")){
           int move = ParseMove(inBuf+9);
-          if(move == INVALID) printf("Illegal move\n");
-          else {
+pboard(board);
+          if(move == INVALID) {
+            if(reason) printf("Illegal move {%s}\n", reason); else printf("%s\n", reason="Illegal move");
+            if(comp) PrintResult(stm, -INF); // against computer: claim
+          } else {
             stm = MakeMove2(stm, move);
-            ponderMove = INVALID;
+            ponderMove = INVALID; listEnd = 0;
             gameMove[moveNr++] = move;  // remember game
           }
           continue;
         }
+        listEnd = 0;
+        if(!strcmp(command, "new"))     {
+          engineSide = BLACK; Init(V_CHESS); stm = Setup2(NULL); maxDepth = MAXPLY; randomize = OFF; curVarNr = comp = 0;
+          continue;
+        }
+        if(!strcmp(command, "variant")) {
+          for(i=0; i<7; i++) {
+            sscanf(inBuf+8, "%s", command);
+            if(!strcmp(variants[i].name, command)) {
+              Init(curVarNr = i); stm = Setup2(NULL); break;
+            }
+	  }
+          continue;
+        }
+        if(!strcmp(command, "setboard")){ engineSide = NONE;  Init(curVarNr); stm = Setup2(inBuf+9); continue; }
+        if(!strcmp(command, "undo"))    { stm = TakeBack(1); continue; }
+        if(!strcmp(command, "remove"))  { stm = TakeBack(2); continue; }
         printf("Error: unknown command\n");
       }
     }