WebSVN – Games.Chess Giants – Diff – /engine-crafty/option.c

 #if defined(UNIX)
 #  include <unistd.h>
 #  include <signal.h>
 #endif
 #include "epdglue.h"
-/* last modified 02/26/14 */
+/* last modified 01/16/15 */
 /*
  *******************************************************************************
  *                                                                             *
  *   Option() is used to handle user input necessary to control/customize the  *
  *   program.  It performs all functions excepting chess move input which is   *
  *   handled by main().                                                        *
  *                                                                             *
  *******************************************************************************
  */
 int Option(TREE * RESTRICT tree) {
+  int v;
 /*
  ************************************************************
  *                                                          *
  *  parse the input.  If it looks like a FEN string, don't  *
  *  parse using "/" as a separator, otherwise do.           *
   if (initialized) {
     if (EGCommandCheck(buffer)) {
       if (thinking || pondering)
         return 2;
       else {
-        (void) EGCommand(buffer);
+        EGCommand(buffer);
         return 1;
+      }
+    }
+  }
 #endif
  *  machine, probably something that is not wanted.         *
  *                                                          *
  ************************************************************
  */
   if (buffer[0] == '!') {
-    if (!xboard)
+    if (!xboard) {
-      system(strchr(buffer, '!') + 1);
+      v = system(strchr(buffer, '!') + 1);
+      if (v != 0)
+        perror("Option() system() error: ");
+    }
+  }
 /*
  ************************************************************
  *                                                          *
  *  "." ignores "." if it happens to get to this point, if  *
     if (nargs != 6) {
       printf("usage:  adaptive NPS hmin hmax pmin pmax\n");
       return 1;
+    }
     if (nargs > 1) {
-      adaptive_hash = (int) atoiKM(args[1]); // Pierre-Marie Baty -- added type cast
+      adaptive_hash = (int) atoiKMB(args[1]); // Pierre-Marie Baty -- added type cast
-      adaptive_hash_min = (size_t) atoiKM(args[2]); // Pierre-Marie Baty -- added type cast
+      adaptive_hash_min = (size_t) atoiKMB(args[2]); // Pierre-Marie Baty -- added type cast
-      adaptive_hash_max = (size_t) atoiKM(args[3]); // Pierre-Marie Baty -- added type cast
+      adaptive_hash_max = (size_t) atoiKMB(args[3]); // Pierre-Marie Baty -- added type cast
-      adaptive_hashp_min = (size_t) atoiKM(args[4]); // Pierre-Marie Baty -- added type cast
+      adaptive_hashp_min = (size_t) atoiKMB(args[4]); // Pierre-Marie Baty -- added type cast
-      adaptive_hashp_max = (size_t) atoiKM(args[5]); // Pierre-Marie Baty -- added type cast
+      adaptive_hashp_max = (size_t) atoiKMB(args[5]); // Pierre-Marie Baty -- added type cast
+    }
-    Print(128, "adaptive estimated NPS =  %s\n", PrintKM(adaptive_hash, 1));
+    Print(32, "adaptive estimated NPS =  %s\n", DisplayKMB(adaptive_hash, 1));
-    Print(128, "adaptive minimum hsize =  %s\n", PrintKM(adaptive_hash_min,
+    Print(32, "adaptive minimum hsize =  %s\n", DisplayKMB(adaptive_hash_min,
 ));
-    Print(128, "adaptive maximum hsize =  %s\n", PrintKM(adaptive_hash_max,
+    Print(32, "adaptive maximum hsize =  %s\n", DisplayKMB(adaptive_hash_max,
 ));
-    Print(128, "adaptive minimum psize =  %s\n", PrintKM(adaptive_hashp_min,
+    Print(32, "adaptive minimum psize =  %s\n", DisplayKMB(adaptive_hashp_min,
 ));
-    Print(128, "adaptive maximum psize =  %s\n", PrintKM(adaptive_hashp_max,
+    Print(32, "adaptive maximum psize =  %s\n", DisplayKMB(adaptive_hashp_max,
 ));
+  }
 /*
  ************************************************************
  *                                                          *
   else if (OptionMatch("annotate", *args) || OptionMatch("annotateh", *args)
       || OptionMatch("annotatet", *args)) {
     if (thinking || pondering)
       return 2;
     Annotate();
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  "autotune" command is used to automatically tune the    *
+ *  SMP search parameters that affect search efficiency.    *
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("autotune", *args)) {
+    if (thinking || pondering)
+      return 2;
+    AutoTune(nargs, args);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "batch" command disables asynchronous I/O so that a     *
     return xboard;
+  }
 /*
  ************************************************************
  *                                                          *
- *  "bench" runs internal performance benchmark             *
+ *  "bench" runs internal performance benchmark.  An        *
+ *  optional second argument can increase or decrease the   *
+ *  time it takes.  "bench 1" increases the default depth   *
+ *  by one ply, and "bench -1" reduces the depth to speed   *
+ *  it up.                                                  *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("bench", *args)) {
+    int mod = 0, time;
-    Bench(0);
+    if (nargs > 1)
-  } else if (OptionMatch("bench1", *args) || OptionMatch("bench-1", *args)) {
+      mod = atoi(args[1]);
-    Bench(-1);
+    time = Bench(mod, 0);
-  } else if (OptionMatch("bench2", *args) || OptionMatch("bench-2", *args)) {
+    Print(32, "time used = %s\n", DisplayTime(time));
-    Bench(-2);
+  }
+/*
+ ***************************************************************
+ *                                                             *
+ *  "pgo" runs an internal performance benchmark used for PGO. *
-  } else if (OptionMatch("bench3", *args) || OptionMatch("bench-3", *args)) {
+ *  An optional second argument can increase or decrease       *
-    Bench(-3);
+ *  the time it takes.  "pgo 1" increases the default          *
-  } else if (OptionMatch("bench+1", *args)) {
+ *  by one ply, and "pgo -1" reduces the depth to speed        *
+ *  it up.                                                     *
+ *                                                             *
+ ************************************************************
-    Bench(1);
+         */
-  } else if (OptionMatch("bench+2", *args)) {
+  else if (OptionMatch("pgo", *args)) {
+    int mod = 0, time;
-    Bench(2);
+    if (nargs > 1)
-  } else if (OptionMatch("bench+3", *args)) {
+      mod = atoi(args[1]);
-    Bench(3);
+    time = Bench_PGO(mod, 0);
+    Print(32, "time used = %s\n", DisplayTime(time));
+  }
 /*
  ************************************************************
  *                                                          *
  *  "bk"  book command from xboard sends the suggested book *
  *                                                          *
  *  "black" command sets black to move (Flip(wtm)).         *
  *                                                          *
  ************************************************************
  */
-  else if (!strcmp("white", *args)) {
+  else if (OptionMatch("white", *args)) {
     if (thinking || pondering)
       return 2;
+    game_wtm = 1;
     ponder_move = 0;
     last_pv.pathd = 0;
     last_pv.pathl = 0;
     if (!game_wtm)
       Pass();
     force = 0;
-  } else if (!strcmp("black", *args)) {
+  } else if (OptionMatch("black", *args)) {
     if (thinking || pondering)
       return 2;
+    game_wtm = 0;
     ponder_move = 0;
     last_pv.pathd = 0;
     last_pv.pathl = 0;
     if (game_wtm)
       Pass();
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("bogus", *args)) {
     return xboard;
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  "book" command updates/creates the opening book file.   *
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("book", *args)) {
+    nargs = ReadParse(buffer, args, " \t;");
+    Bookup(tree, nargs, args);
+  } else if (!strcmp("create", *(args + 1))) {
+    nargs = ReadParse(buffer, args, " \t;");
+    Bookup(tree, nargs, args);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "bookw" command updates the book selection weights.     *
  *                                                          *
  ************************************************************
  */
-  else if (!strcmp("bookw", *args)) {
+  else if (OptionMatch("bookw", *args)) {
     if (nargs > 1) {
-      if (!strcmp("freq", args[1]))
+      if (OptionMatch("frequency", args[1]))
         book_weight_freq = (float) atof(args[2]); // Pierre-Marie Baty -- added type cast
-      else if (!strcmp("eval", args[1]))
+      else if (OptionMatch("evaluation", args[1]))
         book_weight_eval = (float) atof(args[2]); // Pierre-Marie Baty -- added type cast
-      else if (!strcmp("learn", args[1]))
+      else if (OptionMatch("learning", args[1]))
         book_weight_learn = (float) atof(args[2]); // Pierre-Marie Baty -- added type cast
     } else {
-      Print(128, "frequency (freq)..............%4.2f\n", book_weight_freq);
+      Print(32, "frequency (freq)..............%4.2f\n", book_weight_freq);
-      Print(128, "static evaluation (eval)......%4.2f\n", book_weight_eval);
+      Print(32, "static evaluation (eval)......%4.2f\n", book_weight_eval);
-      Print(128, "learning (learn)..............%4.2f\n", book_weight_learn);
+      Print(32, "learning (learn)..............%4.2f\n", book_weight_learn);
+    }
-  }
-/*
- ************************************************************
- *                                                          *
- *  "book" command updates/creates the opening book file.   *
- *                                                          *
- ************************************************************
- */
-  else if (!strcmp("book", *args)) {
-    nargs = ReadParse(buffer, args, " \t;");
-    BookUp(tree, nargs, args);
-  } else if (!strcmp("create", *(args + 1))) {
-    nargs = ReadParse(buffer, args, " \t;");
-    BookUp(tree, nargs, args);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "cache" is used to set the EGTB cache size.  As always  *
  *                                                          *
  ************************************************************
  */
 #if !defined(NOEGTB)
   else if (OptionMatch("cache", *args)) {
-    EGTB_cache_size = (size_t) atoiKM(args[1]); // Pierre-Marie Baty -- added type cast
+    EGTB_cache_size = (size_t) atoiKMB(args[1]); // Pierre-Marie Baty -- added type cast
     if (EGTB_cache)
       free(EGTB_cache);
     EGTB_cache = malloc(EGTB_cache_size);
     if (!EGTB_cache) {
       Print(2095,
           "ERROR:  unable to malloc specified cache size, using default\n");
       EGTB_cache = malloc(4096 * 4096);
+    }
-    Print(128, "EGTB cache memory = %s bytes.\n", PrintKM(EGTB_cache_size,
+    Print(32, "EGTB cache memory = %s bytes.\n", DisplayKMB(EGTB_cache_size,
 ));
     FTbSetCacheSize(EGTB_cache, EGTB_cache_size);
+  }
 #endif
 /*
  */
   else if (OptionMatch("clock", *args)) {
     int side;
     for (side = white; side >= black; side--) {
-      Print(128, "time remaining (%s): %s", (side) ? "white" : "black",
+      Print(32, "time remaining (%s): %s", (side) ? "white" : "black",
           DisplayHHMMSS(tc_time_remaining[side]));
       if (tc_sudden_death != 1)
-        Print(128, "  (%d more moves)", tc_moves_remaining[side]);
+        Print(32, "  (%d more moves)", tc_moves_remaining[side]);
-      printf("\n");
+      Print(32, "\n");
+    }
-    Print(128, "\n");
+    Print(32, "\n");
     if (tc_sudden_death == 1)
-      Print(128, "Sudden-death time control in effect\n");
+      Print(32, "Sudden-death time control in effect\n");
+  }
 /*
  ************************************************************
  *                                                          *
  *  "computer" lets Crafty know it is playing a computer.   *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("computer", *args)) {
-    Print(128, "playing a computer!\n");
+    Print(32, "playing a computer!\n");
     accept_draws = 1;
+    if (resign)
-    resign = 10;
+      resign = 10;
-    resign_counter = 4;
+    resign_count = 4;
     usage_level = 0;
     books_file = (computer_bs_file) ? computer_bs_file : normal_bs_file;
+  }
 /*
  ************************************************************
  *  "display" command sets specific display options which   *
  *  control how "chatty" the program is.  In the variable   *
  *  display_options, the following bits are set/cleared     *
  *  based on the option chosen.                             *
  *                                                          *
- *    1 -> display time for moves.                          *
+ *    1 -> display move/time/results/etc.                   *
- *    2 -> display variation when it changes.               *
+ *    2 -> display PV.                                      *
- *    4 -> display variation at end of iteration.           *
+ *    4 -> display fail high / fail low moves               *
- *    8 -> display basic search statistics.                 *
+ *    8 -> display search statistics.                       *
- *   16 -> display extended search statistics.              *
- *   32 -> display root moves as they are searched.         *
+ *   16 -> display root moves as they are searched.         *
- *   64 -> display move numbers in the PV output.           *
- *  128 -> display general informational messages.          *
+ *   32 -> display general informational messages.          *
- *  256 -> display ply-1 move list / flags after each       *
+ *   64 -> display ply-1 move list / flags after each       *
  *         iteration.                                       *
- *  512 -> display ply-1 moves and positional evaluations   *
+ *  128 -> display root moves and scores before search      *
+ *         begins.                                          *
+ * 2048 -> error messages (can not be disabled).            *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("display", *args)) {
-    if (nargs > 1)
-      do {
-        if (OptionMatch("time", args[1])) {
-          display_options |= 1;
-          Print(128, "display time for moves played in game.\n");
-        } else if (OptionMatch("notime", args[1])) {
-          display_options &= 4095 - 1;
+    int i, set, old_display_options = display_options;
-          Print(128, "don't display time for moves played in game.\n");
-        } else if (OptionMatch("changes", args[1])) {
-          display_options |= 2;
-          Print(128, "display PV each time it changes.\n");
-        } else if (OptionMatch("nochanges", args[1])) {
-          display_options &= 4095 - 2;
-          Print(128, "don't display PV each time it changes.\n");
-        } else if (OptionMatch("variation", args[1])) {
-          display_options |= 4;
-          Print(128, "display PV at end of each iteration.\n");
-        } else if (OptionMatch("novariation", args[1])) {
-          display_options &= 4095 - 4;
-          Print(128, "don't display PV at end of each iteration.\n");
-        } else if (OptionMatch("stats", args[1])) {
-          display_options |= 8;
-          Print(128, "display statistics at end of each search.\n");
-        } else if (OptionMatch("nostats", args[1])) {
-          display_options &= 4095 - 8;
-          Print(128, "don't display statistics at end of each search.\n");
+    char *doptions[8] = { "moveinfo", "pv", "fail", "stats", "moves", "info",
-        } else if (OptionMatch("extstats", args[1])) {
-          display_options |= 16;
+      "ply1", "movelist"
-          Print(128, "display extended statistics at end of each search.\n");
-        } else if (OptionMatch("noextstats", args[1])) {
-          display_options &= 4095 - 16;
-          Print(128,
+    };
-              "don't display extended statistics at end of each search.\n");
-        } else if (OptionMatch("movenum", args[1])) {
-          display_options |= 64;
-          Print(128, "display move numbers in variations.\n");
+    char *descriptions[8] = { "display move time/results/etc",
-        } else if (OptionMatch("nomovenum", args[1])) {
-          display_options &= 4095 - 64;
-          Print(128, "don't display move numbers in variations.\n");
-        } else if (OptionMatch("moves", args[1])) {
-          display_options |= 32;
-          Print(128, "display ply-1 moves as they are searched.\n");
-        } else if (OptionMatch("nomoves", args[1])) {
-          display_options &= 4095 - 32;
-          Print(128, "don't display ply-1 moves as they are searched.\n");
+      "principal variation", "fail highs/lows", "search statistics",
-        } else if (OptionMatch("general", args[1])) {
-          display_options |= 128;
-          Print(128, "display informational messages.\n");
-        } else if (OptionMatch("nogeneral", args[1])) {
+      "root moves as they are searched", "general information",
-          display_options &= 4095 - 128;
-          Print(128, "don't display informational messages.\n");
-        } else if (OptionMatch("movelist", args[1])) {
-          display_options |= 256;
-          Print(128, "display ply-1 move list after each iteration.\n");
+      "ply1 move list after each iteration",
-        } else if (OptionMatch("nomovelist", args[1])) {
-          display_options &= 4095 - 256;
+      "root move list and scores prior to search"
-          Print(128, "don't display ply-1 move list after each iteration.\n");
-        } else if (OptionMatch("ply1", args[1])) {
-          display_options |= 512;
+    };
-          Print(128, "display ply-1 moves/evaluations.\n");
-        } else if (OptionMatch("noply1", args[1])) {
-          display_options &= 4095 - 512;
-          Print(128, "don't display ply-1 moves/evaluations.\n");
-        } else if (OptionMatch("everything", args[1])) {
-          display_options = 4095;
+    if (nargs > 1) {
-          Print(128, "display everything (lots of output).\n");
-        } else if (OptionMatch("nothing", args[1])) {
+      if (!strcmp(args[1], "all"))
-          display_options = 4095 - 1023;
+        old_display_options = ~display_options;
-          Print(128, "display nothing.\n");
-        } else if (OptionMatch("*", args[1])) {
-          if (display_options & 1)
+      for (i = 0; i < 8; i++) {
-            printf("display time for moves\n");
-          if (display_options & 2)
+        if (strstr(args[1], doptions[i])) {
-            printf("display variation when it changes.\n");
-          if (display_options & 4)
+          if (strstr(args[1], "no"))
-            printf("display variation at end of iteration.\n");
-          if (display_options & 8)
+            set = 0;
-            printf("display basic search stats.\n");
-          if (display_options & 16)
-            printf("display extended search stats.\n");
-          if (display_options & 32)
+          else
-            printf("display ply-1 moves as they are searched.\n");
-          if (display_options & 64)
+            set = 1;
-            printf("display move numbers in variations.\n");
-          if (display_options & 128)
+          display_options &= ~(1 << i);
-            printf("display general messages.\n");
-          if (display_options & 256)
-            printf("display ply-1 node counts every iteration.\n");
-          if (display_options & 512)
+          display_options |= set << i;
-            printf("display ply-1 moves and evaluations.\n");
-        } else
           break;
-        return 1;
+        }
+      }
+      for (i = 0; i < 8; i++) {
+        if ((old_display_options & (1 << i)) != (display_options & (1 << i))) {
+          Print(32, "display ");
+          if (!(display_options & (1 << i)))
+            Print(32, "no");
+          Print(32, "%s (%s)\n", doptions[i], descriptions[i]);
-      } while (0);
+        }
+      }
-    else
+    } else
       DisplayChessBoard(stdout, display);
+  }
 /*
  ************************************************************
  *                                                          *
  *  modified to test some modified code function.           *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("debug", *args)) {
-    Print(4095, "No debug code added to Option()\n");
+    Print(32, "ERROR:  no debug code included\n");
+  }
 /*
  ************************************************************
  *                                                          *
  *  "depth" command sets a specific search depth to         *
  *  control the tree search depth. [xboard compatibility].  *
  *                                                          *
  ************************************************************
  */
-  else if (!strcmp("depth", *args)) {
+  else if (OptionMatch("depth", *args)) {
     if (nargs < 2) {
       printf("usage:  depth <n>\n");
       return 1;
+    }
     search_depth = atoi(args[1]);
-    Print(128, "search depth set to %d.\n", search_depth);
+    Print(32, "search depth set to %d.\n", search_depth);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "draw" is used to offer Crafty a draw, or to control    *
   else if (OptionMatch("draw", *args)) {
     if (nargs == 1) {
       draw_offer_pending = 1;
       if (draw_offered) {
         Print(4095, "1/2-1/2 {Draw agreed}\n");
-        strcpy_s(pgn_result, sizeof (pgn_result), "1/2-1/2"); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_result, "1/2-1/2");
+      }
     } else {
       if (!strcmp(args[1], "accept")) {
         accept_draws = 1;
-        Print(128, "accept draw offers\n");
+        Print(32, "accept draw offers\n");
       } else if (!strcmp(args[1], "decline")) {
         accept_draws = 0;
-        Print(128, "decline draw offers\n");
+        Print(32, "decline draw offers\n");
+      } else if (!strcmp(args[1], "dynamic")) {
+        if (nargs > 2)
+          dynamic_draw_score = atoi(args[2]);
+        Print(32, "dynamic draw scores %s\n",
+            (dynamic_draw_score) ? "enabled" : "disabled");
       } else if (!strcmp(args[1], "offer")) {
         offer_draws = 1;
-        Print(128, "offer draws\n");
+        Print(32, "offer draws\n");
       } else if (!strcmp(args[1], "nooffer")) {
         offer_draws = 0;
-        Print(128, "do not offer draws\n");
+        Print(32, "do not offer draws\n");
       } else
-        Print(128, "usage: draw accept|decline|offer|nooffer\n");
+        Print(32, "usage: draw accept|decline|offer|nooffer\n");
+    }
+  }
 /*
  ************************************************************
  *                                                          *
  */
   else if (OptionMatch("easy", *args)) {
     if (thinking || pondering)
       return 2;
     ponder = 0;
-    Print(128, "pondering disabled.\n");
+    Print(32, "pondering disabled.\n");
+  }
 /*
  ************************************************************
  *                                                          *
  *  "echo" command displays messages from command file.     *
  *                                                          *
  *  "edit" command modifies the board position.             *
  *                                                          *
  ************************************************************
  */
-  else if (OptionMatch("edit", *args) && strcmp(*args, "ed")) {
+  else if (OptionMatch("edit", *args)) {
     if (thinking || pondering)
       return 2;
     Edit();
-    move_number = 1;    /* discard history */
+    move_number = 1; /* discard history */
     if (!game_wtm) {
       game_wtm = 1;
       Pass();
+    }
     ponder_move = 0;
     last_pv.pathd = 0;
     last_pv.pathl = 0;
-    strcpy_s(buffer, sizeof (buffer), "savepos *"); // Pierre-Marie Baty -- use safe version
+    strcpy(buffer, "savepos *");
-    (void) Option(tree);
+    Option(tree);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "egtb" command enables/disables tablebases and sets     *
  ************************************************************
  */
 #if !defined(NOEGTB)
   else if (OptionMatch("egtb", *args)) {
     if (!EGTB_setup) {
-      Print(128, "EGTB access enabled\n");
+      Print(32, "EGTB access enabled\n");
-      Print(128, "using tbpath=%s\n", tb_path);
+      Print(32, "using tbpath=%s\n", tb_path);
       EGTBlimit = IInitializeTb(tb_path);
-      Print(128, "%d piece tablebase files found\n", EGTBlimit);
+      Print(32, "%d piece tablebase files found\n", EGTBlimit);
       if (0 != cbEGTBCompBytes)
-        Print(128,
+        Print(32,
             "%dkb of RAM used for TB indices and decompression tables\n",
             (cbEGTBCompBytes + 1023) / 1024);
       if (EGTBlimit) {
         if (!EGTB_cache)
           EGTB_cache = malloc(EGTB_cache_size);
         if (!EGTB_cache) {
-          Print(128, "ERROR  EGTB cache malloc failed\n");
+          Print(32, "ERROR  EGTB cache malloc failed\n");
           EGTB_cache = malloc(4096 * 4096);
         } else
           FTbSetCacheSize(EGTB_cache, EGTB_cache_size);
         EGTB_setup = 1;
+      }
       if (nargs == 1)
         EGTBPV(tree, game_wtm);
       else if (nargs == 2)
         EGTBlimit = Min(atoi(args[1]), 5);
+    }
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  "egtbd" command sets the probe depth limit.  If the     *
+ *  remaining depth is < this limit, probes are not done to *
+ *  avoid slowing the search unnecessarily.                 *
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("egtbd", *args)) {
+    if (nargs > 1)
+      EGTB_depth = atoi(args[1]);
+    Print(32, "EGTB probe depth set to %d\n", EGTB_depth);
+  }
 #endif
 /*
  ************************************************************
  *                                                          *
       return 0;
     if (input_stream != stdin)
       fclose(input_stream);
     input_stream = stdin;
     ReadClear();
-    Print(128, "\n");
+    Print(32, "\n");
+  }
 /*
  ************************************************************
  *                                                          *
  *  "flag" command controls whether Crafty will call the    *
  *  flag in xboard/winboard games (to end the game.)        *
  *                                                          *
  ************************************************************
  */
-  else if (!strcmp("flag", *args)) {
+  else if (OptionMatch("flag", *args)) {
     if (nargs < 2) {
       printf("usage:  flag on|off\n");
       return 1;
+    }
     if (!strcmp(args[1], "on"))
       call_flag = 1;
     else if (!strcmp(args[1], "off"))
       call_flag = 0;
     if (call_flag)
-      Print(128, "end game on time forfeits\n");
+      Print(32, "end game on time forfeits\n");
     else
-      Print(128, "ignore time forfeits\n");
+      Print(32, "ignore time forfeits\n");
+  }
 /*
  ************************************************************
  *                                                          *
  *  "flip" command flips the board, interchanging each      *
     last_pv.pathl = 0;
     save_move_number = move_number;
     movenum = move_number;
     if (game_wtm)
       movenum--;
-    strcpy_s(text, sizeof (text), args[1]); // Pierre-Marie Baty -- use safe version
+    strcpy(text, args[1]);
-    sprintf_s(buffer, sizeof (buffer), "reset %d", movenum); // Pierre-Marie Baty -- use safe version
+    sprintf(buffer, "reset %d", movenum);
     game_wtm = Flip(game_wtm);
-    (void) Option(tree);
+    Option(tree);
-    move = InputMove(tree, text, 0, game_wtm, 0, 0);
+    move = InputMove(tree, 0, game_wtm, 0, 0, text);
     if (move) {
       if (input_stream != stdin)
-        printf("%s\n", OutputMove(tree, move, 0, game_wtm));
+        printf("%s\n", OutputMove(tree, 0, game_wtm, move));
       if (history_file) {
         fseek(history_file, ((movenum - 1) * 2 + 1 - game_wtm) * 10,
             SEEK_SET);
-        fprintf(history_file, "%9s\n", OutputMove(tree, move, 0, game_wtm));
+        fprintf(history_file, "%9s\n", OutputMove(tree, 0, game_wtm, move));
+      }
-      MakeMoveRoot(tree, move, game_wtm);
+      MakeMoveRoot(tree, game_wtm, move);
       last_pv.pathd = 0;
       last_pv.pathl = 0;
     } else if (input_stream == stdin)
       printf("illegal move.\n");
     game_wtm = Flip(game_wtm);
     move_number = save_move_number;
-    strcpy_s(hint, sizeof (hint), "none"); // Pierre-Marie Baty -- use safe version
+    strcpy(ponder_text, "none");
+  }
 /*
  ************************************************************
  *                                                          *
  *  "go" command does nothing, except force main() to start *
  *  a search.  ("move" is an alias for go).                 *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("go", *args) || OptionMatch("move", *args)) {
+    int t;
     char temp[128];
     if (thinking || pondering)
       return 2;
     if (game_wtm) {
       if (strncmp(pgn_white, "Crafty", 6)) {
-        strcpy_s(temp, sizeof (temp), pgn_white); // Pierre-Marie Baty -- use safe version
+        strcpy(temp, pgn_white);
-        strcpy_s(pgn_white, sizeof (pgn_white), pgn_black); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_white, pgn_black);
-        strcpy_s(pgn_black, sizeof (pgn_black), temp); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_black, temp);
+      }
     } else {
       if (strncmp(pgn_black, "Crafty", 6)) {
-        strcpy_s(temp, sizeof (temp), pgn_white); // Pierre-Marie Baty -- use safe version
+        strcpy(temp, pgn_white);
-        strcpy_s(pgn_white, sizeof (pgn_white), pgn_black); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_white, pgn_black);
-        strcpy_s(pgn_black, sizeof (pgn_black), temp); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_black, temp);
+      }
+    }
+    t = tc_time_remaining[white];
+    tc_time_remaining[white] = tc_time_remaining[black];
+    tc_time_remaining[black] = t;
+    t = tc_moves_remaining[white];
+    tc_moves_remaining[white] = tc_moves_remaining[black];
+    tc_moves_remaining[black] = t;
     force = 0;
     return -1;
+  }
 /*
  ************************************************************
     if (history_file) {
       printf("    white       black\n");
       for (i = 0; i < (move_number - 1) * 2 - game_wtm + 1; i++) {
         fseek(history_file, i * 10, SEEK_SET);
-        fscanf(history_file, "%s", buffer);
+        v = fscanf(history_file, "%s", buffer);
+        if (v <= 0)
+          perror("Option() fscanf error: ");
         if (!(i % 2))
           printf("%3d", i / 2 + 1);
         printf("  %-10s", buffer);
         if (i % 2 == 1)
           printf("\n");
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("hard", *args)) {
     ponder = 1;
-    Print(128, "pondering enabled.\n");
+    Print(32, "pondering enabled.\n");
+  }
 /*
  ************************************************************
  *                                                          *
  *  "hash" command controls the transposition table size.   *
- *  The size can be entered in one of three ways:           *
+ *  The size can be entered in one of four ways:            *
  *                                                          *
  *     hash=nnn  where nnn is in bytes.                     *
  *     hash=nnnK where nnn is in K bytes.                   *
  *     hash=nnnM where nnn is in M bytes.                   *
+ *     hash=nnnG where nnn is in G bytes.                   *
  *                                                          *
  *  the only restriction is that the hash table is computed *
  *  as a perfect power of 2.  Any value that is not a       *
  *  perfect power of 2 is rounded down so that it is, in    *
  *  order to avoid breaking the addressing scheme.          *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("hash", *args)) {
-    size_t new_hash_size;
+    size_t old_hash_size = hash_table_size, new_hash_size;
     if (thinking || pondering)
       return 2;
     if (nargs > 1) {
       allow_memory = 0;
+      if (xboard)
-      Print(4095, "Warning--  xboard 'memory' option disabled\n");
+        Print(4095, "Warning--  xboard 'memory' option disabled\n");
-      new_hash_size = (size_t) atoiKM(args[1]); // Pierre-Marie Baty -- added type cast
+      new_hash_size = (size_t) atoiKMB(args[1]); // Pierre-Marie Baty -- added type cast
       if (new_hash_size < 64 * 1024) {
         printf("ERROR.  Minimum hash table size is 64K bytes.\n");
         return 1;
+      }
-      hash_table_size = ((1ull) << MSB(new_hash_size)) / sizeof(HASH_ENTRY);
+      hash_table_size = ((1ull) << MSB(new_hash_size)) / 16;
-      AlignedRemalloc((void **) &trans_ref, 64,
+      AlignedRemalloc((void *) ((void *) &hash_table), 64,
-          sizeof(HASH_ENTRY) * hash_table_size);
+          hash_table_size * sizeof(HASH_ENTRY));
-      if (!trans_ref) {
+      if (!hash_table) {
         printf("AlignedRemalloc() failed, not enough memory.\n");
         exit(1);
+      }
-      hash_mask = ((1ull << (MSB((uint64_t) hash_table_size) - 2)) - 1) << 2;
+      hash_mask = (hash_table_size - 1) & ~3;
-      InitializeHashTables();
+    }
-    Print(128, "hash table memory = %s bytes",
+    Print(32, "hash table memory = %s bytes",
-        PrintKM(hash_table_size * sizeof(HASH_ENTRY), 1));
+        DisplayKMB(hash_table_size * sizeof(HASH_ENTRY), 1));
-    Print(128, " (%s entries).\n", PrintKM(hash_table_size, 1));
+    Print(32, " (%s entries).\n", DisplayKMB(hash_table_size, 1));
+    InitializeHashTables(old_hash_size != hash_table_size);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "phash" command controls the path hash table size. The  *
- *  size can be entered in one of three ways:               *
+ *  size can be entered in one of four ways:                *
  *                                                          *
  *     phash=nnn  where nnn is in bytes.                    *
  *     phash=nnnK where nnn is in K bytes.                  *
  *     phash=nnnM where nnn is in M bytes.                  *
+ *     phash=nnnG where nnn is in G bytes.                  *
  *                                                          *
  *  the only restriction is that the path hash table must   *
  *  have a perfect power of 2 entries.  The value entered   *
  *  will be rounded down to meet that requirement.          *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("phash", *args)) {
-    size_t new_hash_size;
+    size_t old_hash_size = hash_path_size, new_hash_size;
-    size_t i; // Pierre-Marie Baty -- fixed type
     if (thinking || pondering)
       return 2;
     if (nargs > 1) {
-      new_hash_size = (size_t) atoiKM(args[1]); // Pierre-Marie Baty -- added type cast
+      new_hash_size = (size_t) atoiKMB(args[1]); // Pierre-Marie Baty -- added type cast
       if (new_hash_size < 64 * 1024) {
         printf("ERROR.  Minimum phash table size is 64K bytes.\n");
         return 1;
+      }
       hash_path_size = ((1ull) << MSB(new_hash_size / sizeof(HPATH_ENTRY)));
-      AlignedRemalloc((void **) &hash_path, 64,
+      AlignedRemalloc((void *) ((void *) &hash_path), 64,
           sizeof(HPATH_ENTRY) * hash_path_size);
       if (!hash_path) {
         printf("AlignedRemalloc() failed, not enough memory.\n");
         hash_path_size = 0;
         hash_path = 0;
+      }
       hash_path_mask = (hash_path_size - 1) & ~15;
-      for (i = 0; i < hash_path_size; i++)
-        (hash_path + i)->hash_path_age = -99;
+    }
-    Print(128, "hash path table memory = %s bytes",
+    Print(32, "hash path table memory = %s bytes",
-        PrintKM(hash_path_size * sizeof(HPATH_ENTRY), 1));
+        DisplayKMB(hash_path_size * sizeof(HPATH_ENTRY), 1));
-    Print(128, " (%s entries).\n", PrintKM(hash_path_size, 1));
+    Print(32, " (%s entries).\n", DisplayKMB(hash_path_size, 1));
+    InitializeHashTables(old_hash_size != hash_path_size);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "hashp" command controls the pawn hash table size.      *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("hashp", *args)) {
-    size_t i; // Pierre-Marie Baty -- fixed type
+    size_t old_hash_size = pawn_hash_table_size, new_hash_size;
-    size_t new_hash_size;
     if (thinking || pondering)
       return 2;
     if (nargs > 1) {
       allow_memory = 0;
+      if (xboard)
-      Print(4095, "Warning--  xboard 'memory' option disabled\n");
+        Print(4095, "Warning--  xboard 'memory' option disabled\n");
-      new_hash_size = (size_t) atoiKM(args[1]); // Pierre-Marie Baty -- added type cast
+      new_hash_size = (size_t) atoiKMB(args[1]); // Pierre-Marie Baty -- added type cast
       if (new_hash_size < 16 * 1024) {
         printf("ERROR.  Minimum pawn hash table size is 16K bytes.\n");
         return 1;
+      }
       pawn_hash_table_size =
-          (1ull << MSB(new_hash_size)) / sizeof(PAWN_HASH_ENTRY);
+ull << MSB(new_hash_size / sizeof(PAWN_HASH_ENTRY));
-      AlignedRemalloc((void **) &pawn_hash_table, 32,
+      AlignedRemalloc((void *) ((void *) &pawn_hash_table), 64,
           sizeof(PAWN_HASH_ENTRY) * pawn_hash_table_size);
       if (!pawn_hash_table) {
         printf("AlignedRemalloc() failed, not enough memory.\n");
         exit(1);
+      }
-      pawn_hash_mask = (1ull << MSB((uint64_t) pawn_hash_table_size)) - 1;
+      pawn_hash_mask = pawn_hash_table_size - 1;
+    }
-      for (i = 0; i < pawn_hash_table_size; i++) {
+    Print(32, "pawn hash table memory = %s bytes",
-        (pawn_hash_table + i)->key = 0;
+        DisplayKMB(pawn_hash_table_size * sizeof(PAWN_HASH_ENTRY), 1));
-        (pawn_hash_table + i)->score_mg = 0;
+    Print(32, " (%s entries).\n", DisplayKMB(pawn_hash_table_size, 1));
-        (pawn_hash_table + i)->score_eg = 0;
+    InitializeHashTables(old_hash_size != pawn_hash_table_size);
+  }
+/*
+ ************************************************************
-        (pawn_hash_table + i)->defects_k[white] = 0;
+ *                                                          *
-        (pawn_hash_table + i)->defects_q[white] = 0;
+ *  "hashe" command controls the eval hash table size.      *
-        (pawn_hash_table + i)->defects_d[white] = 0;
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("hashe", *args)) {
-        (pawn_hash_table + i)->defects_e[white] = 0;
+    size_t old_hash_size = eval_hash_table_size, new_hash_size;
+    if (thinking || pondering)
+      return 2;
+    if (nargs > 1) {
-        (pawn_hash_table + i)->all[white] = 0;
+      allow_memory = 0;
+      if (xboard)
+        Print(4095, "Warning--  xboard 'memory' option disabled\n");
+      new_hash_size = (size_t) atoiKMB(args[1]); // Pierre-Marie Baty -- added type cast
-        (pawn_hash_table + i)->passed[white] = 0;
+      if (new_hash_size < 16 * 1024) {
-        (pawn_hash_table + i)->defects_k[black] = 0;
+        printf("ERROR.  Minimum eval hash table size is 16K bytes.\n");
+        return 1;
+      }
-        (pawn_hash_table + i)->defects_q[black] = 0;
+      eval_hash_table_size = 1ull << MSB(new_hash_size / sizeof(uint64_t));
-        (pawn_hash_table + i)->defects_d[black] = 0;
+      AlignedRemalloc((void *) ((void *) &eval_hash_table), 64,
-        (pawn_hash_table + i)->defects_e[black] = 0;
+          sizeof(uint64_t) * eval_hash_table_size);
-        (pawn_hash_table + i)->all[black] = 0;
+      if (!eval_hash_table) {
-        (pawn_hash_table + i)->passed[black] = 0;
+        printf("AlignedRemalloc() failed, not enough memory.\n");
+        exit(1);
+      }
+      eval_hash_mask = eval_hash_table_size - 1;
+    }
-    Print(128, "pawn hash table memory = %s bytes",
+    Print(32, "eval hash table memory = %s bytes",
-        PrintKM(pawn_hash_table_size * sizeof(PAWN_HASH_ENTRY), 1));
+        DisplayKMB(eval_hash_table_size * sizeof(uint64_t), 1));
-    Print(128, " (%s entries).\n", PrintKM(pawn_hash_table_size, 1));
+    Print(32, " (%s entries).\n", DisplayKMB(eval_hash_table_size, 1));
+    InitializeHashTables(old_hash_size != eval_hash_table_size);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "help" command lists commands/options.                  *
   else if (OptionMatch("help", *args)) {
     FILE *helpfile;
     char *readstat = (char *) -1;
     int lines = 0;
-    fopen_s (&helpfile, "crafty.hlp", "r"); // Pierre-Marie Baty -- use safe version
+    helpfile = fopen("crafty.hlp", "r");
     if (!helpfile) {
       printf("ERROR.  Unable to open \"crafty.hlp\" -- help unavailable\n");
       return 1;
+    }
     if (nargs > 1) {
       lines++;
       if (lines > 22) {
         lines = 0;
         printf("<return> for more...");
         fflush(stdout);
-        (void) Read(1, buffer, sizeof (buffer));
+        Read(1, buffer);
+      }
+    }
     fclose(helpfile);
+  }
 /*
  *  "hint" displays the expected move based on the last     *
  *  search done. [xboard compatibility]                     *
  *                                                          *
  ************************************************************
  */
-  else if (!strcmp("hint", *args)) {
+  else if (OptionMatch("hint", *args)) {
-    if (strlen(hint)) {
+    if (strlen(ponder_text)) {
-      printf("Hint: %s\n", hint);
+      printf("Hint: %s\n", ponder_text);
       fflush(stdout);
+    }
+  }
 /*
  ************************************************************
     nargs = ReadParse(buffer, args, " \t=");
     if (nargs < 2) {
       printf("usage:  input <filename>\n");
       return 1;
+    }
-    fopen_s(&input_stream, args[1], "r"); // Pierre-Marie Baty -- use safe version
-    if (!input_stream) {
+    if (!(input_stream = fopen(args[1], "r"))) {
       printf("file does not exist.\n");
       input_stream = stdin;
+    }
+  }
 /*
  *  "info" command gives some information about Crafty.     *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("info", *args)) {
-    Print(128, "Crafty version %s\n", version);
+    Print(32, "Crafty version %s\n", version);
-    Print(128, "number of threads =         %2d\n", smp_max_threads);
+    Print(32, "number of threads =         %2d\n", smp_max_threads);
-    Print(128, "hash table memory =      %5s\n",
+    Print(32, "hash table memory = %s bytes", DisplayKMB(hash_table_size * 64,
+));
-        PrintKM(hash_table_size * sizeof(HASH_ENTRY), 1));
+    Print(32, " (%s entries).\n", DisplayKMB(hash_table_size * 5, 0));
-    Print(128, "pawn hash table memory = %5s\n",
+    Print(32, "pawn hash table memory = %5s\n",
-        PrintKM(pawn_hash_table_size * sizeof(PAWN_HASH_ENTRY), 1));
+        DisplayKMB(pawn_hash_table_size * sizeof(PAWN_HASH_ENTRY), 1));
 #if !defined(NOEGTB)
-    Print(128, "EGTB cache memory =      %5s\n", PrintKM(EGTB_cache_size, 1));
+    Print(32, "EGTB cache memory =      %5s\n", DisplayKMB(EGTB_cache_size,
+));
 #endif
     if (!tc_sudden_death) {
-      Print(128, "%d moves/%d minutes %d seconds primary time control\n",
+      Print(32, "%d moves/%d minutes %d seconds primary time control\n",
           tc_moves, tc_time / 6000, (tc_time / 100) % 60);
-      Print(128, "%d moves/%d minutes %d seconds secondary time control\n",
+      Print(32, "%d moves/%d minutes %d seconds secondary time control\n",
           tc_secondary_moves, tc_secondary_time / 6000,
           (tc_secondary_time / 100) % 60);
       if (tc_increment)
-        Print(128, "increment %d seconds.\n", tc_increment / 100);
+        Print(32, "increment %d seconds.\n", tc_increment / 100);
     } else if (tc_sudden_death == 1) {
-      Print(128, " game/%d minutes primary time control\n", tc_time / 6000);
+      Print(32, " game/%d minutes primary time control\n", tc_time / 6000);
       if (tc_increment)
-        Print(128, "increment %d seconds.\n", (tc_increment / 100) % 60);
+        Print(32, "increment %d seconds.\n", (tc_increment / 100) % 60);
     } else if (tc_sudden_death == 2) {
-      Print(128, "%d moves/%d minutes primary time control\n", tc_moves,
+      Print(32, "%d moves/%d minutes primary time control\n", tc_moves,
           tc_time / 6000);
-      Print(128, "game/%d minutes secondary time control\n",
+      Print(32, "game/%d minutes secondary time control\n",
           tc_secondary_time / 6000);
       if (tc_increment)
-        Print(128, "increment %d seconds.\n", tc_increment / 100);
+        Print(32, "increment %d seconds.\n", tc_increment / 100);
+    }
-    Print(128, "book frequency (freq)..............%4.2f\n",
+    Print(32, "book frequency (freq)..............%4.2f\n", book_weight_freq);
-        book_weight_freq);
-    Print(128, "book static evaluation (eval)......%4.2f\n",
+    Print(32, "book static evaluation (eval)......%4.2f\n", book_weight_eval);
-        book_weight_eval);
-    Print(128, "book learning (learn)..............%4.2f\n",
+    Print(32, "book learning (learn)..............%4.2f\n",
         book_weight_learn);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "kibitz" command sets kibitz mode for ICS.  =1 will     *
  *  kibitz mate announcements, =2 will kibitz scores and    *
  *  other info, =3 will kibitz scores and PV, =4 adds the   *
  *  list of book moves, =5 displays the PV after each       *
- *  iteration completes, and =6 displays the PV each time   *
- *  it changes in an iteration.                             *
+ *  iteration completes.                                    *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("kibitz", *args)) {
     if (nargs < 2) {
       printf("usage:  kibitz <level>\n");
       return 1;
+    }
-    kibitz = atoi(args[1]);
+    kibitz = Min(5, atoi(args[1]));
+  }
 /*
  ************************************************************
  *                                                          *
  *  "learn" command enables/disables the learning           *
         int index[32768], i, j, cluster;
         unsigned char buf32[4];
         fseek(book_file, 0, SEEK_SET);
         for (i = 0; i < 32768; i++) {
-          fread(buf32, 4, 1, book_file);
+          v = fread(buf32, 4, 1, book_file);
+          if (v <= 0)
+            perror("Option() fread error: ");
           index[i] = BookIn32(buf32);
+        }
         for (i = 0; i < 32768; i++)
           if (index[i] > 0) {
             fseek(book_file, index[i], SEEK_SET);
-            fread(buf32, 4, 1, book_file);
+            v = fread(buf32, 4, 1, book_file);
+            if (v <= 0)
+              perror("Option() fread error: ");
             cluster = BookIn32(buf32);
+            if (cluster)
-            BookClusterIn(book_file, cluster, book_buffer);
+              BookClusterIn(book_file, cluster, book_buffer);
             for (j = 0; j < cluster; j++)
               book_buffer[j].learn = 0.0;
             fseek(book_file, index[i] + sizeof(int), SEEK_SET);
+            if (cluster)
-            BookClusterOut(book_file, cluster, book_buffer);
+              BookClusterOut(book_file, cluster, book_buffer);
+          }
       } else {
         learning = atoi(args[1]);
         learn = (learning > 0) ? 1 : 0;
         if (learning)
-          Print(128, "book learning enabled {-%d,+%d}\n", learning, learning);
+          Print(32, "book learning enabled {-%d,+%d}\n", learning, learning);
         else
-          Print(128, "book learning disabled\n");
+          Print(32, "book learning disabled\n");
+      }
+    }
+  }
 /*
  ************************************************************
       tc_secondary_time = tc_time;
       tc_moves_remaining[white] = tc_moves;
       tc_moves_remaining[black] = tc_moves;
+    }
     if (!tc_sudden_death) {
-      Print(128, "%d moves/%d seconds primary time control\n", tc_moves,
+      Print(32, "%d moves/%d seconds primary time control\n", tc_moves,
           tc_time / 100);
-      Print(128, "%d moves/%d seconds secondary time control\n",
+      Print(32, "%d moves/%d seconds secondary time control\n",
           tc_secondary_moves, tc_secondary_time / 100);
       if (tc_increment)
-        Print(128, "increment %d seconds.\n", tc_increment / 100);
+        Print(32, "increment %d seconds.\n", tc_increment / 100);
     } else if (tc_sudden_death == 1) {
-      Print(128, " game/%d seconds primary time control\n", tc_time / 100);
+      Print(32, " game/%d seconds primary time control\n", tc_time / 100);
       if (tc_increment)
-        Print(128, "increment %d seconds.\n", tc_increment / 100);
+        Print(32, "increment %d seconds.\n", tc_increment / 100);
+    }
     if (adaptive_hash) {
+      uint64_t positions_per_move;
       float percent;
       int optimal_hash_size;
-      unsigned int positions_per_move; // Pierre-Marie Baty -- fixed type. No sense to make it uint64_t if optimal_hash_size is int.
       TimeSet(think);
       time_limit /= 100;
       positions_per_move = time_limit * adaptive_hash / 16;
-      optimal_hash_size = positions_per_move * 16;
+      optimal_hash_size = (int) positions_per_move * 16; // Pierre-Marie Baty -- added type cast
       printf("optimal=%d\n", optimal_hash_size);
       optimal_hash_size = Max(optimal_hash_size, (int) adaptive_hash_min); // Pierre-Marie Baty -- added type cast
       optimal_hash_size = Min(optimal_hash_size, (int) adaptive_hash_max); // Pierre-Marie Baty -- added type cast
-      sprintf_s(buffer, sizeof (buffer), "hash=%d\n", optimal_hash_size); // Pierre-Marie Baty -- use safe version
+      sprintf(buffer, "hash=%d\n", optimal_hash_size);
-      (void) Option(tree);
+      Option(tree);
       percent =
           (float) (optimal_hash_size -
           adaptive_hash_min) / (float) (adaptive_hash_max -
           adaptive_hash_min);
-      optimal_hash_size =
+      optimal_hash_size = (int) // Pierre-Marie Baty -- added type cast
-          (int) (adaptive_hashp_min + percent * (adaptive_hashp_max -
+          (adaptive_hashp_min + percent * (adaptive_hashp_max -
-          adaptive_hashp_min)); // Pierre-Marie Baty -- added type cast
+          adaptive_hashp_min));
       optimal_hash_size = Max(optimal_hash_size, (int) adaptive_hashp_min); // Pierre-Marie Baty -- added type cast
-      sprintf_s(buffer, sizeof (buffer), "hashp=%d\n", optimal_hash_size); // Pierre-Marie Baty -- use safe version
+      sprintf(buffer, "hashp=%d\n", optimal_hash_size);
-      (void) Option(tree);
+      Option(tree);
+    }
+  }
 /*
  ************************************************************
  *                                                          *
  *  commands direct Crafty to look elsewhere.               *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("list", *args)) {
-    int i, list, lastent = -1;
     char **targs;
     char listname[5][3] = { "AK", "B", "GM", "IM", "SP" };
     char **listaddr[] = { AK_list, B_list, GM_list,
       IM_list, SP_list
     };
+    int i, list, lastent = -1;
     targs = args;
     for (list = 0; list < 5; list++) {
       if (!strcmp(listname[list], args[1]))
         break;
+    }
           for (i = 0; i < 128; i++)
             if (listaddr[list][i]) {
               if (!strcmp(listaddr[list][i], targs[0] + 1)) {
                 free(listaddr[list][i]);
                 listaddr[list][i] = NULL;
-                Print(128, "%s removed from %s list.\n", targs[0] + 1,
+                Print(32, "%s removed from %s list.\n", targs[0] + 1,
                     listname[list]);
                 break;
+              }
+            }
         } else if (targs[0][0] == '+') {
           for (i = 0; i < 128; i++)
             if (listaddr[list][i]) {
               if (!strcmp(listaddr[list][i], targs[0] + 1)) {
-                Print(128, "Warning: %s is already in %s list.\n",
+                Print(32, "Warning: %s is already in %s list.\n",
                     targs[0] + 1, listname[list]);
                 break;
+              }
+            }
           for (i = 0; i < 128; i++)
             if (listaddr[list][i] == NULL)
               break;
           if (i >= 128)
-            Print(128, "ERROR!  %s list is full at 128 entries\n",
+            Print(32, "ERROR!  %s list is full at 128 entries\n",
                 listname[list]);
           else {
             listaddr[list][i] = malloc(strlen(targs[0]));
             strcpy(listaddr[list][i], targs[0] + 1);
-            Print(128, "%s added to %s list.\n", targs[0] + 1,
+            Print(32, "%s added to %s list.\n", targs[0] + 1, listname[list]);
-                listname[list]);
             if (list == 5)
               lastent = i;
+          }
         } else if (!strcmp(targs[0], "clear")) {
           for (i = 0; i < 128; i++) {
+          }
         } else if (!strcmp(targs[0], "book") && lastent != -1) {
           char filename[256];
           FILE *file;
-          strcpy_s(filename, sizeof (filename), book_path); // Pierre-Marie Baty -- use safe version
+          strcpy(filename, book_path);
-          strcat_s(filename, sizeof (filename), "/"); // Pierre-Marie Baty -- use safe version
+          strcat(filename, "/");
-          strcat_s(filename, sizeof (filename), targs[1]); // Pierre-Marie Baty -- use safe version
+          strcat(filename, targs[1]);
           if (!strstr(args[2], ".bin"))
-            strcat_s(filename, sizeof (filename), ".bin"); // Pierre-Marie Baty -- use safe version
+            strcat(filename, ".bin");
-          fopen_s (&file, filename, "r"); // Pierre-Marie Baty -- use safe version
+          file = fopen(filename, "r");
           if (!file) {
             Print(4095, "ERROR  book file %s can not be opened\n", filename);
             break;
+          }
           fclose(file);
           printf("error, name must be preceeded by +/- flag.\n");
         nargs--;
         targs++;
+      }
     } else {
-      Print(128, "%s List:\n", listname[list]);
+      Print(32, "%s List:\n", listname[list]);
       for (i = 0; i < 128; i++) {
         if (listaddr[list][i]) {
-          Print(128, "%s", listaddr[list][i]);
+          Print(32, "%s", listaddr[list][i]);
           if (list == 5) {
             if (SP_opening_filename[i])
-              Print(128, "  book=%s", SP_opening_filename[i]);
+              Print(32, "  book=%s", SP_opening_filename[i]);
             if (SP_personality_filename[i])
-              Print(128, "  personality=%s", SP_personality_filename[i]);
+              Print(32, "  personality=%s", SP_personality_filename[i]);
+          }
-          Print(128, "\n");
+          Print(32, "\n");
+        }
+      }
+    }
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  "lmr" command sets the formla parameters that produce   *
+ *  LMR reduction matrix.  The format is:                   *
+ *                                                          *
+ *     lmr <min> <max> <depth bias> <moves bias> <scale>    *
+ *                                                          *
+ *  <min> is the minimum LMR reduction.  This probably      *
+ *  should not be changed from 1, the default.              *
+ *                                                          *
+ *  <max> is the maximum LMR reduction.  If you adjust the  *
+ *  following values, you might need to increase this as it *
+ *  is an absolute clamp and no value can exceed this no    *
+ *  matter what the formula produces.                       *
+ *                                                          *
+ *  <depth_bias> is simply a multiplier that causes depth   *
+ *  to influence the reduction amount more or less (as the  *
+ *  value drops below the value used for <moves bias> below *
+ *  or as it is increased above <moves bias>.  The default  *
+ *  is 2.0.                                                 *
+ *                                                          *
+ *  <moves bias> is simply a multiplier that causes the     *
+ *  number of moves already searched to become more or less *
+ *  important than the remaining depth as above.  The       *
+ *  default is 1.0.                                         *
+ *                                                          *
+ *  <scale> is used to scale the formula back since it uses *
+ *  a logarithmic expression.  The basic idea is to adjust  *
+ *  the above two values to produce the desired "shape" of  *
+ *  the reduction matrix, then adjust this to change the    *
+ *  reduction amounts overall.  The default is 2.9.         *
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("lmr", *args)) {
+    int i, j;
+    if ((nargs > 1 && nargs < 6) || nargs > 7) {
+      printf("usage:  lmr <min> <max> <depth bias> <move bias> <scale>\n");
+      return 1;
+    }
+    if (nargs > 1) {
+      LMR_min = atoi(args[1]);
+      LMR_max = Min(atoi(args[2]), 15);
+      LMR_db = atof(args[3]);
+      LMR_mb = atof(args[4]);
+      LMR_s = atof(args[5]);
+      InitializeReductions();
+    }
+    if (nargs > 6) {
+      char *axis = "|||||||||||depth left|||||||||||";
+      Print(32,
+          "LMR values:  %d(min) %d(max) %.2f(depth) %.2f(moves) %.2f(scale).\n",
+          LMR_min, LMR_max, LMR_db, LMR_mb, LMR_s);
+      Print(32, "\n                 LMR reductions[depth][moves]\n");
+      Print(32, "  ----------------------moves searched-----------------\n");
+      Print(32, " |      ");
+      for (i = 0; i < 64; i += 1)
+        Print(32, "%3d", i);
+      Print(32, "\n");
+      for (i = 0; i < 32; i += 1) {
+        Print(32, " %c %3d: ", axis[i], i);
+        for (j = 0; j < 64; j += 1)
+          Print(32, " %2d", LMR[i][j]);
+        Print(32, "\n");
+      }
+    } else {
+      char *axis = "||depth left|||";
+      Print(32,
+          "LMR values:  %d(min) %d(max) %.2f(depth) %.2f(moves) %.2f(scale).\n",
+          LMR_min, LMR_max, LMR_db, LMR_mb, LMR_s);
+      Print(32, "\n                 LMR reductions[depth][moves]\n");
+      Print(32, "  ----------------------moves searched------------------\n");
+      Print(32, " |      ");
+      for (i = 2; i < 64; i += 4)
+        Print(32, "%3d", i);
+      Print(32, "\n");
+      for (i = 3; i < 32; i += 2) {
+        Print(32, " %c %3d: ", axis[(i - 3) / 2], i);
+        for (j = 2; j < 64; j += 4)
+          Print(32, " %2d", LMR[i][j]);
+        Print(32, "\n");
+      }
+      Print(32, "    note:  table is shown compressed, each index is in\n");
+      Print(32, "    units of 1, all rows/columns are not shown above\n");
+    }
+  }
 /*
  ************************************************************
  *                                                          *
+    }
     if (!(prob_file = fopen(args[1], "r"))) {
       printf("file does not exist.\n");
       return 1;
+    }
-    strcpy_s(title, sizeof (title), args[2]); // Pierre-Marie Baty -- use safe version
+    strcpy(title, args[2]);
     while (!feof(prob_file)) {
       readstat = fgets(buffer, 128, prob_file);
       if (readstat) {
         char *delim;
+      }
       if (readstat == NULL)
         break;
       nargs = ReadParse(buffer, args, " \t;\n");
       if (!strcmp(args[0], "setboard")) {
-        (void) Option(tree);
+        Option(tree);
         break;
+      }
+    }
+  }
 /*
+    }
     if (!strcmp(args[1], "on")) {
       int id;
       id = InitializeGetLogID();
-      sprintf_s(log_filename, sizeof (log_filename), "%s/log.%03d", log_path, id); // Pierre-Marie Baty -- use safe version
+      sprintf(log_filename, "%s/log.%03d", log_path, id);
-      sprintf_s(history_filename, sizeof (history_filename), "%s/game.%03d", log_path, id); // Pierre-Marie Baty -- use safe version
+      sprintf(history_filename, "%s/game.%03d", log_path, id);
-      fopen_s (&log_file, log_filename, "w"); // Pierre-Marie Baty -- use safe version
+      log_file = fopen(log_filename, "w");
-      fopen_s (&history_file, history_filename, "w+"); // Pierre-Marie Baty -- use safe version
+      history_file = fopen(history_filename, "w+");
     } else if (!strcmp(args[1], "off")) {
       if (log_file)
         fclose(log_file);
       log_file = 0;
-      sprintf_s(filename, sizeof (filename), "%s/log.%03d", log_path, log_id - 1); // Pierre-Marie Baty -- use safe version
+      sprintf(filename, "%s/log.%03d", log_path, log_id - 1);
       remove(filename);
-      sprintf_s(filename, sizeof (filename), "%s/game.%03d", log_path, log_id - 1); // Pierre-Marie Baty -- use safe version
+      sprintf(filename, "%s/game.%03d", log_path, log_id - 1);
       remove(filename);
     } else if (args[1][0] >= '0' && args[1][0] <= '9') {
       if (log_id == 0)
         log_id = atoi(args[1]);
     } else {
-      int nrecs, trecs, lrecs;
       char *eof;
       FILE *log;
+      int nrecs, trecs, lrecs;
       nrecs = atoi(args[1]);
       output_file = stdout;
       if (nargs > 2)
         output_file = fopen(args[2], "w");
     size_t hmemory, pmemory;
     if (nargs < 2) {
       printf("usage:  memory <size>\n");
       return 1;
+    }
+    if (allow_memory) {
-    size = atoi(args[1]) * 1024 * 1024;
+      size = (uint64_t) atoi(args[1]);
-    if (size == 0) {
+      if (size == 0) {
-      Print(4095, "ERROR - memory size can not be zero\n");
+        Print(4095, "ERROR - memory size can not be zero\n");
-      return 1;
+        return 1;
-    }
+      }
-    hmemory = (1ull) << MSB(size);
+      hmemory = (1ull) << MSB(size);
-    size &= ~hmemory;
+      size &= ~hmemory;
-    pmemory = (1ull) << MSB(size);
+      pmemory = (1ull) << MSB(size);
-    if (pmemory < 1024 * 1024)
-      pmemory = 0;
-    sprintf_s(buffer, sizeof (buffer), "hash %" PRIu64 "\n", (uint64_t) hmemory); // Pierre-Marie Baty -- use safe version
+      sprintf(buffer, "hash %" PRIu64 "M\n", (uint64_t) hmemory);
-    (void) Option(tree);
+      Option(tree);
-    if (pmemory) {
+      if (pmemory) {
-      sprintf_s(buffer, sizeof (buffer), "hashp %" PRIu64 "\n", (uint64_t) pmemory); // Pierre-Marie Baty -- use safe version
+        sprintf(buffer, "hashp %" PRIu64 "M\n", (uint64_t) pmemory);
-      (void) Option(tree);
+        Option(tree);
-    }
+      }
+    } else
+      Print(4095, "WARNING - memory command ignored.\n");
+  }
 /*
  ************************************************************
  *                                                          *
  *   "mode" command sets tournament mode or normal mode.    *
         book_weight_learn = 1.0;
         book_weight_freq = 1.0;
         book_weight_eval = 0.5;
       } else if (!strcmp(args[1], "match")) {
         mode = normal_mode;
-        book_weight_learn = 1.0f; // Pierre-Marie Baty -- added float suffix
+        book_weight_learn = 1.0;
-        book_weight_freq = 0.2f; // Pierre-Marie Baty -- added float suffix
+        book_weight_freq = 0.2f; // Pierre-Marie Baty -- added type cast
-        book_weight_eval = 0.1f; // Pierre-Marie Baty -- added float suffix
+        book_weight_eval = 0.1f; // Pierre-Marie Baty -- added type cast
       } else {
         printf("usage:  mode normal|tournament|match\n");
         mode = normal_mode;
-        book_weight_learn = 1.0f; // Pierre-Marie Baty -- added float suffix
+        book_weight_learn = 1.0;
-        book_weight_freq = 1.0f; // Pierre-Marie Baty -- added float suffix
+        book_weight_freq = 1.0;
-        book_weight_eval = 0.5f; // Pierre-Marie Baty -- added float suffix
+        book_weight_eval = 0.5;
+      }
+    }
     if (mode == tournament_mode)
       printf("tournament mode.\n");
     else if (mode == normal_mode)
  *   accordingly.                                           *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("name", *args)) {
-    int i;
     char *next;
+    int i;
     if (nargs < 2) {
       printf("usage:  name <name>\n");
       return 1;
+    }
     if (game_wtm) {
-      strcpy_s(pgn_white, sizeof (pgn_white), args[1]); // Pierre-Marie Baty -- use safe version
+      strcpy(pgn_white, args[1]);
-      sprintf_s(pgn_black, sizeof (pgn_black), "Crafty %s", version);
+      sprintf(pgn_black, "Crafty %s", version);
     } else {
-      strcpy_s(pgn_black, sizeof (pgn_black), args[1]); // Pierre-Marie Baty -- use safe version
+      strcpy(pgn_black, args[1]);
-      sprintf_s(pgn_white, sizeof (pgn_white), "Crafty %s", version);
+      sprintf(pgn_white, "Crafty %s", version);
+    }
-    Print(128, "Crafty %s vs %s\n", version, args[1]);
+    Print(32, "Crafty %s vs %s\n", version, args[1]);
     next = args[1];
     while (*next) {
       *next = tolower(*next);
       next++;
+    }
           kibitz = 4;
           break;
+        }
       for (i = 0; i < 128; i++)
         if (GM_list[i] && !strcmp(GM_list[i], args[1])) {
-          Print(128, "playing a GM!\n");
+          Print(32, "playing a GM!\n");
           book_selection_width = 3;
           resign = Min(6, resign);
           resign_count = 4;
           draw_count = 4;
           accept_draws = 1;
           kibitz = 0;
           break;
+        }
       for (i = 0; i < 128; i++)
         if (IM_list[i] && !strcmp(IM_list[i], args[1])) {
-          Print(128, "playing an IM!\n");
+          Print(32, "playing an IM!\n");
           book_selection_width = 4;
           resign = Min(9, resign);
           resign_count = 5;
           draw_count = 4;
           accept_draws = 1;
+        }
       for (i = 0; i < 128; i++)
         if (SP_list[i] && !strcmp(SP_list[i], args[1])) {
           FILE *normal_bs_file = books_file;
-          Print(128, "playing a special player!\n");
+          Print(32, "playing a special player!\n");
           if (SP_opening_filename[i]) {
             books_file = fopen(SP_opening_filename[i], "rb");
             if (!books_file) {
               Print(4095, "Error!  unable to open %s for player %s.\n",
                   SP_opening_filename[i], SP_list[i]);
               books_file = normal_bs_file;
+            }
+          }
           if (SP_personality_filename[i]) {
-            sprintf_s(buffer, sizeof (buffer), "personality load %s\n", // Pierre-Marie Baty -- use safe version
+            sprintf(buffer, "personality load %s\n",
                 SP_personality_filename[i]);
-            (void) Option(tree);
+            Option(tree);
+          }
           break;
+        }
+    }
     printf("tellicsnoalias kibitz Hello from Crafty v%s! (%d cpus)\n",
     if (thinking || pondering)
       return 3;
     if (smp_max_threads) {
       int proc;
-      Print(128, "parallel threads terminated.\n");
+      Print(32, "parallel threads terminated.\n");
       for (proc = 1; proc < CPUS; proc++)
-        thread[proc].tree = (TREE *) - 1;
+        thread[proc].terminate = 1;
+    }
     NewGame(0);
     return 3;
+  }
 /*
  ************************************************************
  *                                                          *
- *  "noise" command sets a minimum limit on nodes searched  *
+ *  "noise" command sets a minimum limit on time searched   *
- *  such that until this number of nodes has been searched  *
+ *  before we start to display the normal search output.    *
- *  no program output will occur.  This is used to prevent  *
+ *  With today's hardware and deep searches, it is easy to  *
- *  simple endgames from swamping the display device since  *
+ *  get "swamped" with output.  Using "noise" you can say   *
- *  30+ ply searches are possible, which can produce 100's  *
+ *  "hold the output until you have searched for <x> time   *
- *  of lines of output.                                     *
+ *  (where time can be x.xx seconds or just x seconds.)     *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("noise", *args)) {
     if (nargs < 2) {
       printf("usage:  noise <n>\n");
       return 1;
+    }
-    noise_level = atoi(args[1]);
+    noise_level = (int) (atof(args[1]) * 100); // Pierre-Marie Baty -- added type cast
-    Print(128, "noise level set to %d.\n", noise_level);
+    Print(32, "noise level set to %.2f seconds.\n",
+        (float) noise_level / 100.0);
+  }
 /*
  ************************************************************
  *                                                          *
- *  "operator" command sets the operator time.  This time   *
+ *  "null" command sets the minimum null-move reduction and *
- *  is the time per move that the operator needs.  It is    *
+ *  a value that is used to compute the max reduction.      *
+ *                                                          *
+ *     null <min> <divisor>                                 *
+ *                                                          *
- *  multiplied by the number of moves left to time control  *
+ *  <min> is the minimum null move reduction.  The default  *
+ *  is 3 which is pretty reliable.                          *
- *  to reserve operator time.                               *
+ *                                                          *
+ *  <divisor> increases the null move by the following      *
+ *  simple formula:                                         *
+ *                                                          *
+ *    null_reduction = min + depth / divisor                *
+ *                                                          *
+ *  The default value is currently 10, which will increase  *
+ *  R (null-move reduction) by one at any position where    *
+ *  depth >= 10 and < 20.  Or by two when depth > 20.  Etc. *
  *                                                          *
  ************************************************************
  */
-  else if (OptionMatch("operator", *args)) {
+  else if (OptionMatch("null", *args)) {
-    if (nargs < 2) {
+    if (nargs > 3) {
-      printf("usage:  operator <seconds>\n");
+      printf("usage:  null <min> <divisor>\n");
       return 1;
+    }
-    tc_operator_time = ParseTime(args[1]) * 100;
+    if (nargs > 1) {
-    Print(128, "reserving %d seconds per move for operator overhead.\n",
+      null_depth = atoi(args[1]);
-        tc_operator_time / 100);
+      null_divisor = atoi(args[2]);
+    }
+    Print(32, "null move:  R = %d + depth / %d\n", null_depth, null_divisor);
+  }
 /*
  ************************************************************
  *                                                          *
- *  "otime" command sets the opponent's time remaining.     *
+ *  "otim" command sets the opponent's time remaining.      *
  *  This is used to determine if the opponent is in time    *
  *  trouble, and is factored into the draw score if he is.  *
  *                                                          *
  ************************************************************
  */
-  else if (OptionMatch("otime", *args)) {
+  else if (OptionMatch("otim", *args)) {
     if (nargs < 2) {
       printf("usage:  otime <time(unit=.01 secs))>\n");
       return 1;
+    }
-    tc_time_remaining[Flip(root_wtm)] = atoi(args[1]);
+    tc_time_remaining[game_wtm] = atoi(args[1]);
     if (log_file && time_limit > 99)
       fprintf(log_file, "time remaining: %s (opponent).\n",
-          DisplayTime(tc_time_remaining[Flip(root_wtm)]));
+          DisplayTime(tc_time_remaining[game_wtm]));
-    if (call_flag && xboard && tc_time_remaining[Flip(root_wtm)] < 1) {
+    if (call_flag && xboard && tc_time_remaining[game_wtm] < 1) {
       if (crafty_is_white)
-        Print(128, "1-0 {Black ran out of time}\n");
+        Print(32, "1-0 {Black ran out of time}\n");
       else
-        Print(128, "0-1 {White ran out of time}\n");
+        Print(32, "0-1 {White ran out of time}\n");
+    }
+  }
 /*
  ************************************************************
  *                                                          *
     else if (!strcmp(args[1], "short"))
       output_format = 0;
     else
       printf("usage:  output long|short\n");
     if (output_format == 1)
-      Print(128, "output moves in long algebraic format\n");
+      Print(32, "output moves in long algebraic format\n");
     else if (output_format == 0)
-      Print(128, "output moves in short algebraic format\n");
+      Print(32, "output moves in short algebraic format\n");
+  }
 /*
  ************************************************************
  *                                                          *
  *  "personality" command is used to adjust the eval terms  *
           continue;
         if (personality_packet[i].value) {
           switch (personality_packet[i].type) {
             case 1:
               printf("%3d  %s %7d\n", i, personality_packet[i].description,
-                  *personality_packet[i].value);
+                  *(int *) personality_packet[i].value);
               break;
             case 2:
               printf("%3d  %s %7d (mg) %7d (eg)\n", i,
                   personality_packet[i].description,
-                  personality_packet[i].value[mg],
+                  ((int *) personality_packet[i].value)[mg],
-                  personality_packet[i].value[eg]);
+                  ((int *) personality_packet[i].value)[eg]);
               break;
             case 3:
-              printf("%3d  %s\n", i, personality_packet[i].description);
+              printf("%3d  %s %7.2f\n", i, personality_packet[i].description,
-              DisplayType3(personality_packet[i].value,
+                  *(double *) personality_packet[i].value);
-                  personality_packet[i].value + 128);
               break;
             case 4:
-              printf("%3d  %s\n", i, personality_packet[i].description);
+              printf("%3d  %s    ", i, personality_packet[i].description);
-              DisplayType4(personality_packet[i].value,
-                  personality_packet[i].value + 64);
+              for (j = 0; j < personality_packet[i].size; j++)
-              break;
-            case 5:
-              printf("%3d  %s\n", i, personality_packet[i].description);
+                printf("%4d", ((int *) personality_packet[i].value)[j]);
-              DisplayType5(personality_packet[i].value,
-                  personality_packet[i].size);
-              break;
+              printf("\n");
-            case 6:
-              printf("%3d  %s\n", i, personality_packet[i].description);
-              DisplayType6(personality_packet[i].value);
               break;
+          }
         } else {
           printf("==================================================\n");
           printf("=         %s  =\n", personality_packet[i].description);
  */
     if (!strcmp(args[1], "load")) {
       FILE *file;
       char filename[256];
-      strcpy_s(filename, sizeof (filename), args[2]); // Pierre-Marie Baty -- use safe version
+      strcpy(filename, args[2]);
       if (!strstr(filename, ".cpf"))
-        strcat_s(filename, sizeof (filename), ".cpf"); // Pierre-Marie Baty -- use safe version
+        strcat(filename, ".cpf");
-      Print(128, "Loading personality file %s\n", filename);
+      Print(32, "Loading personality file %s\n", filename);
-      fopen_s (&file, filename, "r+"); // Pierre-Marie Baty -- use safe version
-      if (file) {
+      if ((file = fopen(filename, "r+"))) {
         while (fgets(buffer, 4096, file)) {
           char *delim;
           delim = strchr(buffer, '\n');
           if (delim)
           if (delim)
             *delim = 0;
           delim = strchr(buffer, '\r');
           if (delim)
             *delim = ' ';
-          (void) Option(tree);
+          Option(tree);
+        }
         fclose(file);
+      }
       return 1;
+    }
  */
     if (nargs == 3 && !strcmp(args[1], "save")) {
       char filename[256];
       FILE *file;
-      strcpy_s(filename, sizeof (filename), args[2]); // Pierre-Marie Baty -- use safe version
+      strcpy(filename, args[2]);
       if (!strstr(filename, ".cpf"))
-        strcat_s(filename, sizeof (filename), ".cpf"); // Pierre-Marie Baty -- use safe version
+        strcat(filename, ".cpf");
-      fopen_s (&file, filename, "w"); // Pierre-Marie Baty -- use safe version
+      file = fopen(filename, "w");
       if (!file) {
         printf("ERROR.  Unable to open %s for writing\n", args[2]);
         return 1;
+      }
       printf("saving to file \"%s\"\n", filename);
         if (!personality_packet[i].description)
           continue;
         if (personality_packet[i].value) {
           if (personality_packet[i].size <= 1)
             fprintf(file, "personality %3d %7d\n", i,
-                *personality_packet[i].value);
+                *((int *) personality_packet[i].value));
           else if (personality_packet[i].size > 1) {
             fprintf(file, "personality %3d ", i);
             for (j = 0; j < personality_packet[i].size; j++)
-              fprintf(file, "%d ", personality_packet[i].value[j]);
+              fprintf(file, "%d ", ((int *) personality_packet[i].value)[j]);
             fprintf(file, "\n");
+          }
+        }
+      }
       fprintf(file, "exit\n");
     if (personality_packet[param].size == 0) {
       if (nargs > 3) {
         printf("this eval term requires exactly 1 value.\n");
         return 1;
+      }
-      *personality_packet[param].value = value;
+      *(int *) personality_packet[param].value = value;
+    }
 /*
  ************************************************************
  *                                                          *
  *  Handle the "personality index v1 v2 .. vn" command that *
             personality_packet[param].description, param,
             Abs(personality_packet[param].size), index);
         return 1;
+      }
       for (i = 0; i < index; i++)
-        personality_packet[param].value[i] = atoi(args[i + 2]);
+        ((int *) personality_packet[param].value)[i] = atoi(args[i + 2]);
+    }
     InitializeKingSafety();
+  }
 /*
  ************************************************************
       printf("usage:  bookpath|perspath|logpath|tbpath <path>\n");
       return 1;
+    }
     if (!strchr(args[1], '(')) {
       if (strstr(args[0], "bookpath"))
-        strcpy_s(book_path, sizeof (book_path), args[1]); // Pierre-Marie Baty -- use safe version
+        strcpy(book_path, args[1]);
       else if (strstr(args[0], "logpath"))
-        strcpy_s(log_path, sizeof (log_path), args[1]); // Pierre-Marie Baty -- use safe version
+        strcpy(log_path, args[1]);
 #if !defined(NOEGTB)
       else if (strstr(args[0], "tbpath"))
-        strcpy_s(tb_path, sizeof (tb_path), args[1]); // Pierre-Marie Baty -- use safe version
+        strcpy(tb_path, args[1]);
 #endif
     } else {
       if (strchr(args[1], ')')) {
         *strchr(args[1], ')') = 0;
         if (strstr(args[0], "bookpath"))
-          strcpy_s(book_path, sizeof (book_path), args[1] + 1); // Pierre-Marie Baty -- use safe version
+          strcpy(book_path, args[1] + 1);
         else if (strstr(args[0], "logpath"))
-          strcpy_s(log_path, sizeof (log_path), args[1] + 1); // Pierre-Marie Baty -- use safe version
+          strcpy(log_path, args[1] + 1);
 #if !defined(NOEGTB)
         else if (strstr(args[0], "tbpath"))
-          strcpy_s(tb_path, sizeof (tb_path), args[1] + 1); // Pierre-Marie Baty -- use safe version
+          strcpy(tb_path, args[1] + 1);
 #endif
       } else
         Print(4095, "ERROR multiple paths must be enclosed in ( and )\n");
+    }
+  }
  *                                                          *
  ************************************************************
  */
 #define PERF_CYCLES 4000000
   else if (OptionMatch("perf", *args)) {
-    int i, *mv, clock_before, clock_after;
+    int i, clock_before, clock_after;
+    unsigned *mv;
     float time_used;
     if (thinking || pondering)
       return 2;
     clock_before = clock();
     clock_before = clock();
     for (i = 0; i < PERF_CYCLES; i++) {
       tree->last[1] = GenerateCaptures(tree, 0, game_wtm, tree->last[0]);
       tree->last[1] = GenerateNoncaptures(tree, 0, game_wtm, tree->last[1]);
       for (mv = tree->last[0]; mv < tree->last[1]; mv++) {
-        MakeMove(tree, 0, *mv, game_wtm);
+        MakeMove(tree, 0, game_wtm, *mv);
-        UnmakeMove(tree, 0, *mv, game_wtm);
+        UnmakeMove(tree, 0, game_wtm, *mv);
+      }
+    }
     clock_after = clock();
     time_used =
         ((float) clock_after - (float) clock_before) / (float) CLOCKS_PER_SEC;
  *  "perft" command turns tests move generator/make_move.   *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("perft", *args)) {
-    int i, clock_before, clock_after;
     float time_used;
+    int i, clock_before, clock_after;
     if (thinking || pondering)
       return 2;
     clock_before = clock();
     while (clock() == clock_before);
     clock_before = clock();
     if (nargs < 2) {
-      printf("usage:  perftest <depth>\n");
+      printf("usage:  perft <depth>\n");
       return 1;
+    }
     tree->status[1] = tree->status[0];
     tree->last[0] = tree->move_list;
     i = atoi(args[1]);
     if (i <= 0) {
-      Print(128, "usage:  perft <maxply>\n");
+      Print(32, "usage:  perft <maxply>\n");
       return 1;
+    }
     total_moves = 0;
     OptionPerft(tree, 1, i, game_wtm);
     clock_after = clock();
       return 1;
+    }
     if (!strcmp(args[1], "Event")) {
       pgn_event[0] = 0;
       for (i = 2; i < nargs; i++) {
-        strcat_s(pgn_event, sizeof (pgn_event), args[i]); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_event + strlen(pgn_event), args[i]);
-        strcat_s(pgn_event, sizeof (pgn_event), " "); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_event + strlen(pgn_event), " ");
+      }
     } else if (!strcmp(args[1], "Site")) {
       pgn_site[0] = 0;
       for (i = 2; i < nargs; i++) {
-        strcat_s(pgn_site, sizeof (pgn_site), args[i]); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_site + strlen(pgn_site), args[i]);
-        strcat_s(pgn_site, sizeof (pgn_site), " "); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_site + strlen(pgn_site), " ");
+      }
     } else if (!strcmp(args[1], "Round")) {
       pgn_round[0] = 0;
-      strcpy_s(pgn_round, sizeof (pgn_round), args[2]); // Pierre-Marie Baty -- use safe version
+      strcpy(pgn_round, args[2]);
     } else if (!strcmp(args[1], "White")) {
       pgn_white[0] = 0;
       for (i = 2; i < nargs; i++) {
-        strcat_s(pgn_white, sizeof (pgn_white), args[i]); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_white + strlen(pgn_white), args[i]);
-        strcat_s(pgn_white, sizeof (pgn_white), " "); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_white + strlen(pgn_white), " ");
+      }
     } else if (!strcmp(args[1], "WhiteElo")) {
       pgn_white_elo[0] = 0;
-      strcpy_s(pgn_white_elo, sizeof (pgn_white_elo), args[2]); // Pierre-Marie Baty -- use safe version
+      strcpy(pgn_white_elo, args[2]);
     } else if (!strcmp(args[1], "Black")) {
       pgn_black[0] = 0;
       for (i = 2; i < nargs; i++) {
-        strcat_s(pgn_black, sizeof (pgn_black), args[i]); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_black + strlen(pgn_black), args[i]);
-        strcat_s(pgn_black, sizeof (pgn_black), " "); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_black + strlen(pgn_black), " ");
+      }
     } else if (!strcmp(args[1], "BlackElo")) {
       pgn_black_elo[0] = 0;
-      strcpy_s(pgn_black_elo, sizeof (pgn_black_elo), args[2]); // Pierre-Marie Baty -- use safe version
+      strcpy(pgn_black_elo, args[2]);
+    }
+  }
 /*
  ************************************************************
  *                                                          *
  *  to let it know all previous commands have been executed *
  *  and we are ready for whatever is next.                  *
  *                                                          *
  ************************************************************
  */
-  else if (!strcmp("ping", *args)) {
+  else if (OptionMatch("ping", *args)) {
-    if (pondering) {
+    if (pondering)
-      Print(4095, "pong %s\n", args[1]);
+      Print(-1, "pong %s\n", args[1]);
-    } else {
+    else
       pong = atoi(args[1]);
-    }
+  }
 /*
  ************************************************************
  *                                                          *
  *  "playother" command says "position is set up, we are    *
  *  waiting on the opponent to move, ponder if you want to  *
  *  do so.                                                  *
  *                                                          *
  ************************************************************
  */
-  else if (!strcmp("playother", *args)) {
+  else if (OptionMatch("playother", *args)) {
     force = 0;
+  }
 /*
  ************************************************************
  *                                                          *
       printf("usage:  ponder off|on|<move>\n");
       return 1;
+    }
     if (!strcmp(args[1], "on")) {
       ponder = 1;
-      Print(128, "pondering enabled.\n");
+      Print(32, "pondering enabled.\n");
     } else if (!strcmp(args[1], "off")) {
       ponder = 0;
-      Print(128, "pondering disabled.\n");
+      Print(32, "pondering disabled.\n");
     } else {
-      ponder_move = InputMove(tree, args[1], 0, game_wtm, 0, 0);
+      ponder_move = InputMove(tree, 0, game_wtm, 0, 0, args[1]);
       last_pv.pathd = 0;
       last_pv.pathl = 0;
+    }
+  }
 /*
  *  "post/nopost" command sets/resets "show thinking" mode  *
  *  for xboard compatibility.                               *
  *                                                          *
  ************************************************************
  */
-  else if (!strcmp("post", *args)) {
+  else if (OptionMatch("post", *args)) {
     post = 1;
-  } else if (!strcmp("nopost", *args)) {
+  } else if (OptionMatch("nopost", *args)) {
     post = 0;
+  }
 /*
  ************************************************************
  *                                                          *
  *  xboard protocol version and discover what the engine    *
  *  can handle.                                             *
  *                                                          *
  ************************************************************
  */
-  else if (!strcmp("protover", *args)) {
+  else if (OptionMatch("protover", *args)) {
     int pversion = atoi(args[1]);
     if (pversion >= 1 && pversion <= 3) {
       if (pversion >= 2) {
-        Print(4095, "feature ping=1 setboard=1 san=1 time=1 draw=1\n");
+        Print(-1, "feature ping=1 setboard=1 san=1 time=1 draw=1\n");
-        Print(4095, "feature sigint=0 sigterm=0 reuse=1 analyze=1\n");
+        Print(-1, "feature sigint=0 sigterm=0 reuse=1 analyze=1\n");
-        Print(4095, "feature myname=\"Crafty-%s\" name=1\n", version);
+        Print(-1, "feature myname=\"Crafty-%s\" name=1\n", version);
-        Print(4095, "feature playother=1 colors=0 memory=%d\n", allow_memory);
+        Print(-1, "feature playother=1 colors=0 memory=%d\n", allow_memory);
 #if (CPUS > 1)
-        Print(4095, "feature smp=%d\n", allow_cores);
+        Print(-1, "feature smp=%d\n", allow_cores);
 #endif
-        Print(4095, "feature variants=\"normal,nocastle\"\n");
+        Print(-1, "feature variants=\"normal,nocastle\"\n");
-        Print(4095, "feature done=1\n");
+        Print(-1, "feature done=1\n");
-        done = 1;
+        xboard_done = 1;
+      }
     } else
       Print(4095, "ERROR, bogus xboard protocol version received.\n");
+  }
 /*
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("rating", *args)) {
     int rd;
     if (nargs < 3) {
       printf("usage:  rating <Crafty> <opponent>\n");
       return 1;
+    }
     crafty_rating = atoi(args[1]);
     opponent_rating = atoi(args[2]);
     if (crafty_rating == 0 && opponent_rating == 0) {
       crafty_rating = 2500;
       opponent_rating = 2300;
+    }
+    if (dynamic_draw_score) {
-    rd = opponent_rating - crafty_rating;
+      rd = opponent_rating - crafty_rating;
-    rd = Max(Min(rd, 300), -300);
+      rd = Max(Min(rd, 300), -300);
-    abs_draw_score = (rd + 60) / 7;
+      abs_draw_score = rd / 8;
-    if (log_file) {
+      if (log_file) {
-      fprintf(log_file, "Crafty's rating: %d.\n", crafty_rating);
+        fprintf(log_file, "Crafty's rating: %d.\n", crafty_rating);
-      fprintf(log_file, "opponent's rating: %d.\n", opponent_rating);
+        fprintf(log_file, "opponent's rating: %d.\n", opponent_rating);
-      fprintf(log_file, "draw score: %d.\n", abs_draw_score);
+        fprintf(log_file, "draw score: %d.\n", abs_draw_score);
+      }
+    }
+  }
 /*
  ************************************************************
  *                                                          *
  *  leaving the opponent still on move.  It's intended for  *
  *  xboard compatibility, but works in any mode.            *
  *                                                          *
  ************************************************************
  */
-  else if (!strcmp("remove", *args)) {
+  else if (OptionMatch("remove", *args)) {
     if (thinking || pondering)
       return 2;
     move_number--;
-    sprintf_s(buffer, sizeof (buffer), "reset %d", move_number); // Pierre-Marie Baty -- use safe version
-    (void) Option(tree);
-  }
-/*
- ************************************************************
- *                                                          *
- *  "reset" restores (backs up) a game to a prior position  *
- *  with the same side on move.  Reset 17 would reset the   *
- *  position to what it was at move 17 with the current     *
- *  still on move (you can use white/black commands to      *
- *  change the side to move first, if needed.)              *
- *                                                          *
- ************************************************************
- */
-  else if (OptionMatch("reset", *args)) {
-    int i, move, nmoves;
-    if (!history_file)
-      return 1;
-    if (thinking || pondering)
-      return 2;
-    if (nargs < 2) {
-      printf("usage:  reset <movenumber>\n");
+    sprintf(buffer, "reset %d", move_number);
-      return 1;
-    }
-    ponder_move = 0;
-    last_mate_score = 0;
-    last_pv.pathd = 0;
-    last_pv.pathl = 0;
-    if (thinking || pondering)
-      return 2;
-    over = 0;
-    move_number = atoi(args[1]);
-    if (!move_number) {
-      move_number = 1;
-      return 1;
-    }
-    nmoves = (move_number - 1) * 2 + 1 - game_wtm;
-    root_wtm = Flip(game_wtm);
-    InitializeChessBoard(tree);
-    game_wtm = 1;
-    move_number = 1;
-    tc_moves_remaining[white] = tc_moves;
-    tc_moves_remaining[black] = tc_moves;
-    for (i = 0; i < nmoves; i++) {
-      fseek(history_file, i * 10, SEEK_SET);
-      fscanf_s(history_file, "%s", buffer, sizeof (buffer)); // Pierre-Marie Baty -- use safe version
-/*
- If the move is "pass", that means that the side on move passed.
- This includes the case where the game started from a black-to-move
- position; then white's first move is recorded as a pass.
- */
-      if (strcmp(buffer, "pass") == 0) {
-        game_wtm = Flip(game_wtm);
-        if (game_wtm)
-          move_number++;
-        continue;
-      }
-      move = InputMove(tree, buffer, 0, game_wtm, 0, 0);
-      if (move) {
+    Option(tree);
-        MakeMoveRoot(tree, move, game_wtm);
-      } else {
-        printf("ERROR!  move %s is illegal\n", buffer);
-        break;
-      }
-      TimeAdjust(0, game_wtm);
-      game_wtm = Flip(game_wtm);
-      if (game_wtm)
-        move_number++;
-    }
-    moves_out_of_book = 0;
-    printf("NOTICE: %d moves to next time control\n",
-        tc_moves_remaining[root_wtm]);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "read" reads game moves in and makes them.  This can    *
  *  before reading moves.                                   *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("read", *args) || OptionMatch("reada", *args)) {
-    int append, move, readstat;
     FILE *read_input = 0;
+    int append, move, readstat;
     if (thinking || pondering)
       return 2;
     nargs = ReadParse(buffer, args, " \t=");
     if (!strcmp("reada", *args))
       append = 0;
     ponder_move = 0;
     last_pv.pathd = 0;
     last_pv.pathl = 0;
     if (nargs > 1) {
-      fopen_s(&read_input, args[1], "r"); // Pierre-Marie Baty -- use safe version
-      if (!read_input) {
+      if (!(read_input = fopen(args[1], "r"))) {
         printf("file %s does not exist.\n", args[1]);
         return 1;
+      }
     } else {
       printf("type \"exit\" to terminate.\n");
     do {
       move = 0;
       move = ReadNextMove(tree, buffer, 0, game_wtm);
       if (move) {
         if (read_input != stdin) {
-          printf("%s ", OutputMove(tree, move, 0, game_wtm));
+          printf("%s ", OutputMove(tree, 0, game_wtm, move));
           if (!(move_number % 8) && Flip(game_wtm))
             printf("\n");
+        }
         fseek(history_file, ((move_number - 1) * 2 + 1 - game_wtm) * 10,
             SEEK_SET);
-        fprintf(history_file, "%9s\n", OutputMove(tree, move, 0, game_wtm));
+        fprintf(history_file, "%9s\n", OutputMove(tree, 0, game_wtm, move));
-        MakeMoveRoot(tree, move, game_wtm);
+        MakeMoveRoot(tree, game_wtm, move);
-        TimeAdjust(0, game_wtm);
+        TimeAdjust(game_wtm, 0);
 #if defined(DEBUG)
         ValidatePosition(tree, 1, move, "Option()");
 #endif
       } else if (!read_input)
         printf("illegal move.\n");
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("rejected", *args)) {
     Print(4095, "ERROR.  feature %s rejected by xboard\n", args[1]);
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  "reset" restores (backs up) a game to a prior position  *
+ *  with the same side on move.  Reset 17 would reset the   *
+ *  position to what it was at move 17 with the current     *
+ *  still on move (you can use white/black commands to      *
+ *  change the side to move first, if needed.)              *
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("reset", *args)) {
+    int i, move, nmoves;
+    if (!history_file)
+      return 1;
+    if (thinking || pondering)
+      return 2;
+    if (nargs < 2) {
+      printf("usage:  reset <movenumber>\n");
+      return 1;
+    }
+    ponder_move = 0;
+    last_mate_score = 0;
+    last_pv.pathd = 0;
+    last_pv.pathl = 0;
+    if (thinking || pondering)
+      return 2;
+    over = 0;
+    move_number = atoi(args[1]);
+    if (!move_number) {
+      move_number = 1;
+      return 1;
+    }
+    nmoves = (move_number - 1) * 2 + 1 - game_wtm;
+    root_wtm = Flip(game_wtm);
+    InitializeChessBoard(tree);
+    game_wtm = 1;
+    move_number = 1;
+    tc_moves_remaining[white] = tc_moves;
+    tc_moves_remaining[black] = tc_moves;
+    for (i = 0; i < nmoves; i++) {
+      fseek(history_file, i * 10, SEEK_SET);
+      v = fscanf(history_file, "%s", buffer);
+      if (v <= 0)
+        perror("Option() fscanf error: ");
+/*
+ If the move is "pass", that means that the side on move passed.
+ This includes the case where the game started from a black-to-move
+ position; then white's first move is recorded as a pass.
+ */
+      if (strcmp(buffer, "pass") == 0) {
+        game_wtm = Flip(game_wtm);
+        if (game_wtm)
+          move_number++;
+        continue;
+      }
+      move = InputMove(tree, 0, game_wtm, 0, 0, buffer);
+      if (move)
+        MakeMoveRoot(tree, game_wtm, move);
+      else {
+        printf("ERROR!  move %s is illegal\n", buffer);
+        break;
+      }
+      TimeAdjust(game_wtm, 0);
+      game_wtm = Flip(game_wtm);
+      if (game_wtm)
+        move_number++;
+    }
+    moves_out_of_book = 0;
+    printf("NOTICE: %d moves to next time control\n",
+        tc_moves_remaining[root_wtm]);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "resign" command sets the resignation threshold to the  *
  */
   else if (OptionMatch("resign", *args)) {
     if (nargs < 2) {
       if (crafty_is_white) {
         Print(4095, "result 1-0\n");
-        strcpy_s(pgn_result, sizeof (pgn_result), "1-0"); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_result, "1-0");
       } else {
         Print(4095, "result 0-1\n");
-        strcpy_s(pgn_result, sizeof (pgn_result), "0-1"); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_result, "0-1");
+      }
       learn_value = 300;
       LearnBook();
       return 1;
+    }
     resign = atoi(args[1]);
     if (nargs == 3)
       resign_count = atoi(args[2]);
     if (resign)
-      Print(128, "resign after %d consecutive moves with score < %d.\n",
+      Print(32, "resign after %d consecutive moves with score < %d.\n",
           resign_count, -resign);
     else
-      Print(128, "disabled resignations.\n");
+      Print(32, "disabled resignations.\n");
+  }
 /*
  ************************************************************
  *                                                          *
  *  "result" command comes from xboard/winboard and gives   *
  ************************************************************
  */
   else if (OptionMatch("result", *args)) {
     if (nargs > 1) {
       if (!strcmp(args[1], "1-0")) {
-        strcpy_s(pgn_result, sizeof (pgn_result), "1-0"); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_result, "1-0");
         if (crafty_is_white)
           learn_value = 300;
         else
           learn_value = -300;
       } else if (!strcmp(args[1], "0-1")) {
-        strcpy_s(pgn_result, sizeof (pgn_result), "0-1"); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_result, "0-1");
         if (crafty_is_white)
           learn_value = -300;
         else
           learn_value = 300;
       } else if (!strcmp(args[1], "1/2-1/2")) {
-        strcpy_s(pgn_result, sizeof (pgn_result), "1/2-1/2"); // Pierre-Marie Baty -- use safe version
+        strcpy(pgn_result, "1/2-1/2");
         learn_value = 1;
+      }
       LearnBook();
       return 1;
+    }
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  "safety" command sets a specific time safety margin     *
+ *  target for normal timed games.  This can generally be   *
+ *  left at the default value unless Crafty is being        *
+ *  manually operated.                                      *
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("safety", *args)) {
+    if (nargs == 2)
+      tc_safety_margin = atoi(args[1]) * 100;
+    Print(32, "safety margin set to %s.\n", DisplayTime(tc_safety_margin));
+  }
 /*
  ************************************************************
  *                                                          *
  *  "savegame" command saves the game in a file in PGN      *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("savegame", *args)) {
     struct tm *timestruct;
-    int i, more, swtm;
-    time_t secs;
     FILE *output_file;
+    time_t secs;
+    int i, more, swtm;
     char input[128], text[128], *next;
     output_file = stdout;
     secs = time(0);
     timestruct = localtime((time_t *) & secs);
     if (nargs > 1) {
-      fopen_s(&output_file, args[1], "w"); // Pierre-Marie Baty -- use safe version
-      if (!output_file) {
+      if (!(output_file = fopen(args[1], "w"))) {
         printf("unable to open %s for write.\n", args[1]);
         return 1;
+      }
+    }
     fprintf(output_file, "[Event \"%s\"]\n", pgn_event);
     fprintf(output_file, "[Result \"%s\"]\n", pgn_result);
 /* Handle setup positions and initial pass by white */
     swtm = 1;
     if (move_number > 1 || !game_wtm) {
       fseek(history_file, 0, SEEK_SET);
-      if (fscanf_s(history_file, "%s", input, sizeof (input)) == 1 && // Pierre-Marie Baty -- use safe version
+      if (fscanf(history_file, "%s", input) == 1 &&
           strcmp(input, "pass") == 0)
         swtm = 0;
+    }
     if (initial_position[0])
       fprintf(output_file, "[FEN \"%s\"]\n[SetUp \"1\"]\n", initial_position);
           "[SetUp \"1\"]\n");
+    }
     fprintf(output_file, "\n");
     next = text;
     if (!swtm) {
-      strcpy_s(text, sizeof (text), "1... "); // Pierre-Marie Baty -- use safe version
+      strcpy(next, "1... ");
       next = text + strlen(text);
+    }
 /* Output the moves */
     more = 0;
     for (i = (swtm ? 0 : 1); i < (move_number - 1) * 2 - game_wtm + 1; i++) {
       fseek(history_file, i * 10, SEEK_SET);
-      fscanf(history_file, "%s", input);
+      v = fscanf(history_file, "%s", input);
+      if (v <= 0)
+        perror("Option() fscanf error: ");
       if (!(i % 2)) {
         sprintf(next, "%d. ", i / 2 + 1);
         next = text + strlen(text);
+      }
       sprintf(next, "%s ", input);
  *  used to recreate this exact position.                   *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("savepos", *args)) {
-    int rank, file, nempty;
     FILE *output_file;
+    int rank, file, nempty;
     output_file = stdout;
     if (nargs > 1) {
       if (!strcmp(args[1], "*")) {
         output_file = 0;
-        initial_position[0] = 0; // Pierre-Marie Baty -- use safe version
+        strcpy(initial_position, "");
       } else if (!(output_file = fopen(args[1], "w"))) {
         printf("unable to open %s for write.\n", args[1]);
         return 1;
+      }
+    }
+      }
       if (rank != RANK1) {
         if (output_file)
           fprintf(output_file, "/");
         else
-          strcat_s(initial_position, sizeof (initial_position), "/"); // Pierre-Marie Baty -- use safe version
+          sprintf(initial_position + strlen(initial_position), "/");
+      }
+    }
     if (output_file)
       fprintf(output_file, " %c ", (game_wtm) ? 'w' : 'b');
     else
-      strcat_s(initial_position, sizeof (initial_position), (game_wtm) ? " w " : " b "); // Pierre-Marie Baty -- use safe version
+      sprintf(initial_position + strlen(initial_position), " %c ",
+          (game_wtm) ? 'w' : 'b');
     if (Castle(0, white) & 1) {
       if (output_file)
         fprintf(output_file, "K");
       else
-        strcat_s(initial_position, sizeof (initial_position), "K"); // Pierre-Marie Baty -- use safe version
+        sprintf(initial_position + strlen(initial_position), "K");
+    }
     if (Castle(0, white) & 2) {
       if (output_file)
         fprintf(output_file, "Q");
       else
-        strcat_s(initial_position, sizeof (initial_position), "Q"); // Pierre-Marie Baty -- use safe version
+        sprintf(initial_position + strlen(initial_position), "Q");
+    }
     if (Castle(0, black) & 1) {
       if (output_file)
         fprintf(output_file, "k");
       else
-        strcat_s(initial_position, sizeof (initial_position), "k"); // Pierre-Marie Baty -- use safe version
+        sprintf(initial_position + strlen(initial_position), "k");
+    }
     if (Castle(0, black) & 2) {
       if (output_file)
         fprintf(output_file, "q");
       else
-        strcat_s(initial_position, sizeof (initial_position), "q"); // Pierre-Marie Baty -- use safe version
+        sprintf(initial_position + strlen(initial_position), "q");
+    }
     if (!Castle(0, white) && !Castle(0, black)) {
       if (output_file)
         fprintf(output_file, " -");
       else
-        strcat_s(initial_position, sizeof (initial_position), " -"); // Pierre-Marie Baty -- use safe version
+        sprintf(initial_position + strlen(initial_position), " -");
+    }
     if (EnPassant(0)) {
       if (output_file)
         fprintf(output_file, " %c%c", File(EnPassant(0)) + 'a',
             Rank(EnPassant(0)) + '1');
             File(EnPassant(0)) + 'a', Rank(EnPassant(0)) + '1');
     } else {
       if (output_file)
         fprintf(output_file, " -");
       else
-        strcat_s(initial_position, sizeof (initial_position), " -"); // Pierre-Marie Baty -- use safe version
+        sprintf(initial_position + strlen(initial_position), " -");
+    }
     if (output_file)
       fprintf(output_file, "\n");
     if (output_file && output_file != stdout) {
       fprintf(output_file, "exit\n");
  *  scale some scoring value(s) by a percentage that can    *
  *  be either positive or negative.                         *
  *                                                          *
  ************************************************************
  */
   else if (!strcmp("scale", *args)) {
     scale = atoi(args[1]);
-  }
-/*
- ************************************************************
- *                                                          *
- *  "search" command sets a specific move for the search    *
- *  to analyze, ignoring all others completely.             *
- *                                                          *
- ************************************************************
- */
-  else if (OptionMatch("search", *args)) {
-    if (thinking || pondering)
-      return 2;
-    if (nargs < 2) {
-      printf("usage:  search <move>\n");
-      return 1;
-    }
-    search_move = InputMove(tree, args[1], 0, game_wtm, 0, 0);
-    if (!search_move)
-      search_move = InputMove(tree, args[1], 0, Flip(game_wtm), 0, 0);
-    if (!search_move)
-      printf("illegal move.\n");
-  }
-/*
- ************************************************************
- *                                                          *
- *  "settc" command is used to reset the time controls      *
- *  after a complete restart.                               *
- *                                                          *
- ************************************************************
- */
-  else if (OptionMatch("settc", *args)) {
-    if (thinking || pondering)
-      return 2;
-    if (nargs < 4) {
-      printf("usage:  settc <wmoves> <wtime> <bmoves> <btime>\n");
-      return 1;
-    }
-    tc_moves_remaining[white] = atoi(args[1]);
-    tc_time_remaining[white] = ParseTime(args[2]) * 6000;
-    tc_moves_remaining[black] = atoi(args[3]);
-    tc_time_remaining[black] = ParseTime(args[4]) * 6000;
-    Print(128, "time remaining: %s (white).\n",
-        DisplayTime(tc_time_remaining[white]));
-    Print(128, "time remaining: %s (black).\n",
-        DisplayTime(tc_time_remaining[black]));
-    if (tc_sudden_death != 1) {
-      Print(128, "%d moves to next time control (white)\n",
-          tc_moves_remaining[white]);
-      Print(128, "%d moves to next time control (black)\n",
-          tc_moves_remaining[black]);
-    } else
-      Print(128, "Sudden-death time control in effect\n");
-  }
-/*
- ************************************************************
- *                                                          *
- *  "setboard" command sets the board to a specific         *
- *  position for analysis by the program.                   *
- *                                                          *
- ************************************************************
- */
-  else if (OptionMatch("setboard", *args)) {
-    if (thinking || pondering)
-      return 2;
-    nargs = ReadParse(buffer, args, " \t;=");
-    if (nargs < 3) {
-      printf("usage:  setboard <fen>\n");
-      return 1;
-    }
-    SetBoard(tree, nargs - 1, args + 1, 0);
-    move_number = 1;
-    if (!game_wtm) {
-      game_wtm = 1;
-      Pass();
-    }
-    ponder_move = 0;
-    last_pv.pathd = 0;
-    last_pv.pathl = 0;
-    over = 0;
-    strcpy_s(buffer, sizeof (buffer), "savepos *"); // Pierre-Marie Baty -- use safe version
-    (void) Option(tree);
-  } else if (StrCnt(*args, '/') > 3) {
-    if (thinking || pondering)
-      return 2;
-    nargs = ReadParse(buffer, args, " \t;=");
-    SetBoard(tree, nargs, args, 0);
-    move_number = 1;
-    if (!game_wtm) {
-      game_wtm = 1;
-      Pass();
-    }
-    ponder_move = 0;
-    last_pv.pathd = 0;
-    last_pv.pathl = 0;
-    over = 0;
-    strcpy_s(buffer, sizeof (buffer), "savepos *"); // Pierre-Marie Baty -- use safe version
-    (void) Option(tree);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "score" command displays static evaluation of the       *
  *  current board position.                                 *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("score", *args)) {
-    int phase, s, tw, tb;
-    int mgb, mgw, egb, egw;
+    int phase, s, tw, tb, mgb, mgw, egb, egw, trop[2];
     if (thinking || pondering)
       return 2;
+    memset((void *) &(tree->pawn_score), 0, sizeof(tree->pawn_score));
-    Print(128, "note: scores are for the white side\n");
+    Print(32, "note: scores are for the white side\n");
-    Print(128, "                       ");
+    Print(32, "                       ");
-    Print(128, " +-----------white----------+");
+    Print(32, " +-----------white----------+");
-    Print(128, "-----------black----------+\n");
+    Print(32, "-----------black----------+\n");
     tree->score_mg = 0;
     tree->score_eg = 0;
     mgb = tree->score_mg;
     EvaluateMaterial(tree, game_wtm);
     mgb = tree->score_mg - mgb;
-    Print(128, "material.......%s", DisplayEvaluation(mgb, 1));
+    Print(32, "material.......%s", DisplayEvaluation(mgb, 1));
-    Print(128, "  |    comp     mg      eg   |");
+    Print(32, "  |    comp     mg      eg   |");
-    Print(128, "    comp     mg      eg   |\n");
+    Print(32, "    comp     mg      eg   |\n");
     root_wtm = Flip(game_wtm);
     tree->status[1] = tree->status[0];
     s = Evaluate(tree, 1, game_wtm, -99999, 99999);
+    trop[black] = tree->tropism[black];
+    trop[white] = tree->tropism[white];
     if (!game_wtm)
       s = -s;
     tree->score_mg = 0;
     tree->score_eg = 0;
-    tree->tropism[black] = 0;
-    tree->tropism[white] = 0;
     phase =
         Min(62, TotalPieces(white, occupied) + TotalPieces(black, occupied));
     tree->pawn_score.score_mg = 0;
     tree->pawn_score.score_eg = 0;
     mgb = tree->pawn_score.score_mg;
     EvaluatePawns(tree, white);
     mgw = tree->pawn_score.score_mg - mgw;
     egw = tree->pawn_score.score_eg - egw;
     tb = (mgb * phase + egb * (62 - phase)) / 62;
     tw = (mgw * phase + egw * (62 - phase)) / 62;
-    Print(128, "pawns..........%s  |", DisplayEvaluation(tb + tw, 1));
+    Print(32, "pawns..........%s  |", DisplayEvaluation(tb + tw, 1));
-    Print(128, " %s", DisplayEvaluation(tw, 1));
+    Print(32, " %s", DisplayEvaluation(tw, 1));
-    Print(128, " %s", DisplayEvaluation(mgw, 1));
+    Print(32, " %s", DisplayEvaluation(mgw, 1));
-    Print(128, " %s  |", DisplayEvaluation(egw, 1));
+    Print(32, " %s  |", DisplayEvaluation(egw, 1));
-    Print(128, " %s", DisplayEvaluation(tb, 1));
+    Print(32, " %s", DisplayEvaluation(tb, 1));
-    Print(128, " %s", DisplayEvaluation(mgb, 1));
+    Print(32, " %s", DisplayEvaluation(mgb, 1));
-    Print(128, " %s  |\n", DisplayEvaluation(egb, 1));
+    Print(32, " %s  |\n", DisplayEvaluation(egb, 1));
     mgb = tree->score_mg;
     egb = tree->score_eg;
     EvaluatePassedPawns(tree, black, game_wtm);
     mgb = tree->score_mg - mgb;
     egb = tree->score_eg - egb;
     EvaluatePassedPawns(tree, white, game_wtm);
     mgw = tree->score_mg - mgw;
     egw = tree->score_eg - egw;
     tb = (mgb * phase + egb * (62 - phase)) / 62;
     tw = (mgw * phase + egw * (62 - phase)) / 62;
-    Print(128, "passed pawns...%s  |", DisplayEvaluation(tb + tw, 1));
+    Print(32, "passed pawns...%s  |", DisplayEvaluation(tb + tw, 1));
-    Print(128, " %s", DisplayEvaluation(tw, 1));
+    Print(32, " %s", DisplayEvaluation(tw, 1));
-    Print(128, " %s", DisplayEvaluation(mgw, 1));
+    Print(32, " %s", DisplayEvaluation(mgw, 1));
-    Print(128, " %s  |", DisplayEvaluation(egw, 1));
+    Print(32, " %s  |", DisplayEvaluation(egw, 1));
-    Print(128, " %s", DisplayEvaluation(tb, 1));
+    Print(32, " %s", DisplayEvaluation(tb, 1));
-    Print(128, " %s", DisplayEvaluation(mgb, 1));
+    Print(32, " %s", DisplayEvaluation(mgb, 1));
-    Print(128, " %s  |\n", DisplayEvaluation(egb, 1));
+    Print(32, " %s  |\n", DisplayEvaluation(egb, 1));
     mgb = tree->score_mg;
     egb = tree->score_eg;
     EvaluateKnights(tree, black);
     mgb = tree->score_mg - mgb;
     egb = tree->score_eg - egb;
     EvaluateKnights(tree, white);
     mgw = tree->score_mg - mgw;
     egw = tree->score_eg - egw;
     tb = (mgb * phase + egb * (62 - phase)) / 62;
     tw = (mgw * phase + egw * (62 - phase)) / 62;
-    Print(128, "knights........%s  |", DisplayEvaluation(tb + tw, 1));
+    Print(32, "knights........%s  |", DisplayEvaluation(tb + tw, 1));
-    Print(128, " %s", DisplayEvaluation(tw, 1));
+    Print(32, " %s", DisplayEvaluation(tw, 1));
-    Print(128, " %s", DisplayEvaluation(mgw, 1));
+    Print(32, " %s", DisplayEvaluation(mgw, 1));
-    Print(128, " %s  |", DisplayEvaluation(egw, 1));
+    Print(32, " %s  |", DisplayEvaluation(egw, 1));
-    Print(128, " %s", DisplayEvaluation(tb, 1));
+    Print(32, " %s", DisplayEvaluation(tb, 1));
-    Print(128, " %s", DisplayEvaluation(mgb, 1));
+    Print(32, " %s", DisplayEvaluation(mgb, 1));
-    Print(128, " %s  |\n", DisplayEvaluation(egb, 1));
+    Print(32, " %s  |\n", DisplayEvaluation(egb, 1));
     mgb = tree->score_mg;
     egb = tree->score_eg;
     EvaluateBishops(tree, black);
     mgb = tree->score_mg - mgb;
     egb = tree->score_eg - egb;
     EvaluateBishops(tree, white);
     mgw = tree->score_mg - mgw;
     egw = tree->score_eg - egw;
     tb = (mgb * phase + egb * (62 - phase)) / 62;
     tw = (mgw * phase + egw * (62 - phase)) / 62;
-    Print(128, "bishops........%s  |", DisplayEvaluation(tb + tw, 1));
+    Print(32, "bishops........%s  |", DisplayEvaluation(tb + tw, 1));
-    Print(128, " %s", DisplayEvaluation(tw, 1));
+    Print(32, " %s", DisplayEvaluation(tw, 1));
-    Print(128, " %s", DisplayEvaluation(mgw, 1));
+    Print(32, " %s", DisplayEvaluation(mgw, 1));
-    Print(128, " %s  |", DisplayEvaluation(egw, 1));
+    Print(32, " %s  |", DisplayEvaluation(egw, 1));
-    Print(128, " %s", DisplayEvaluation(tb, 1));
+    Print(32, " %s", DisplayEvaluation(tb, 1));
-    Print(128, " %s", DisplayEvaluation(mgb, 1));
+    Print(32, " %s", DisplayEvaluation(mgb, 1));
-    Print(128, " %s  |\n", DisplayEvaluation(egb, 1));
+    Print(32, " %s  |\n", DisplayEvaluation(egb, 1));
     mgb = tree->score_mg;
     egb = tree->score_eg;
     EvaluateRooks(tree, black);
     mgb = tree->score_mg - mgb;
     egb = tree->score_eg - egb;
     EvaluateRooks(tree, white);
     mgw = tree->score_mg - mgw;
     egw = tree->score_eg - egw;
     tb = (mgb * phase + egb * (62 - phase)) / 62;
     tw = (mgw * phase + egw * (62 - phase)) / 62;
-    Print(128, "rooks..........%s  |", DisplayEvaluation(tb + tw, 1));
+    Print(32, "rooks..........%s  |", DisplayEvaluation(tb + tw, 1));
-    Print(128, " %s", DisplayEvaluation(tw, 1));
+    Print(32, " %s", DisplayEvaluation(tw, 1));
-    Print(128, " %s", DisplayEvaluation(mgw, 1));
+    Print(32, " %s", DisplayEvaluation(mgw, 1));
-    Print(128, " %s  |", DisplayEvaluation(egw, 1));
+    Print(32, " %s  |", DisplayEvaluation(egw, 1));
-    Print(128, " %s", DisplayEvaluation(tb, 1));
+    Print(32, " %s", DisplayEvaluation(tb, 1));
-    Print(128, " %s", DisplayEvaluation(mgb, 1));
+    Print(32, " %s", DisplayEvaluation(mgb, 1));
-    Print(128, " %s  |\n", DisplayEvaluation(egb, 1));
+    Print(32, " %s  |\n", DisplayEvaluation(egb, 1));
     mgb = tree->score_mg;
     egb = tree->score_eg;
     EvaluateQueens(tree, black);
     mgb = tree->score_mg - mgb;
     egb = tree->score_eg - egb;
     EvaluateQueens(tree, white);
     mgw = tree->score_mg - mgw;
     egw = tree->score_eg - egw;
     tb = (mgb * phase + egb * (62 - phase)) / 62;
     tw = (mgw * phase + egw * (62 - phase)) / 62;
-    Print(128, "queens.........%s  |", DisplayEvaluation(tb + tw, 1));
+    Print(32, "queens.........%s  |", DisplayEvaluation(tb + tw, 1));
-    Print(128, " %s", DisplayEvaluation(tw, 1));
+    Print(32, " %s", DisplayEvaluation(tw, 1));
-    Print(128, " %s", DisplayEvaluation(mgw, 1));
+    Print(32, " %s", DisplayEvaluation(mgw, 1));
-    Print(128, " %s  |", DisplayEvaluation(egw, 1));
+    Print(32, " %s  |", DisplayEvaluation(egw, 1));
-    Print(128, " %s", DisplayEvaluation(tb, 1));
+    Print(32, " %s", DisplayEvaluation(tb, 1));
-    Print(128, " %s", DisplayEvaluation(mgb, 1));
+    Print(32, " %s", DisplayEvaluation(mgb, 1));
-    Print(128, " %s  |\n", DisplayEvaluation(egb, 1));
+    Print(32, " %s  |\n", DisplayEvaluation(egb, 1));
+    tree->tropism[black] = trop[black];
+    tree->tropism[white] = trop[white];
     mgb = tree->score_mg;
     egb = tree->score_eg;
-    EvaluateKings(tree, 1, black);
+    EvaluateKing(tree, 1, black);
     mgb = tree->score_mg - mgb;
     egb = tree->score_eg - egb;
     mgw = tree->score_mg;
     egw = tree->score_eg;
-    EvaluateKings(tree, 1, white);
+    EvaluateKing(tree, 1, white);
     mgw = tree->score_mg - mgw;
     egw = tree->score_eg - egw;
     tb = (mgb * phase + egb * (62 - phase)) / 62;
     tw = (mgw * phase + egw * (62 - phase)) / 62;
-    Print(128, "kings..........%s  |", DisplayEvaluation(tb + tw, 1));
+    Print(32, "kings..........%s  |", DisplayEvaluation(tb + tw, 1));
-    Print(128, " %s", DisplayEvaluation(tw, 1));
+    Print(32, " %s", DisplayEvaluation(tw, 1));
-    Print(128, " %s", DisplayEvaluation(mgw, 1));
+    Print(32, " %s", DisplayEvaluation(mgw, 1));
-    Print(128, " %s  |", DisplayEvaluation(egw, 1));
+    Print(32, " %s  |", DisplayEvaluation(egw, 1));
-    Print(128, " %s", DisplayEvaluation(tb, 1));
+    Print(32, " %s", DisplayEvaluation(tb, 1));
-    Print(128, " %s", DisplayEvaluation(mgb, 1));
+    Print(32, " %s", DisplayEvaluation(mgb, 1));
-    Print(128, " %s  |\n", DisplayEvaluation(egb, 1));
+    Print(32, " %s  |\n", DisplayEvaluation(egb, 1));
     mgb = tree->score_mg;
     egb = tree->score_eg;
-    EvaluateDevelopment(tree, 1, black);
+    EvaluateCastling(tree, 1, black);
     mgb = tree->score_mg - mgb;
     egb = tree->score_eg - egb;
     mgw = tree->score_mg;
     egw = tree->score_eg;
-    EvaluateDevelopment(tree, 1, white);
+    EvaluateCastling(tree, 1, white);
     mgw = tree->score_mg - mgw;
     egw = tree->score_eg - egw;
     tb = (mgb * phase + egb * (62 - phase)) / 62;
     tw = (mgw * phase + egw * (62 - phase)) / 62;
-    Print(128, "development....%s  |", DisplayEvaluation(tb + tw, 1));
+    Print(32, "castling.......%s  |", DisplayEvaluation(tb + tw, 1));
-    Print(128, " %s", DisplayEvaluation(tw, 1));
+    Print(32, " %s", DisplayEvaluation(tw, 1));
-    Print(128, " %s", DisplayEvaluation(mgw, 1));
+    Print(32, " %s", DisplayEvaluation(mgw, 1));
-    Print(128, " %s  |", DisplayEvaluation(egw, 1));
+    Print(32, " %s  |", DisplayEvaluation(egw, 1));
-    Print(128, " %s", DisplayEvaluation(tb, 1));
+    Print(32, " %s", DisplayEvaluation(tb, 1));
-    Print(128, " %s", DisplayEvaluation(mgb, 1));
+    Print(32, " %s", DisplayEvaluation(mgb, 1));
-    Print(128, " %s  |\n", DisplayEvaluation(egb, 1));
+    Print(32, " %s  |\n", DisplayEvaluation(egb, 1));
     egb = tree->score_eg;
     if ((TotalPieces(white, occupied) == 0 && tree->pawn_score.passed[black])
         || (TotalPieces(black, occupied) == 0 &&
             tree->pawn_score.passed[white]))
       EvaluatePassedPawnRaces(tree, game_wtm);
     egb = tree->score_eg - egb;
-    Print(128, "pawn races.....%s", DisplayEvaluation(egb, 1));
+    Print(32, "pawn races.....%s", DisplayEvaluation(egb, 1));
-    Print(128, "  +--------------------------+--------------------------+\n");
+    Print(32, "  +--------------------------+--------------------------+\n");
-    Print(128, "total..........%s\n", DisplayEvaluation(s, 1));
+    Print(32, "total..........%s\n", DisplayEvaluation(s, 1));
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  "screen" command runs runs through a test suite of      *
+ *  positions and culls any where a search returns a value  *
+ *  outside the margin given to the screen command.         *
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("screen", *args)) {
+    int margin = 9999999, save_noise, save_display;
+    nargs = ReadParse(buffer, args, " \t;=");
+    if (thinking || pondering)
+      return 2;
+    if (nargs < 3) {
+      printf("usage:  screen <filename> score-margin\n");
+      return 1;
+    }
+    save_noise = noise_level;
+    save_display = display_options;
+    early_exit = 99;
+    margin = atoi(args[2]);
+    noise_level = 99999999;
+    display_options = 2048;
+    Test(args[1], 0, 1, margin);
+    noise_level = save_noise;
+    display_options = save_display;
+    ponder_move = 0;
+    last_pv.pathd = 0;
+    last_pv.pathl = 0;
+  }
 /*
  ************************************************************
  *                                                          *
  *  "sd" command sets a specific search depth to control    *
     if (nargs < 2) {
       printf("usage:  sd <depth>\n");
       return 1;
+    }
     search_depth = atoi(args[1]);
-    Print(128, "search depth set to %d.\n", search_depth);
+    Print(32, "search depth set to %d.\n", search_depth);
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  "search" command sets a specific move for the search    *
+ *  to analyze, ignoring all others completely.             *
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("search", *args)) {
+    if (thinking || pondering)
+      return 2;
+    if (nargs < 2) {
+      printf("usage:  search <move>\n");
+      return 1;
+    }
+    search_move = InputMove(tree, 0, game_wtm, 0, 0, args[1]);
+    if (!search_move)
+      search_move = InputMove(tree, 0, Flip(game_wtm), 0, 0, args[1]);
+    if (!search_move)
+      printf("illegal move.\n");
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  "setboard" command sets the board to a specific         *
+ *  position for analysis by the program.                   *
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("setboard", *args)) {
+    if (thinking || pondering)
+      return 2;
+    nargs = ReadParse(buffer, args, " \t;=");
+    if (nargs < 3) {
+      printf("usage:  setboard <fen>\n");
+      return 1;
+    }
+    SetBoard(tree, nargs - 1, args + 1, 0);
+    move_number = 1;
+    if (!game_wtm) {
+      game_wtm = 1;
+      Pass();
+    }
+    ponder_move = 0;
+    last_pv.pathd = 0;
+    last_pv.pathl = 0;
+    over = 0;
+    strcpy(buffer, "savepos *");
+    Option(tree);
+  } else if (StrCnt(*args, '/') > 3) {
+    if (thinking || pondering)
+      return 2;
+    nargs = ReadParse(buffer, args, " \t;=");
+    SetBoard(tree, nargs, args, 0);
+    move_number = 1;
+    if (!game_wtm) {
+      game_wtm = 1;
+      Pass();
+    }
+    ponder_move = 0;
+    last_pv.pathd = 0;
+    last_pv.pathl = 0;
+    over = 0;
+    strcpy(buffer, "savepos *");
+    Option(tree);
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  "settc" command is used to reset the time controls      *
+ *  after a complete restart.                               *
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("settc", *args)) {
+    if (thinking || pondering)
+      return 2;
+    if (nargs < 4) {
+      printf("usage:  settc <wmoves> <wtime> <bmoves> <btime>\n");
+      return 1;
+    }
+    tc_moves_remaining[white] = atoi(args[1]);
+    tc_time_remaining[white] = ParseTime(args[2]) * 6000;
+    tc_moves_remaining[black] = atoi(args[3]);
+    tc_time_remaining[black] = ParseTime(args[4]) * 6000;
+    Print(32, "time remaining: %s (white).\n",
+        DisplayTime(tc_time_remaining[white]));
+    Print(32, "time remaining: %s (black).\n",
+        DisplayTime(tc_time_remaining[black]));
+    if (tc_sudden_death != 1) {
+      Print(32, "%d moves to next time control (white)\n",
+          tc_moves_remaining[white]);
+      Print(32, "%d moves to next time control (black)\n",
+          tc_moves_remaining[black]);
+    } else
+      Print(32, "Sudden-death time control in effect\n");
+    TimeSet(999);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "show" command enables/disables whether or not we want  *
       return 1;
+    }
     if (OptionMatch("book", args[1])) {
       show_book = !show_book;
       if (show_book)
-        Print(128, "show book statistics\n");
+        Print(32, "show book statistics\n");
       else
-        Print(128, "don't show book statistics\n");
+        Print(32, "don't show book statistics\n");
+    }
+  }
 /*
  ************************************************************
  *                                                          *
   else if (OptionMatch("skill", *args)) {
     if (nargs < 2) {
       printf("usage:  skill <1-100>\n");
       return 1;
+    }
-    if (skill != 100) {
+    if (skill != 100)
       printf("ERROR:  skill can only be changed one time in a game\n");
-    } else {
+    else {
       skill = atoi(args[1]);
       if (skill < 1 || skill > 100) {
         printf("ERROR: skill range is 1-100 only\n");
         skill = 100;
+      }
-      Print(128, "skill level set to %d%%\n", skill);
+      Print(32, "skill level set to %d%%\n", skill);
-      null_depth = null_depth * skill / 100;
+      null_depth = (null_depth * skill + 50) / 100;
+      if (skill < 100)
+        null_divisor = null_divisor + 2 * (100 - skill) / 10;
-      check_depth = check_depth * skill / 100;
+      check_depth = (check_depth * skill + 50) / 100;
-      LMR_min_reduction = LMR_min_reduction * skill / 100;
+      LMR_min = (LMR_min * skill + 50) / 100;
-      LMR_max_reduction = LMR_max_reduction * skill / 100;
+      LMR_max = (LMR_max * skill + 50) / 100;
+      InitializeReductions();
+    }
+  }
 #endif
 /*
  ************************************************************
  *                                                          *
  *   "smp" command is used to tune the various SMP search   *
  *   parameters.                                            *
+ *                                                          *
+ *   "smpaffinity" command is used to enable (>= 0) and to  *
+ *   disable smp processor affinity (off).  If you try to   *
+ *   run two instances of Crafty on the same machine, ONE   *
+ *   them (if not both) need to have processor affinity     *
+ *   disabled or else you can use the smpaffinity=<n> to    *
+ *   prevent processor conflicts.  If you use a 32 core     *
+ *   machine, and you want to run two instances of Crafty,  *
+ *   use smpaffinity=0 on one, and smpaffinity=16 on the    *
+ *   other.  The first will bind to processors 0-15, and    *
+ *   the second will bind to processors 16-31.              *
  *                                                          *
  *   "smpgroup" command is used to control how many threads *
  *   may work together at any point in the tree.  The       *
  *   usual default is 6, but this might be reduced on a     *
  *   machine with a large number of processors.  It should  *
  *   larger than the compiled-in -DCPUS=n value.            *
  *                                                          *
  *   "smpnice" command turns on "nice" mode where idle      *
  *   processors are terminated between searches to avoid    *
  *   burning CPU time in the idle loop.                     *
+ *                                                          *
+ *   "smpnuma" command enables NUMA mode which distributes  *
+ *   hash tables across all NUMA nodes evenly.  If your     *
+ *   machine is not NUMA, or only has one socket (node) you *
+ *   should set this to zero as it will be slightly more    *
+ *   efficient when you change hash sizes.                  *
  *                                                          *
  *   "smproot" command is used to enable (1) or disable (0) *
  *   splitting the tree at the root (ply=1).  Splitting at  *
  *   the root is more efficient, but might slow finding the *
  *   move in some test positions.                           *
  *                                                          *
+ *   "smpgsd" sets the minimum depth remaining at which a   *
+ *   gratuitous split can be done.                          *
+ *                                                          *
- *   "smpsn" sets the minimum number of nodes that must be  *
+ *   "smpgsl" sets the maximum number of gratuitous splits  *
- *   searched at any node before we can do a parallel split *
+ *   per thread.  This only counts splits that have not yet *
- *   to search the remaining moves there in parallel.       *
+ *   been joined.                                           *
  *                                                          *
  ************************************************************
  */
+  else if (OptionMatch("smpaffinity", *args)) {
+    if (nargs < 2) {
+      printf("usage:  smpaffinity <0/1>\n");
+      return 1;
+    }
+    if (!strcmp(args[1], "off"))
+      smp_affinity = -1;
+    else
+      smp_affinity = atoi(args[1]);
+    if (smp_affinity >= 0)
+      Print(32, "smp processor affinity enabled.\n");
+    else
+      Print(32, "smp processor affinity disabled.\n");
-  else if (OptionMatch("smpmin", *args)) {
+  } else if (OptionMatch("smpmin", *args)) {
     if (nargs < 2) {
       printf("usage:  smpmin <depth>\n");
       return 1;
+    }
     smp_min_split_depth = atoi(args[1]);
-    Print(128, "minimum thread depth set to %d.\n", smp_min_split_depth);
+    Print(32, "minimum thread depth set to %d.\n", smp_min_split_depth);
   } else if (OptionMatch("smpgroup", *args)) {
     if (nargs < 2) {
       printf("usage:  smpgroup <threads>\n");
       return 1;
+    }
     smp_split_group = atoi(args[1]);
-    Print(128, "maximum thread group size set to %d.\n", smp_split_group);
+    Print(32, "maximum thread group size set to %d.\n", smp_split_group);
   } else if (OptionMatch("smpmt", *args) || OptionMatch("mt", *args)
       || OptionMatch("cores", *args)) {
     int proc;
     if (nargs < 2) {
       return 1;
+    }
     if (thinking || pondering)
       return 3;
     allow_cores = 0;
+    if (xboard)
-    Print(4095, "Warning--  xboard 'cores' option disabled\n");
+      Print(4095, "Warning--  xboard 'cores' option disabled\n");
     smp_max_threads = atoi(args[1]);
     if (smp_max_threads > CPUS) {
       Print(4095, "ERROR - Crafty was compiled with CPUS=%d.", CPUS);
       Print(4095, "  mt can not exceed this value.\n");
       smp_max_threads = CPUS;
+    }
+    if (smp_max_threads == 1) {
+      Print(4095, "ERROR - max threads can be set to zero (0) to");
+      Print(4095, " disable parallel search, otherwise it must be > 1.\n");
+      smp_max_threads = 0;
+    }
     if (smp_max_threads)
-      Print(128, "max threads set to %d.\n", smp_max_threads);
+      Print(32, "max threads set to %d.\n", smp_max_threads);
     else
-      Print(128, "parallel threads disabled.\n");
+      Print(32, "parallel threads disabled.\n");
     for (proc = 1; proc < CPUS; proc++)
-      if (proc >= smp_max_threads)
+      if (proc >= (int) smp_max_threads) // Pierre-Marie Baty -- added type cast
-        thread[proc].tree = (TREE *) - 1;
+        thread[proc].terminate = 1;
   } else if (OptionMatch("smpnice", *args)) {
     if (nargs < 2) {
       printf("usage:  smpnice 0|1\n");
       return 1;
+    }
     smp_nice = atoi(args[1]);
     if (smp_nice)
-      Print(128, "SMP terminate extra threads when idle.\n");
+      Print(32, "SMP terminate extra threads when idle.\n");
     else
-      Print(128, "SMP keep extra threads spinning when idle.\n");
+      Print(32, "SMP keep extra threads spinning when idle.\n");
+  } else if (OptionMatch("smpnuma", *args)) {
+    if (nargs < 2) {
+      printf("usage:  smpnuma 0|1\n");
+      return 1;
+    }
+    smp_numa = atoi(args[1]);
+    if (smp_numa)
+      Print(32, "SMP NUMA mode enabled.\n");
+    else
+      Print(32, "SMP NUMA mode disabled.\n");
   } else if (OptionMatch("smproot", *args)) {
     if (nargs < 2) {
       printf("usage:  smproot 0|1\n");
       return 1;
+    }
     smp_split_at_root = atoi(args[1]);
     if (smp_split_at_root)
-      Print(128, "SMP search split at ply >= 1.\n");
+      Print(32, "SMP search split at ply >= 1.\n");
     else
-      Print(128, "SMP search split at ply > 1.\n");
+      Print(32, "SMP search split at ply > 1.\n");
+  } else if (OptionMatch("smpgsl", *args)) {
+    if (nargs < 2) {
+      printf("usage:  smpgsl <n>\n");
+      return 1;
+    }
+    smp_gratuitous_limit = atoi(args[1]);
+    Print(32, "maximum gratuitous splits allowed %d.\n",
+        smp_gratuitous_limit);
-  } else if (OptionMatch("smpsn", *args)) {
+  } else if (OptionMatch("smpgsd", *args)) {
     if (nargs < 2) {
-      printf("usage:  smpsn <nodes>\n");
+      printf("usage:  smpgsd <nodes>\n");
       return 1;
+    }
-    smp_split_nodes = atoi(args[1]);
+    smp_gratuitous_depth = atoi(args[1]);
-    Print(128, "minimum nodes before a split %d.\n", smp_split_nodes);
+    Print(32, "gratuitous split min depth %d.\n", smp_gratuitous_depth);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "sn" command sets a specific number of nodes to search  *
     if (nargs < 2) {
       printf("usage:  sn <nodes>\n");
       return 1;
+    }
     search_nodes = atoi(args[1]);
-    Print(128, "search nodes set to %" PRIu64 ".\n", search_nodes);
+    Print(32, "search nodes set to %" PRIu64 ".\n", search_nodes);
     ponder = 0;
+  }
 /*
  ************************************************************
  *                                                          *
  *  "st" command sets a specific search time to control the *
  *  tree search time.                                       *
  *                                                          *
  ************************************************************
  */
-  else if (!strcmp("st", *args)) {
+  else if (OptionMatch("st", *args)) {
     if (nargs < 2) {
       printf("usage:  st <time>\n");
       return 1;
+    }
     search_time_limit = (int) (atof(args[1]) * 100); // Pierre-Marie Baty -- added type cast
-    Print(128, "search time set to %.2f.\n",
+    Print(32, "search time set to %.2f.\n",
         (float) search_time_limit / 100.0);
-  }
-/*
- ************************************************************
- *                                                          *
- *  "surplus" command sets a specific time surplus target   *
- *  for normal tournament games.                            *
- *                                                          *
- ************************************************************
- */
-  else if (OptionMatch("surplus", *args)) {
-    if (nargs == 2)
-      tc_safety_margin = atoi(args[1]) * 6000;
-    Print(128, "time surplus set to %s.\n", DisplayTime(tc_safety_margin));
+  }
 /*
  ************************************************************
  *                                                          *
  *  "swindle" command turns swindle mode off/on.            *
  *  displays results.                                       *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("test", *args)) {
+    FILE *unsolved = NULL;
-    nargs = ReadParse(buffer, args, "\t ;=");
+    int save_noise, save_display;
     if (thinking || pondering)
       return 2;
+    nargs = ReadParse(buffer, args, " \t;=");
     if (nargs < 2) {
       printf("usage:  test <filename> [exitcnt]\n");
       return 1;
+    }
+    save_noise = noise_level;
+    save_display = display_options;
     if (nargs > 2)
       early_exit = atoi(args[2]);
-    Test(args[1]);
+    if (nargs > 3)
+      unsolved = fopen(args[3], "w+");
+    Test(args[1], unsolved, 0, 0);
+    noise_level = save_noise;
+    display_options = save_display;
     ponder_move = 0;
     last_pv.pathd = 0;
     last_pv.pathl = 0;
+    if (unsolved)
+      fclose(unsolved);
+  }
 /*
  ************************************************************
  *                                                          *
  *  "time" is used to set the basic search timing controls. *
  *                                                          *
  ************************************************************
  */
   else if (OptionMatch("time", *args)) {
     if (xboard) {
-      tc_time_remaining[root_wtm] = atoi(args[1]);
+      tc_time_remaining[Flip(game_wtm)] = atoi(args[1]);
       if (log_file && time_limit > 99)
         fprintf(log_file, "time remaining: %s (Crafty).\n",
-            DisplayTime(tc_time_remaining[root_wtm]));
+            DisplayTime(tc_time_remaining[Flip(game_wtm)]));
     } else {
       if (thinking || pondering)
         return 2;
       tc_moves = 60;
       tc_time = 180000;
       tc_time_remaining[white] = tc_time;
       tc_time_remaining[black] = tc_time;
       tc_moves_remaining[white] = tc_moves;
       tc_moves_remaining[black] = tc_moves;
       if (!tc_sudden_death) {
-        Print(128, "%d moves/%d minutes primary time control\n", tc_moves,
+        Print(32, "%d moves/%d minutes primary time control\n", tc_moves,
             tc_time / 100);
-        Print(128, "%d moves/%d minutes secondary time control\n",
+        Print(32, "%d moves/%d minutes secondary time control\n",
             tc_secondary_moves, tc_secondary_time / 100);
         if (tc_increment)
-          Print(128, "increment %d seconds.\n", tc_increment / 100);
+          Print(32, "increment %d seconds.\n", tc_increment / 100);
       } else if (tc_sudden_death == 1) {
-        Print(128, " game/%d minutes primary time control\n", tc_time / 100);
+        Print(32, " game/%d minutes primary time control\n", tc_time / 100);
         if (tc_increment)
-          Print(128, "increment %d seconds.\n", tc_increment / 100);
+          Print(32, "increment %d seconds.\n", tc_increment / 100);
       } else if (tc_sudden_death == 2) {
-        Print(128, "%d moves/%d minutes primary time control\n", tc_moves,
+        Print(32, "%d moves/%d minutes primary time control\n", tc_moves,
             tc_time / 100);
-        Print(128, "game/%d minutes secondary time control\n",
+        Print(32, "game/%d minutes secondary time control\n",
             tc_secondary_time / 100);
         if (tc_increment)
-          Print(128, "increment %d seconds.\n", tc_increment / 100);
+          Print(32, "increment %d seconds.\n", tc_increment / 100);
+      }
       tc_time *= 60;
       tc_time_remaining[white] *= 60;
       tc_time_remaining[black] *= 60;
       tc_secondary_time *= 60;
  *  "undo" command backs up 1/2 move, which leaves the      *
  *  opposite side on move. [xboard compatibility]           *
  *                                                          *
  ************************************************************
  */
-  else if (!strcmp("undo", *args)) {
+  else if (OptionMatch("undo", *args)) {
     if (thinking || pondering)
       return 2;
     if (!game_wtm || move_number != 1) {
       game_wtm = Flip(game_wtm);
       if (Flip(game_wtm))
         move_number--;
-      sprintf_s(buffer, sizeof (buffer), "reset %d", move_number); // Pierre-Marie Baty -- use safe version
+      sprintf(buffer, "reset %d", move_number);
-      (void) Option(tree);
+      Option(tree);
+    }
+  }
 /*
- *****************************************************************
+ ************************************************************
- *                                                               *
+ *                                                          *
- *  "usage" command controls the time usage multiplier factors   *
+ *  "usage" command controls the time usage multiplier      *
- *  used in the game  - percentage increase or decrease in time  *
+ *  factors used in the game  - percentage increase or      *
- *  used up front.  Enter a number between 1 to 100 for the %    *
+ *  decrease in time used up front.  Enter a number between *
+ *  1 to 100 for the % decrease (negative value) or to      *
- *  decrease (negative value) or to increase (positive value)    *
+ *  increase (positive value) although other time           *
- *  although other time limitation controls may kick in.  This   *
+ *  limitation controls may kick in.  This more commonly    *
- *  more commonly used in the .craftyrc/crafty.rc file.          *
+ *  used in the .craftyrc/crafty.rc file.                   *
- *                                                               *
+ *                                                          *
- *****************************************************************
+ ************************************************************
  */
   else if (OptionMatch("usage", *args)) {
     if (nargs < 2) {
       printf("usage:  usage <percentage>\n");
       return 1;
     usage_level = atoi(args[1]);
     if (usage_level > 50)
       usage_level = 50;
     else if (usage_level < -50)
       usage_level = -50;
-    Print(128,
-        "time usage up front set to %d percent increase/(-)decrease.\n",
+    Print(32, "time usage up front set to %d percent increase/(-)decrease.\n",
         usage_level);
+  }
 /*
  ************************************************************
  *                                                          *
   else if (OptionMatch("whisper", *args)) {
     if (nargs < 2) {
       printf("usage:  whisper <level>\n");
       return 1;
+    }
-    kibitz = 16 + atoi(args[1]);
+    kibitz = 16 + Min(0, atoi(args[1]));
+  }
+/*
+ ************************************************************
+ *                                                          *
+ *  "white" command sets white to move (wtm).               *
+ *                                                          *
+ ************************************************************
+ */
+  else if (OptionMatch("white", *args)) {
+    if (thinking || pondering)
+      return 2;
+    ponder_move = 0;
+    last_pv.pathd = 0;
+    last_pv.pathl = 0;
+    if (!game_wtm)
+      Pass();
+    force = 0;
+  }
 /*
  ************************************************************
  *                                                          *
  *  "wild" command sets up an ICS wild position (only 7 at  *
       return 1;
+    }
     i = atoi(args[1]);
     switch (i) {
       case 7:
-        strcpy_s(buffer, sizeof (buffer), "setboard 4k/5ppp/////PPP/3K/ w"); // Pierre-Marie Baty -- use safe version
+        strcpy(buffer, "setboard 4k/5ppp/////PPP/3K/ w");
-        (void) Option(tree);
+        Option(tree);
         break;
       default:
         printf("sorry, only wild7 implemented at present\n");
         break;
+    }
-  }
-/*
- ************************************************************
- *                                                          *
- *  "white" command sets white to move (wtm).               *
- *                                                          *
- ************************************************************
- */
-  else if (OptionMatch("white", *args)) {
-    if (thinking || pondering)
-      return 2;
-    ponder_move = 0;
-    last_pv.pathd = 0;
-    last_pv.pathl = 0;
-    if (!game_wtm)
-      Pass();
-    force = 0;
+  }
 /*
  ************************************************************
  *                                                          *
  *  "xboard" command is normally invoked from main() via    *
  */
   else if (OptionMatch("xboard", *args) || OptionMatch("winboard", *args)) {
     if (!xboard) {
       signal(SIGINT, SIG_IGN);
       xboard = 1;
-      display_options &= 4095 - 1 - 2 - 4 - 8 - 16 - 32 - 128;
+      display_options = 2048;
-      printf("\n");
+      Print(-1, "\n");
-      printf("tellicsnoalias set 1 Crafty v%s (%d cpus)\n", version, Max(1,
+      Print(-1, "tellicsnoalias set 1 Crafty v%s (%d cpus)\n", version, Max(1,
               smp_max_threads));
-      printf("tellicsnoalias kibitz Hello from Crafty v%s! (%d cpus)\n",
+      Print(-1, "tellicsnoalias kibitz Hello from Crafty v%s! (%d cpus)\n",
           version, Max(1, smp_max_threads));
-      fflush(stdout);
+    }
+  }
 /*
  ************************************************************
  *                                                          *
  */
   if (strstr(command, input) == command)
     return 1;
   return 0;
+}
 void OptionPerft(TREE * RESTRICT tree, int ply, int depth, int wtm) {
-  int *mv;
+  unsigned *mv;
 #if defined(TRACE)
   static char line[256];
   static char move[16], *p[64];
 #endif
   tree->last[ply] = GenerateCaptures(tree, ply, wtm, tree->last[ply - 1]);
   for (mv = tree->last[ply - 1]; mv < tree->last[ply]; mv++)
     if (Captured(*mv) == king)
       return;
   tree->last[ply] = GenerateNoncaptures(tree, ply, wtm, tree->last[ply]);
 #if defined(TRACE)
   p[1] = line;
 #endif
   for (mv = tree->last[ply - 1]; mv < tree->last[ply]; mv++) {
 #if defined(TRACE)
-    strcpy_s(move, sizeof (move), OutputMove(tree, *mv, ply, wtm)); // Pierre-Marie Baty -- use safe version
+    strcpy(move, OutputMove(tree, ply, wtm, *mv));
 #endif
-    MakeMove(tree, ply, *mv, wtm);
+    MakeMove(tree, ply, wtm, *mv);
 #if defined(TRACE)
     if (ply <= trace_level) {
       strcpy(p[ply], move);
-      strcat_s(line, sizeof (line), " "); // Pierre-Marie Baty -- use safe version
+      strcpy(line + strlen(line), " ");
       p[ply + 1] = line + strlen(line);
       if (ply == trace_level)
         printf("%s\n", line);
+    }
 #endif
     if (depth - 1)
       OptionPerft(tree, ply + 1, depth - 1, Flip(wtm));
     else if (!Check(wtm))
       total_moves++;
-    UnmakeMove(tree, ply, *mv, wtm);
+    UnmakeMove(tree, ply, wtm, *mv);
+  }
+}

Subversion Repositories Games.Chess Giants

Games.Chess Giants/engine-crafty/option.c – Rev 33 → 108