main.c

#include "chess.h"
#include "data.h"
#if defined(UNIX)
#  include <unistd.h>
#  include <pwd.h>
#  include <sys/types.h>
#endif
#include <signal.h>
/* last modified 02/24/14 */
/*
 *******************************************************************************
 *                                                                             *
 *  Crafty, copyright 1996-2015 by Robert M. Hyatt, Ph.D., Associate Professor *
 *  of Computer and Information Sciences, University of Alabama at Birmingham. *
 *                                                                             *
 *  Crafty is a team project consisting of the following members.  These are   *
 *  the people involved in the continuing development of this program, there   *
 *  are no particular members responsible for any specific aspect of Crafty,   *
 *  although R. Hyatt wrote 99%+ of the existing code, excepting the Magic .   *
 *  move stuff by Pradu Kaanan, egtb.cpp written by Eugene Nalimov, and the    *
 *  epd stuff written by S. Edwards.                                           *
 *                                                                             *
 *     Robert Hyatt, University of Alabama at Birmingham.                      *
 *     Mike Byrne, Pen Argyl, PA.                                              *
 *     Tracy Riegle, Hershey, PA.                                              *
 *     Peter Skinner, Edmonton, AB  Canada.                                    *
 *                                                                             *
 *  All rights reserved.  No part of this program may be reproduced in any     *
 *  form or by any means, for other than your personal use, without the        *
 *  express written permission of the authors.  This program may not be used   *
 *  in whole, nor in part, to enter any computer chess competition without     *
 *  written permission from the authors.  Such permission will include the     *
 *  requirement that the program be entered under the name "Crafty" so that    *
 *  the program's ancestry will be known.                                      *
 *                                                                             *
 *  Copies of the source must contain the original copyright notice intact.    *
 *                                                                             *
 *  Any changes made to this software must also be made public to comply with  *
 *  the original intent of this software distribution project.  These          *
 *  restrictions apply whether the distribution is being done for free or as   *
 *  part or all of a commercial product.  The authors retain sole ownership    *
 *  and copyright on this program except for 'personal use' explained below.   *
 *                                                                             *
 *  Personal use includes any use you make of the program yourself, either by  *
 *  playing games with it yourself, or allowing others to play it on your      *
 *  machine,  and requires that if others use the program, it must be clearly  *
 *  identified as "Crafty" to anyone playing it (on a chess server as one      *
 *  example).  Personal use does not allow anyone to enter this into a chess   *
 *  tournament where other program authors are invited to participate.  IE you *
 *  can do your own local tournament, with Crafty + other programs, since this *
 *  is for your personal enjoyment.  But you may not enter Crafty into an      *
 *  event where it will be in competition with other programs/programmers      *
 *  without permission as stated previously.                                   *
 *                                                                             *
 *  Crafty is the "son" (direct descendent) of Cray Blitz.  it is designed     *
 *  totally around the bit-board data structure for reasons of speed of ex-    *
 *  ecution, ease of adding new knowledge, and a *significantly* cleaner       *
 *  overall design.  it is written totally in ANSI C with some few UNIX system *
 *  calls required for I/O, etc.                                               *
 *                                                                             *
 *  main() is the driver for the chess program.  Its primary function is to    *
 *  cycle between asking the user for a move and calling for a tree search     *
 *  to produce a move for the program.  After accepting an input string from   *
 *  the user, this string is first passed to Option() which checks to see if   *
 *  it is a command to the program.  If Option() returns a non-zero result,    *
 *  the input was a command and was executed, otherwise the input should be    *
 *  passed to input() for conversion to the internal move format.              *
 *                                                                             *
 *  The following diagram shows how bit numbers / squares match up in Crafty's *
 *  bitboard arrays.  Note that bit zero (LSB) corresponds to square A, which  *
 *  makes this a mental challenge to take a 64 bit value and visualize it as   *
 *  chess board, since the files are reversed.  This was done for the          *
 *  following reasons:  (1) bit 0 needs to be the LSB, and bit 63 needs to be  *
 *  the MSB so that the Intel BSF/BSR instructions return the proper square    *
 *  number without any remapping.  (2) the lower 3 bits (file number) are now  *
 *  0 for A, 1 for B, ..., 7 for H.  The upper 3 bits (rank number) are then   *
 *  0 for rank 1, 1 for rank 2, ..., 7 for rank 8.                             *
 *                                                                             *
 *  A8 B8 C8 D8 E8 F8 G8 H8                                                    *
 *  A7 B7 C7 D7 E7 F7 G7 H7                                                    *
 *  A6 B6 C6 D6 E6 F6 G6 H6                                                    *
 *  A5 B5 C5 D5 E5 F5 G5 H5                                                    *
 *  A4 B4 C4 D4 E4 F4 G4 H4                                                    *
 *  A3 B3 C3 D3 E3 F3 G3 H3                                                    *
 *  A2 B2 C2 D2 E2 F2 G2 H2                                                    *
 *  A1 B1 C1 D1 E1 F1 G1 H1                                                    *
 *                                                                             *
 *  56 57 58 59 60 61 62 63                                                    *
 *  48 49 50 51 52 53 54 55                                                    *
 *  40 41 42 43 44 45 46 47                                                    *
 *  32 33 34 35 36 37 38 39                                                    *
 *  24 25 26 27 28 29 30 31                                                    *
 *  16 17 18 19 20 21 22 23                                                    *
 *   8  9 10 11 12 13 14 15                                                    *
 *   0  1  2  3  4  5  6  7                                                    *
 *                                                                             *
 *  version  description                                                       *
 *                                                                             *
 *    1.0    First version of the bit-board program to play a legitimate game  *
 *           even though significant features are missing:  transposition      *
 *           table, sophisticated scoring, etc.                                *
 *                                                                             *
 *    1.1    Added the minimal window search.  At each ply in the tree, the    *
 *           first branch is searched with the normal alpha/beta window, while *
 *           remaining nodes are searched with value/value+1 which was         *
 *           returned from searching the first branch.  If such a search       *
 *           returns the upper bound, this position is once again searched     *
 *           with the normal window.                                           *
 *                                                                             *
 *    1.2    Added the classic null-move search.  The program searches the     *
 *           sub-tree below the null move (typically) one play shallower than  *
 *           the normal search, saving a lot of time.                          *
 *                                                                             *
 *    1.3    Added the transposition table support.  This also includes the    *
 *           code in Iterate() necessary to propagate the principal variation  *
 *           from one iteration to the next to improve move ordering.          *
 *                                                                             *
 *    1.4    Modified the transposition table to use three tables, one for 64  *
 *           bits of white entry, one for 64 bits of black entry, and one with *
 *           the remaining 32 bits of white and black entry combined into one  *
 *           64 bit word.  Eliminated the "bit fields" since they seemed to be *
 *           erratic on most compilers and made portability nearly impossible. *
 *                                                                             *
 *    1.5    Pawn scoring added.  This required three additions to the code:   *
 *           (1) InitializePawnMasks() which produces the necessary masks to   *
 *           let us efficiently detect isolated, backward, passed, etc. pawns; *
 *           (2) a pawn hash table to store recently computed pawn scores so   *
 *           it won't be too expensive to do complex analysis;  (3) Evaluate() *
 *           now evaluates pawns if the current pawn position is not in the    *
 *           pawn hash table.                                                  *
 *                                                                             *
 *    1.6    Piece scoring added, although it is not yet complete.  Also, the  *
 *           search now uses the familiar zero-width window search for all but *
 *           the first move at the root, in order to reduce the size of the    *
 *           tree to a nearly optimal size.  This means that a move that is    *
 *           only one point better than the first move will "fail high" and    *
 *           have to be re-searched a second time to get the true value.  If   *
 *           the new best move is significantly better, it may have to be      *
 *           searched a third time to increase the window enough to return the *
 *           score.                                                            *
 *                                                                             *
 *    1.7    Replaced the old "killer" move ordering heuristic with the newer  *
 *           "history" ordering heuristic.   This version uses the 12-bit key  *
 *           formed by <from><to> to index into the history table.             *
 *                                                                             *
 *    1.8    Added pondering for both PC and UNIX-based machines.  Also other  *
 *           improvements include the old Cray Blitz algorithm that takes the  *
 *           P.V. returned by the tree search, and "extends" it by looking up  *
 *           positions in the transposition table, which improves move         *
 *           ordering significantly.  Repetitions are now handled correctly.   *
 *                                                                             *
 *    1.9    Added an opening book with flags to control which moves are       *
 *           selected for play.  The book maintenance code is stubbed directly *
 *           into the program, so that no additional executables are needed.   *
 *                                                                             *
 *    1.10   Added king safety + hashing (as done in the old Cray Blitz).      *
 *           Nothing novel other than the use of bit-masks to speed up some of *
 *           the tests.                                                        *
 *                                                                             *
 *    1.11   Additional evaluation knowledge plus log_file so that program     *
 *           saves a record of the game statistics for later analysis.  Added  *
 *           the "annotate" command to make the program analyze a game or part *
 *           of a game for testing/debugging.                                  *
 *                                                                             *
 *    1.12   Added ICS (Internet Chess Server) support for Xboard support so   *
 *           that Crafty can play on ICS in an automated manner.  Added new    *
 *           commands to be compatible with Xboard.  Crafty also has a new     *
 *           command-line interface that allows options to be entered on the   *
 *           command-line directly, ie:  "crafty alarm=off verbose=2" will     *
 *           start the program, set the move alarm off, and set verbose to     *
 *           2.  This allows an "alias" to easily customize the program.       *
 *                                                                             *
 *    1.13   Added time-control logic to the program.  It now monitors how     *
 *           much time both it and its opponent uses when thinking about a     *
 *           move to make.  When pondering, it only times itself from the      *
 *           point that a move is actually entered.                            *
 *                                                                             *
 *    1.14   Added the piece/square tables to the program to move static       *
 *           scoring to the root of the tree since it never changes (things    *
 *           like centralization of pieces, etc.)  also some minor tuning of   *
 *           numbers to bring positional score "swings" down some.             *
 *                                                                             *
 *    1.15   Added edit so that positions can be altered (and so ICS games     *
 *           can be resumed after they are adjourned).  Also added a "force"   *
 *           command to force the program to play a different move than the    *
 *           search selected.  Search timing allocation slightly altered to    *
 *           improve ICS performance.                                          *
 *                                                                             *
 *    1.16   Significant adjustments to evaluation weights to bring positional *
 *           scores down to below a pawn for "normal" positions.  Some small   *
 *           "tweaks" to king safety as well to keep the king safer.           *
 *                                                                             *
 *    1.17   Added "development" evaluation routine to encourage development   *
 *           and castling before starting on any tactical "sorties."  Also     *
 *           repaired many "bugs" in evaluation routines.                      *
 *                                                                             *
 *    1.18   Added the famous Cray Blitz "square of the king" passed pawn      *
 *           evaluation routine.  This will evaluate positions where one       *
 *           side has passed pawns and the other side has no pieces, to see    *
 *           if the pawn can outrun the defending king and promote.  Note that *
 *           this is ridiculously fast because it only requires one AND        *
 *           to declare that a pawn can't be caught!                           *
 *                                                                             *
 *    2.0    initial version preparing for search extension additions.  This   *
 *           version has a new "next_evasion()" routine that is called when    *
 *           the king is in check.  It generates sensible (nearly all are      *
 *           legal) moves which include capturing the checking piece (if there *
 *           is only one), moving the king (but not along the checking ray),   *
 *           and interpositions that block the checking ray (if there is only  *
 *           one checking piece.                                               *
 *                                                                             *
 *    2.1    Search is now broken down into three cleanly-defined phases:      *
 *           (1) basic full-width search [Search()]; (2) extended tactical     *
 *           search [extend()] which includes winning/even captures and then   *
 *           passed pawn pushes to the 6th or 7th rank (if the pawn pushes     *
 *           are safe);  (3) normal quiescence search [Quiesce()] which only   *
 *           includes captures that appear to gain material.                   *
 *                                                                             *
 *    2.2    King safety code re-written and cleaned up.  Crafty was giving    *
 *           multiple penalties which was causing the king safety score to be  *
 *           extremely large (and unstable.)  Now, if it finds something wrong *
 *           with king safety, it only penalizes a weakness once.              *
 *                                                                             *
 *    2.3    King safety code modified further, penalties were significant     *
 *           enough to cause search anomolies.  Modified rook scoring to avoid *
 *           having the rook trapped in the corner when the king is forced to  *
 *           move rather than castle, and to keep the rook in a position to be *
 *           able to reach open files in one move, which avoids getting them   *
 *           into awkward positions where they become almost worthless.        *
 *                                                                             *
 *    2.4    King safety code completely rewritten.  It now analyzes "defects" *
 *           in the king safety field and counts them as appropriate.  These   *
 *           defects are then summed up and used as an index into a vector of  *
 *           of values that turns them into a score in a non-linear fashion.   *
 *           Increasing defects quickly "ramp up" the score to about 1/3+ of   *
 *           a pawn, then additional faults slowly increase the penalty.       *
 *                                                                             *
 *    2.5    First check extensions added.  In the extension search (stage     *
 *           between full-width and captures-only, up to two checking moves    *
 *           can be included, if there are checks in the full-width part of    *
 *           the search.  If only one check occurs in the full-width, then     *
 *           only one check will be included in the extension phase of the     *
 *           selective search.                                                 *
 *                                                                             *
 *    2.6    Evaluation modifications attempting to cure Crafty's frantic      *
 *           effort to develop all its pieces without giving a lot of regard   *
 *           to the resulting position until after the pieces are out.         *
 *                                                                             *
 *    2.7    New evaluation code to handle the "outside passed pawn" concept.  *
 *           Crafty now understands that a passed pawn on the side away from   *
 *           the rest of the pawns is a winning advantage due to decoying the  *
 *           king away from the pawns to prevent the passer from promoting.    *
 *           The advantage increases as material is removed from the board.    *
 *                                                                             *
 *    3.0    The 3.* series of versions will primarily be performance en-      *
 *           hancements.  The first version (3.0) has a highly modified        *
 *           version of MakeMove() that tries to do no unnecessary work.  It   *
 *           is about 25% faster than old version of MakeMove() which makes    *
 *           Crafty roughly 10% faster.  Also calls to Mask() have been        *
 *           replaced by constants (which are replaced by calls to Mask() on   *
 *           the Crays for speed) to eliminate function calls.                 *
 *                                                                             *
 *    3.1    Significantly modified king safety again, to better detect and    *
 *           react to king-side attacks.  Crafty now uses the recursive null-  *
 *           move search to depth-2 instead of depth-1, which results in       *
 *           slightly improved speed.                                          *
 *                                                                             *
 *    3.2    Null-move restored to depth-1.  Depth-2 proved unsafe as Crafty   *
 *           was overlooking tactical moves, particularly against itself,      *
 *           which lost several "won" games.                                   *
 *                                                                             *
 *    3.3    Additional king-safety work.  Crafty now uses the king-safety     *
 *           evaluation routines to compare king safety for both sides.  If    *
 *           one side is "in distress" pieces are attracted to that king in    *
 *           "big hurry" to either attack or defend.                           *
 *                                                                             *
 *    3.4    "Threat extensions" added.  Simply, this is a null-move search    *
 *           used to determine if a move is good only because it is a horizon  *
 *           effect type move.  We do a null move search after a move fails    *
 *           high anywhere in the tree.  The window is normally lowered by 1.5 *
 *           pawns, the idea being that if the fail-high move happens in a     *
 *           position that fails "really low" with a null move, then this move *
 *           might be a horizon move.  To test this, re-search this move with  *
 *           the depth increased by one.                                       *
 *                                                                             *
 *    3.5    50-move rule implemented.  A count of moves since the last pawn   *
 *           move or capture is kept as part of the position[] structure.  It  *
 *           is updated by MakeMove().  When this number reaches 100 (which    *
 *           in plies is 50 moves) Repeat() will return the draw indication    *
 *           immediately, just as though the position was a repetition draw.   *
 *                                                                             *
 *    3.6    Search extensions cleaned up to avoid excessive extensions which  *
 *           produced some wild variations, but which was also slowing things  *
 *           down excessively.                                                 *
 *                                                                             *
 *    3.7    Endgame strategy added.  Two specifics: KBN vs K has a piece/sq   *
 *           table that will drive the losing king to the correct corner.  For *
 *           positions with no pawns, scoring is altered to drive the losing   *
 *           king to the edge and corner for mating purposes.                  *
 *                                                                             *
 *    3.8    Hashing strategy modified.  Crafty now stores search value or     *
 *           bound, *and* positional evaluation in the transposition table.    *
 *           This avoids about 10-15% of the "long" evaluations during the     *
 *           middlegame, and avoids >75% of them in endgames.                  *
 *                                                                             *
 *    4.0    Evaluation units changed to "millipawns" where a pawn is now      *
 *           1000 rather than the prior 100 units.  This provides more         *
 *           "resolution" in the evaluation and will let Crafty have large     *
 *           positional bonuses for significant things, without having the     *
 *           small positional advantages add up and cause problems.  V3.8      *
 *           exhibited a propensity to "sac the exchange" frequently because   *
 *           of this.  It is hoped that this is a thing of the past now.       *
 *           Also, the "one legal reply to check" algorithm is now being used. *
 *           In short, if one side has only one legal reply to a checking move *
 *           then the other side is free to check again on the next ply. this  *
 *           only applies in the "extension" search, and allows some checks    *
 *           that extend() would normally not follow.                          *
 *                                                                             *
 *    4.1    Extension search modified.  It now "tracks" the basic iteration   *
 *           search depth up to some user-set limit (default=6).  For shallow  *
 *           depths, this speeds things up, while at deeper depths it lets the *
 *           program analyze forcing moves somewhat deeper.                    *
 *                                                                             *
 *    4.2    Extension search modified.  Fixed a problem where successive      *
 *           passed-pawn pushes were not extended correctly by extend() code.  *
 *           Threat-extension margin was wrong after changing the value of a   *
 *           pawn to 1000, it is now back to 1.5 pawns.                        *
 *                                                                             *
 *    4.3    Hash scoring "repaired."  As the piece/square tables changed, the *
 *           transposition table (positional evaluation component) along with  *
 *           the pawn and king-safety hash tables prevented the changes from   *
 *           affecting the score, since the hashed scores were based on the    *
 *           old piece/square table values.  Now, when any piece/square table  *
 *           is modified, the affected hash tables are cleared of evaluation   *
 *           information.                                                      *
 *                                                                             *
 *    4.4    Piece/square tables simplified, king tropism scoring moved to     *
 *           Evaluate() where it is computed dynamically now as it should be.  *
 *                                                                             *
 *    4.5    Book move selection algorithm replaced.  Crafty now counts the    *
 *           number of times each book move was played as the book file is     *
 *           created.  Since these moves come (typically) from GM games, the   *
 *           more frequently a move appears, the more likely it is to lead to  *
 *           a sound position.  Crafty then enumerates all possible book moves *
 *           for the current position, computes a probability distribution for *
 *           each move so that Crafty will select a move proportional to the   *
 *           number of times it was played in GM games (for example, if e4 was *
 *           played 55% of the time, then Crafty will play e4 55% of the time) *
 *           although the special case of moves played too infrequently is     *
 *           handled by letting the operator set a minimum threshold (say 5)   *
 *           Crafty won't play moves that are not popular (or are outright     *
 *           blunders as the case may be.)  Pushing a passed pawn to the 7th   *
 *           rank in the basic search [Search() module] now extends the search *
 *           by two plies unless we have extended this ply already (usually a  *
 *           check evasion) or unless we have extended the whole line to more  *
 *           than twice the nominal iteration depth.                           *
 *                                                                             *
 *    5.0    Selective search extensions removed.  With the extensions now in  *
 *           the basic full-width search, these became more a waste of time    *
 *           than anything useful, and removing them simplifies things quite   *
 *           a bit.                                                            *
 *                                                                             *
 *    5.1    Pondering logic now has a "puzzling" feature that is used when    *
 *           the search has no move to ponder.  It does a short search to find *
 *           a move and then ponders that move, permanently eliminating the    *
 *           "idle" time when it has nothing to ponder.                        *
 *                                                                             *
 *    5.2    Evaluation terms scaled down to prevent positional scores from    *
 *           reaching the point that sacrificing material to avoid simple      *
 *           positional difficulties begins to look attractive.                *
 *                                                                             *
 *    5.3    Performance improvement produced by avoiding calls to MakeMove()  *
 *           when the attack information is not needed.  Since the first test  *
 *           done in Quiesce() is to see if the material score is so bad that  *
 *           a normal evaluation and/or further search is futile, this test    *
 *           has been moved to inside the loop *before* Quiesce() is           *
 *           recursively called, avoiding the MakeMove() work only to          *
 *           discover that the resulting position won't be searched further.   *
 *                                                                             *
 *    5.4    New SEE() function that now understands indirect attacks through  *
 *           the primary attacking piece(s).  This corrects a lot of sloppy    *
 *           move ordering as well as make the "futility" cutoffs added in     *
 *           in version 5.3 much more reliable.                                *
 *                                                                             *
 *    5.5    Checks are now back in the quiescence search.  Crafty now stores  *
 *           a negative "draft" in the transposition table rather than forcing *
 *           any depth < 0 to be zero.  The null-move search now searches the  *
 *           null-move to depth-1 (R=1) rather than depth-2 (R=2) which seemed *
 *           to cause some tactical oversights in the search.                  *
 *                                                                             *
 *    5.6    Improved move ordering by using the old "killer move" idea.  An   *
 *           additional advantage is that the killers can be tried before      *
 *           generating any moves (after the captures.)  Quiescence now only   *
 *           includes "safe" checks (using SEE() to determine if it is a safe  *
 *           checking move.                                                    *
 *                                                                             *
 *    5.7    King safety now "hates" a pawn at b3/g3 (white) or b6/g6 (black)  *
 *           to try and avoid the resulting mate threats.                      *
 *                                                                             *
 *    5.8    EvaluateOutsidePassedPawns() fixed to correctly evaluate those    *
 *           positions where both sides have outside passed pawns.  Before     *
 *           this fix, it only evaluated positions where one side had a passed *
 *           pawn, which overlooked those won/lost positions where both sides  *
 *           have passed pawns but one is "distant" or "outside" the other.    *
 *                                                                             *
 *    5.9    Removed "futility" forward pruning.  Exhaustive testing has       *
 *           proved that this causes significant tactical oversights.          *
 *                                                                             *
 *    5.10   Added code to handle king and pawn vs king, which understands     *
 *           the cases where the pawn can't outrun the king, but has to be     *
 *           assisted along by the king.                                       *
 *                                                                             *
 *    5.11   Two king-safety changes.  (1) The program's king safety score is  *
 *           now "doubled" to make it much less likely that it will try to win *
 *           a pawn but destroy it's king-side.  (2) The attack threshold has  *
 *           been lowered which is used to key the program that it is now      *
 *           necessary to move pieces to defend the king-side, in an effort to *
 *           protect a king-side that is deemed somewhat unsafe.               *
 *                                                                             *
 *    5.12   Improved null-move code by computing the Knuth/Moore node type    *
 *           and then only trying null-moves at type 2 nodes.  This has        *
 *           resulted in a 2x speedup in test positions.                       *
 *                                                                             *
 *    5.13   Optimization to avoid doing a call to MakeMove() if it can be     *
 *           avoided by noting that the move is not good enough to bring the   *
 *           score up to an acceptable level.                                  *
 *                                                                             *
 *    5.14   Artificially isolated pawns recognized now, so that Crafty won't  *
 *           push a pawn so far it can't be defended.  Also, the bonus for a   *
 *           outside passed pawn was nearly doubled.                           *
 *                                                                             *
 *    5.15   Passed pawns supported by a king, or connected passed pawns now   *
 *           get a large bonus as they advance.  Minor fix to the ICC resume   *
 *           feature to try to avoid losing games on time.                     *
 *                                                                             *
 *    6.0    Converted to rotated bitboards to make attack generation *much*   *
 *           faster.  MakeMove() now can look up the attack bit vectors        *
 *           rather than computing them which is significantly faster.         *
 *                                                                             *
 *    6.1    Added a "hung piece" term to Evaluate() which penalizes the side  *
 *           to move if a piece is attacked by a lesser piece, or a piece is   *
 *           attacked and not defended at all.  Additionally, a new scoring    *
 *           term was added to detect a weak back rank (where the king does    *
 *           not attack an empty square on the 2nd rank, and there are no      *
 *           horizontally sliding pieces [rook or queen] on the first rank to  *
 *           guard against back-rank mates.                                    *
 *                                                                             *
 *    6.2    Modified the "futility" cutoff to (a) emulate the way the program *
 *           normally searches, but avoiding MakeMove() calls when possible,   *
 *           and (2) not searching a move near the horizon if the material     *
 *           score is hopeless.                                                *
 *                                                                             *
 *    6.3    Null-move code moved from NextMove() directly into Search().      *
 *           this results is a "cleaner" implementation, as well as fixing an  *
 *           error in the node type, caused by Search() thinking that after    *
 *           the first move tried fails to cause a cutoff, that suddenly this  *
 *           node is a type=3 node (Knuth and Moore).  This bug would then     *
 *           introduce null-moves into later nodes that are a waste of time.   *
 *                                                                             *
 *    6.4    Pawn scoring modified.  Passed pawns were scored low enough that  *
 *           Crafty would let the opponent create one in the endgame (as long  *
 *           as it wasn't an "outside" passed pawn).  This required adjusting  *
 *           isolated pawns as well.  All "weak" pawns (pawns on open files    *
 *           that aren't defended by a pawn) are not penalized so much if      *
 *           there aren't any rooks/queens to attack on the file.              *
 *                                                                             *
 *    7.0    Removed the to.attack and from.attack bitboards.  These are now   *
 *           computed as needed, using the rotated bitboards.  Hung piece      *
 *           stuff removed due to lack of any verified benefit.                *
 *                                                                             *
 *    7.1    Modified next.c and nextc.c so that they check "mvv_lva_ordering" *
 *           to determine which capture ordering strategy to use.  Note that   *
 *           setting this to "1" (default at present) disables the forward     *
 *           pruning in quiescence search that wants to cull losing captures.  *
 *                                                                             *
 *    7.2    Major clean-up of MakeMove() using macros to make it easier to    *
 *           read and understand.  Ditto for other modules as well.  Fixed a   *
 *           bug in Evaluate() where bishop scoring failed in endgame          *
 *           situations, and discouraged king centralization.                  *
 *                                                                             *
 *    7.3    Evaluate() is no longer called if material is too far outside the *
 *           current alpha/beta window.  The time-consuming part of Evaluate() *
 *           is no longer done if the major scoring contributors in Evaluate() *
 *           haven't pulled the score within the alpha/beta window, and the    *
 *           remainder of Evaluate() can't possible accomplish this either.    *
 *           Gross error in EvaluatePawns() fixed, which would "forget" all    *
 *           of the pawn scoring done up to the point where doubled white      *
 *           pawns were found.  Error was xx=+ rather than xx+=, which had     *
 *           an extremely harmful effect on pawn structure evaluation.         *
 *                                                                             *
 *    7.4    Performance improvements produced by elimination of bit-fields.   *
 *           This was accomplished by hand-coding the necessary ANDs, ORs, and *
 *           SHIFTs necessary to accomplish the same thing, only faster.       *
 *                                                                             *
 *    7.5    Repetition code modified.  It could store at replist[-1] which    *
 *           clobbered the long long word just in front of this array.         *
 *                                                                             *
 *    7.6    Null move search now searches with R=2, unless within 3 plies     *
 *           of the quiescence search, then it searches nulls with R=1.        *
 *                                                                             *
 *    8.0    Re-vamp of evaluation, bringing scores back down so that Crafty   *
 *           will stop sacrificing the exchange, or a piece for two pawns just *
 *           it thinks it has lots of positional compensation.  The next few   *
 *           versions are going to be tuning or coding modifications to eval.  *
 *                                                                             *
 *    8.1    Futility() re-written to be more efficient, as well as to stop    *
 *           tossing moves out based on the +/- 2 pawn window, which was too   *
 *           speculative.  It still saves roughly 20% in speed over the same   *
 *           searches without futility, but seems to have *no* harmful effects *
 *           in tests run to date.                                             *
 *                                                                             *
 *    8.2    Futility() removed once and for all.  Since MakeMove() is so      *
 *           fast after the new attack generation algorithm, this was actually *
 *           slower than not using it.                                         *
 *                                                                             *
 *    8.3    EvaluatePawns() weak pawn analysis bug fixed.  Other minor        *
 *           performance enhancements and cleanup.                             *
 *                                                                             *
 *    8.4    Dynamic "king tropism" evaluation term now used, which varies     *
 *           based on how exposed the target king is.  The more exposed, the   *
 *           larger the bonus for placing pieces near the king.  New "analyze" *
 *           feature that complements the "annotate" feature that Crafty has   *
 *           had for a while.  Annotate is used to play over moves that are    *
 *           either in the current game history, or have been read in using    *
 *           the "read <filename>" command.  Analyze, on the other hand, will  *
 *           immediately begin searching the current position.  Each time the  *
 *           operator enters a move, it will make that move on the board, and  *
 *           then search the resulting position for the other side.  In effect *
 *           this gives a running commentary on a "game in progress".  These   *
 *           moves can be pumped into Crafty in many ways so that "on the fly" *
 *           analysis of a game-in-progress is possible.                       *
 *                                                                             *
 *    8.5    More cleanup.  Pawn promotions were searched twice, thanks to the *
 *           killer moves, although often they resulted in no search overhead  *
 *           due to transposition table hits the second time around.  Other    *
 *           minor fixes, including one serious "undefined variable" in        *
 *           Evaluate() that caused grief in endings.                          *
 *                                                                             *
 *    8.6    New book file structure.  It is no longer necessary to enter the  *
 *           "number of records" as Crafty now uses a new compressed hashing   *
 *           technique so that the book has no empty space in it, and the size *
 *           is computed "on the fly" producing a smaller book without the     *
 *           user having to compute the size.  Tweaks to Evaluate() to cure    *
 *           minor irritating habits.                                          *
 *                                                                             *
 *    8.7    Repaired optimization made in null-move search, that forgot to    *
 *           clear "EnPassant_Target".  A double pawn push, followed by a null *
 *           left the side on move "very confused" and would let it play an    *
 *           illegal enpassant capture in the tree. Sort.<n> files are now     *
 *           removed after book.bin is created.  Also, minor change to book    *
 *           format makes it incompatible with older book versions, but also   *
 *           allows book lines to be as long as desired, and the book size to  *
 *           reach any reasonable size.  Dynamic king tropism replaced by a    *
 *           dynamic computation, but with a static king tropism score, rather *
 *           than a score based on king exposure.  There was simply too much   *
 *           interaction, although this may prove workable later.              *
 *                                                                             *
 *    8.8    Tweaks to passed pawn scoring.  Scores were too low, making       *
 *           Crafty "ignore" them too much.                                    *
 *                                                                             *
 *    8.9    Internal iterative deepening is now used in those rare positions  *
 *           where a PV node has no hash move to search.  This does a shallow  *
 *           search to depth-2 to find a good move for ordering.               *
 *                                                                             *
 *    8.10   Internal interative deepening modified to handle cases where lots *
 *           of tactics make the deepening search fail high or low, and        *
 *           occasionally end up with no move to try.  This produced a "bad    *
 *           move from hash table" error.                                      *
 *                                                                             *
 *    8.11   Minor bug in internal iterative deepening fixed.  Also, macros    *
 *           for accessing the "position" data structure are now used to make  *
 *           things a little more readable.                                    *
 *                                                                             *
 *    8.12   Fixed minor bugs in quiescence checks, which let Crafty include   *
 *           more checks than intended (default quiescence_checks=2, but the   *
 *           comparison was <= before including a check, which made it include *
 *           three.  Additionally, a hashed check was *always* tried, even if  *
 *           quiescence_checks had already been satisfied.  Pawn scoring also  *
 *           had a bug, in that there was a "crack" between opening and middle *
 *           game, where Crafty would conclude that it was in an endgame, and  *
 *           adjust the pawn advance scores accordingly, sometimes causing an  *
 *           odd a4/a5/etc move "out of the blue."  Minor bug in next_capture  *
 *           was pruning even exchanges very early in quiescence search.  That *
 *           has now been removed, so only losing exchanges are pruned.        *
 *                                                                             *
 *    8.13   NextCapture() now *always* tries checking moves if the move at    *
 *           the previous ply was a null-move.  This avoids letting the null   *
 *           move hide some serious mating threats.  A minor bug where Crafty  *
 *           could draw by repetition after announcing a mate.  This was a     *
 *           result of finding a mate score in hash table, and, after the      *
 *           search iteration completed, the mate score would terminate the    *
 *           search completely.  Now, the search won't terminate until it      *
 *           finds a mate shorter than the previous search did.  Minor eval    *
 *           tweaks and bugfixes as well.                                      *
 *                                                                             *
 *    8.14   Checks after null moves discontinued.  Worked in some cases, but, *
 *           in general made the tree larger for nothing.  Eval tweaks to stop *
 *           sacs that resulted in connected passed pawns, often at the        *
 *           expense of a minor piece for a pawn or two, which usually lost.   *
 *           Mobility coeffecient increased for all pieces.  Asymmetric king   *
 *           safety discontinued.  King safety for both sides is now equally   *
 *           important.  King safety is now also proportional to the number of *
 *           pieces the other side has, so that a disrupted king-side will     *
 *           encourage trading pieces to reduce attacking chances.             *
 *                                                                             *
 *    8.15   Weak pawn scoring modified further.  The changes are designed to  *
 *           cause Crafty to keep pawns "mobile" where they can advance,       *
 *           rather than letting them become blocked or locked.                *
 *                                                                             *
 *    8.16   Still more weak pawn modifications.  In addition, there is no     *
 *           "rook on half-open file" any longer.  If there are only enemy     *
 *           pawns on the file, and the most advanced one is weak, then the    *
 *           file is treated as though it were open.  Technical error in the   *
 *           EvaluateDevelopment() code that caused screwey evaluations is     *
 *           fixed, making Crafty more likely to castle.  :)  Book() now       *
 *           verifies that the current position is in book, before trying any  *
 *           moves to see if the resulting positions are in book.  This avoids *
 *           something like e4 e5 Bb5 a6 Nf3 from causing Crafty to play Nc6   *
 *           which takes it back into book, rather than axb5 winning a piece.  *
 *           This will occasionally backfire and prevent Crafty from trans-    *
 *           posing back into book, but seems safer at present.                *
 *                                                                             *
 *    8.17   Piece values changed somewhat, to avoid Crafty's propensity to    *
 *           make unfavorable trades.  An example:  Crafty is faced with the   *
 *           loss of a pawn.  Instead, it trades the queen for a rook and      *
 *           bishop, which used to be the same as losing a pawn.  This is not  *
 *           so good, and often would result in a slow loss.  This version     *
 *           also implements several "user-supplied" patches to make Crafty    *
 *           compile cleanly on various machines.  In addition, you no longer  *
 *           have to continually modify types.h for different configurations.  *
 *           the Makefile now supplies a -D<target> to the compiler.  You need *
 *           to edit Makefile and set "target" to the appropriate value from   *
 *           the list provided.  Then, when getting a new version, save your   *
 *           Makefile, extract the new source, copy in your makefile and you   *
 *           will be ready, except for those rare occasions where I add a new  *
 *           source module.  Other changes are performance tweaks.  One is a   *
 *           simple trick to order captures while avoiding SEE() if possible.  *
 *           If the captured piece is more valuable than the capturing piece,  *
 *           we can simply use the difference (pessimistic value) rather than  *
 *           calling SEE() since this pessimistic value is still > 0.  Other   *
 *           tweaks to the various Next_*() routines to avoid a little un-     *
 *           necessary work.                                                   *
 *                                                                             *
 *    8.18   Book move selection algorithm changed.  Note that this is highly  *
 *           speculative, but when best book play is selected, Crafty will     *
 *           use the books.bin file as always.  If there is no move in books,  *
 *           Crafty reverts to book.bin, but now finds all known book moves    *
 *           and puts them into the root move list.  It then does a fairly     *
 *           short search, only considering these moves, and it will play the  *
 *           best one so long as the evaluation is acceptable.  If not, it     *
 *           simply returns as though there was no book move, and executes a   *
 *           search as it normally would.  The book hashing algorithm was also *
 *           modified so that the 64-bit hash key is slightly different from   *
 *           the real hash key.  In effect, the upper 16 bits are only set as  *
 *           a result of the side-not-to-move's pieces.  This means that for a *
 *           given position, all the book moves will be in the same "cluster"  *
 *           which makes the book dramatically faster, since one seek and read *
 *           produces all the possible book moves (plus some others too, since *
 *           the upper 16 bits are not unique enough.)  A significant speed    *
 *           improvement is noticable, particularly with a 60mb opening book.  *
 *           Crafty now understands (if that's the right word) that endings    *
 *           with bishops of opposite colors are to be avoided.  When such an  *
 *           ending is encountered, the total score is simply divided by two   *
 *           to make the ending look more drawish.                             *
 *                                                                             *
 *    8.19   Book selection algorithm further modified, so that the result of  *
 *           each game in the GM database is known.  Now Crafty will not play  *
 *           a move from book, if all games were lost by the side on move,     *
 *           hopefully avoiding many blunders.  Crafty now understands how to  *
 *           attack if both players castle on opposite sides, by encouraging   *
 *           pawn advances against the kings.  Other minor modifications to    *
 *           the eval values.                                                  *
 *                                                                             *
 *    8.20   PVS search finally implemented fully.  Problems several months    *
 *           ago prevented doing the PVS search along the PV itself.  This is  *
 *           therefore quite a bit faster, now that it's fully implemented and *
 *           working properly.  Elapsed time code modified so that Crafty now  *
 *           uses gettimeofday() to get fractions of a second elapsed time.    *
 *           Slight modification time allocation algorithm to avoid using too  *
 *           much time early in the game.                                      *
 *                                                                             *
 *    8.21   Courtesy of Mark Bromley, Crafty may run significantly faster on  *
 *           your machine.  There are some options in the Makefile that will   *
 *           eliminate many of the large attack computation long longs, which  *
 *           helps prevent cache thrashing.  On some machines this will be     *
 *           slower, on others 20% (or maybe more) faster.  You'll have to     *
 *           try -DCOMPACT_ATTACKS, and if that's faster, then it's time to    *
 *           try -DUSE_SPLIT_SHIFTS which may help even more.  Finally, if you *
 *           are running on a supersparc processor, you can use the fastattack *
 *           assembly module fastattack.s and get another big boost.  (Attack  *
 *           function is largest compute user in Crafty at present.) Serious   *
 *           search problem fixed.  It turns out that Crafty uses the hash     *
 *           table to pass PV moves from one iteration to the next, but for    *
 *           moves at the root of the tree the hash table has no effect, so a  *
 *           special case was added to RootMoveList to check the list of moves *
 *           and if one matches the PV move, move it to the front of the list. *
 *           This turned out to be critical because after completing a search, *
 *           (say to 9 plies) Crafty makes its move, then chops the first two  *
 *           moves off of the PV and then passes that to iterate to start a    *
 *           search.  This search starts at lastdepth-1 (8 in this case) since *
 *           the n-2 search was already done.  The "bug" showed up however, in *
 *           that RootMoveList() was not checking for the PV move correctly,   *
 *           which meant the root moves were ordered by static eval and static *
 *           exchange evaluation.  Normally not a serious problem, just that   *
 *           move ordering is not so good.  However, suppose that the opponent *
 *           takes a real long time to make a move (say 30 seconds) so that    *
 *           Crafty completes a 10 ply search.  It then starts the next search *
 *           at depth=9, but with the wrong move first.  If the target time is *
 *           not large enough to let it resolve this wrong move and get to the *
 *           other moves on the list, Crafty is "confused" into playing this   *
 *           move knowing absolutely nothing about it.  The result is that it  *
 *           can play a blunder easily.  The circumstances leading to this are *
 *           not common, but in a 60 move game, once is enough.  PV was pretty *
 *           well mis-handled in carrying moves from one search to another     *
 *           (not from one iteration to another, but from one complete search  *
 *           to another) and has been fixed.  A cute glitch concerning storing *
 *           PV from one iteration to another was also fixed, where the score  *
 *           stored was confusing the following search.                        *
 *                                                                             *
 *    8.22   EPD support (courtesy of Steven Edwards [thanks]) is now standard *
 *           in Crafty.  For porting, I'll provide a small test run which can  *
 *           be used to validate Crafty once it's been compiled.               *
 *                                                                             *
 *    8.23   Cleanup/speedup in hashing.  ProbeTransRef() and StoreTransRef()  *
 *           now carefully cast the boolean operations to the most efficient   *
 *           size to avoid 64bit operations when only the right 32 bits are    *
 *           significant. Repeat() code completely re-written to maintain two  *
 *           repetition lists, one for each side.  Quiesce() now handles the   *
 *           repetition check a little different, being careful to not call it *
 *           when it's unimportant, but calling it when repetitions are        *
 *           possible.                                                         *
 *                                                                             *
 *    8.24   Tweaks for king tropism to encourage pieces to collect near the   *
 *           king, or to encourage driving them away when being attacked.  A   *
 *           modification to Evaluate() to address the problem where Crafty    *
 *           is forced to play Kf1 or Kf8, blocking the rook in and getting    *
 *           into tactical difficulties as a result.  Book problem fixed where *
 *           Bookup was attempting to group moves with a common ancestor       *
 *           position together.  Unfortunately, captures were separated from   *
 *           this group, meaning capture moves in the book could never be      *
 *           played.  If a capture was the only move in book, it sort of       *
 *           worked because Crafty would drop out of book (not finding the     *
 *           capture) and then the search would "save" it.  However, if there  *
 *           was a non-capture alternative, it would be forced to play it,     *
 *           making it play gambits, and, often, bad ones.  Tablebase support  *
 *           is now in.  The tablebase files can be downloaded from the ftp    *
 *           machine at chess.onenet.net, pub/chess/TB.  Currently, Steven     *
 *           Edwards has all interesting 4 piece endings done.  To make this   *
 *           work, compile with -DTABLEBASES, and create a TB directory where  *
 *           Crafty is run, and locate the tablebase files in that directory.  *
 *           If you are running under UNIX, TB can be a symbolic or hard link  *
 *           to a directory anywhere you want.                                 *
 *                                                                             *
 *    8.25   Minor repair on draw by repetition.  Modified how books.bin was   *
 *           being used.  Now, a move in books.bin has its flags merged with   *
 *           the corresponding move from book.bin, but if the move does not    *
 *           exist in book.bin, it is still kept as a book move.  Repetitions  *
 *           are now counted as a draw if they occur two times, period.  The   *
 *           last approach was causing problems due to hashing, since the hash *
 *           approach used in Crafty is fairly efficient and frequently will   *
 *           carry scores across several searches.  This resulted in Crafty    *
 *           stumbling into a draw by repetition without knowing.  The con-    *
 *           figuration switch HAS-64BITS has been cleaned up and should be    *
 *           set for any 64bit architecture now, not just for Cray machines.   *
 *                                                                             *
 *    8.26   New search extension added, the well-known "one legal response to *
 *           check" idea.  If there's only one legal move when in check, we    *
 *           extend two plies rather than one, since this is a very forcing    *
 *           move.  Also, when one side has less than a rook, and the other    *
 *           has passed pawns, pushing these pawns to the 6th or 7th rank      *
 *           will extend the search one ply, where in normal positions, we     *
 *           only extend when a pawn reaches the 7th rank.                     *
 *                                                                             *
 *    9.0    Minor constraint added to most extensions:  we no longer extend   *
 *           if the side on move is either significantly ahead or behind,      *
 *           depending on the extension.  For example, getting out of check    *
 *           won't extend if the side on move is a rook behind, since it's     *
 *           already lost anyway.  We don't extend on passed pawn pushes if    *
 *           the side on move is ahead a rook, since he's already winning.     *
 *           minor adjustments for efficiency as well.  The next few versions  *
 *           in this series will have module names in these comments           *
 *           indicating which modules have been "cleaned" up.  This is an      *
 *           effort at optimizing, although it is currently directed at a line *
 *           by line analysis within modules, rather than major changes that   *
 *           effect more global ideas.  This type of optimization will come at *
 *           a later point in time.                                            *
 *                                                                             *
 *    9.1    NextMove(), NextCapture() and NextEvasion() were re-structured    *
 *           to eliminate unnecessary testing and speed them up significantly. *
 *           EvaluateTrades() was completely removed, since Crafty already has *
 *           positional scores that encourage/discourage trading based on the  *
 *           status of the game.  EvaluateTempo() was evaluated to be a        *
 *           failure and was removed completely.                               *
 *                                                                             *
 *    9.2    Quiesce()) and Search() were modified to be more efficient.  In   *
 *           addition, the null-move search was relaxed so that it always does *
 *           a search to depth-R, even if close to the end of the tree.        *
 *                                                                             *
 *    9.3    Check() is no longer used to make sure a position is legal after  *
 *           MakeMove() called, but before Search() is called recursively.  We *
 *           now use the same approach as Cray Blitz, we make a move and then  *
 *           capture the king at the next ply to prove the position is not a   *
 *           valid move.  If the side-on-move is already in check, we use      *
 *           NextEvasion() which only generates legal moves anyway, so this    *
 *           basically eliminates 1/2 of the calls to Check(), a big win.      *
 *           This resulted in modifications to Search(), Quiesce(), and        *
 *           QuiesceFull().  Connected passed pawns on 6th-7th no longer       *
 *           trigger search extensions.  Solved some problems like Win at      *
 *           Chess #2, but overall was a loser.                                *
 *                                                                             *
 *    9.4    Lookup now checks the transposition table entry and then informs  *
 *           Search() when it appears that a null move is useless.  This is    *
 *           found when the draft is too low to use the position, but it is at *
 *           least as deep as a null-move search would go, and the position    *
 *           did not cause a fail-high when it was stored.  King-safety was    *
 *           modified again.  The issue here is which king should attract the  *
 *           pieces, and for several months the answer has been the king that  *
 *           is most exposed attracts *all* pieces.  This has been changed to  *
 *           always attract one side's pieces to the other king.  Crafty's     *
 *           asymmetric king-safety was making it overly-defensive, even when  *
 *           the opponent's king was more exposed.  This should cure that and  *
 *           result in more aggressive play.                                   *
 *                                                                             *
 *    9.5    "Vestigial code" (left over from who-knows-when) removed from     *
 *           Evaluate().  This code used an undefined variable when there was  *
 *           no bishop or knight left on the board, and could add in a penalty *
 *           on random occasions.  Quiescence checks removed completely to see *
 *           how this works, since checks extend the normal search significant *
 *           amounts in any case.  QuiesceFull() removed and merged into       *
 *           Quiesce() which is faster and smaller.  First impression: faster, *
 *           simpler, better.  The benefit of no quiescence checks is that the *
 *           exhaustive search goes deeper to find positional gains, rather    *
 *           than following checks excessively.  No noticable loss in tactical *
 *           strength (so far).                                                *
 *                                                                             *
 *    9.6    legal move test re-inserted in Search() since null-moves could    *
 *           make it overlook the fact that a move was illegal.  New assembly  *
 *           code for X86 improves performance about 1/3, very similarly to    *
 *           the results obtained with the sparc-20 assembly code.  This was   *
 *           contributed by Eugene Nalimov and is a welcome addition.          *
 *                                                                             *
 *    9.7    Optimizations continuing.  Minor bug in pawn evaluation repaired. *
 *           Crafty looked at most advanced white pawn, but least-advanced     *
 *           black pawn on a file when doing its weak pawn evaluation.  The    *
 *           history heuristic was slightly broken, in that it was supposed to *
 *           be incrementing the history count by depth*depth, but this was    *
 *           somehow changed to 7*depth, which was not as good.  Assembly      *
 *           language interface fixed to cleanly make Crafty on all target     *
 *           architectures.                                                    *
 *                                                                             *
 *    9.8    The first change was to borrow a time-allocation idea from Cray   *
 *           Blitz.  Essentially, when Crafty notices it has used the normal   *
 *           time allotment, rather than exiting the search immediately, it    *
 *           will wait until it selects the next move at the root of the tree. *
 *           The intent of this is that if it has started searching a move     *
 *           that is going to be better than the best found so far, this will  *
 *           take more time, while a worse move will fail low quickly.  Crafty *
 *           simply spends more time to give this move a chance to fail high   *
 *           or else quickly fail low.  A fairly serious bug, that's been      *
 *           around for a long time, has finally been found/fixed.  In simple  *
 *           terms, if the "noise" level was set too high, it could make       *
 *           Crafty actually play a bad move.  The more likely effect was to   *
 *           see "bad move hashed" messages and the first few lines of output  *
 *           from the search often looked funny.  The bug was "noise" was used *
 *           as a limit, until that many nodes had been searched, no output    *
 *           would be produced.  Unfortunately, on a fail-high condition, the  *
 *           same code that produced the "++  Nh5" message also placed the     *
 *           fail-high move in the PV.  Failing to do this meant that the      *
 *           search could fail high, but not play the move it found.  Most     *
 *           often this happened in very fast games, or near the end of long   *
 *           zero-increment games.  It now always saves this move as it should *
 *           regardless of whether it prints the message or not.               *
 *                                                                             *
 *    9.9    Interface to Xboard changed from -ics to -xboard, so that -ics    *
 *           can be used with the custom interface.  Additional code to        *
 *           communicate with custom interface added.  Search() extensions are *
 *           restricted so that there can not be more than one extension at a  *
 *           node, rather than the two or (on occasion) more of the last       *
 *           version.                                                          *
 *                                                                             *
 *    9.10   Converted to Ken Thompson's "Belle" hash table algorithm.  Simply *
 *           put, each side has two tables, one that has entries replaced on a *
 *           depth-priority only, the other is an "always replace" table, but  *
 *           is twice as big.  This allows "deep" entries to be kept along     *
 *           with entries close to search point.  Basically, when the depth-   *
 *           priority table gets a position stored in it, the displaced        *
 *           position is moved to the always-replace table.  If the position   *
 *           can not replace the depth-priority entry, it always overwrites    *
 *           the other always-replace entry.  However, a position is never put *
 *           in both tables at the same time.                                  *
 *                                                                             *
 *    9.11   Bug in Search() that could result in the "draft" being recorded   *
 *           incorrectly in the hash table.  Caused by passing depth, which    *
 *           could be one or two plies more than it should be due to the last  *
 *           move extending the search.  Repeat() completely removed from      *
 *           Quiesce() since only capture moves are included, and it's         *
 *           impossible to repeat a position once a capture has been made.     *
 *                                                                             *
 *    9.12   optimizations: history.c, other minor modifications.              *
 *                                                                             *
 *    9.13   EvaluatePawns() modified significantly to simplify and be more    *
 *           accurate as well.  Pawns on open files are now not directly       *
 *           penalized if they are weak, rather the penalty is added when the  *
 *           rooks are evaluated.  Pawn hashing modified to add more info to   *
 *           the data that is hashed.  King safety scores toned down almost    *
 *           50% although it is still asymmetric.                              *
 *                                                                             *
 *    9.14   EvaluatePawns() modified further so that it now does the same     *
 *           computations for king safety as the old EvaluateKingSafety*()     *
 *           modules did, only it produces four values, two for each king,     *
 *           for each side of the board (king or queen-side).  This is now     *
 *           hashed with the rest of the pawn scoring, resulting in less       *
 *           hashing and computation, and more hits for king-safety too.  King *
 *           safety modified further.  Asymmetric scoring was accidentally     *
 *           disabled several versions ago, this is now enabled again.         *
 *                                                                             *
 *    9.15   Evaluate() now attempts to recognize the case where a knight is   *
 *           trapped on one of the four corner squares, much like a bishop     *
 *           trapped at a2/a7/h2/h7.  If a knight is on a corner square, and   *
 *           neither of the two potential flight squares are safe (checked by  *
 *           SEE()) then a large penalty is given.  This was done to avoid     *
 *           positions where Crafty would give up a piece to fork the king and *
 *           rook at (say) c7, and pick up the rook at a8 and think it was an  *
 *           exchange ahead, when often the knight was trapped and it was      *
 *           two pieces for a rook and pawn (or worse.)  Two timing bugs fixed *
 *           in this version:  (1) nodes_per_second was getting clobbered at   *
 *           the end of iterate, which would then corrupt the value stored in  *
 *           nodes_between_time_checks and occasionally make Crafty not check  *
 *           the time very often and use more time than intended; (2) the      *
 *           "don't stop searching after time is out, until the current move   *
 *           at the root of the tree has been searched" also would let Crafty  *
 *           use time unnecessarily.                                           *
 *                                                                             *
 *    9.16   Significant changes to the way MakeMove() operates.  Rather than  *
 *           copying the large position[ply] structure around, the piece       *
 *           location bitmaps and the array of which piece is on which square  *
 *           are now simple global variables.  This means that there is now an *
 *           UnmakeMove() function that must be used to restore these after a  *
 *           a move has been made.  The benefit is that we avoid copying 10    *
 *           bitmaps for piece locations when typically only one is changed,   *
 *           Ditto for the which piece is on which square array which is 64    *
 *           bytes long.  The result is much less memory traffic, with the     *
 *           probability that the bitmaps now stay in cache all the time. The  *
 *           EvaluatePawns() code now has an exponential-type penalty for      *
 *           isolated pawns, but it penalizes the difference between white and *
 *           black isolated pawns in this manner.  King evaluation now         *
 *           evaluates cases where the king moves toward one of the rooks and  *
 *           traps it in either corner.                                        *
 *                                                                             *
 *    9.17   Xboard compatibility version!  Now supports, so far as I know,    *
 *           the complete xboard interface, including hint, show thinking,     *
 *           taking back moves, "move now" and so forth.  Additionally, Crafty *
 *           now works with standard xboard.  Notice that this means that a    *
 *           ^C (interrupt) will no long terminate Crafty, because xboard uses *
 *           this to implement the "move now" facility.  This should also      *
 *           work with winboard and allow pondering, since there is now a      *
 *           special windows version of CheckInput() that knows how to check   *
 *           Win95 or WinNT pipes when talking with winboard.                  *
 *                                                                             *
 *    9.18   Xboard compatibility update.  "force" (gnu) mode was broken, so   *
 *           that reading in a PGN file (via xboard) would break.  Now, Crafty *
 *           can track the game perfectly as xboard reads the moves in.  King  *
 *           safety modified to discourage g3/g6 type moves without the bishop *
 *           to defend the weak squares.  Significant other changes to the     *
 *           Evaluate() procedure and its derivatives.  Very nasty trans/ref   *
 *           bug fixed.  Been there since transposition tables added.  When    *
 *           storing a mate score, it has to be adjusted since it's backed up  *
 *           as "mate in n plies from root" but when storing, it must be saved *
 *           as "mate in n plies from current position".  Trivial, really, but *
 *           I overlooked one important fact:  mate scores can also be upper   *
 *           or lower search bounds, and I was correcting them in the same way *
 *           which is an error.  The effect was that Crafty would often find a *
 *           mate in 2, fail high on a move that should not fail high, and end *
 *           up making a move that would mate in 3.  In particularly bad cases *
 *           this would make the search oscillate back and forth and draw a    *
 *           won position.  The fix was to only adjust the score if it's a     *
 *           score, not if it's a bound.  The "age" field of the trans/ref     *
 *           table was expanded to 3 bits.  Iterate now increments a counter   *
 *           modulo 8, and this counter is stored in the 3 ID bits of the      *
 *           trans/ref table.  If they are == the transposition_id counter,    *
 *           we know that this is a position stored during the current search. *
 *           If not, it's an "old" position.  This avoids the necessity of     *
 *           stepping through each entry in the trans/ref table (at the begin- *
 *           ning of a search) to set the age bit.  Much faster in blitz games *
 *           as stepping through the trans/ref table, entry by entry, would    *
 *           blow out cache.  This idea was borrowed from Cray Blitz, which    *
 *           used this same technique for many years.                          *
 *                                                                             *
 *    9.19   New evaluation code for passed pawns.  Crafty now gives a large   *
 *           bonus for two or more connected passed pawns, once they reach the *
 *           sixth rank, when the opponent has less than a queen remaining.    *
 *           this will probably be tuned as experience produces the special    *
 *           cases that "break" it.  Such things as the king too far away or   *
 *           the amount of enemy material left might be used to further im-    *
 *           prove the evaluation.                                             *
 *                                                                             *
 *    9.20   Bug in SetBoard() fixed.  Validity checks for castling status and *
 *           en passant status was broken for castle status.  It was checking  *
 *           the wrong rook to match castling status, and would therefore not  *
 *           accept some valid positions, including #8 in Win At Chess suite.  *
 *           Minor repetition bug fixed, where Crafty would recognize that a   *
 *           three-fold repetition had occurred, but would not claim it when   *
 *           playing on a chess server.  Crafty now does not immediately re-   *
 *           search the first move when it fails low.  Rather, it behaves like *
 *           Cray Blitz, and searches all moves.  If all fail low, Crafty will *
 *           then relax (lower) alpha and search the complete list again.      *
 *           This is a simple gamble that there is another move that will      *
 *           "save the day" so that we avoid the overhead of finding out just  *
 *           how bad the first move is, only to have more overhead when a good *
 *           move fails high.  Minor repetition bug fixed.  When running test  *
 *           suites of problems, SetBoard() neglected to put the starting      *
 *           position in the repetition list, which would occasionally waste   *
 *           time.  One notable case was Win At Chess #8, where Crafty would   *
 *           find Nf7+ Kg8 Nh6+ Kh8 (repeating the original position) followed *
 *           by Rf7 (the correct move, but 4 tempi behind.)  Display() bug     *
 *           fixed.  Crafty now displays the current board position, rather    *
 *           than the position that has been modified by a search in progress. *
 *           Castling evaluation modified including a bug in the black side    *
 *           that would tend to make Crafty not castle queen-side as black if  *
 *           the king-side was shredded.  Minor bug in Book(). If the book was *
 *           turned off (which is done automatically when using the test com-  *
 *           mand since several of the Win At Chess positions are from games   *
 *           in Crafty's large opening book) Book() would still try to read    *
 *           the file and then use the data from the uninitialized buffer.     *
 *           This would, on occasion, cause Crafty to crash in the middle of   *
 *           a test suite run.                                                 *
 *                                                                             *
 *    9.21   Castling evaluation has been significantly modified to handle the *
 *           following three cases better:                                     *
 *           (a) One side can castle at the root of the tree, but can not      *
 *           castle at a tip position.  If the move that gave up the right to  *
 *           castle was *not* a castle move, penalize the score.               *
 *           (b) One side can castle short or long at the root, but has al-    *
 *           ready castled by the time the search reaches a tip position.      *
 *           Here the goal is to make sure the player castled to the "better"  *
 *           side by comparing king safety where the king really is, to king   *
 *           safety had the king castled to the other side.  If the latter is  *
 *           "safer" then penalize the current position by the "difference"    *
 *           in king safety to encourage that side to delay castling.  This is *
 *           a problem when Crafty can castle kingside *now*, but the kingside *
 *           has been disrupted somehow.  If the search is not deep enough to  *
 *           see clearing out the queenside and castling long, then it will    *
 *           often castle short rather than not castle at all.  This fix will  *
 *           make it delay, develop the queenside, and castle to a safer king  *
 *           shelter, unless tactics force it to castle short.                 *
 *           (c) One side can castle short or long at the root, but can only   *
 *           castle one way at a tip position, because a rook has been moved.  *
 *           If the remaining castle option is worse than castling to the side *
 *           where the rook was moved, then we penalize the rook move to keep  *
 *           castling to that side open as an option.                          *
 *                                                                             *
 *    9.22   More castling evaluation changes, to tune how/when Crafty chooses *
 *           to castle.  Bugs in Option() where certain commands could be ex-  *
 *           ecuted while a search was in progress.  If these commands did     *
 *           anything to the board position, It would break Crafty badly.      *
 *           All that was needed was to check for an active search before some *
 *           commands were attempted, and if a search was in progress, return  *
 *           to abort the search then re-try the command.  When playing games  *
 *           with computers (primarily a chess-server consideration) Crafty is *
 *           now defaulting to "book random 0" to use a short search to help   *
 *           avoid some ugly book lines on occasion.  In this version, *all*   *
 *           positional scores were divided by 2 to reduce the liklihood that  *
 *           Crafty would sacrifice material and make up the loss with some    *
 *           sort of positional gain that was often only temporary.  Note that *
 *           king safety scores were not reduced while doing this.  New book   *
 *           random options:  0=search, 1=most popular move, 2=move that       *
 *           produces best positional value, 3=choose from most frequently     *
 *           played moves, 4=emulate GM frequency of move selection, 5=use     *
 *           sqrt() on frequencies to give more randomness, 6=random.  For     *
 *           now, computers get book_random=1, while GM's now get 4 (same as   *
 *           before), everyone else gets 5.  Until now, there has been no      *
 *           penalty for doubled/tripled pawns.  It now exists.  Also, if the  *
 *           king stands on E1/E8, then the king-side king safety term is used *
 *           to discourage disrupting the king-side pawns before castling.     *
 *           Crafty now has a start-up initialization file (as most Unix       *
 *           programs do).  This file is named ".craftyrc" if the macro UNIX   *
 *           is defined, otherwise a "dossy" filename "crafty.rc" is used.     *
 *           Crafty opens this file and executes every command in it as though *
 *           they were typed by the operator.  The last command *must* be      *
 *           "exit" to revert input back to STDIN.                             *
 *                                                                             *
 *    9.23   More evaluation tuning, including the complete removal of the     *
 *           mobility term for rooks/queens.  Since rooks already have lots    *
 *           of scoring terms like open files, connected, etc, mobility is     *
 *           redundant at times and often misleading.  The queen's mobility    *
 *           is so variable it is nearly like introducing a few random points  *
 *           at various places in the search.  Minor Xboard compatibility bug  *
 *           fixed where you could not load a game file, then have Crafty play *
 *           by clicking the "machine white" or "machine black" options.       *
 *                                                                             *
 *    9.24   Minor bug in Quiesce() repaired.  When several mate-in-1 moves    *
 *           were available at the root, Crafty always took the last one,      *
 *           which was often an under-promotion to a rook rather than to a     *
 *           queen.  It looked silly and has been fixed so that it will play   *
 *           the first mate-in-1, not the last.  RootMoveList() went to great  *
 *           pains to make sure that promotion to queen occurs before rook.    *
 *           Bug in EvaluateOutsidePassedPawns() would fail to recognize that  *
 *           one side had an outside passer, unless both sides had at least    *
 *           one passer, which failed on most cases seen in real games.        *
 *           Minor "tweak" to move ordering.  GenerateMoves() now uses the     *
 *           LSB() function to enumerate white moves, while still using MSB()  *
 *           for black moves.  This has the effect of moving pieces toward     *
 *           your opponent before moving them away.  A severe oversight        *
 *           regarding the use of "!" (as in wtm=!wtm) was found and corrected *
 *           to speed things up some.  !wtm was replaced by wtm^1 (actually,   *
 *           a macro Flip(wtm) is used to make it more readable) which         *
 *           resulted in significant speedup on the sparc, but a more modest   *
 *           improvement on the pentium.                                       *
 *                                                                             *
 *    9.25   Minor bug in Book() fixed where it was possible for Crafty to     *
 *           play a book move that was hardly ever played.  Minor change to    *
 *           time utilization to use a little more time "up front".  Tuned     *
 *           piece/square tables to improve development some.  Saw Crafty lose *
 *           an occasional game because (for example) the bishop at c1 or c8   *
 *           had not moved, but the king had already castled, which turned the *
 *           EvaluateDevelopment() module "off".  first[ply] removed, since it *
 *           was redundant with last[ply-1].  The original intent was to save  *
 *           a subscript math operation, but the compilers are quite good with *
 *           the "strength-reduction" optimization, making referencing a value *
 *           by first[ply] or last[ply-1] exactly the same number of cycles.   *
 *           Passed pawn scores increased.  The reduction done to reduce all   *
 *           scores seemed to make Crafty less attentive to passed pawns and   *
 *           the threats they incur.  Minor bug in Book() fixed, the variable  *
 *           min_percent_played was inoperative due to incorrect test on the   *
 *           book_status[n] value.  Pawn rams now scored a little differently, *
 *           so that pawn rams on Crafty's side of the board are much worse    *
 *           than rams elsewhere.  This avoids positional binds where, for ex- *
 *           ample Crafty would like black with pawns at e6 d5 c6, white with  *
 *           pawns at e5 and c5.  Black has a protected passed pawn at d5 for  *
 *           sure, but the cramp makes it easy for white to attack black, and  *
 *           makes it difficult for black to defend because the black pawns    *
 *           block the position badly.  King safety tweaked up about 30%, due  *
 *           to using nearly symmetrical scoring, the values had gotten too    *
 *           small and were not overriding minor positional things.            *
 *                                                                             *
 *    9.26   Minor bug fixes in time allocation.  This mainly affects Crafty   *
 *           as it plays on a chess server.  The problem is, simply, that the  *
 *           current internal timing resolution is 1/10 of a second, kept in   *
 *           an integer variable.  .5 seconds is stored as 5, for example.     *
 *           This became a problem when the target time for a search dropped   *
 *           below .3 seconds, because the "easy move" code would terminate    *
 *           the search after 1/3 of the target time elapsed if there were no  *
 *           fail lows or PV changes.  Unfortunately, 2 divided by 3 (.2 secs  *
 *           /3) is "zero" which would let the search quickly exit, possibly   *
 *           without producing a PV with a move for Crafty to play.  Crafty    *
 *           would play the first PV move anyway, which was likely the PV move *
 *           from the last search.  This would corrupt the board information,  *
 *           often produce the error "illegal move" when the opponent tried to *
 *           move, or, on occasion, blow Crafty up.  On a chess server, Crafty *
 *           would simply flag and lose.  After this fix, I played several     *
 *           hundred games with a time control of 100 moves in 1 second and    *
 *           there were no failures.  Before the fix, this time control could  *
 *           not result in a single completed game.  If you don't run Crafty   *
 *           on a chess server, this version is not important, probably. a     *
 *           minor fix for move input, so that moves like e2e4 will always be  *
 *           accepted, where before they would sometimes be flagged as errors. *
 *                                                                             *
 *    9.27   This version has an interesting modification to NextCapture().    *
 *           Quiesce() now passes alpha to NextCapture() and if a capture      *
 *           appears to win material, but doesn't bring the score up to the    *
 *           value of alpha, the capture is ignored.  In effect, if we are so  *
 *           far behind that a capture still leaves us below alpha, then there *
 *           is nothing to gain by searching the capture because our opponent  *
 *           can simply stand pat at the next ply leaving the score very bad.  *
 *           One exception is if the previous ply was in check, we simply look *
 *           for any safe-looking capture just in case it leads to mate.  Bad  *
 *           book bug with book random=1 or 2 fixed (this is set when playing  *
 *           a computer).  This bug would cause Crafty to play an illegal move *
 *           and bust wide open with illegal move errors, bad move hashed, and *
 *           other things.  Book randomness also quite a bit better now.       *
 *                                                                             *
 *    9.28   Piece/square table added for rooks.  Primary purpose is to dis-   *
 *           courage rooks moving to the edge of the board but in front of     *
 *           pawns, where it is easy to trap it.  Crafty now understands the   *
 *           concept of blockading a passed pawn to prevent it from advancing. *
 *           it always understood that advancing one was good, which would     *
 *           tend to encourage blockading, but it would also often ignore the  *
 *           pawn and let it advance a little here, a little there, until it   *
 *           suddenly realized that it was a real problem.  The command to set *
 *           the size of the hash table has been modified.  This command is    *
 *           now "hash n", "hash nK" or "hash nM" to set the hash table to one *
 *           of bytes, Kbytes, or Mbytes.  Note that if the size is not an     *
 *           exact multiple of what Crafty needs, it silently reduces the size *
 *           to an optimum value as close to the suggested size as possible.   *
 *           Trade bonus/penalty is now back in, after having been removed     *
 *           when the new UnmakeMove() code was added.  Crafty tries to trade  *
 *           pawns but not pieces when behind, and tries to trade pieces but   *
 *           not pawns when ahead.  EvaluateDraws() now understands that rook  *
 *           pawns + the wrong bishop is a draw.  Minor adjustment to the      *
 *           quiescence-search pruning introduced in 9.27, to avoid excluding  *
 *           captures that didn't lose material, but looked bad because the    *
 *           positional score was low.  Slightly increased the values of the   *
 *           pieces relative to that of a pawn to discourage the tendency to   *
 *           trade a piece for two or three pawns plus some positional plusses *
 *           that often would slowly vanish.  Null-move search modified to try *
 *           null-moves, even after captures.  This seems to hurt some prob-   *
 *           lem positions, but speeds up others significantly.  Seems better  *
 *           but needs close watching.  EvaluateDraws() call moved to the top  *
 *           of Evaluate() to check for absolute draws first.  Quiesce() now   *
 *           always calls Evaluate() which checks for draws before trying the  *
 *           early exit tests to make sure that draws are picked up first.     *
 *           EvaluateDraws() substantially re-written to get rid of lots of    *
 *           unnecessary instructions, and to also detect RP+B of wrong color  *
 *           even if the losing side has a pawn of its own.  Crafty would      *
 *           often refuse to capture that last pawn to avoid reaching an end-  *
 *           game it knew was drawn.                                           *
 *                                                                             *
 *    9.29   New time.c as contributed by Mike Byrne.  Basically makes Crafty  *
 *           use more time up front, which is a method of anticipating that    *
 *           Crafty will predict/ponder pretty well and save time later on     *
 *           anyway.  InCheck() is never called in Quiesce() now.  As a        *
 *           result, Crafty won't recognize mates in the q-search.  This has   *
 *           speeded the code up with no visible penalty, other than it will   *
 *           occasionally find a win of material rather than a mate score, but *
 *           this has not affected the problem suite results in a measurable   *
 *           way, other than Crafty is now about 10% faster in average type    *
 *           position, and much faster in others.  The latest epd code from    *
 *           Steven Edwards is a part of this version, which includes updated  *
 *           tablebase access code.                                            *
 *                                                                             *
 *   10.0    New time.c with a "monitoring feature" that has two distinct      *
 *           functions:  (1) monitor Crafty's time remaining and if it is too  *
 *           far behind the opponent, force it to speed up, or if it is well   *
 *           ahead on time, slow down some;  (2) if opponent starts moving     *
 *           quickly, Crafty will speed up as well to avoid getting too far    *
 *           behind.  EvaluateDraws() modified to detect that if one side has  *
 *           insufficient material to win, the score can never favor that side *
 *           which will make Crafty avoid trading into an ending where it has  *
 *           KNN vs KB for example, where KNN seems to be ahead.               *
 *                                                                             *
 *   10.1    New book.c.  Crafty now counts wins, losses and draws for each    *
 *           possible book move and can use these to play a move that had a    *
 *           high percentage of wins, vs the old approach of playing a move    *
 *           just because it was played a lot in the past.                     *
 *                                                                             *
 *   10.2    Evaluation tuning.  Rook on 7th, connected rooks on 7th, etc.,    *
 *           are now more valuable.  Crafty was mistakenly evaluating this     *
 *           too weakly.  Book() changed so that the list of moves is first    *
 *           sorted based on winning percentages, but then, after selecting    *
 *           the sub-set of this group, the list is re-sorted based on the     *
 *           raw total games won so that the most popular opening is still the *
 *           most likely to be played.                                         *
 *                                                                             *
 *   10.3    Timer resolution changed to 1/100th of a second units, with all   *
 *           timing variables conforming to this, so that it is unnecessary    *
 *           to multiply by some constant to convert one type of timing info   *
 *           to the standard resolution.  Bug in evaluate.c fixed.  Trapped    *
 *           rook (rook at h1, king at g1 for example) code had a bad sub-     *
 *           script that caused erroneous detection of a trapped rook when     *
 *           there was none.                                                   *
 *                                                                             *
 *   10.4    Quiesce() no longer checks for time exceeded, nor does it do any  *
 *           hashing whatsoever, which makes it significantly faster, while    *
 *           making the trees only marginally bigger.                          *
 *                                                                             *
 *   10.5    Quiesce() now calls GenerateCaptures() to generate capture moves. *
 *           This new move generator module is significantly faster, which     *
 *           speeds the quiescence search up somewhat.                         *
 *                                                                             *
 *   10.6    CastleStatus is now handled slightly differently.  The right two  *
 *           bits still indicate whether or not that side can castle to either *
 *           side, and 0 -> no castling at all, but now, <0 means that no      *
 *           castling can be done, and that castling rights were lost by       *
 *           making a move that was not castling.  This helps in Evaluate()    *
 *           by eliminating a loop to see if one side castled normally or had  *
 *           to give up the right to castle for another (bad) reason.  This is *
 *           simply an efficiency issue, and doesn't affect play or anything   *
 *           at all other than to make the search faster.                      *
 *                                                                             *
 *   10.7    NextMove() now doesn't try history moves forever, rather it will  *
 *           try the five most popular history moves and if it hasn't gotten a *
 *           cutoff by then, simply tries the rest of the moves without the    *
 *           history testing, which is much faster.                            *
 *                                                                             *
 *   10.8    Book() now "puzzles" differently.  In puzzling, it is trying to   *
 *           find a move for the opponent.  Since a book move by the opponent  *
 *           will produce an instant move, puzzle now enumerates the set of    *
 *           legal opponent moves, and from this set, removes the set of known *
 *           book moves and then does a quick search to choose the best.  We   *
 *           then ponder this move just in case the opponent drops out of book *
 *           and uses a normal search to find a move.  Crafty now penalizes    *
 *           a pawn that advances, leaving its neighbors behind where both     *
 *           the advancing pawn, and the ones being left behind become weaker. *
 *           the opening phase of the game has been modified to "stay active"  *
 *           until all minor pieces are developed and Crafty has castled, to   *
 *           keep EvaluateDevelopment() active monitoring development.  Minor  *
 *           change to DrawScore() so that when playing a computer, it will    *
 *           return "default_draw_score" under all circumstances rather than   *
 *           adjusting this downward, which makes Crafty accept positional     *
 *           weaknesses rather than repeat a position.                         *
 *                                                                             *
 *   10.9    Evaluate() now handles king safety slightly differently, and      *
 *           increases the penalty for an exposed king quite a bit when there  *
 *           is lots of material present, but scales this increase down as the *
 *           material comes off.  This seems to help when attacking or getting *
 *           attacked.  Since Quiesce() no longer probes the hash table, the   *
 *           idea of storing static evaluations there became worthless and was *
 *           burning cycles that were wasted.  This has been removed. Check    *
 *           extensions relaxed slightly so that if ply is < iteration+10 it   *
 *           will allow the extension.  Old limit was 2*iteration.  Connected  *
 *           passed pawns on 6th now evaluated differently.  They get a 1 pawn *
 *           bonus, then if material is less than a queen, another 1 pawn      *
 *           bonus, and if not greater than a rook is left, and the king can't *
 *           reach the queening square of either of the two pawns, 3 more      *
 *           more pawns are added in for the equivalent of + a rook.           *
 *                                                                             *
 *   10.10   Evaluate() modified.  King safety was slightly broken, in that    *
 *           an uncastled king did not get a penalty for open center files.    *
 *           new evaluation term for controlling the "absolute 7th rank", a    *
 *           concept from "My System".                                         *
 *                                                                             *
 *   10.11   Lazy evaluation implemented.  Now as the Evaluate() code is ex-   *
 *           ecuted, Crafty will "bail out" when it becomes obvious that the   *
 *           remainder of the evaluation can't bring the score back inside the *
 *           alpha/beta window, saving time.                                   *
 *                                                                             *
 *   10.12   More Jakarta time control commands added so operator can set the  *
 *           time accurately if something crashes, and so the operator can set *
 *           a "cushion" to compensate for operator inattention.  "Easy" is    *
 *           more carefully qualified to be a recapture, or else a move that   *
 *           preserves the score, rather than one that appears to win material *
 *           as was done in the past.  King safety tweaked a little so that if *
 *           one side gives up the right to castle, and could castle to a safe *
 *           position, the penalty for giving up the right is substantially    *
 *           larger than before.  A minor bug also made it more likely for     *
 *           black to give up the right to castle than for white.              *
 *                                                                             *
 *   10.13   Modifications to Book() so that when using "book random 0" mode   *
 *           (planned for Jakarta) and the search value indicates that we are  *
 *           losing a pawn, we return "out of book" to search *all* the moves, *
 *           Not just the moves that are "in book."  This hopefully avoids     *
 *           some book lines that lose (gambit) material unsoundly.            *
 *                                                                             *
 *   10.14   Final timing modifications.  Puzzling/booking searches now take   *
 *           1/30th of the normal time, rather than 1/10th.  New command       *
 *           "mode=tournament" makes Crafty assess DRAW as "0" and also makes  *
 *           it prompt the operator for time corrections as required by WMCCC  *
 *           rules.                                                            *
 *                                                                             *
 *   10.15   Evaluate() tuning to reduce development bonuses, which were able  *
 *           to overwhelm other scores and lead to poor positions.             *
 *                                                                             *
 *   10.16   "Lazy" (early exit) caused some problems in Evaluate() since so   *
 *           many scores are very large.  Scaled this back significantly and   *
 *           also EvaluateOutsidePassedPawns() could double the score if one   *
 *           side had passers on both sides.  This was fixed.                  *
 *                                                                             *
 *   10.17   Crafty's Book() facility has been significantly modified to be    *
 *           more understandable.  book random <n> has the following options:  *
 *           (0) do a search on set of book moves; (1) choose from moves that  *
 *           are played most frequently; (2) choose from moves with best win   *
 *           ratio; (3) choose from moves with best static evaluation; and     *
 *           (4) choose completely randomly.  book width <n> can be used to    *
 *           control how large the "set" of moves will be, with the moves in   *
 *           the "set" being the best (according to the criteria chosen) from  *
 *           the known book moves.  Minor tweak to Search() so that it extends *
 *           passed pawn pushes to the 6th or 7th rank if the move is safe,    *
 *           and this is an endgame.                                           *
 *                                                                             *
 *   10.18   New annotate command produces a much nicer analysis file and also *
 *           lets you exert control over what has to happen to trigger a com-  *
 *           ment among other things.  AKA Crafty/Jakarta version.             *
 *                                                                             *
 *   11.1    Fractional depth allows fractional ply increments.  The reso-     *
 *           lution is 1/4 of a ply, so all of the older "depth++" lines now   *
 *           read depth+=PLY, where #define PLY 4 is used everywhere.  This    *
 *           gives added flexibility in that some things can increment the     *
 *           depth by < 1 ply, so that it takes two such things before the     *
 *           search actually extends one ply deeper.  Crafty now has full PGN  *
 *           support.  A series of pgn commands (pgn Event 14th WMCCC) allow   *
 *           the PGN tags to be defined, when Crafty reads or annotates a PGN  *
 *           file it reads and parses the headers and will display the info    *
 *           in the annotation (.can) file or in the file you specify when you *
 *           execute a "savegame <filename>" command.                          *
 *                                                                             *
 *   11.2    Fractional ply increments now implemented.  11.1 added the basic  *
 *           fractional ply extension capabilities, but this version now uses  *
 *           them in Search().  There are several fractional ply extensions    *
 *           being used, all are #defined in types.h to make playing with them *
 *           somewhat easier.  One advantage is that now all extensions are    *
 *           3/4 of a ply, which means the first time any extension is hit, it *
 *           has no effect, but the next three extensions will result in an    *
 *           additional ply, followed by another ply where the extension does  *
 *           nothing, followed by ...  This allowed me to remove the limit on  *
 *           how deep in the tree the extensions were allowed, and also seems  *
 *           to not extend as much unless there's "something" going on.  When  *
 *           the position gets interesting, these kick in.  Asymmetric king    *
 *           safety is back in.  Crafty's king safety is a little more im-     *
 *           portant than the opponent's now to help avoid getting its king-   *
 *           side shredded to win a pawn.  A new term, ROOK_ON_7TH_WITH_PAWN   *
 *           to help Crafty understand how dangerous a rook on the 7th is if   *
 *           it is supported by a pawn.  It is difficult to drive off and the  *
 *           pawn provides additional threats as well.                         *
 *                                                                             *
 *   11.3    King safety modifications.  One fairly serious bug is that Crafty *
 *           considered that king safety became unimportant when the total     *
 *           pieces dropped below 16 material points.  Note that this was      *
 *           pieces only, not pieces and pawns, which left plenty of material  *
 *           on the board to attack with.  As a result, Crafty would often     *
 *           allow its king-side to be weakened because it was either in an    *
 *           endgame, or close to an endgame.  *Incorrectly*, it turns out. :) *
 *           Going back to a very old Crafty idea, king tropism is now tied to *
 *           how exposed each king is, with pieces being attracted to the most *
 *           exposed king for attack/defense.                                  *
 *                                                                             *
 *   11.4    Tuning on outside passed pawn code.  Values were not large enough *
 *           and didn't emphasize how strong such a pawn is.  General passed   *
 *           pawn value increased as well.  Minor bug in edit that would let   *
 *           Crafty flag in some wild games was fixed.  Basically, edit has no *
 *           way to know if castling is legal, and has to assume if a rook and *
 *           king are on the original squares, castling is o.k.  For wild2     *
 *           games in particular, this can fail because castling is illegal    *
 *           (by the rules for wild 2) while it might be that rooks and king   *
 *           are randomly configured to make it look possible.  Crafty would   *
 *           then try o-o or o-o-o and flag when the move was rejected as      *
 *           illegal.  richard Lloyd suggested a speed-up for the annotate     *
 *           command which I'm using temporarily.  Crafty now searches all     *
 *           legal moves in a position, and if the best move matches the game  *
 *           move, the second search of just the move played is not needed.  I *
 *           was searching just the game move first, which was a waste of time *
 *           in many positions.  I'll resume this later, because I want to see *
 *           these values:  (1) score for move actually played; (2) score for  *
 *           the rest of the moves only, not including the move actually       *
 *           played, to see how often a player finds a move that is the *only* *
 *           good move in a position.                                          *
 *                                                                             *
 *   11.5    More fractional ply extension tuning.  A few positions could blow *
 *           up the search and go well beyond 63 plies, the max that Crafty    *
 *           can handle.  Now, extensions are limited to no more than one ply  *
 *           of extensions for every ply of search.  Note that "in check" is   *
 *           extended on the checking move ply, not on the out of check ply,   *
 *           so that one-reply-to-check still extends further.  Minor changes  *
 *           to time.c to further help on long fast games.  Another important  *
 *           timing bug repaired.  If Crafty started an iteration, and failed  *
 *           high on the first move, it would not terminate the search until   *
 *           this move was resolved and a score returned.  This could waste a  *
 *           lot of time in already won positions.  Interesting bug in the     *
 *           capture search pruning fixed.  At times, a piece would be hung,   *
 *           but the qsearch would refuse to try the capture because it would  *
 *           not bring the score back to above alpha.  Unfortunately, taking   *
 *           the piece could let passed pawns race in undisturbed which would  *
 *           affect the score.  This pruning is turned off when there are not  *
 *           at least two pieces left on the board.  Another bug in the move   *
 *           generator produced pawn promotions twice, once when captures were *
 *           generated, then again when the rest of the moves are produced.    *
 *           this was also repaired.  Small book now will work.  The Bookup()  *
 *           code now assumes white *and* black won in the absence of a valid  *
 *           PGN Result tag, so that the small book will work correctly.       *
 *                                                                             *
 *   11.6    Modifications to time allocation in a further attempt to make     *
 *           Crafty speed up if time gets short, to avoid flagging.  It is now *
 *           *very* difficult to flag this thing.  :)  Minor evaluation tweaks *
 *           and a fix to Quiesce() to speed it up again after a couple of bad *
 *           fixes slowed things down.                                         *
 *                                                                             *
 *   11.7    Minor modification to Evaluate().  Rooks behind a passed pawn are *
 *           good, but two rooks behind the pawn don't help if the pawn is     *
 *           blockaded and can't move, unless the two rooks are not the same   *
 *           color as the pawn.                                                *
 *                                                                             *
 *   11.8    First stage of "book learning" implemented.  Crafty monitors the  *
 *           search evaluation for the first 10 moves out of book.  It then    *
 *           computes a "learn value" if it thinks this set of values shows    *
 *           that the book line played was very good or very bad.  This value  *
 *           is added to a "learn count" for each move in the set of book      *
 *           moves it played, with the last move getting the full learn value, *
 *           and moves closer to the start of the game getting a smaller       *
 *           percentage.  (See learn.c for more details).  These values are    *
 *           used by Book() to help in selecting/avoiding book lines.  Crafty  *
 *           produces a "book.lrn" file that synthesizes this information into *
 *           a portable format that will be used by other Crafty programs,     *
 *           once the necessary code is added later on.                        *
 *                                                                             *
 *   11.9    An age-old problem caused by null-move searching was eliminated   *
 *           in this version.  Often the null-move can cause a move to fail    *
 *           high when it should not, but then the move will fail low on the   *
 *           re-search when beta is relaxed.  This would, on occasion, result  *
 *           in Crafty playing a bad move for no reason.  Now, if a fail high  *
 *           is followed by a fail-low, the fail high condition is ignored.    *
 *           This can be wrong, but with null-move pruning, it can also be     *
 *           even "more wrong" to accept a fail high move after it fails low   *
 *           due to a null-move failure, than it would be right to accept the  *
 *           fail high/fail low that is caused by trans/ref table anomalies.   *
 *                                                                             *
 *   11.10   Crafty is now using the Kent, et. al, "razoring" algorithm, which *
 *           simply eliminates the last ply of full-width searching and goes   *
 *           directly to the capture search if the move before the last full-  *
 *           width ply is uninteresting, and the Material eval is 1.5 pawns    *
 *           below alpha.  It's a "modest futility" idea that doesn't give up  *
 *           on the uninteresting move, but only tries captures after the move *
 *           is played in the tree.  Net result is 20-30% average faster times *
 *           to reach the same depth.  Minor mod to book.lrn to include Black, *
 *           White and Date PGN tags just for reference.  Next learning mod is *
 *           another "book random n" option, n=3.  This will use the "learned" *
 *           score to order book moves, *if* any of them are > 0.  What this   *
 *           does is to encourage Crafty to follow opening lines that have     *
 *           been good, even if the learn count hasn't reached the current     *
 *           threshold of 1,000.  This makes learning "activate" faster.  This *
 *           has one hole in it, in that once Crafty learns that one move has  *
 *           produced a positive learn value, it will keep playing that move   *
 *           (since no others will yet have a positive value) until it finally *
 *           loses enough to take the learn value below zero.  This will be    *
 *           taken care of in the next version, hopefully.                     *
 *                                                                             *
 *   11.11   New "book random 4" mode that simply takes *all* learning scores  *
 *           for the set of legal book moves, translates them so that the      *
 *           worst value is +1 (by adding -Min(all_scores)+1 to every learn    *
 *           value) and then squaring the result.  This encourages Crafty to   *
 *           follow book lines that it has learned to be good, while still     *
 *           letting it try openings that it has not yet tried (learn value    *
 *           =0) and even lets it try (albeit rarely) moves that it has        *
 *           learned to be bad.  Minor evaluation tweaking for king placement  *
 *           in endgames to encourage penetration in the center rather than on *
 *           a wing where the king might get too far from the "action."        *
 *                                                                             *
 *   11.12   LearnFunction() now keeps positional score, rather than using a   *
 *           constant value for scores < PAWN_VALUE, to improve learning       *
 *           accuracy.  Book learn <filename> [clear] command implemented to   *
 *           import learning files from other Crafty programs.                 *
 *                                                                             *
 *   11.13   Endgame threshold lowered to the other side having a queen or     *
 *           less (9) rather than (13) points.  Queen+bishop can be very       *
 *           dangerous to the king for example, or two rooks and a bishop.     *
 *           Learning "curve" modified.  It was accidentally left in a sort    *
 *           of "geometric" shape, with the last move getting the full learn   *
 *           value, the next one back getting 1/2, the next 1/3, etc.  Now     *
 *           it is uniformly distributed from front to back.  If there are 20  *
 *           moves, the last gets the full value, the next gets 19/20, etc..   *
 *           Also the "percentage played" was hosed and is fixed.              *
 *                                                                             *
 *   11.14   Minor modification to book learn 4 code so that when you start    *
 *           off with *no* learned data, Book() won't exclude moves from the   *
 *           possible set of opening moves just because one was not played     *
 *           very often.  Due to the lack of "ordering" info in this case, it  *
 *           would often discover the second or third move in the list had not *
 *           been played very often and cull the rest of the list thinking it  *
 *           was ordered by the number of times it was played.  This code      *
 *           contains all of Frank's xboard patches so that analyze mode and   *
 *           so forth works cleanly.  A new book random option <5> modifies    *
 *           the probability of playing a move by letting the popularity of a  *
 *           move affect the learned-value sorting algorithm somewhat. Minor   *
 *           adjustment in pawn ram asymmetric term to simply count rams and   *
 *           not be too concerned about which half of the board they are on.   *
 *           adjustment to weak pawn code.  Also increased bonus for king      *
 *           tropism to attract pieces toward enemy king to improve attacking. *
 *           code that detects drawn K+RP+wrong bishop had a bug in that on    *
 *           occasion, the defending king might not be able to reach the       *
 *           queening square before the opposing king blocks it out.  This     *
 *           would let some positions look like draws when they were not. King *
 *           safety now uses square(7-distance(piece,king)) as one multiplier  *
 *           to really encourage pieces to get closer to the king.  In cases   *
 *           whre one king is exposed, all pieces are attracted to that king   *
 *           to attack or defend.   This is turned off during the opening.     *
 *           minor 50-move rule draw change to fix a bug, in that the game is  *
 *           not necessarily a draw after 50 moves by both sides, because one  *
 *           side might be mated by the 50th move by the other side.  This     *
 *           occurred in a game Crafty vs Ferret, and now works correctly.     *
 *                                                                             *
 *   11.15   Modified LearnBook() so that when Crafty terminates, or resigns,  *
 *           or sees a mate, it will force LearnBook() to execute the learning *
 *           analysis even if 10 moves have not been made sine leaving the     *
 *           book.  Crafty now trusts large positive evals less when learning  *
 *           about an opening, since such evals are often the result of the    *
 *           opponent's blunder, rather than a really  good opening line.      *
 *           second learning stage implemented.  Crafty maintains a permanent  *
 *           hash file that it uses to store positions where the search value  *
 *           (at the root of the tree) suddenly drop, and then it "seeds" the  *
 *           real transposition table with these values at the start of each   *
 *           of each search so that information is available earlier the next  *
 *           time this game is played.  Position.bin has the raw binary data   *
 *           this uses, while position.lrn has the "importable" data.  New     *
 *           import <filename> [clear] command imports all learning data now,  *
 *           eliminating the old book learn command.  LearnFunction() modified *
 *           to handle "trusted" values (negative scores, because we are sure  *
 *           that Crafty won't make an outright blunder very often) and        *
 *           "untrusted" values (positive values often caused by the opponent  *
 *           hanging a piece.  Trusted values are scaled up if the opponent is *
 *           weaker than Crafty since a weaker opponent forcing a negative     *
 *           eval means the position must really be bad, and are scaled down   *
 *           somewhat if the opponent is stronger than Crafty (from the rating *
 *           information from ICC or the operator using the rating command.)   *
 *           Untrusted values are scaled down harshly, unless the opponent is  *
 *           much stronger than Crafty, since it is unlikely such an opponent  *
 *           would really blunder, while weaker opponents drastically scale    *
 *           untrusted value (which is positive, remember) down.  minor depth  *
 *           problem fixed in learning code.  The depth used in LearnFunction  *
 *           was not the depth for the search that produced the "learn value"  *
 *           the LearnBook() chooses, it was the depth for the search last     *
 *           done.  Now, in addition to the 10 last search values, I store the *
 *           depth for each as well.  When a particular search value is used   *
 *           to "learn", the corresponding (correct) depth is also now used.   *
 *           These learn values are now limited to +6000/-6000 because in one  *
 *           book line, Crafty discovered it was getting mated in 2 moves at   *
 *           the end of the book line which was 30 moves deep.  If you try to  *
 *           distribute a "mate score" as the learned value, it will instantly *
 *           make every move for the last 26 moves look too bad to play.  This *
 *           is not desirable, rather the last few moves should be unplayable, *
 *           but other moves further back should be o.k.  Another bug that let *
 *           Crafty overlook the above mate also fixed.  The search value was  *
 *           not correct if Crafty got mated, which would avoid learning in    *
 *           that case.  This has been fixed, although it was obviously a rare *
 *           problem anyway.  Minor draw bug fixed, where Crafty would offer   *
 *           a draw when time was way low, caused by the resolution change a   *
 *           few months back, and also it would offer a draw after the         *
 *           opponent moved, even if he made a blunder.  It now only offers a  *
 *           draw after moving to make sure it's reasonable.  Crafty now won't *
 *           resign if there is a deep mate, such as a mate in 10+, because we *
 *           want to be sure that the opponent can demonstrate making progress *
 *           before we toss in the towel.  LearnBook() now learns on all games *
 *           played.  The old algorithm had a serious problem in that negative *
 *           scores were trusted fully, positive scores were treated with low  *
 *           confidence, and scores near zero were ignored totally.  The net   *
 *           result was that learning values became more and more negative as  *
 *           games were played.  Now equal positions are also factored in to   *
 *           the learning equation to help pull some of these negative values  *
 *           back up.  Book() now excludes moves that have not been played     *
 *           many times (if there is at least one move that has) for book      *
 *           random = 2, 3 and 4.  This stops some of the silly moves.         *
 *           position learning is turned off after 15 moves have passed since  *
 *           leaving book, to avoid learning things that won't be useful at a  *
 *           later time.  Hashing changed slightly to include "permanent"      *
 *           entries so that the learned stuff can be copied into the hash     *
 *           table with some confidence that it will stay there long enough to *
 *           be used.                                                          *
 *                                                                             *
 *   11.16   King tropism toned down a little to not be quite so intent on     *
 *           closeness to the kings, so that other positional ideas don't get  *
 *           "lost" in the eval.  Back to normal piece values (1,3,3,5,9) for  *
 *           a while.  Optimizations in Quiesce() speeded things up about 2%.  *
 *           Pawns pushed toward the king are not so valuable any more so that *
 *           Crafty won't prefer to hold on to them rather than trading to     *
 *           open a file(s) on the enemy king.  BookLearn() call was moved in  *
 *           Resign() so that it first learns, then resigns, so that it won't  *
 *           get zapped by a SIGTERM right in the middle of learning when      *
 *           xboard realizes the game is over.  Edit/setboard logic modified   *
 *           so that it is now possible to back up, and move forward in a game *
 *           that was set up via these commands.                               *
 *                                                                             *
 *   11.17   EvaluatePawns() modified to eliminate "loose pawn" penalty which  *
 *           was not particularly effective and produced pawn scores that were *
 *           sometimes misleading.  Several optimizations dealing with cache   *
 *           efficiency, primarily changing int's to signed char's so that     *
 *           multiple values fit into a cache line together, to eliminate some *
 *           cache thrashing.  PopCnt() no longer used to recognize that we    *
 *           have reached an endgame database, there's now a counter for the   *
 *           total number of pieces on the board, as it's much faster to inc   *
 *           and dec that value rather than count 1 bits.  Tweaks to MakeMove  *
 *           and UnmakeMove to make things a couple of percent faster, but a   *
 *           whole lot cleaner.  Ditto for SEE and Quiesce.  More speed, and   *
 *           cleaner code.  Outside passed pawn scored scaled down except when *
 *           the opponent has no pieces at all.  "Lazy eval" cleaned up.  We   *
 *           now have two early exits, one before king safety and one after    *
 *           king safety.  There are two saved values so we have an idea of    *
 *           how large the positional scores have gotten to make this work.    *
 *           Bug in passed pawn code was evaluating black passed pawns as less *
 *           valuable than white.  Fixed and passed pawn scores increased      *
 *           slightly.  Isolated pawn scoring modified so the penalty is pro-  *
 *           portional to the number of isolani each side has, rather than the *
 *           old approach of penalizing the "excess" isolani one side has over *
 *           the other side.  Seems to be more accurate, but we'll see.  Fixed *
 *           a rather gross bug in ValidateMove() related to the way castling  *
 *           status not only indicates whether castling is legal or not, but   *
 *           if it's not, whether that side castled or move the king/rooks.    *
 *           this let ValidateMove() fail to correctly detect that a castling  *
 *           move from the hash table might be invalid, which could wreck the  *
 *           search easily.  This was an oversight from the new status code.   *
 *           Serious book bug fixed.  Bookup() was not counting wins and       *
 *           losses correctly, a bug introduced to make small.pgn work. Minor  *
 *           bug in the "trapped bishop" (a2/h2/a7/h7) code fixed.  Minor bug  *
 *           in SEE() also fixed (early exit that was not safe in rare cases.) *
 *                                                                             *
 *   11.18   EvaluatePawns() modified to recognize that if there are two white *
 *           pawns "rammed" by black pawns at (say) c4/c5 and e4/e5, then any  *
 *           pawns on the d-file are also effectively rammed as well since     *
 *           there is no hope for advancing it.  Auto232 automatic play code   *
 *           seems to be working, finally.  The problem was Crafty delayed     *
 *           echoing the move back to auto232, if the predicted move was the   *
 *           move played by the opponent.  Auto232 gave Crafty 3 seconds and   *
 *           then said "too late, you must be hung."  Outpost knight scoring   *
 *           modified to produce scores between 0 and .2 pawns.  A knight was  *
 *           getting too valuable, which caused some confusion in the scoring. *
 *                                                                             *
 *   11.19   Slight reduction in the value of passed pawns, as they were       *
 *           getting pretty large.  Cleaned up annotate.c to get rid of code   *
 *           that didn't work out.  Annotate now gives the PV for the move     *
 *           actually played as well as the move Crafty suggests is best.      *
 *           Crafty now has a reasonable "trade" bonus that kicks in when it   *
 *           has 20 points of material (or less) and is ahead or behind at     *
 *           least 2 pawns.  This trade bonus ranges from 0 to 1000 (one pawn) *
 *           and encourages the side that is winning to trade, while the side  *
 *           that is losing is encouraged to avoid trades.  More minor tweaks  *
 *           for auto232 including trying a delay of 100ms before sending      *
 *           a move.  New annotate command gives the option to get more than   *
 *           one suggested best move displayed, as well as fixes a few bugs    *
 *           in the older code.  Fix to bishop + wrong rook pawn code to also  *
 *           recognize the RP + no pieces is just as bad if the king can reach *
 *           the queening square first.                                        *
 *                                                                             *
 *   11.20   Cleanup to annotate command.  It now won't predict that one side  *
 *           will follow a book line that only resulted in losses.  Also a     *
 *           couple of glitches in annotate where it was possible for a move   *
 *           to take an exhorbitant amount of time if the best move was a      *
 *           book move, but there were no other possible book moves.  The      *
 *           trade bonus now includes trade pawns if behind, but not if ahead  *
 *           as well as now considering being ahead or behind only one pawn    *
 *           rather than the two pawns used previously in 11.19.               *
 *                                                                             *
 *   11.21   Additional bug fix in annotate command that would fail if there   *
 *           was only one legal move to search.  Passed pawn values now have   *
 *           an added evaluation component based on material on the board, so  *
 *           that they become more valuable as material is traded.             *
 *                                                                             *
 *   11.22   Test command modified.  Test <filename> [N] (where N is optional  *
 *           and defaults to 99) will terminate a test position after N con-   *
 *           secutive iterations have had the correct solution.  Bug in        *
 *           Quiesce() fixed, which would incorrectly prune (or fail to prune) *
 *           some captures, due to using "Material" which is computed with     *
 *           respect to white-to-move.  This was fixed many versions ago, but  *
 *           the fix was somehow lost.  Fix to EvaluateDraws that mistakenly   *
 *           declared some endings drawn when there were rookpawns on both     *
 *           sides of the board, and the king could get in front of one. Minor *
 *           fix to Repeat() that was checking one too many entries.  No       *
 *           harmful effect other than one extra iteration in the loop that    *
 *           would make "purify/purity" fail as well as slow things down 1% or *
 *           so.                                                               *
 *                                                                             *
 *   11.23   logpath=, bookpath= and tbpath= command line options added to     *
 *           direct logs, books and tb files to the indicated path.  These     *
 *           only work as command line options, and can't be used in normal    *
 *           places since the files are already opened and in use.  A bug in   *
 *           Evaluate() would call EvaluatePawns() when there were no pawns,   *
 *           breaking things on many systems.                                  *
 *                                                                             *
 *   12.0    Rewrite of Input/Output routines.  Crafty no longer relies on the *
 *           C library buffered I/O routine scanf() for input.  This made it   *
 *           basically impossible to determine when to read data from the key- *
 *           board, which made xboard/winboard difficult to interface with.    *
 *           Now Crafty does its own I/O using read(), which is actually much  *
 *           cleaner and easier.  Minor bug where a fail high in very short    *
 *           time controls might not get played...                             *
 *                                                                             *
 *   12.1    Clean-up of Main().  The code had gotten so obtuse with the       *
 *           pondering call, plus handling Option() plus move input, that it   *
 *           was nearly impossible to follow.  It is now *much* cleaner and    *
 *           easier to understand/follow.                                      *
 *                                                                             *
 *   12.2    Continued cleanup of I/O, particularly the way main() is          *
 *           structured, to make it more understandable.  Rewritten time.c     *
 *           to make it more readable and understandable, not to mention       *
 *           easier to modify.  Fixed a timing problem where Crafty could be   *
 *           pondering, and the predicted move is made followed immediately by *
 *           "force", caused when the opponent makes a move and loses on time, *
 *           or makes a move and resigns.  This would leave the engine state   *
 *           somewhat confused, and would result in the "new" command not      *
 *           reinitializing things at all, which would hang Crafty on xboard   *
 *           or winboard.                                                      *
 *                                                                             *
 *   12.3    Modified piece values somewhat to increase their worth relative   *
 *           to a pawn, to try to stop the tendency to sac a piece for 3 pawns *
 *           and get into trouble for doing so.  Minor fixes in NewGame() that *
 *           caused odd problems, such as learning positions after 1. e4.  The *
 *           position.lrn/.bin files were growing faster than they should.     *
 *           Other minor tweaks to fix a few broken commands in Option().      *
 *           Slight reduction in trade bonus to match slightly less valuable   *
 *           pawns.                                                            *
 *                                                                             *
 *   12.4    Added ABSearch() macro, which makes Search() much easier to read  *
 *           by doing the test to call Search() or Quiesce() in the macro      *
 *           where it is hidden from sight.  Bugs in the way the log files     *
 *           were closed and then used caused crashed with log=off.            *
 *                                                                             *
 *   12.5    Development bonus for central pawns added to combat the h4/a3     *
 *           sort of openings that would get Crafty into trouble.  It now will *
 *           try to seize the center if the opponent dallies around.           *
 *                                                                             *
 *   12.6    Bug in EvaluateDraws() that would erroneously decide that a KNP   *
 *           vs K was drawn if the pawn was a rook pawn and the king could get *
 *           in front of it, which was wrong.  Another minor bug would use     *
 *           EvaluateMate() when only a simple exchange ahead, which would     *
 *           result in sometimes giving up a pawn to reach such a position.    *
 *           Minor bug in SetBoard() would incorrectly reset many important    *
 *           game state variables if the initial position was set to anything  *
 *           other than the normal starting position, such as wild 7.  This    *
 *           would make learning add odd PV's to the .lrn file.  Development   *
 *           bonus modified to penalize moving the queen before minor pieces,  *
 *           and not moving minor pieces at all.  It is now possible to build  *
 *           a "wild 7" book, by first typing "wild 7", and then typing the    *
 *           normal book create command.  Crafty will remember to reset to the *
 *           "wild 7" position at the start of each book line.  Note that it   *
 *           is not possible to have both wild 7 book lines *and* regular book *
 *           lines in the same book.                                           *
 *                                                                             *
 *   12.7    Failsoft added, so that scores can now be returned outside the    *
 *           alpha/beta window.  Minor null-move threat detection added where  *
 *           a mate in 1 score, returned by a null-move search, causes a one   *
 *           ply search extension, since a mate in one is a serious threat.    *
 *           razoring is now disabled if there is *any* sort of extension in   *
 *           the search preceeding the point where razoring would be applied,  *
 *           to avoid razoring taking away one ply from a search that was ex-  *
 *           tended (for good reasons) earlier.  Fail-soft discarded, due to   *
 *           no advantages at all, and a slight slowdown in speed.  Rewrite of *
 *           pawn hashing, plus a rewrite of the weak pawn scoring code to     *
 *           make it significantly more accurate, while going a little slower  *
 *           (but since hashing hits 99% of the time, the slower speed is not  *
 *           noticable at all.)  Evaluation tweaking as well.                  *
 *                                                                             *
 *   12.8    Continued work on weak pawn analysis, as well as a few minor      *
 *           changes to clean the code up.                                     *
 *                                                                             *
 *   13.0    Preparation for the Paris WMCCC version starts here.  First new   *
 *           thing is the blocked pawn evaluation code.  This recognizes when  *
 *           a pawn is immobolized and when a pawn has lever potential, but    *
 *           is disabled if playing a computer opponent.  Passed pawn scoring  *
 *           modified to eliminate duplicate bonuses that were added in        *
 *           EvaluatePawns as well as EvaluatePassedPawns.  Trade bonus code   *
 *           rewritten to reflect trades made based on the material when the   *
 *           search begins.  This means that some things have to be cleared in *
 *           the hash table after a capture is really made on the board, but   *
 *           prevents the eval from looking so odd near the end of a game.     *
 *           minor bug with book random 0 fixed.  If there was only one book   *
 *           move, the search could blow up.                                   *
 *                                                                             *
 *   13.1    All positional scores reduced by 1/4, in an attempt to balance    *
 *           things a little better.  Also more modifications to the weak and  *
 *           blocked pawn code.  Added evaluation code to help with KRP vs KR, *
 *           so that the pawn won't be advanced too far before the king comes  *
 *           to its aid.  Ditto for defending, it knows that once the king is  *
 *           in front of the pawn, it is a draw.                               *
 *                                                                             *
 *   13.2    Blocked pawn scoring changed slightly to not check too far to see *
 *           if a pawn can advance.  Also pawns on center squares are weighted *
 *           more heavily to encourage keeping them there, or trying to get    *
 *           rid of them if the opponent has some there.  Discovered that      *
 *           somehow, the two lines of code that add in bonuses for passed     *
 *           pawns were deleted as I cleaned up and moved code around.  These  *
 *           were reinserted (missing from 13.0 on).                           *
 *                                                                             *
 *   13.3    Modified tablebase code to support 5 piece endings.  There is now *
 *           a configuration option (see Makefile) to specify 3, 4 or 5 piece  *
 *           endgame databases.  More evaluation tuning.                       *
 *                                                                             *
 *   13.4    Modified null-move search.  If there is more than a rook left for *
 *           the side on move, null is always tried, as before.  If there is   *
 *           a rook or less left, the null move is only tried within 5 plies   *
 *           of the leaf positions, so that as the search progresses deeper,   *
 *           null-move errors are at least moved away from the root.  Many     *
 *           evaluation changes, particularly to king safety and evaluating    *
 *           castling to one side while the other side is safer.  Also it now  *
 *           handles pre-castled positions better.                             *
 *                                                                             *
 *   13.5    "From-to" display patch from Jason added.  This shows the from    *
 *           and to squares on a small diagram, oriented to whether Crafty is  *
 *           playing black or white.  The intent is to minimize operator       *
 *           errors when playing black and the board coordinates are reversed. *
 *           More eval changes.                                                *
 *                                                                             *
 *   13.6    Weak pawns on open files now add value to the opponent's rooks    *
 *           since they are the pieces that will primarily use an open file to *
 *           attack a weak pawn.                                               *
 *                                                                             *
 *   13.7    Minor eval tweaks, plus fixes for the CR/LF file reading problems *
 *           in windows NT.                                                    *
 *                                                                             *
 *   13.8    Adjustments to book.c, primarily preventing Crafty from playing   *
 *           lines that had very few games in the file, because those are      *
 *           often quite weak players.  Minor fix to InputMoves() so that a    *
 *           move like bxc3 can *never* be interpreted as a bishop move.  A    *
 *           bishop move must use an uppercase B, as in Bxc3.  Bug in the      *
 *           king safety for white only was not checking for open opponent     *
 *           files on the king correctly.                                      *
 *                                                                             *
 *   13.9    Minor adjustment to time allocation to allow "operator time" to   *
 *           affect time per move.  This is set by "operator <n>" where <n> is *
 *           time in seconds per move that should be "reserved" to allow the   *
 *           operator some typing/bookkeeping time.  New command "book         *
 *           trigger <n>" added so that in tournament mode, when choosing a    *
 *           book line, Crafty will revert to book random 0 if the least       *
 *           popular move was played fewer times than <n>.  This is an attempt *
 *           to avoid trusting narrow book lines too much while still allowing *
 *           adequate randomness.  If the least frequently played move in the  *
 *           set of book moves was played fewer times than this, then a search *
 *           over all the book moves is done.  If the best one doesn't look    *
 *           so hot, Crafty drops out of book and searches *all* legal moves   *
 *           instead.                                                          *
 *                                                                             *
 *   13.10   Minor adjustments.  This is the gold Paris version that is going  *
 *           with Jason.  Any changes made during the event will be included   *
 *           in the next version.                                              *
 *                                                                             *
 *   14.0    Major eval modification to return to centipawn evaluation, rather *
 *           then millipawns.  This reduces the resolution, but makes it a lot *
 *           easier to understand evaluation changes.  Significant eval mods   *
 *           regarding king safety and large positional bonuses, where the ad- *
 *           vantage is not pretty solid.  Note that old book learning will    *
 *           not work now, since the evals are wrong.  Old position learning   *
 *           must be deleted completely.  See the read.me file for details on  *
 *           what must be done about book learning results.  New egtb=n option *
 *           to replace the older -DTABLEBASES=n Makefile option, so that the  *
 *           tablebases can be enabled or disabled without recompiling.        *
 *                                                                             *
 *   14.1    Glitch in EvaluateDevelopment() was producing some grossly large  *
 *           positional scores.  Also there were problems with where the       *
 *           PreEvaluate() procedure were called, so that it could be called   *
 *           *after* doing RootMoveslist(), but before starting a search.  This*
 *           caused minor problems with hashing scores.  One case was that it  *
 *           was possible for a "test suite" to produce slightly different     *
 *           scores than the same position run in normal mode.  This has been  *
 *           corrected.  St=n command now supports fractional times to .01     *
 *           second resolution.                                                *
 *                                                                             *
 *   14.2    MATE reduced to 32768, which makes all scores now fit into 16     *
 *           bits.  Added code to EvaluatePawns() to detect the Stonewall      *
 *           pawn formation and not like it as black.  Also it detects a       *
 *           reversed Stonewall formation (for black) and doesn't like it as   *
 *           white.  EvaluateOutsidePassedPawns() removed.  Functionality is   *
 *           incorporated in EvaluatePawns() and is hashed, which speeds the   *
 *           evaluation up a bit.  King safety is now fully symmetric and is   *
 *           folded into individual piece scoring to encourage pieces to       *
 *           attack an unsafe king.                                            *
 *                                                                             *
 *   14.3    Minor adjustments to the king safety code for detecting attacks   *
 *           initiated by pushing kingside pawns.  Flip/flop commands added to *
 *           mirror the board either horizontally or vertically to check for   *
 *           symmetry bugs in the evaluation.  Other eval tuning changes.      *
 *                                                                             *
 *   14.4    Queen value increased to stop trading queen for two rooks.  Book  *
 *           learning slightly modified to react quicker.  Also scores are now *
 *           stored in the book file as floats to get rid of an annoying trun- *
 *           cation problem that was dragging scores toward zero.  The book    *
 *           file now has a "version" so that old book versions won't cause    *
 *           problems due to incorrect formats.  Null-move mated threat ex-    *
 *           tension was modified.  If null-move search fails high, I fail     *
 *           high as always, if it fails low, and it says I get mated in N     *
 *           moves, I extend all moves at this ply, since something is going   *
 *           on.  I also carry this threat extension into the hash table since *
 *           a hash entry can say "don't do null move, it will fail low."  I   *
 *           now have a flag that says not only will null-move fail low, it    *
 *           fails to "mated in N" so this ply needs extending even without a  *
 *           null-move search to tell it so.  Book learning greatly modified   *
 *           in the way it "distributes" the learned values, in an effort to   *
 *           make learning happen faster.  I now construct a sort of "tree"    *
 *           so I know how many book alternatives Crafty had at each move it   *
 *           at each book move it played.  I then assign the whole learn value *
 *           to all moves below the last book move where there was a choice,   *
 *           and also assign the whole learn value to the move where there     *
 *           was a choice.  I then divide the learn value by the number of     *
 *           choices and assign this to each book move (working backward once  *
 *           again) until the next point where there were choices.  This makes *
 *           sure that if there is a choice, and it is bad, it won't be played *
 *           again, even if this choice was at move 2, and the remainder of    *
 *           the book line was completely forced.  All in an effort to learn   *
 *           more quickly.                                                     *
 *                                                                             *
 *   14.5    annotate bug fixed where if there was only one legal move, the    *
 *           annotation would stop with no warning.  Bookup() now produces a   *
 *           more useful error message, giving the exact line number in the    *
 *           input file where the error occurred, to make fixing them easier.  *
 *           If you are playing without a book.bin, 14.4 would crash in the    *
 *           book learning code.  This is now caught and avoided.  Bookup()    *
 *           now knows how to skip analysis in PGN files, so you can use such  *
 *           files to create your opening book, without having problems.  It   *
 *           understands that nesting () {} characters "hides" the stuff in-   *
 *           side them, as well as accepting non-standard PGN comments that    *
 *           are inside [].  Annotate() now will annotate a PGN file with      *
 *           multiple games, although it will use the same options for all of  *
 *           the games.  PGN headers are preserved in the .can file.  Annotate *
 *           now will recognize the first move in a comment (move) or {move}   *
 *           and will search that move and give analysis for it in addition to *
 *           the normal output.                                                *
 *                                                                             *
 *   14.6    Minor change to book random 4 (use learned value.)  if all the    *
 *           learned values are 0, then use the book random 3 option instead.  *
 *           Bug in 50-move counter fixed.  Learn() could cause this to be set *
 *           to a value that didn't really reflect the 50-move status, and     *
 *           cause games to be drawn when they should not be.  Modified the    *
 *           "Mercilous" attack code to recognize a new variation he worked    *
 *           out that sacrifices a N, R and B for a mating attack.  No more.   *
 *                                                                             *
 *   14.7    "Verbose" command removed and replaced by a new "display" command *
 *           that sets display options.  Use "help display" for more info on   *
 *           how this works.  The "mercilous" attack scoring is only turned on *
 *           when playing "mercilous".  But there is a new "special" list that *
 *           you can add players too if you want, and this special scoring is  *
 *           turned on for them as well.                                       *
 *                                                                             *
 *   14.8    New scoring term to penalize unbalanced trades.  IE if Crafty has *
 *           to lose a pawn, it would often trade a knight for two pawns in-   *
 *           stead, which is actually worse.  This new term prevents this sort *
 *           of trades.                                                        *
 *                                                                             *
 *   14.9    "Mercilous" attack code modified to handle a new wrinkle he (and  *
 *           one other player) found.                                          *
 *                                                                             *
 *   14.10   New "bench" command runs a test and gives a benchmark comparison  *
 *           for Crafty and compares this to a P6/200 base machine.  Minor bug *
 *           disabled the "dynamic draw score" and fixed it at zero, even if   *
 *           the opponent was much weaker (rating) or behind on time.  Also    *
 *           draw_score was not reset to 0 at start of each new game, possibly *
 *           leaving it at +.20 after playing a higher-rated opponent.         *
 *                                                                             *
 *   14.11   Release to make mercilous attack detection code the default, to   *
 *           prevent the rash of mercilous attacks on the chess servers.       *
 *                                                                             *
 *   14.12   Modified tuning of evaluation.  Scores were reduced in the past,  *
 *           to discourage the piece for two pawns sort of trades, but since   *
 *           this was basically solved in 14.8, scores are going "back up".    *
 *           Particularly passed pawn scores.  Crafty now accepts draw offers  *
 *           if the last search result was <= the current result returned by   *
 *           DrawScore().  It also honors draw requests via xboard when        *
 *           against a human opponent as well, and will flag the game as over. *
 *           Minor modification to annotate.c to display move numbers in the   *
 *           PV's to match the PV output format used everywhere else in        *
 *           Crafty.  A new type of learning, based on results, has been added *
 *           and is optional (learn=7 now enables every type of learning.)     *
 *           this type of learning uses the win/lose game result to flag an    *
 *           opening that leads to a lost game as "never" play again.  The     *
 *           book move selection logic has been modified.  There are four com- *
 *           ponents used in choosing book moves:  frequency of play; win/lose *
 *           ratio; static evaluation; and learned score.  There are four      *
 *           weights that can be modified with the bookw command, that control *
 *           how these 4 values are used to choose book moves.  Each weight is *
 *           a floating point value between 0 and 1, and controls how much the *
 *           corresponding term factors in to move selection.                  *
 *                                                                             *
 *   14.13   Fixed a book parsing bug that now requires a [Site "xxx"] tag in  *
 *           any book file between lines for the "minplay" option of book      *
 *           create to work properly.                                          *
 *                                                                             *
 *   15.0    This is the first version to support a parallel search using      *
 *           multiple processors on a shared-memory machinel.  This version    *
 *           uses the "PVS" algorithm (Principal Variation Search) that is an  *
 *           early form of "Young Brothers Wait".  This is not the final       *
 *           search algorithm that will be used, but it is relatively easy to  *
 *           implement, so that the massive data structure changes can be de-  *
 *           bugged before getting too fancy.  The major performance problem   *
 *           with this approach is that all processors work together at a node *
 *           and when one finishes, it has to wait until all others finish     *
 *           before it can start doing anything more.  This adds up to a       *
 *           significant amount of time and really prevents good speedups on   *
 *           multiprocessor machines.  This restriction will be eliminanted in *
 *           future versions, but it makes debugging much simpler for the      *
 *           first version.  After much agonizing, I finally chose to write my *
 *           own "spinlock" macros to avoid using the pthread_mutex_lock stuff *
 *           that is terribly inefficient due to its trying to be cute and     *
 *           yield the processor rather than spinning, when the lock is al-    *
 *           ready set.  i'd rather spin than context-switch.                  *
 *                                                                             *
 *   15.1    This version actually unleashes the full design of the parallel   *
 *           search, which lets threads split away from the "pack" when        *
 *           they become idle, and they may then jump in and help another      *
 *           busy thread.  This eliminates the significant delays that         *
 *           occur near the end of a search at a given ply.  Now as those pro- *
 *           cessors drop out of the search at that ply, they are reused at    *
 *           other locations in the tree without any significant delays.       *
 *                                                                             *
 *   15.2    WinNT support added.  Also fixed a small bug in Interrupt() that  *
 *           could let it exit with "busy" set so that it would ignore all     *
 *           input from that point forward, hanging the game up.  Added a new  *
 *           "draw accept" and "draw decline" option to enable/disable Crafty  *
 *           accepting draw offers if it is even or behind.  Turned on by      *
 *           an IM/GM opponent automatically.  Thread pools now being used to  *
 *           avoid the overhead of creating/destroying threads at a high rate  *
 *           rate of speed.  It is now quite easy to keep N processors busy.   *
 *                                                                             *
 *   15.3    CPU time accounting modified to correctly measure the actual time *
 *           spent in a parallel search, as well as to modify the way Crafty   *
 *           handles time management in an SMP environment.  A couple of bugs  *
 *           fixed in book.c, affecting which moves were played.  Also veri-   *
 *           fied that this version will play any ! move in books.bin, even if *
 *           it was not played in the games used to build the main book.bin    *
 *           file.                                                             *
 *                                                                             *
 *   15.4    This version will terminate threads once the root position is in  *
 *           a database, to avoid burning cpu cycles that are not useful.  A   *
 *           flag "done" is part of each thread block now.  When a thread goes *
 *           to select another move to search, and there are no more left, it  *
 *           sets "done" in the parent task thread block so that no other pro- *
 *           cessors will attempt to "join the party" at that block since no   *
 *           work remains to be done.  Book selection logic modified so that   *
 *           frequency data is "squared" to improve probabilities.  Also, the  *
 *           frequency data is used to cull moves, in that if a move was not   *
 *           played 1/10th of the number of times that the "most popular" move *
 *           was played, then that move is eliminated from consideration.      *
 *                                                                             *
 *   15.5    Changes to "volatile" variables to enhance compiler optimization  *
 *           in places where it is safe.  Added a function ThreadStop() that   *
 *           works better at stopping threads when a fail high condition       *
 *           occurs at any nodes.  It always stopped all sibling threads at    *
 *           the node in question, but failed to stop threads that might be    *
 *           working somewhere below the fail-high node.  ThreadStop() will    *
 *           recursively call itself to stop all of those threads. Significant *
 *           increase in king centralization (endgame) scoring to encourage    *
 *           the king to come out and fight rather than stay back and get      *
 *           squeezed to death.  Minor change to queen/king tropism to only    *
 *           conside the file distance, not ranks also.  Bug in interrupt.c    *
 *           fixed.  This bug would, on very rare occasion, let Crafty read in *
 *           a move, but another thread could read on top of this and lose the *
 *           move.  Xboard would then watch the game end with a <flag>.        *
 *                                                                             *
 *   15.6    Ugly repetition draw bug (SMP only) fixed.  I carefully copied    *
 *           the repetition list from parent to child, but also copied the     *
 *           repetition list pointer...  which remained pointing at the parent *
 *           repetition list.  Which failed, of course.                        *
 *                                                                             *
 *   15.7    Problem in passing PV's back up the search fixed.  The old bug of *
 *           a fail high/fail low was not completely handled, so that if the   *
 *           *last* move on a search failed high, then low, the PV could be    *
 *           broken or wrong, causing Crafty to make the wrong move, or else   *
 *           break something when the bogus PV was used.  Piece/square tables  *
 *           now only have the _w version initialized in data.c, to eliminate  *
 *           the second copy which often caused errors.  Initialize() now will *
 *           copy the _w tables to the _b tables (reflected of course.)        *
 *                                                                             *
 *   15.8    trade bonus modified to not kick in until one side is two pawns   *
 *           ahead or behind, so that trading toward a draw is not so common.  *
 *           Fixed a whisper bug that would cause Crafty to whisper nonsense   *
 *           if it left book, then got back in book.  It also now whispers the *
 *           book move it played, rather than the move it would play if the    *
 *           opponent played the expected book move, which was confusing.      *
 *                                                                             *
 *   15.9    Bug in positions with one legal move would abort the search after *
 *           a 4 ply search, as it should, but it was possible that the result *
 *           from the aborted search could be "kept" which would often make    *
 *           Crafty just "sit and wait" and flag on a chess server.            *
 *                                                                             *
 *   15.10   Fixed "draw" command to reject draw offers if opponent has < ten  *
 *           seconds left and no increment is being used.  Fixed glitch in     *
 *           LearnResult() that would crash Crafty if no book was being used,  *
 *           and it decides to resign.  Modified trade bonus code to eliminate *
 *           a hashing inconsistency.  Minor glitch in "show thinking" would   *
 *           show bad value if score was mate.  Added Tim Mann's new xboard/   *
 *           winboard "result" command and modified the output from Crafty to  *
 *           tell xboard when a game is over, using the new result format that *
 *           Tim now expects.  Note that this is xboard 3.6.9, and earlier     *
 *           versions will *not* work correctly (ok on servers, but not when   *
 *           you play yourself) as the game won't end correctly due to the     *
 *           change in game-end message format between the engine and xboard.  *
 *                                                                             *
 *   15.11   Modified SMP code to not start a parallel search at a node until  *
 *           "N" (N=2 at present) moves have been search.  N was 1, and when   *
 *           move ordering breaks down the size of the tree gets larger.  This *
 *           controls that much better.  Fixed an ugly learning bug.  If the   *
 *           last move actually in the game history was legal for the other    *
 *           side, after playing it for the correct side, it could be played   *
 *           a second time, which would break things after learning was done.  *
 *           An example was Rxd4 for white, where black can respond with Rxd4. *
 *           Changes for the new 3.6.10 xboard/winboard are also included as   *
 *           well as a fix to get book moves displayed in analysis window as   *
 *           it used to be done.                                               *
 *                                                                             *
 *   15.12   "The" SMP repetition bug was finally found and fixed.  CopyToSMP  *
 *           was setting the thread-specific rephead_* variable *wrong* which  *
 *           broke so many things it was not funny.  Evaluation tuning in this *
 *           version as well to try to "center" values in a range of -X to +X  *
 *           rather than 0 to 2X.  Trade bonus had a bug in the pawn part that *
 *           not only encouraged trading pawns when it should be doing the     *
 *           opposite, but the way it was written actually made it look bad to *
 *           win a pawn.  More minor xboard/winboard compatibility bugs fixed  *
 *           so that games end when they should.  DrawScore() had a quirk that *
 *           caused some problems, in that it didn't know what to do with non- *
 *           zero draw scores, and could return a value with the wrong sign at *
 *           times.  It is now passed a flag, "Crafty_is_white" to fix this.   *
 *           Modification so that Crafty can handle the "FEN" PGN tag and set  *
 *           the board to the correct position when it is found.  Xboard       *
 *           options "hard" and "easy" now enable and disable pondering.       *
 *                                                                             *
 *   15.13   Modification to "bad trade" code to avoid any sort of unbalanced  *
 *           trades, like knight/bishop for 2-3 pawns, or two pieces for a     *
 *           rook and pawn.  More new xboard/winboard fixes for Illegal move   *
 *           messages and other engine interface changes made recently.  Minor *
 *           change to null move search, to always search with the alpha/beta  *
 *           window of (beta-1,beta) rather than (alpha,beta), which is very   *
 *           slightly more efficient.                                          *
 *                                                                             *
 *   15.14   Rewrite of ReadPGN() to correctly handle nesting of various sorts *
 *           of comments.  This will now correctly parse wall.pgn, except for  *
 *           promotion moves with no promotion piece specified.  The book      *
 *           create code also now correctly reports when you run out of disk   *
 *           space and this should work under any system to let you know when  *
 *           you run out of space.                                             *
 *                                                                             *
 *   15.15   Major modifications to Book() and Bookup().  Bookup() now needs   *
 *           1/2 the temp space to build a book that it used to need (even     *
 *           less under windows).  Also, a book position is now 16 bytes in-   *
 *           stead of 20 (or 24 under windows) further reducing the space      *
 *           requirements.  The "win/lose/draw" counts are no longer absolute, *
 *           rather they are relative so they can be stored in one byte. A new *
 *           method for setting "!" moves in books.bin is included in this     *
 *           version.  For any move in the input file used to make books.bin,  *
 *           you can add a {play nn%} string, which says to play this move nn% *
 *           of the time, regardless of how frequently it was played in the    *
 *           big book file.  For example, e4 {play 50%} says to play e4 50% of *
 *           the time.  Note two things here:  (1) If the percentages for all  *
 *           of white's first moves add up to a number > 100, then the         *
 *           percentage played is taken as is, but all will be treated as if   *
 *           they sum to 100 (ie if there are three first moves, each with a   *
 *           percentage of 50%, they will behave as though they are all 33%    *
 *           moves).  (2) For any moves not marked with a % (assuming at least *
 *           one move *is* marked with a percent) then such moves will use the *
 *           remaining percentage left over applied to them equally. Note that *
 *           using the % *and* the ! flags together slightly changes things,   *
 *           because normally only the set of ! moves will be considered, and  *
 *           within that set, any with % specified will have that percent used *
 *           as expected.  But if you have some moves with !, then a percent   *
 *           on any of the *other* moves won't do a thing, because only the !  *
 *           moves will be included in the set to choose from.                 *
 *                                                                             *
 *   15.16   Bug in the king tropism code, particularly for white pieces that  *
 *           want to be close to the black king, fixed in this version.  New   *
 *           History() function that handles all history/killer cases, rather  *
 *           than the old 2-function approach.  Ugly Repeat() bug fixed in     *
 *           CopyToChild().  This was not copying the complete replist due to  *
 *           a ply>>2 rather than ply>>1 counter.                              *
 *                                                                             *
 *   15.17   Adjustments to "aggressiveness" to slightly tone it down.  Minor  *
 *           fix to avoid the odd case of whispering one move and playing an-  *
 *           other, caused by a fail-high/fail-low overwriting the pv[1] stuff *
 *           and then Iterate() printing that rather than pv[0] which is the   *
 *           correct one.  New LegalMove() function that strengthens the test  *
 *           for legality at the root, so that it is impossible to ponder a    *
 *           move that looks legal, but isn't.  Modifications to king safety   *
 *           to better handle half-open files around the king as well as open  *
 *           files.  EGTB "swindler" added.  If the position is drawn at the   *
 *           root of the tree, then all losing moves are excluded from the     *
 *           move list and the remainder are searched normally with the EGTB   *
 *           databases disabled, in an effort to give the opponent a chance to *
 *           go wrong and lose.  Fixed "mode tournament" and "book random 0"   *
 *           so that they will work correctly with xboard/winboard, and can    *
 *           even be used to play bullet games on a server if desired. Minor   *
 *           fix to attempt to work around a non-standard I/O problem on the   *
 *           Macintosh platform dealing with '\r' as a record terminator       *
 *           rather than the industry/POSIX-standard \n terminator character.  *
 *                                                                             *
 *   15.18   Fix to the "material balance" evaluation term so that it will not *
 *           like two pieces for a rook (plus pawn) nor will it like trading a *
 *           piece for multiple pawns.  A rather gross bug in the repetition   *
 *           code (dealing with 50 move rule) could overwrite random places in *
 *           memory when the 50 move rule approached, because the arrays were  *
 *           not long enough to hold 50 moves, plus allow the search to go     *
 *           beyond the 50-move rule (which is legal and optional) and then    *
 *           output moves (which uses ply=65 data structures).  This let the   *
 *           repetition (50-move-rule part) overwrite things by storing well   *
 *           beyond the end of the repetition list for either side.  Minor fix *
 *           to EGTB "swindle" code.  It now only tries the searches if it is  *
 *           the side with swindling chances.  Ie it is pointless to try for   *
 *           a swindle in KRP vs KR if you don't have the P.  :)  Some very    *
 *           substantial changes to evaluate.c to get things back into some    *
 *           form of synch with each other.                                    *
 *                                                                             *
 *   15.19   More evaluation changes.  Slight change to the Lock() facility    *
 *           as it is used to lock the hash table.  Modifications to the book  *
 *           selection logic so that any move in books.bin that is not in the  *
 *           regular book.bin file still can be played, and will be played if  *
 *           it has a {play xxx%} or ! option.  New option added to the book   *
 *           create command to allow the creation of a better book.  This      *
 *           option lets you specify a percentage that says "exclude a book    *
 *           move it if didn't win xx% as many games as it lost.  IE, if the   *
 *           book move has 100 losses, and you use 50% for the new option, the *
 *           move will only be included if there are at least 50 wins.  This   *
 *           allows culling lines that only lost, for example.  New bad trade  *
 *           scoring that is simpler.  If one side has one extra minor piece   *
 *           and major pieces are equal, the other side has traded a minor for *
 *           pawns and made a mistake.  If major pieces are not matched, and   *
 *           one side has two or more extra minors, we have seen either a rook *
 *           for two minor pieces (bad) or a queen for three minor pieces (bad *
 *           also).  Horrible bug in initializing min_thread_depth, which is   *
 *           supposed to control thrashing.  The SMP search won't split the    *
 *           tree within "min_thread_depth" of the leaf positions.  Due to a   *
 *           gross bug, however, this was initialized to "2", and would have   *
 *           been the right value except that a ply in Crafty is 4.  The       *
 *           mtmin command that adjusts this correctly multiplied it by 4,     *
 *           but in data.c, it was left at "2" which lets the search split way *
 *           too deeply and can cause thrashing.  It now correctly defaults to *
 *           120 (2*PLY) as planned.  Crafty now *only* supports               *
 *           winboard/xboard 4.0 or higher, by sending the string "move xxx"   *
 *           to indicate its move.  This was done to eliminate older xboard    *
 *           versions that had some incompatibilities with Crafty that were    *
 *           causing lots of questions/problems.  Xboard 4.0 works perfectly   *
 *           and is the only recommended GUI now.                              *
 *                                                                             *
 *   15.20   New evaluation term to ensure that pawns are put on squares of    *
 *           the opposite color as the bishop in endings where one side only   *
 *           has a single bishop.  Another new evaluation term to favor        *
 *           bishops over knights in endings with pawns on both sides of the   *
 *           board.  Search extensions now constrained so that when doing an   *
 *           N-ply search, the first 2N plies can extend normally, but beyond  *
 *           that the extensions are reduced by one-half.  This eliminates a   *
 *           few tree explosions that wasted lots of time but didn't produce   *
 *           any useful results.  This version solves 299/300 of the Win at    *
 *           Chess positions on a single-cpu pentium pro 200mhz machine now.   *
 *           New evaluation term to reward "pawn duos" (two pawns side by side *
 *           which gives them the most flexibility in advancing.  A change to  *
 *           the bishops of opposite color to not just consider B vs B drawish *
 *           when the B's are on opposite colors, but to also consider other   *
 *           positons like RB vs RB drawish with opposite B's.                 *
 *                                                                             *
 *   16.0    Hash functions renamed to ProbeTransRef() and StoreTransRef().    *
 *           The store functions (2) were combined to eliminate some duplicate *
 *           code and shrink the cache footprint a bit.  Adjustment to "losing *
 *           the right to castle" so that the penalty is much less if this is  *
 *           done when trading queens, since a king in the center becomes less *
 *           of a problem there. Several eval tweaks.  Support for Eugene      *
 *           Nalimov's new endgame databases that reduce the size by 50%.      *
 *           Added a new cache=xxx command to set the tablebase cache (more    *
 *           memory means less I/O of course).  The "egtb" command now has two *
 *           uses.  If you enter egtb=0, you can disable tablebases for        *
 *           testing.  Otherwise, you just add "egtb" to your command line or  *
 *           .craftyrc file and Crafty automatically recognizes the files that *
 *           are present and sets up to probe them properly.  Added an eval    *
 *           term to catch a closed position with pawns at e4/d3/c4 and then   *
 *           avoiding the temptation to castle into an attack.  Most of the    *
 *           evaluation discontinuities have been removed, using the two new   *
 *           macros ScaleToMaterial() and InverseScaleToMaterial().  Scale()   *
 *           is used to reduce scores as material is removed from the board,   *
 *           while InverseScale() is used to increase the score as material    *
 *           is removed.  This removed a few ugly effects of things happening  *
 *           right around the EG_MAT threshold.                                *
 *                                                                             *
 *   16.1    Bug in EGTBProbe() which used the wrong variable to access the    *
 *           enpassant target square was fixed.  The cache=x command now       *
 *           checks for a failed malloc() and reverts to the default cache     *
 *           size to avoid crashes.  Major eval tuning changes.  Cache bug     *
 *           would do an extra malloc() and if it is done after the "egtb"     *
 *           command it would crash.  Analyze mode now turns off the "swindle" *
 *           mode.                                                             *
 *                                                                             *
 *   16.2    More evaluation changes, specifically to bring king safety down   *
 *           to reasonable levels.  Support for the DGT electronic chess board *
 *           is now included (but only works in text mode, not in conjunction  *
 *           with xboard/winboard yet.  Fix to StoreTransRef() that corrected  *
 *           a problem with moving an entry from tablea to tableb, but to the  *
 *           wrong address 50% of the time (thanks to J. Wesley Cleveland).    *
 *                                                                             *
 *   16.3    Performance tweaks plus a few evaluation changes.  An oversight   *
 *           would let Crafty play a move like exd5 when cxd5 was playable.    *
 *           IE it didn't follow the general rule "capture toward the center." *
 *           this has been fixed.  King safety ramped up just a bit.           *
 *                                                                             *
 *   16.4    Search extension fixed.  One-reply was being triggered when there *
 *           was only one capture to look at as well, which was wrong.  Minor  *
 *           fix to king safety in Evaluate().  Adjustments to preeval to fix  *
 *           some "space" problems caused by not wanting to advance pawns at   *
 *           all, plus some piece/square pawn values that were too large near  *
 *           the opponent's king position.  New swindle on*off command allows  *
 *           the user to disable "swindle mode" so that Crafty will report     *
 *           tablebase draws as draws.  Swindle mode is now disabled auto-     *
 *           matically in analysis or annotate modes.  DrawScore() now returns *
 *           a draw score that is not nearly so negative when playing humans.  *
 *           The score was a bit large (-.66 and -.33) so that this could tend *
 *           to force Crafty into losing rather than drawn positions at times. *
 *           EGTB probe code now monitors how the probes are affecting the nps *
 *           and modifies the probe depth to control this.  IE it adjusts the  *
 *           max depth of probes to attempt to keep the NPS at around 50% or   *
 *           thereabouts of the nominal NPS rate.  Fixed a nasty bug in the    *
 *           EGTB 'throttle' code.  It was possible that the EGTB_mindepth     *
 *           could get set to something more than 4 plies, then the next       *
 *           search starts off already in a tablebase ending, but with this    *
 *           probe limit, it wouldn't probe yet Iterate() would terminate the  *
 *           search after a couple of plies.  And the move chosen could draw.  *
 *           New code submitted by George Barrett, which adds a new command    *
 *           "html on".  Using this will cause the annotate command to produce *
 *           a game.html file (rather than game.can) which includes nice board *
 *           displays (bitmapped images) everywhere Crafty suggests a          *
 *           different move.  You will need to download the bitmaps directory  *
 *           files to make this work.  Note that html on enables this or you   *
 *           will get normal annotation output in the .can file.  Final        *
 *           hashing changes made.  Now crafty has only two hash tables, the   *
 *           'depth preferred' and 'always store' tables, but not one for each *
 *           side.                                                             *
 *                                                                             *
 *   16.5    Minor glitch in internal iterative deepening code (in search.c)   *
 *           could sometimes produce an invalid move.  Crafty now probes the   *
 *           hash table to find the best move which works in all cases.        *
 *           Interesting tablebase bug fixed.  By probing at ply=2, the        *
 *           search could overlook a repetition/50 move draw, and turn a won   *
 *           position into a draw.  Crafty now only probes at ply > 2, to      *
 *           let the Repeat() function have a chance.  Added code by Dan       *
 *           Corbitt to add environment variables for the tablebases, books,   *
 *           logfiles and the .craftyrc file paths.  The environment variables *
 *           CRAFTY_TB_PATH, CRAFTY_BOOK_PATH, CRAFTY_LOG_PATH and             *
 *           CRAFTY_RC_PATH should point to where these files are located and  *
 *           offer an alternative to specifying them on the command line.      *
 *           Final version of the EGTB code is included in this version.  This *
 *           allows Crafty to use either compressed (using Andrew Kadatch's    *
 *           compressor, _not_ zip or gzip) or non-compressed tablebases.  It  *
 *           will use non-compressed files when available, and will also use   *
 *           compressed files that are available so long as there is no non-   *
 *           compressed version of the same file.  It is allowable to mix and  *
 *           match as you see fit, but with all of the files compressed, the   *
 *           savings is tremendous, roughly a factor of 5 in space reduction.  *
 *                                                                             *
 *   16.6    Major rewrite of king-safety pawn shelter code to emphasize open  *
 *           files (and half-open files) moreso than just pawns that have been *
 *           moved.  Dynamic EGTB probe depth removed.  This caused far too    *
 *           many search inconsistencies.  A fairly serious SMP bug that could *
 *           produce a few hash glitches was found.  Rewrite of the 'king-     *
 *           tropism' code completed.  Now the pieces that are 'crowding' the  *
 *           king get a bigger bonus if there are more of them.  Ie it is more *
 *           than twice as good if we have two pieces close to the king, while *
 *           before this was purely 'linear'.  Minor fix to book.c to cure an  *
 *           annotate command bug that would produce odd output in multi-game  *
 *           PGN files.                                                        *
 *                                                                             *
 *   16.7    Minor bug in 'book create' command would produce wrong line num-  *
 *           bers if you used two book create commands without restarting      *
 *           Crafty between uses.  Replaced "ls" command with a !cmd shell     *
 *           escape to allow _any_ command to be executed by a shell. Change   *
 *           to bishop scoring to avoid a bonus for a bishop pair _and_ a good *
 *           bishop sitting at g2/g7/etc to fill a pawn hole.  If the bishop   *
 *           fills that hole, the bishop pair score is reduced by 1/2 to avoid *
 *           scores getting too large.  Another ugly SMP bug fixed.  It was    *
 *           for the CopyFromSMP() function to fail because Search() put the   *
 *           _wrong_ value into tree->value.  The "don't castle into an unsafe *
 *           king position" code was scaled up a bit as it wasn't quite up to  *
 *           detecting all cases of this problem.  The parallel search has     *
 *           been modified so that it can now split the tree at the root, as   *
 *           well as at deeper nodes.  This has improved the parallel search   *
 *           efficiency noticably while also making the code a bit more        *
 *           complex.  This uses an an adaptive algorithm that pays close      *
 *           attention to the node count for each root move.  If one (or more) *
 *           moves below the best move have high node counts (indicating that  *
 *           these moves might become new 'best' moves) then these moves are   *
 *           flagged as "don't search in parallel" so that all such moves are  *
 *           searched one by one, using all processors so that a new best move *
 *           if found faster.  Positional scores were scaled back 50% and the  *
 *           king safety code was again modified to incorporate pawn storms,   *
 *           which was intentionally ignored in the last major revision.  Many *
 *           other scoring terms have been modified as well to attempt to      *
 *           bring the scores back closer to something reasonable.             *
 *                                                                             *
 *   16.8    Bug in evaluate.c (improper editing) broke the scoring for white  *
 *           rooks on open files (among other things.)  New twist on null-     *
 *           move search...  Crafty now uses R=3 near the root of the tree,    *
 *           and R=2 near the top.  It also uses null-move so long as there is *
 *           a single piece on the board, but when material drops to a rook or *
 *           less, null move is turned off and only used in the last 7 plies   *
 *           to push the zugzwang errors far enough off that they can be       *
 *           avoided, hopefully.                                               *
 *                                                                             *
 *   16.9    Tuning to king safety.  King in center of board was way too high  *
 *           which made the bonus for castling way too big.  More fine-tuning  *
 *           on the new 'tropism' code (that tries to coordinate piece attacks *
 *           on the king).  It understands closeness and (now) open files for  *
 *           the rooks/queens.  Modified blocked center pawn code so that an   *
 *           'outpost' in front of an unmoved D/E pawn is made even stronger   *
 *           since it restrains that pawn and cramps the opponent.             *
 *                                                                             *
 *   16.10   All scores are back to 16.6 values except for king safety, as     *
 *           these values played well.  King safety is quite a bit different   *
 *           and now has two fine-tuning paramaters that can be set in the     *
 *           crafty.rc file (try help ksafety for more details, or see the new *
 *           crafty.doc for more details.  Suffice it to say that you can now  *
 *           tune it to be aggressive or passive as you wish.                  *
 *                                                                             *
 *   16.11   Adjustment to king safety asymmetry to make Crafty a bit more     *
 *           cautious about starting a king-side attack.  New "ksafe tropism"  *
 *           command allows the tropism scores (pulling pieces toward opponent *
 *           king) to be adjusted up or down (up is more aggressive).          *
 *                                                                             *
 *   16.12   evaluation adjustment options changed.  The new command to modify *
 *           this stuff is "evaluation option value".  For example, to change  *
 *           the asymmetry scoring for king safety, you now use "evaluation    *
 *           asymmetry 120".  See "help evaluation" for more details.  There   *
 *           is a new "bscale" option to adjust the scores for 'blocked' type  *
 *           positions, and I added a new "blockers_list" so that players that *
 *           continually try to lock things up to get easy draws can be better *
 *           handled automatically.  The command is "list B +name".  There are *
 *           other adjustable evaluation scaling parameters now (again, use    *
 *           "help evaluation" to see the options.)                            *
 *                                                                             *
 *   16.13   Bug in Evaluate() fixed.  King safety could produce impossibly    *
 *           large scores due to negative subscript values.  Minor change to   *
 *           root.c to allow partial tablebase sets while avoiding the ugly    *
 *           potential draw problem.  This was supplied by Tim Hoooebeek and   *
 *           seems to work ok for those wanting to have files like kpk with-   *
 *           out the corresponding promotion files.                            *
 *                                                                             *
 *   16.14   Bug in Evaluate() fixed.  King safety could produce impossibly    *
 *           large scores due to a subscript two (2) larger than expected for  *
 *           max values.  A couple of other minor tweaks to rook on 7th as     *
 *           well.  Setboard now validates enpassant target square to be sure  *
 *           that an enpassant capture is physically possible, and that the    *
 *           target square is on the right rank with pawns in the right place. *
 *                                                                             *
 *   16.15   Bug in EGTBProbe() usage fixed.  It was possible to call this     *
 *           function before tablebases were initialized, or when there were   *
 *           more than 3 pieces on one side, which would break a subscript.    *
 *                                                                             *
 *   16.16   Changes to the way EvaluatePassedPawn() works.  It now does a     *
 *           reasonable job of penalizing blockaded passed pawns.  Also a bug  *
 *           in king scoring used a variable set from the previous call to the *
 *           Evaluate() procedure, which could produce bizarre effects.  A few *
 *           minor eval glitches that caused asymmetric scores unintentionally *
 *           were removed.                                                     *
 *                                                                             *
 *   16.17   Minor "hole" in SMP code fixed.  It was possible that a move      *
 *           displayed as the best in Output() would not get played.           *
 *           Very subtle timing issue dealing with the search timing out and   *
 *           forgetting to copy the best move back to the right data area.     *
 *           Minor fixes to the modified -USE_ATTACK_FUNCTIONS option that     *
 *           was broken when the And()/Or()/ShiftX() macros were replaced by   *
 *           their direct bitwise operator replacements.                       *
 *                                                                             *
 *   16.18   Adjustments to king tropism scoring terms (these attract pieces   *
 *           toward the opponent king in a coordinated way).  The scoring term *
 *           that kept the queen from going to the opposite side of the board  *
 *           was not working well which would also cause attacking problems.   *
 *           Razoring code has been disabled, as it neither helps or hurts on  *
 *           tactical tests, and it creates a few hashing problems that are    *
 *           annoying.  Bug in StoreTransRefPV() that would store the PV into  *
 *           the hash table, but possibly in the wrong table entry, which      *
 *           could stuff a bad move in a hash entry, or overwrite a key entry  *
 *           that could have been useful later.  Book random 0 was slightly    *
 *           wrong as it could not ignore book moves if the search said that   *
 *           the score was bad.  Also the search would not time-out properly   *
 *           on a forced move, it would use the entire time alotted which was  *
 *           a big waste of time when there was only one legal move to make.   *
 *           A very interesting bug was found in storing mate bounds in the    *
 *           hash table, one I had not heard of before.  Another change to     *
 *           Iterate() to make it avoid exiting as soon as a mate is found, so *
 *           that it can find the shortest mate possible.                      *
 *                                                                             *
 *   16.19   Savepos now pads each rank to 8 characters so that programs that  *
 *           don't handle abbreviated FEN will be able to parse Crafty's FEN   *
 *           output without problems.  Threads are no longer started and       *
 *           stopped before after searches that seem to not need multiple      *
 *           threads (such as when the starting position is in the databases   *
 *           or whatever) because in fast games, it can start and stop them    *
 *           after each search, due to puzzling for a ponder move, and this is *
 *           simply to inefficient to deal with, and burning the extra cpus is *
 *           only bad if the machine is used for other purposes.  And when the *
 *           machine is not dedicated to chess only, the SMP search is very    *
 *           poor anyway.  New lockless hashing (written by Tim Mann) added    *
 *           to improve SMP performance.  New eval term that handles various   *
 *           types of candidate passed pawns, most commonly the result of a    *
 *           position where one side has an offside majority that later turns  *
 *           into an outside passed pawn.  New EGTBPV() procedure added.  This *
 *           code will print the entire PV of a tablebase mating line.  If it  *
 *           given an option of ! (command is "egtb !") it will add a ! to any *
 *           move where there is only one optimal choice.  Crafty will now     *
 *           automatically display the EGTB PV if you give it a setboard FEN   *
 *           command, or if you just give it a raw FEN string (the setboard    *
 *           command is now optional except in test suites).  This version now *
 *           supports the 6 piece database files.  To include this support,    *
 *           you need to -DEGTB6 when compiling everything.  The majority code *
 *           has been temporarily removed so that this version can be released *
 *           to get the 6 piece ending stuff out.                              *
 *                                                                             *
 *   17.0    Connected passed pawn scoring modified so that connected passers  *
 *           don't get any sort of bonus, except for those cases where the     *
 *           opponent has a rook or more.  This will avoid liking positions    *
 *           where Crafty has two connected passers on the d/e files, and the  *
 *           opponent has passers on the b/g files.  The split passers win if  *
 *           all pieces are traded, while the connected passers are better     *
 *           when pieces are present.  A new scoring term evaluates the        *
 *           "split" passers similar to outside passers, this at the request   *
 *           (make that demand) of GM Roman Dzindzichashvili. Book() now finds *
 *           the most popular move as the move to ponder.  This eliminated all *
 *           'puzzling' searches which result in clearing the hash tables two  *
 *           times for every book move, which can slow it down when a large    *
 *           hash table is used.  New book option for playing against computer *
 *           opponents was written for this version.  Crafty now supports two  *
 *           "books.bin" type files, books.bin and bookc.bin (the bookc create *
 *           command can be used to make bookc.bin).  Bookc will only be used  *
 *           when Crafty is playing a computer.  This is supplied by xboard or *
 *           winboard when playing on a server, or can be included int the     *
 *           crafty.rc/.craftyrc file when playing directly.  Bookc.bin will   *
 *           be used when playing a computer only, and should be used to avoid *
 *           unsound lines that are fine against humans, but not against other *
 *           computers.  If you don't use a bookc.bin, it will use the normal  *
 *           books.bin as always.  If you use both, it will only use bookc.bin *
 *           in games that have been started and then given the 'computer'     *
 *           command.  Minor adjustment to EGTB probe code so that it will     *
 *           always probe TBs at ply=2 (if the right number of pieces are on   *
 *           the board) but won't probe beyond ply=2 unless the move at the    *
 *           previous ply was a capture/promotion and the total pieces drops   *
 *           into the proper range for TB probes.  This makes the 6 piece      *
 *           files far more efficient as before it would continuously probe    *
 *           after reaching 6 piece endings, even if it didn't have the right  *
 *           file.  now after the capture that takes us to a 6 piece ending    *
 *           we probe one time...  and if there is no hit we don't probe at    *
 *           the next node (or any successors) unless there is another capture *
 *           or promotion that might take us to a database we have.  The book  *
 *           (binary) format has once again been modified, meaning that to use *
 *           16.20 and beyond the book.bin/books.bin files must be re-built    *
 *           from the raw PGN input.  This new format includes an entry for    *
 *           the CAP project score, so that deep searches can be used to guide *
 *           opening book lines.  A new weight (bookw CAP) controls how much   *
 *           this affects book move ordering/selection.  A new import command  *
 *           will take the raw CAPS data and merge it into the book.bin after  *
 *           the file has been built.  Serious bug in SetBoard() would leave   *
 *           old EP status set in test suites.  This has been fixed.  Outpost  *
 *           knight code was modified so that a knight in a hole is good, a    *
 *           knight in a hole supported by a pawn is better, supported by two  *
 *           pawns is still better, and if the opponent has no knights or a    *
 *           bishop that can attack this knight it is even better.  The out-   *
 *           post bonus for a bishop was removed.  A pretty serious parallel   *
 *           search bug surfaced.  In non-parallel searches, Crafty _always_   *
 *           completed the current ply=1 move after the time limit is reached, *
 *           just to be sure that this move isn't going to become a new best   *
 *           move.  However, when parallel searching, this was broken, and at  *
 *           the moment time runs out, the search would be stopped if the      *
 *           parallel split was done at the root of the tree, which means that *
 *           where the search would normally find a new best move, it would    *
 *           not.  This has been fixed.  New "store <val>" command can be used *
 *           to make "position learning" remember the current position and the *
 *           score (val) you supply.  This is useful in analyze mode to move   *
 *           into the game, then let Crafty know that the current position is  *
 *           either lost or won (with a specific score).                       *
 *                                                                             *
 *   17.1    Book structure fixed, since compilers can't quite agree on how    *
 *           structures ought to be aligned, for reasons not clear to me.  A   *
 *           serious eval bug that could produce gross scores when one side    *
 *           had two queens was fixed.                                         *
 *                                                                             *
 *   17.2    Isolated pawn scoring tweaked a bit, plus a couple of bugs in the *
 *           way EvaluateDevelopment() was called were fixed.                  *
 *                                                                             *
 *   17.3    Passed pawn scores increased somewhat to improve endgame play.    *
 *                                                                             *
 *   17.4    Minor bug with "black" command (extra line from unknown origin)   *
 *           would make "black" command fail to do anything.  Minor tweaks to  *
 *           passed pawn scoring again...  And a slight performance improve-   *
 *           ment in how EvaluateKingSafety() is called.  Code for "bk"        *
 *           from xboard was somehow lost.  It now provides a book hint.       *
 *                                                                             *
 *   17.5    Rewrite of outside passed pawn/pawn majority code.  It is now     *
 *           much faster by using pre-computed bitmaps to recognize the right  *
 *           patterns.                                                         *
 *                                                                             *
 *   17.6    Minor fix in interrupt.c, which screwed up handling some commands *
 *           while pondering.  Minor fix to score for weak back rank.  Score   *
 *           was in units of 'defects' but should have been in units of        *
 *           "centipawns".   Minor bug in "drawn.c" could mis-classify some    *
 *           positions as drawn when they were not.                            *
 *                                                                             *
 *   17.7    Repair to DrawScore() logic to stop the occasional backward sign  *
 *           that could create some funny-looking scores (-20 and +20 for      *
 *           example).  Minor fix to majority code to recognize the advantage  *
 *           of having a majority when the opponent has no passers or majority *
 *           even if the candidate in the majority is not an 'outside' passer  *
 *           candidate.  Minor change to passed pawns so that a protected      *
 *           passed pawn is not considered a winning advantage if the          *
 *           opponent has two or more passed pawns.  But in input_status       *
 *           would cause an infinite loop if you reset a game to a position    *
 *           that was in book, after searching a position that was not in      *
 *           the book.  Bug in position learning fixed also.  This was caused  *
 *           by the new hashing scheme Tim Mann introduced to avoid locking    *
 *           the hash table.  I completed the changes he suggested, but forgot *
 *           about how it might affect the position learning since it is also  *
 *           hash-based.  Needless to say, I broke it quite nicely, thank you. *
 *                                                                             *
 *   17.8    This is the version used in the first ICC computer chess          *
 *           tournament.  Crafty won with a score of 7.0/8.0 which included    *
 *           only 2 draws and no losses.  Changes are minimal except for a few *
 *           non-engine syntax changes to eliminate warnings and fix a bad bug *
 *           in 'bench.c' that would crash if there was no books.bin file.     *
 *                                                                             *
 *   17.9    LearnPosition() called with wrong arguments from main() which     *
 *           effectively disabled position learning.  This was broken in 17.7  *
 *           but is now fixed.                                                 *
 *                                                                             *
 *   17.10   Minor change to "threat" extension now only extends if the null-  *
 *           move search returns "mated in 1" and not "mated in N".  This      *
 *           tends to shrink the trees a bit with no noticable effect in       *
 *           tactical strength.  EvaluatePawns() was not doing a reasonable    *
 *           job of recognizing blocked pawns and candidate passers.  It did   *
 *           not do well in recognizing that the pawn supporting a candidate   *
 *           could not advance far enough to help make a real passed pawn.     *
 *           Minor change to Repeat() to not count two-fold repeats as draws   *
 *           in the first two plies, which prevents some odd-looking repeats   *
 *           at the expense of a little inefficiency.  Ugly repetition bug     *
 *           fixed.  Rephead was off by one for whatever side Crafty was       *
 *           playing which would screw up repetition detection in some cases.  *
 *           Minor bug in main() that would report stalemate on some mates     *
 *           when the ponder score was forgotten.                              *
 *                                                                             *
 *   17.11   Fail high/low logic changed to move the ++ output into Iterate()  *
 *           where the -- output was already located.  (This was done for      *
 *           consistecy only, it was not a problem.  New function to detect    *
 *           draws RepetitionCheckBook() was added to count two-fold repeats   *
 *           as draws while in book.  This lets Crafty search to see if it     *
 *           wants tht draw or not, rather than just repeating blindly.  Minor *
 *           bug in "go"/"move" command fixed.  The command did not work if    *
 *           the engine was pondering.  Minor change to Evaluate() that makes  *
 *           BAD_TRADE code more acurate.  Minor change to pawn majority code  *
 *           to fix two bugs.  White pawns on g2/h2 with black pawn on h7 was  *
 *           not seen as a majority (outside candidate passer) but moving the  *
 *           black pawn to g7 made it work fine.   Also if both sides had an   *
 *           equal number of pawns (black pawn at a7/b7, white pawns at b2/c2  *
 *           the code would not notice black had an outside passer candidate   *
 *           since pawns were 'equal' in number.                               *
 *                                                                             *
 *   17.12   Bookup() will now create a book with all sorts of games in it, so *
 *           long as the various games have the FEN string to properly set the *
 *           initial chess board position.                                     *
 *                                                                             *
 *   17.13   Endgame evaluation problem fixed.  King scoring now dynamically   *
 *           chooses the right piece/square table depending on which side of   *
 *           the board has pawns, rather than using root pre-processing which  *
 *           could make some gross errors.  Glitch with majorities would make  *
 *           an "inside majority candidate" offset a real outside passed pawn  *
 *           even if the candidate would not be outside.  A suggestion by      *
 *           Blass Uri (CCC) was added.  This adds .01 to tablebase scores if  *
 *           the side on move is ahead in material, and -.01 if the side on    *
 *           move is behind in material (only for drawn positions.)  the       *
 *           intent is to favor positions where you are ahead in material      *
 *           rather than even in material, which gives 'swindle mode' a chance *
 *           to work.  Bug in EvaluateDraws() would mis-categorize some B+RP   *
 *           (wrong bishop) as drawn, even if the losing king could not make   *
 *           it to the corner square in time.                                  *
 *                                                                             *
 *   17.14   Another endgame evaluation problem fixed.  The outside passed     *
 *           pawn code worked well, up until the point the pawn had to be      *
 *           given up to decoy the other side's king away from the remainder   *
 *           of the pawns.  Crafty now understands the king being closer to    *
 *           the pawns than the enemy king, and therefore transitions from     *
 *           outside passer to won king-pawn ending much cleaner.  New command *
 *           "selective" as requested by S. Lim, which allows the user to      *
 *           set the min/max null move R values (default=2/3).  They can be    *
 *           set to 0 which disables null-move totally, or they can be set     *
 *           larger than the default for testing.  Minor changes to init.c     *
 *           sent by Eugene Nalimov to handle 64 bit pointer declarations for  *
 *           win64 executable compilation.  NetBSD changes included along with *
 *           a new Makefile that requires no editing to use for any known      *
 *           configuration ("make help" will explain how to use it).  This was *
 *           submitted by Johnny Lam.  Serious changes to the outside passed   *
 *           pawn code.  The evaluator now understands that outside passers    *
 *           on _both_ sides of the board is basically winning.  Same goes for *
 *           candidate passers.                                                *
 *                                                                             *
 *   18.0    Bug in EvaluateDraws() could incorrectly decide that if one side  *
 *           had only rook pawns in a king/pawn ending, the ending was a draw. *
 *           Even if the other side had pawns all over the board.  Passed pawn *
 *           scores increased a bit.  Minor change to "bad trade" code to turn *
 *           off in endings.  S list removed.  The trojan horse check is now   *
 *           automatically enabled when the key position is recognized at the  *
 *           root of the tree.  It is disabled once the key position is no     *
 *           longer seen at the root.  Bug in Bookup() would break if a FEN    *
 *           string was included in a game used for input.  SetBoard() was     *
 *           setting castling status incorrectly.  Internal iterative          *
 *           deepening bug could (on very rare occasions) cause Crafty to try  *
 *           to search an illegal move that would bomb the search.  This       *
 *           version fully supports the new xboard protocol version 2.  One    *
 *           other major change is that the eval is now consistently displayed *
 *           as +=good for white, -=good for black.  In the log file.  In the  *
 *           console output window.  And when whispering/kibitzing on a chess  *
 *           server.  This should eliminate _all_ confusion about the values   *
 *           that are displayed as there are now no exceptions to the above    *
 *           policy of any kind.  Book() was changed so that if it notices     *
 *           that the opponent has a "stonewall pattern" set up (IE Crafty     *
 *           is black, has a pawn at e7 or e6, and the opponent has pawns at   *
 *           d4/f4) then it won't play a castle move from book.  It will do a  *
 *           normal search instead and let the evaluation guide it on whether  *
 *           to castle or not (generally it won't unless it is forced).        *
 *                                                                             *
 *   18.1    Easy move code broken, so that no move ever appeared to be "easy" *
 *           even if it was the only possible recapture move to make.  A minor *
 *           problem in analysis mode dealing with pawn promotions was fixed.  *
 *           It was possible for a move like h8=Q to be rejected even though   *
 *           it was perfectly legal.                                           *
 *                                                                             *
 *   18.2    Minor bug in analyze mode would break the "h" command when black  *
 *           was on move, and show one less move for either side that had      *
 *           actually been played in the game.  Another bug also reversed the  *
 *           sign of a score whispered in analysis mode.  Recapture extension  *
 *           is disabled by default.  To turn it on, it is necessary to use    *
 *           -DRECAPTURE when compiling search.c and option.c.  LearnBook()    *
 *           has been modified to 'speed up' learning.  See the comments in    *
 *           that module to see how it was changed.  LearnResult() has been    *
 *           removed.  LearnBook() is now used to do the same thing, except    *
 *           that a good (or bad) score is used.                               *
 *                                                                             *
 *   18.3    Minor bug in "avoid_null_move" test used R=2 for the test rather  *
 *           than testing R=2/3 as the real null-move search uses.  The kibitz *
 *           for "Hello from Crafty Vx.xx" has been moved so that it works     *
 *           with the new xboard/winboard 4.2.2 versions.  Book learning was   *
 *           badly broken in the previous version and has been fixed/tested.   *
 *                                                                             *
 *   18.4    Recapture extension was left in SearchParallel() by mistake.      *
 *           This has now been protected by a #ifdef just like it was in       *
 *           Search().  Bug in Repeat() was causing problems in SMP versions.  *
 *           The entire repetition list code was modified to clean this up.    *
 *           The problem was most noticable on things like fine #70.  Bug in   *
 *           LearnImportBook() confused the learn value sign, due to the other *
 *           changes to make +=white all the time.  Opposite bishop scoring    *
 *           has been beefed up a bit to avoid these drawish endings.          *
 *                                                                             *
 *   18.5    Minor change to RootMove() to use Quiesce() rather than the more  *
 *           complicated way it was ordering with Evaluate()/EnPrise().  This  *
 *           is no faster, but it is simpler and eliminated the need for the   *
 *           EnPrise() function totally, making the code a bit smaller.  Bug   *
 *           in EvaluateDraws() would let it think that the bishop+wrong rook  *
 *           pawn endings were winnable if both kings were very close to the   *
 *           queening square, even with the wrong bishop.                      *
 *                                                                             *
 *   18.6    "New" no longer produces a new log.nnn/game.nnn file if no moves  *
 *           have actually been played.  Minor change to rook scoring gives a  *
 *           penalty when a rook has no horizontal (rank) mobility, to avoid   *
 *           moves like Ra2 protecting the pawn on b2, etc.  Glitch in the     *
 *           code that initializes is_outside[][] and is_outside_c[][] could   *
 *           cause missed outside pawn cases to happen.  This has been there   *
 *           a long time.                                                      *
 *                                                                             *
 *   18.7    BOOK_CLUSTER_SIZE increased to 2000 to handle making really large *
 *           books.  A book made without this change could produce clusters    *
 *           that would cause memory overwrites.                               *
 *                                                                             *
 *   18.8    Recapture extension turned back on for a while.  Changes to the   *
 *           evaluation code, particularly EvaluatePawns() to make it more     *
 *           efficient and accurate.  IE it was possible for an isolated pawn  *
 *           to be penalized for being isolated, weak, and blocked, which made *
 *           little sense.                                                     *
 *                                                                             *
 *   18.9    Book() modified to increase the responsiveness of book learning.  *
 *           The new code, plus the default weights for the book parameters    *
 *           now make Crafty learn very aggressively and repeat good opening   *
 *           lines and avoid bad ones.                                         *
 *                                                                             *
 *   18.10   Minor bug in book.c would let Crafty play lines that were very    *
 *           rarely played even though there were others that had been played  *
 *           far more times and were more reliable.  King safety scores ramped *
 *           up a bit and made more "responsive".                              *
 *                                                                             *
 *   18.11   Minor bug in EvaluateDevelopment() found by Bruce Moreland.  The  *
 *           pawn ram code is now disabled when playing a computer, although   *
 *           the normal 'blocked pawn' code is always active.  Bug in the code *
 *           that penalizes a rook with no horizontal mobility was fixed.  If  *
 *           the first rook scored had horizontal mobility, the second rook    *
 *           appeared to have this mobility as well, which was wrong.  Pawn    *
 *           hash statistics were wrong on longer searches due to an int       *
 *           overflow on a multiply and divide calculation.  This has been     *
 *           re-ordered to avoid the overflow.  For unknown reasons, epd       *
 *           support was disabled.  It is now enabled as it should be.  Some   *
 *           strange adjustements to root_alpha/root_beta were removed from    *
 *           searchr.c.  They were probably left-over from some sort of test.  *
 *                                                                             *
 *   18.12   Bug in EvaluateDraws() fixed to not call KBB vs KN a draw if the  *
 *           correct tablebase is not available.  Bishop pair scores now vary  *
 *           depending on how many pawns are left on the board.  A pair is not *
 *           worth a lot if there are 7-8 pawns left as most diagonals will be *
 *           blocked by pawns.  Test() modified so that it will now run using  *
 *           an EPD test suite with am/bm and id tags.  The old testfile for-  *
 *           mat will continue to work for a while, but Test() now notices the *
 *           EPD format and processes it correctly.  A new way of handling the *
 *           search extensions is in place.  With the old approach, one ply    *
 *           could not extend more than one full ply.  With the new approach,  *
 *           borrowed from Deep Blue, two consecutive plies can not extend     *
 *           more than two plies total.  It averages out to be the same, of    *
 *           course, but the effect is a bit different.  Now it is possible    *
 *           for a check and recapture to be applied at the same ply, where    *
 *           they could not before (since a check was already a full one-ply   *
 *           extension).  Whether this is better or not is not clear yet, but  *
 *           it is worth careful analysis.  EvaluateDraws() has been replaced  *
 *           by EvaluateWinner().  This function returns an indicator that     *
 *           specifices whether white, black, both or neither can win in the   *
 *           present position.                                                 *
 *                                                                             *
 *   18.13   Deep Blue extension limit removed and restored to one ply of      *
 *           extension per ply of search.  Pruning in q-search fixed so that   *
 *           a capture will be considered if it takes the total material on    *
 *           the board down to a bishop or less for the opponent, as that can  *
 *           greatly influence the evaluation with the EvaluateWinner() code.  *
 *           As the 50 move rule draws near, the hash table scores are marked  *
 *           as invalid every 5 moves so that hashing can't hide potential     *
 *           50-move-rule draws.  Lazy evaluation code modified to be more     *
 *           conservative, since in endgames the positional score can be a     *
 *           large change.  EvaluatePassedPawnRaces() fixed so that if one     *
 *           side has two pawns that are far enough apart, it will recognize   *
 *           that even though the king is "in the square" of either, it can't  *
 *           always stay in the square of one if it has to capture the other.  *
 *           Pawn hash signature restored to 64 bits after testing proved that *
 *           32 was producing an unacceptable number of collisions.  Search    *
 *           node counter is now 64 bits as well to avoid overflows.  Bug in   *
 *           the outside passed pawn code fixed (bad mask).                    *
 *                                                                             *
 *   18.14   Minor bug in ResignOrDraw() code caused Crafty to not offer draws *
 *           although it would accept them when appropriate.  Rook vs Minor    *
 *           is now evaluated as "neither side can win" an oversight in the    *
 *           EvaluateWinner() code.  Minor bug in ResignOrDraw() would fail to *
 *           offer draws due to the +0.01/-0.01 draw scores returned by the    *
 *           EGTB probe code.                                                  *
 *                                                                             *
 *   18.15   Change in endgame draw recognition to handle the case where one   *
 *           side appears to be in a lost ending but is stalemated.  The code  *
 *           now evaluates such positions as "DrawScore()" instead.  The code  *
 *           to accept/decline draws has been modified.  When a draw offer is  *
 *           received, a global variable "draw_offer_pending" is set to 1.     *
 *           When the search for a move for Crafty terminates, Crafty then     *
 *           uses this value to decide whether to accept or decline the draw.  *
 *           This means that the accept/decline won't happen until _after_ the *
 *           search has a chance to see if something good is happening that    *
 *           should cause the draw to be declined, closing a timing hole that  *
 *           used to exist that let a few "suspects" get away with draws that  *
 *           should not have happened (ie Crafty has - scores for a long time, *
 *           the opponent suddenly fails low and sees he is losing and offers  *
 *           a draw quickly.  Crafty would accept before doing a search and    *
 *           noticing that it was suddenly winning.)  minor evaluation change  *
 *           to notice that K+B+right RP vs K+B is not necessarily won if the  *
 *           weaker side has a bishop of the right color.                      *
 *                                                                             *
 *   19.0    Significant change to the search extension limits.  First, the    *
 *           limit of no more than 1 ply of extensions per ply has been tossed *
 *           out.  Now, any number of extensions are allowed in the first N    *
 *           plies, where N=iteration_depth of the current iteration.  After   *
 *           the first N plies, extensions are reduced by 50% for the next N   *
 *           plies.  They are then reduced by another 50% for the next N plies *
 *           and then completely disabled after that.  IE for a 12 ply search, *
 *           all extensions (even > one ply) are allowed for the first 12      *
 *           plies, then the extensions are reduced by 1/2 for the next 12     *
 *           plies, then by 1/4 for the next 12 plies, then turned off from    *
 *           that point forward.  Minor tweak (suggested by GCP) to reduce the *
 *           time limit by 1/4 for ponder=off games was done in time.c.  Fix   *
 *           to EvaluateWinner() to correctly realize that KR[BN] vs KRR is a  *
 *           draw for the KRR side if it doesn't have at least a pawn left.    *
 *           Minor bug in RejectBookMove() would reject all moves if the op-   *
 *           ponent had a stonewall-type pawn set-up.  It was supposed to only *
 *           reject castling into the attack.  Minor change to code in the     *
 *           EvaluateMaterial() function to lower the penalty for sacrificing  *
 *           the exchange.  it was considered just as bad as trading a rook    *
 *           for two pawns which was wrong.  Change to hashing code so that we *
 *           can now determine that a hash entry came from the EGTB so that    *
 *           PVs are displayed with <EGTB> when appropriate, not <EGTB> if it  *
 *           originally came from the EGTB but later <HT> when it was picked   *
 *           up from the hash table instead.  Minor changes to search/searchmp *
 *           to make them identical in "look" where possible, for consistency  *
 *           in source reading if nothing else.  If the first argument on the  *
 *           command-line is "xboard" or if the environment variable           *
 *           "CRAFTY_XBOARD" is set, Crafty sends a "feature done=0" command   *
 *           to tell xboard it has not yet initialized things.  Significant    *
 *           changes to EvaluateWinner() to recognize new cases of draws such  *
 *           as Q+minor+nopawns vs Q+pawns as unwinnable by the Q+minor side.  *
 *           Other cases were fixed/improved as well.                          *
 *                                                                             *
 *   19.1    Changes to the outside passed pawn and outside candidate pawn     *
 *           code to more correctly recognize when one side has a simple end-  *
 *           game position that is easy to win.  Futility pruning and razoring *
 *           (Jeremiah Penery) was added.  To endable it, you will need to add *
 *           -DFUTILITY to the Makefile options, otherwise it is disabled by   *
 *           default.  EvaluateWinner() had a bug dealing with KR vs KN or     *
 *           KRR vs KRN(B) that has been fixed.                                *
 *                                                                             *
 *   19.2    CCT-5 version 01/20/03.                                           *
 *           Changes to the LimitExtensions() macro.  The extensions are now   *
 *           a bit more aggressive, but after 2*iteration_depth, then they     *
 *           taper off smoothly so that by the time the depth reaches          *
 *           4*iteration_depth, the extensions are cut to zero.  Fixed bug in  *
 *           EvaluatePawns() that missed candidate passed pawns so that the    *
 *           new endgame stuff didn't work completely.  Change to hash.c to    *
 *           combine the two hash tables into one so that the two probed       *
 *           entries are adjacent in memory to be more cache friendly.  A bug  *
 *           in moving a replaced entry from depth-preferred to always-store   *
 *           caused the moved entry to go to the wrong address which would     *
 *           make it impossible to match later.  New hash table layout is more *
 *           cache-friendly by putting one entry from depth-preferred table    *
 *           with two entries from always-store, so that they often end up in  *
 *           the same cache-line.                                              *
 *                                                                             *
 *   19.3    Change to EvaluateMaterial to realize that a rook for five pawns  *
 *           is also likely a "bad trade."  Adaptive hash table size code was  *
 *           added so that the hash size is set automatically based on the     *
 *           estimated NPS and time per move values for a specific "level"     *
 *           command setting.  Repeat() rewritten.  The old code had an        *
 *           unexplained bug that would overlook repetitions in a parallel     *
 *           search in rare cases.  The old cold was complex enough that it    *
 *           was time to rewrite it and simplify it significantly.             *
 *                                                                             *
 *   19.4    Initial depth "seed" value changed to iteration_depth + 1/2 ply,  *
 *           so that fractional extensions kick in earlier rather than deeper  *
 *           in the search.  This performs _much_ better in tactical tests     *
 *           such as WAC and similar suites.  Minor book fix for a bug that    *
 *           could cause a crash with book=off in xboard/winboard.             *
 *                                                                             *
 *   19.5    Default draw score set to 1, because endgame table draws can be   *
 *           0, -.01 or +.01, which translates to -1, 0 or 1 in real scores    *
 *           inside Crafty.  +1 means a draw where white has extra material    *
 *           and that would break accepting draws with such a score.  A few    *
 *           NUMA-related changes.  One global variable was made thread-       *
 *           private to avoid cache thrashing.  Split blocks are now allocated *
 *           by each individual processor to make them local to the specific   *
 *           processor so that access is much faster.  CopyToSMP() now tries   *
 *           to allocate a block for a thread based on the thread's ID so that *
 *           the split block will be in that thread's local memory.  A few     *
 *           other NUMA-related changes to help scaling on NUMA machines.      *
 *                                                                             *
 *   19.6    New egtb.cpp module that cuts decompression indices memory by 50% *
 *           with no harmful side-effects.  Fixes to NUMA code to make SMP and *
 *           non-SMP windows compiles go cleanly.                              *
 *                                                                             *
 *   19.7    Changes to draw code so that Crafty will first claim a draw and   *
 *           then play the move, to avoid any confusion in whether the draw    *
 *           was made according to FIDE rules or not.  Minor bug in evaluate() *
 *           dealing with candidate passed pawns fixed.  A few additions to    *
 *           support my AMD Opteron inline assembly for MSB(), LSB()           *
 *           and PopCnt() procedures.                                          *
 *                                                                             *
 *   19.8    Changes to lock.h to (a) eliminate NT/alpha, since Microsoft no   *
 *           longer supports the alpha, which makes lock.h much more readable. *
 *           CLONE is no longer an option either, further simplyfying the .h   *
 *           files.  New mode option "match" which sets an aggressive learning *
 *           mode, which is now the default.  The old learning mode can be set *
 *           by using the command "mode normal".  Memory leak in new windows   *
 *           NUMA code fixed by Eugene Nalimov.  AMD fix to make the history   *
 *           counts thread-local rather than global (to avoid excessive cache  *
 *           invalidate traffic).                                              *
 *                                                                             *
 *   19.9    Two new pieces of code submitted by Alexander Wagner.  The first  *
 *           adds speech to Crafty for unix users.  /opt/chess/sounds needs to *
 *           exist and the common/sounds.tar.gz file needs to be untarred in   *
 *           directory.  "Speech on*off" controls it.  A new annotatet command *
 *           outputs the annotated file in LaTeX format for those that prefer  *
 *           that platform.  Lots of source reformatting to make indenting and *
 *           other things more consistent, using the unix "indent" utility.    *
 *           Singular extension (simplistic approach) has been added and needs *
 *           -DSINGULAR to activate it.  Once it has been compiled in, you can *
 *           turn it on/off by setting the singular extension depth using the  *
 *           ext command.  Default is on if you compile it in.  Ext/sing=0     *
 *           disable it.  Changes to non-COMPACT_ATTACKS code to shrink the    *
 *           array sizes.  This was done primarily for the Opteron where the   *
 *           COMPACT_ATTACKS stuff was a bit slower than the direct look-up    *
 *           approach.  This change reduced the table sizes by 75%.  A small   *
 *           change to Evaluate() to better handle the 50-move draw problem.   *
 *           What used to happen was when the counter hit 100 (100 plies since *
 *           last capture or pawn push) the score just dumped to DrawScore()   *
 *           instantly.  It was possible that by the time the draw was seen,   *
 *           it was too late to do anything to avoid it without wrecking the   *
 *           position.  what happens now is that once the 50-move counter      *
 *           reaches 80 plies (40 moves by both sides with no pawn push or     *
 *           capture) the score starts dropping toward DrawScore() no matter   *
 *           which side is winning.  Dave Slate called this a "weariness       *
 *           factor" in that after playing 40 moves with no progress, the      *
 *           evaluation shows that the program is getting "weary".  The idea   *
 *           is that the score starts to slip over the last 10 moves by each   *
 *           side to that if either can do something to reset the counter,     *
 *           they will do it sooner rather than later.                         *
 *                                                                             *
 *   19.10   A fix to the EvaluateWinner() code to recognize that while KRB vs *
 *           KR can not normally be won by the KRB side, we require that the   *
 *           KR side not be trapped on the edge of the board, where it can be  *
 *           mated.  FUTILITY code put back in.  19.9 will be the SE version   *
 *           for those wanting to play with it.  New "learn" command option to *
 *           allow the user to set the position learning parameters that are   *
 *           used to trigger position learning and disable position learning   *
 *           after the game is already lost.  The command syntax is as follows *
 *           "learn trigger cutoff" and are expressed as fractions of a pawn   *
 *           with a decimel point.  The default is learn .33 -2.0 which says   *
 *           to do position learning when the score drops 1/3 of a pawn, but   *
 *           turn it off after the score reaches -2.00 as the game is already  *
 *           lost and learning won't help at this point.  This is the CCT-6    *
 *           version exactly as played in the CCT-6 tournament.                *
 *                                                                             *
 *   19.11   A fix to the Annotate() code that could, in certain cases, fail   *
 *           to display N moves when asked.  This happened when there were     *
 *           fewer than N moves total, and on occasion it would not display    *
 *           all the moves that were possible, omitting the last one.  Fix to  *
 *           egtb.cpp to correctly set 16 bit index mode for a few of the      *
 *           recent 6-piece tables.                                            *
 *                                                                             *
 *   19.12   Fix to allocating split blocks that did not let all blocks get    *
 *           used, which would produce slow-downs on large parallel boxes      *
 *           (cpus > 8-16).  Change to fail-high/fail-low window adjustment.   *
 *           I now use the old Cray Blitz approach ("Using time wisely -       *
 *           revisited", JICCA) where a fail-high (or low) now adjusts the     *
 *           root alpha or beta bound by 1 pawn on the first fail, another two *
 *           pawns on the second failure, and finally relaxes the bound to     *
 *           +/- infinity on the third fail for the same move.  This speeds up *
 *           searching many fail-high/fail-low conditions, although it will    *
 *           occasionally cause the search to take a bit longer.               *
 *                                                                             *
 *   19.13   Fix to evaluating split passed pawns.  Code is cleaner and is not *
 *           applied if the opposing side has any pieces at all since a piece  *
 *           and the king can stop both.  New egtb.cpp that opens the tables   *
 *           approximately 20-25% faster is included in this version (code by  *
 *           Eugene Nalimov of course).                                        *
 *                                                                             *
 *   19.14   New "eval" command (eval list and eval help to start) allow a     *
 *           user to modify all internal evaluation values via commands that   *
 *           may be entered directly or via the .craftyrc/crafty.rc init file. *
 *           This was mainly done for the automated evaluation tuning project  *
 *           I am working on with Anthony Cozzie, but it will be useful for    *
 *           merging Mike Byrne's "personality" stuff as well.  New command    *
 *           "personality load/save <filename>" which saves eval and search    *
 *           parameters to create new personalities that can be loaded at any  *
 *           time.  "Crafty.cpf" is the "default" personality file that is     *
 *           used at start-up if it exists.  Evaluation tuning changes based   *
 *           on some results from the new annealing code, although all of the  *
 *           annealed values are not yet fully understood nor utilized yet.    *
 *           LearnBook() is now used to learn good and bad game results.  IE   *
 *           if Crafty wins with a particular opening, it will remember it as  *
 *           good and try it again, in addition to the previous method that    *
 *           would remember bad openings and avoid them.  It also now handles  *
 *           draws as well which can make slightly bad openings appear better. *
 *           Minor change to SMP code to eliminate the possibility of a shared *
 *           variable getting overwritten unintentionally.  Several changes to *
 *           evaluation weights and evaluation code as testing for the WCCC    *
 *           continues.  New "help" command uses a file "crafty.hlp" which now *
 *           contains all the help information.  This makes the help info      *
 *           easier to maintain and gets rid of a bunch of printf()s in the    *
 *           Option() source (option.c).  Rewrite of the "list" code.  Crafty  *
 *           now supports six lists, AK (auto-kibitz), B (blocker), C (comp),  *
 *           GM, IM and SP (special player).  The SP list has two extra items  *
 *           that can be specified to go with a player's name, namely a book   *
 *           filename (to replace the normal books.bin, but not book.bin) and  *
 *           a personality file that will be loaded each time this particular  *
 *           named opponent plays.  The format is available in the new help    *
 *           facility.  Bug fix for outside passed pawn code that would cause  *
 *           an outside passer to appear to be a winning advantage even if the *
 *           opponent has a protected passer, which easily negates the outside *
 *           passer's threat.                                                  *
 *                                                                             *
 *   19.15   Fix to outside passed pawn code that requires pawns on both sides *
 *           of the board for the side with an "outside passer" or "outside    *
 *           candidate" to avoid some bizarre evaluations. Sel 0/0 now works   *
 *           without crashing Crafty.  This would fail in previous versions as *
 *           the hash signature would be modified but not restored.  Slightly  *
 *           more conservative limit on using null-move search to head off a   *
 *           few notable zugzwang problems was added.  Fix to time control     *
 *           code to remove a hole that could cause a divide-by-zero at a time *
 *           control boundary.  Stonewall detection removed completely as it   *
 *           appears to be no longer needed.  Rook scoring changed to better   *
 *           evaluate "open files" by measuring mobility on them.  Complete    *
 *           removal of Phase() (phase.c) and references to the opening,       *
 *           middlegame and endgame phases as they were no longer referenced   *
 *           anywhere in the code.                                             *
 *                                                                             *
 *   19.16   Fix to "Trojan code" to eliminate the time limit exclusion since  *
 *           many users still have old and slow hardware, and the time limit   *
 *           was not set correctly when PreEvaluate() was called anyway.  The  *
 *           code to display fail-high/fail-low information was cleaned up so  *
 *           that the +1 or +3 now makes sense from the black side where the   *
 *           score is really going down (good for black) rather than showing   *
 *           a +3 fail high (when Crafty is black) and the score is really     *
 *           going to drop (get better for black).  Now the fail-high-fail-low *
 *           +/- sign is also relative to +=good for white like the scores     *
 *           have been for years.  Adjustments to pawn evaluation terms to     *
 *           improve the scoring balance.  "New" now terminates parallel       *
 *           threads (they will be re-started when needed) so that we don't    *
 *           burn CPU time when not actually playing a game.                   *
 *                                                                             *
 *   19.17   Changes to pawn evaluation to limit positional scores that could  *
 *           get a bit out of sane boundaries in some positions.               *
 *                                                                             *
 *   19.18   ProbeTransRef() no longer adjusts alpha/beta bounds if the entry  *
 *           is not good enough to terminate the search here.  This has helped *
 *           speed things up (reduced size of tree) over many test positions   *
 *           so either it was buggy or not worthwhile.  Regardless, it is now  *
 *           'gone'.  Connected passed pawns now scored as a simple pair of    *
 *           pawns that are better as they are advanced, the old connected     *
 *           passed pawns on the 6th rank special code has been removed.       *
 *                                                                             *
 *   19.19   Repeat3x() had a bug that would cause it to miss a draw claim on  *
 *           the 50th move, often making a strange (losing) move that would    *
 *           not lose if the draw is was claimed, but which would cause a loss *
 *           if the draw was not claimed because the piece might be instantly  *
 *           captured if the opponent can play a move.                         *
 *                                                                             *
 *   19.20   Bug in the EvaluateMaterial() (bad trade) code that would not     *
 *           penalize a single piece vs 3 pawns properly.  Now the penalty is  *
 *           added in unless the side with the piece has nothing else to go    *
 *           with it at all (no pawns or other pieces).  Pawn scoring changed, *
 *           doubled pawns were scored too badly because the penalties were    *
 *           added twice (as expected) but they were set as if they were just  *
 *           added once.  Eval command also had a bug in displaying the pawn   *
 *           evaluation parameters.  Move input changed to accept pawn         *
 *           promotions of the form a8Q (this is needed as ChessBase violates  *
 *           the PGN/SAN standard that mandates a8=Q as the proper syntax for  *
 *           pawn promotions.)  annoying glitch in epdglue.c that would        *
 *           produce the wrong score for positions with exactly one legal move *
 *           was fixed.  New InvalidPosition() function verifies that FEN      *
 *           setup positions are reasonable, without extra pawns or too many   *
 *           pieces total, etc.  Passed pawn to 7th search extension removed,  *
 *           mate threat extension tuned down to 1/2 ply.  Bug in SetBoard()   *
 *           fixed.  This bug made it impossible to import many epd records    *
 *           due to incorrectly handling the wtm flag.  This was introduced in *
 *           the recent changes to disallow certain types of illegal positions *
 *           that were impossible (more than 9 queens of one color, etc.) new  *
 *           eval term for space added.  This simply counts the number of      *
 *           squares on each rank attacked by pawns, and then multiplies by a  *
 *           constant that scales the attacks so that attacking ranks on the   *
 *           opponent's side of the board is more valuable than attacking      *
 *           squares on our side of the board and vice-versa.  Significant     *
 *           coding changes for the unix parallel search.  POSIX threads are   *
 *           gone, due to too many differences between vendor's implementation *
 *           details.  Crafty now uses SYSV shared memory to share the search  *
 *           data (this is exactly the same parallel search approach always    *
 *           used, but with a completely different implementation) and fork()  *
 *           to spawn processes for each CPU.  It simply became too much work  *
 *           to figure out what each vendor was doing about CPU time, how      *
 *           threads were scheduled, plus debug thread library implementations *
 *           that were often buggy.  There are no performance benefits to this *
 *           approach other than falling back to features found in all Unix    *
 *           implementations.  New NUMA changes to make sure that the local    *
 *           thread "blocks" are actually allocated on the NUMA node where     *
 *           the process actually runs, rather than on a remote node that      *
 *           will cause extra memory latency for often-used memory data.  Bug  *
 *           in EvaluatePawns() caused the outside passer / outside            *
 *           candidate bonus to be triggered when the opponent has a simple    *
 *           protected passed pawn.  Since the decoy value is nil with a       *
 *           protected passer (we can't take the supporing pawn or the passer  *
 *           will run) the outside candidate or passer doesn't help.  Bug in   *
 *           king safety caused pieces to be attracted to the opponent's king, *
 *           even in simple endgames, inflating/deflating the score for a      *
 *           feature that was pointless.  (2005 WCCC final version).           *
 *                                                                             *
 *   20.0    First in a new series.  First change is to produce an endian-     *
 *           independent opening book.  The format has not changed so that old *
 *           book.bin/books.bin files will work fine, but they may now be      *
 *           freely between big-endian and little-endian architectures.  This  *
 *           makes the binary format compatible between a PC and a Sun or HP   *
 *           box, for example, so that just one book.bin file is needed.       *
 *                                                                             *
 *   20.1    First step toward a complete redesign of the evaluation code in   *
 *           Evaluate() (evaluate.c).  This first set of changes are mainly    *
 *           restructuring related, an attempt to collect the various bits of  *
 *           evaluation code that are related to a common theme (i.e. All      *
 *           bishop scoring, all passed pawn scoring, etc) are not contained   *
 *           in one routine, with a sensible name.  This makes it much easier  *
 *           to find evaluation code and modify it, without having bits and    *
 *           pieces scattered all over the place.  Perhaps the most signifi-   *
 *           cant is that the current evaluation has dropped the asymmetric    *
 *           king safety, and later the asymmetric blocked pawn code will go   *
 *           as well.  To do this, I did have to make some changes in terms    *
 *           of the "tropism" code.  The basic idea is that white's "tropism"  *
 *           bonus in incremented for each white piece that attacks the black  *
 *           king, but it is also decrement for each black piece that attacks  *
 *           the black king, so that a defender offsets an attacker.  This has *
 *           certainly changed the "personality" of how it plays.  It is now   *
 *           far more aggressive, and further changes planned for the future   *
 *           will hopefully improve on this change.  It is playing quite a bit *
 *           better, but whether this aggressiveness is "over the top" remains *
 *           to be seen.  Fix to "won kp ending" logic.  If one king is closer *
 *           to the opponent's "average pawn square" than the other, by at     *
 *           least 2 moves, then that side is credited as having a won k+p     *
 *           ending. New code for time allocation testing added.  A new        *
 *           "timebook <factor> <moves>" command that says use "factor" extra  *
 *           time (factor is expressed as a percent, 100 means use 100% extra  *
 *           time) tapered off for "moves" out of book.  For example,          *
 *           "timebook 100 10" says use 100% extra time on first non-book move *
 *           followed by 90% extra on the next move, 80% on the next, until    *
 *           after 10 moves we are back to the normal time average.            *
 *                                                                             *
 *   20.2    Significant evaluation changes to try to limit positional scores  *
 *           so that new tuning can be accomplished.  In particular, the king  *
 *           safety code has been greatly simplified, now having two separate  *
 *           components, one for pawn structure, one for piece tropism.  A new *
 *           SearchControl() procedure now handles all the search extensions   *
 *           in one centralized place, shared by normal and parallel search    *
 *           code.  The plan is that eventually this piece of code will also   *
 *           be able to recommend search reductions as well as extensions to   *
 *           speed the tree traversal process significantly with a form of     *
 *           of forward pruning that is commonly called "search reductions".   *
 *                                                                             *
 *   20.3    Search reduction code added.  Part of this dates back to 1997     *
 *           when Bruce Moreland and I played with the idea of reducing the    *
 *           depth on the last part of the move list when it seemed to become  *
 *           fairly certain that no fail-high was going to happen.  That was a *
 *           big search speed improvement, but also risky.  Recently, several  *
 *           started to do this again, except they added one fairly useful     *
 *           constraint, that the "history value" for a specific move has to   *
 *           be below some threshold before a reduction can happen.  The idea  *
 *           is that we don't want to reduce the depth of moves that have      *
 *           failed high in the past, because they might fail high again if    *
 *           they are not reduced too much.  Tord Romstad suggested an         *
 *           additional improvement, namely that if a reduced move does fail   *
 *           high, re-search with the proper (non-reduced) depth to verify     *
 *           that it will fail high there as well.  All of this is included    *
 *           in version 20.3, but the values (reduction amount, history        *
 *           threshold, min depth to do a reduction) need serious testing and  *
 *           tuning.  The current values are simply "legal" but hardly could   *
 *           be considered optimal without substantial testing.  New code to   *
 *           "age" history counters added.  After each iteration, this code    *
 *           divides each counter by 2, to scale the values back, so that      *
 *           moves that are no longer causing fail highs will have a history   *
 *           value that won't prevent reduction pruning.  The "minimum depth"  *
 *           value indicates how much search to leave after doing a reduction  *
 *           in the tree.  A value of 1 ply guarantees that after a reduction  *
 *           is done, there will always be one full-width ply of search done   *
 *           after such reductions to avoid gross tactical oversights.  Tuning *
 *           to extensions to reduce the tree size.  The recapture extension   *
 *           has been completely removed, while the check extension has been   *
 *           left at 1.0 as in the past.  The mate threat and one-legal-reply  *
 *           extensions are now both set to .75 after extensive testing.  This *
 *           is the CCT8 version of Crafty.                                    *
 *                                                                             *
 *   20.4    History counters changed.  There is now one large history[8192]   *
 *           array to simplify indexing.  More importantly, these values are   *
 *           now limited to a max value of 32000.  During the update process,  *
 *           if any value reaches that limit, all values are divided by 2 to   *
 *           prevent deep searches from producing very large history values    *
 *           which would essentially disable late move reductions based on the *
 *           big history values.  The reduce/history=n command now uses values *
 *           0 <= n <= 100.  A value of 100 will cause all non-tactical moves  *
 *           to be reduced (most aggressive) while a value of 0 will result in *
 *           no moves being reduced (most conservative).  The value, loosely   *
 *           interpreted, means "reduce if a move fails high < n% of the time  *
 *           when at least one move fails high in a search."  the default is   *
 *           currently 50%, but further testing is needed.                     *
 *                                                                             *
 *   20.5    Old "mask" code removed and replaced by constants, since this is  *
 *           never intended to run on a Cray specifically any longer.  Change  *
 *           to "won king and pawn ending" to make it more accurate, this code *
 *           is used when there are nothing but pawns left, all on one side of *
 *           board, and one king is closer to a capturable pawn than the other *
 *           king is.  This is intended to help in outside passed pawn games   *
 *           where one side has to eventually give up the outside passer to    *
 *           decoy the opposing king away from the rest of the pawns.  New     *
 *           king safety now factors in king pawn shelter and opponent piece   *
 *           tropism into one score, but the score is now an arithmetic        *
 *           value that goes up more quickly as both indices increase, to do a *
 *           more accurate evaluation of safety and attacking chances.  Change *
 *           to bishop mobility, which now goes in units of 2 rather than 1,   *
 *           to increase the value of mobility somewhat.  Also mobility is now *
 *           'centered' in that it is computed as (squares - 6) * 2, to keep   *
 *           the bishop value from going way over its normal range with these  *
 *           new and somewhat larger numbers.                                  *
 *                                                                             *
 *   20.6    New eval code to look for bishops that are blocked in the forward *
 *           direction by friendly pawns.  That basically turns a bishop into  *
 *           a "tall pawn" since movement in the critical direction is not     *
 *           possible.                                                         *
 *                                                                             *
 *   20.7    Manually tuned kinf_safety[][] array values.  Modified the new    *
 *           bishop code to only consider the "long diagonal" if the bishop    *
 *           is in either 9-square corner on its own side of the board, so     *
 *           that the short diagonal being open won't offset the long          *
 *           diagonal that is blocked.  Bishop-pair bonus is now adjusted by   *
 *           how open or closed the center is.  If 3 of the four center pawns  *
 *           are gone, the center is open and the bishop pair bonus is set to  *
 *           the max.  If the four center pawns are locked (e4/e5/d5/d6 for    *
 *           example) then the bishop pair bonus is eliminated.  if the center *
 *           is somewhere in the middle of those extremes, then the bishop     *
 *           pair bonus is present but reduced.  Castling now is a bit more    *
 *           intelligent.  If a side has not castled, then moving either rook  *
 *           receives a penalty, where moving the king or the last unmoved     *
 *           rook receives a larger penalty.  If the king has not castled, its *
 *           'safety' score is based on the most safe position of the possible *
 *           options.  If neither rook has moved, then the score is based on   *
 *           the safest of the three locations, either in the center where it  *
 *           is, or on the safest wing.  If uncastled, this safaty is always   *
 *           reduced a bit to encourage castling before it becomes too late to *
 *           do so.  This was done to avoid a problem where the queen rook had *
 *           been moved, Crafty had not castled, and it pushed the kingside    *
 *           pawns making it unsafe to castle there, leaving the center as the *
 *           best place, yet had it not pushed the kingside pawns, castling    *
 *           would have been a better alternative.   Two new 16 word vectors,  *
 *           safety_vector[]/tropism_vectorp[] are used to set the edge values *
 *           for the king_safetyp[][] array.  Interior values are filled in    *
 *           based on these two vectors, making it much easier to tweak the    *
 *           king safety scores without pulling your hair out.                 *
 *                                                                             *
 *   20.8    When queens come off, the previous version cut the tropism scores *
 *           and pawn shelter scores by 1/2 each, which had the effect of      *
 *           dropping the overall score by 75% (the score is a geometric       *
 *           computation).  The safety/tropism values are now dropped, but by  *
 *           a smaller amount, since bishops + rooks + knights are still a     *
 *           dangerous threat.                                                 *
 *                                                                             *
 *   20.9    Simple lazy eval (Mike Byrne) added.  This simply avoids the more *
 *           expensive piece evaluations if the pawn scoring and material      *
 *           leave the score well outside the alpha/beta search window.  Looks *
 *           like a 20% speed improvement in general.                          *
 *                                                                             *
 *   20.10   Change to king safety pawn structure.  Open files around the king *
 *           are dangerous, but the h/g (or b/a) files are more dangerous than *
 *           the f-e-d-c files since they are much harder to defend against    *
 *           with the castled king in the way.  Modified the way the king      *
 *           safety matrix is computed so that at the tropism/pawnstructure    *
 *           values are more sane.  It currently will get the same value for   *
 *           array indices of 5,0, 4,1, 3,2, 2,3, 1,4, or 0,5, which is better *
 *           than what it was doing.  I plan to tweak this more later to make  *
 *           3,2 or 2,3 worse than 4,1 or 1,4 and 0,5 or 5,0, as the latter    *
 *           mean "unsafe king but no piece pressure" or "piece pressure but   *
 *           king pawn shelter is safe" whereas the middle values mean both    *
 *           components of an attack are present, unsafe king position and the *
 *           pieces are closing in.                                            *
 *                                                                             *
 *   20.11   Minor fix to late move reduction code.  Turns out it is possible  *
 *           to reach the block of code if (first_move) { } with status set to *
 *           REMAINING_MOVES (this means no captures, no killer, no hash move, *
 *           no history move, etc).  That would let me try a reduction, and if *
 *           it failed high, we would use that score as-is.  We now re-search  *
 *           a fail-high here just like we did in the other block of code so   *
 *           that a fail-high on a reduction search is never trusted.          *
 *                                                                             *
 *   20.12   Further modifications to king safety initialization code to try   *
 *           scale back the values a bit to control score limits.              *
 *                                                                             *
 *   20.13   Fix to bench.c to remove two file closes that would wreck the     *
 *           program after the bench command was finished.  Also the           *
 *           SMP-time-to-ply measurement was removed since it had no meaning.  *
 *           Old FUTILITY code re-inserted along with an extension limit       *
 *           modification by Mike Byrne to avoid limiting the search extension *
 *           on one-reply extensions only.  New lock.h submitted by Andreas    *
 *           Guettinger to support spinlocks on the PPC architecture (Linux).  *
 *           Some -D configuration options were changed so that none are       *
 *           needed to compile the "standard" Crafty.  Futility is normally on *
 *           now, and -DNOFUTILITY is required to compile it out.  The new     *
 *           Makefile gives the configuration options, but the only ones that  *
 *           would normally need setting are the SMP and CPUS= options if you  *
 *           have a SMP platform.                                              *
 *                                                                             *
 *   20.14   Fix to EvaluateWinningChances() to correctly evaluate KRP vs KR   *
 *           type endings.  Previously this was done in the wrong place and    *
 *           the score would favor the side with the pawn significantly, where *
 *           the score is now zero.  Minor bugfix to code that detects that an *
 *           illegal position has been set up.  It caught every possible       *
 *           problem except for positions with a king (or kings) missing.      *
 *                                                                             *
 *   20.15   Change to how Crafty chooses where to split.  Previously, there   *
 *           was a min remaining depth limit to prevent Crafty from trying to  *
 *           split too close to the frontier nodes.  Now that is specified as  *
 *           a percentage of the nominal search depth.  For example, the       *
 *           default value is 50%, which says that on a 16 ply search, we can  *
 *           split if at least 8 plies of search are left.  This provides      *
 *           better split overhead than a simple limit that doesn't take the   *
 *           actual search depth into consideration.  History data arranged to *
 *           be more cache friendly.  The three values for a common history    *
 *           index value are now stored in adjacent memory words to take       *
 *           advantage of pre-fetching within a cache line.  Additional        *
 *           tuning of the king safety matrix.                                 *
 *                                                                             *
 *   20.16   Evaluation of knights, bishops, rooks, queens and kings is now    *
 *           done on a 1000 point scale, then the sum is divided by 10.  This  *
 *           allows us to use the same hashing mechanism, but with finer       *
 *           tuning precision.  Minor queen eval tweak for 7th rank position.  *
 *                                                                             *
 *   20.17   New book learning, with a simplified book system.  The export     *
 *           files (book.lrn, position.lrn) no longer are created/used, the    *
 *           learn mechanism no longer touches the real chess board which      *
 *           could cause problems in certain xboard/winboard timing            *
 *           situations.  One major learning change is that we now only learn  *
 *           things from "Crafty's perspective".  That is, if Crafty loses a   *
 *           game as black, it won't think that opening is good when it plays  *
 *           white since it might well not understand how to win using that    *
 *           particular opening.  It will only "learn" on the actual moves it  *
 *           plays in a game.  Old "history heuristic" removed.  Testing       *
 *           showed that the LMR idea produced better results without the      *
 *           history ordering, since now more moves are reduced, but moves     *
 *           with good history values don't get reduced.                       *
 *                                                                             *
 *   21.0    Finally did the bit-renumbering task so that bit 0 = LSB = A1,    *
 *           to eliminate the 63-n translation to the numbering scheme used    *
 *           on the Cray architecture.  For all bit operations now, LSB=0,     *
 *           MSB=7, 15, 31 or 63 depending on the data size.  A few minor      *
 *           bugs were fixed along the way as these changes were debugged.     *
 *           Minor bug in EvaluateKings() where it tested for a "won ending"   *
 *           and used a test that was too aggressive.  This test did not get   *
 *           things quite right when the two kings were very close together    *
 *           and "opposition" prevented one king from moving closer to the     *
 *           pawns.                                                            *
 *                                                                             *
 *   21.1    New piece scoring from Tracy, which changes the way pieces are    *
 *           scored based on squares they attack.                              *
 *                                                                             *
 *   21.2    The scores are now scaled better for the transition from middle-  *
 *           game to end-game.  Passed pawn scores climb as material is        *
 *           removed from the board, to prevent them from overwhelming the     *
 *           middlegame king safety scores.  We do exactly the same scaling on *
 *           king-safety scores, but they are scaled downward as material is   *
 *           removed so that they "phase out" as the endgame is reached.       *
 *           Weak pawn code changed to more accurately identify weak pawns.    *
 *           These are totaled and then used to index a scoring array that     *
 *           penalizes the number of weak pawns on each side.  Pawn islands    *
 *           are now recognized and each side is penalized according to the    *
 *           number of islands he has, more being worse.                       *
 *                                                                             *
 *   21.3    "Magic" move generation is now used, which eliminates the rotated *
 *           bitboard approach completely.  Not a significant speed change,    *
 *           but it is far simpler overall.  Original code by Pradu Kannan as  *
 *           posted on CCC/Winboard forums, modified to work with Crafty.      *
 *                                                                             *
 *   21.4    Misc eval changes.  More king safety changes to include a tropism *
 *           distance of 1 for bishops or rooks that can slide to intercept    *
 *           any square surrounding the enemy king.  Reduced rook slide score  *
 *           by 40%.
 *                                                                             *
 *   21.5    passed pawn extension revisited.  Bad trade was giving a penalty  *
 *           for being down an exchange (or a bonus for being up an exchange)  *
 *           which was not expected behavior.  This has been fixed.  EGTB      *
 *           initialization was being done during the first pass over the      *
 *           RC file, which was too early as the rest of the engine had not    *
 *           been initialized.  Now the "egtb" command is the only thing that  *
 *           triggers initialization, and is only processed during the second  *
 *           pass over the RC file after paths have been properly set up.      *
 *           Abs() function bug fix.                                           *
 *                                                                             *
 *   21.6    Passed pawn evaluation changed with respect to distant passed     *
 *           pawns and distant majorities.  Now, if both have a pawn majority  *
 *           we check to see if one is "distant" (away from the enemy king) as *
 *           this represents a significant time advantage because the other    *
 *           side has to waste moves to reach and capture the pawn to prevent  *
 *           promotion.  LMR no longer uses the history counters, which proved *
 *           to be essentially random numbers.  LMR decisions are now based    *
 *           solely on static characteristics of an individual move, rather    *
 *           than trying to determine how the move affected the search at      *
 *           other points in the tree.  New wtm bonus added to evaluation.     *
 *           EvaluateMate() bug fixed where the score was set to a non-zero    *
 *           value which broke EvaluateMate() completely.  New mobility code   *
 *           for bishops/rooks encourages better piece placement.  Note that   *
 *           there are many other evaluation changes too numerous to list here *
 *           in detail.                                                        *
 *                                                                             *
 *   21.7    New reduce at root code added to do reductions at the root, but   *
 *           not on any move that has been a "best move" during the current    *
 *           search, unless the move drops too far in the move list.  New nice *
 *           mode for parallel search terminates threads while waiting on the  *
 *           opponent's move to avoid burning unnecessary CPU time (this nice  *
 *           mode is NOT the default mode however.) -DNOFUTILITY removed as    *
 *           futility is on by default and should not be removed.  All of the  *
 *           search() code has been cleaned up and streamlined a bit for more  *
 *           clarity when reading the code.  Nasty bug in EvaluatePawns() that *
 *           unfortunattely used the king squares to make a decision dealing   *
 *           with outside passed pawns, but the hash signature for pawns does  *
 *           not include king position.  This code was deemed unnecessary and  *
 *           was summarily removed (not summarily executed, it has had that    *
 *           done far too many times already).                                 *
 *                                                                             *
 *   22.0    Redesign of the data structures completed so that Crafty will no  *
 *           longer have duplicated code for wtm and btm cases.  This has      *
 *           already resulted in a rewrite of movgen(), SEE(), Make() and      *
 *           Unmake() and cut that code size by almost exactly 50%. The result *
 *           has been slightly faster speeds, but also the future benefits     *
 *           will be enormous by eliminating a lot of debugging caused by the  *
 *           duplicated code.  Timing change to avoid starting an iteration    *
 *           and wasting significant time.  We still search enough to get a    *
 *           quick fail-low, otherwise we stop and make the move and save the  *
 *           time we used to burn.  Massive cleanup in the macros used to      *
 *           access much of the data since the new [wtm] approach resulted in  *
 *           many old macros becoming unused.  Yet another rewrite of the code *
 *           that handles repetition detection.  There is an undetected bug in *
 *           the previous code, related to pondering and SMP, that was not     *
 *           obvious.  The code was completely rewritten and is now much       *
 *           simpler to understand, and has been verified to be bug-free with  *
 *           massive cluster testing.                                          *
 *                                                                             *
 *   22.1    Minor fix for CPUS=1, which would cause compile errors.  Other    *
 *           eval tweaks to improve scoring.  New "skill" command that can be  *
 *           used to "dumb down" Crafty.  "Skill <n>" where n is a number      *
 *           between 1 and 100.  100 is max (default) skill.  Skill 70 will    *
 *           drop the playing Elo by about 200 points.  Skill 50 will drop it  *
 *           about 400 points.  The curve is not linear, and the closer you    *
 *           get to 1, the lower the rating.  To use this feature, you need to *
 *           add -DSKILL to your Makefile options otherwise it is not included *
 *           in the executable.                                                *
 *                                                                             *
 *   22.2    We are now back to using POSIX threads, since all current Linux   *
 *           distributions now use the posix-conforming NTPL implementation    *
 *           which should eliminate the various compatibility issues that      *
 *           caused problems in the past.  This also should make the new       *
 *           smpnice mode work correctly for Linux and Windows since they will *
 *           now both use threads for the SMP search.  Fruit-like scoring      *
 *           (interpolation between mg and eg scores) fully implemented.  AEL  *
 *           pruning (Heinz 2000) also fully implemented (we had razoring and  *
 *           futility, but not extended futility).  "Eval" command has been    *
 *           removed and combined with the "personality" command so that eval  *
 *           parameters can be modified, in addition to some search parameters *
 *           that also belong in the personality data.  Mate threat extension  *
 *           and one legal reply to check extensions have been removed.  Tests *
 *           proved them to be absolutely useless, over 30,000 games for each  *
 *           test showed no gain and sometimes a loss in playing strength with *
 *           them so we followed the "simple is better" and removed them.  The *
 *           fractional ply code was also removed since the only extension we  *
 *           now use is the "give check" extension which is a whole ply.  A    *
 *           significant number of evaluation parameters have been changed,    *
 *           a few even removed as cluster testing helped us find optimal      *
 *           values.  There are a few new terms, with more planned.            *
 *                                                                             *
 *   22.3    Corrected a bug in analysis mode where "back n" would crash.  A   *
 *           bad array reference broke this during recent changes.             *
 *                                                                             *
 *   22.4    Corrected a bug in NextRootMove() that tries to calculate the NPS *
 *           by adding up the node counters in each used split block.  However *
 *           should you not use all possible threads (mt=n where n is < the    *
 *           max CPUS value compiled in) then all split blocks will not be     *
 *           properly initialized (not even allocated) which will cause a      *
 *           segfault instantly.  Pawn island evaluation term has also been    *
 *           removed as cluster testing showed that setting these values to    *
 *           zero produced a +14 Elo gain.  There might be a better value for  *
 *           them, but the old value was too high.  Further cluster testing is *
 *           underway to test other (but smaller than original) values to see  *
 *           if one of them turns out to be better than zero.  So far, no, but *
 *           the test has not completed.                                       *
 *                                                                             *
 *   22.5    Minor eval tweaks.  Pthread_create was called without giving it   *
 *           any attributes for the new thread(s) which makes them default to  *
 *           "joinable".  When smpnice=1 terminates threads, the threads hang  *
 *           around using memory expecting that the parent will join with them *
 *           to check the exit status.  We now set "detached" as the proper    *
 *           attribute so that this memory leak no longer happens.             *
 *                                                                             *
 *   22.6    Compile issue fixed which would cause the pthread_lib calls to    *
 *           be used in a windows compile, which was incorrect.  They are now  *
 *           protected by a #if defined(UNIX) && (CPUS > 1) conditional test.  *
 *                                                                             *
 *   22.7    Windows NUMA support fix to eliminate a memory leak caused by     *
 *           re-malloc'ing the split blocks each time a new game is started.   *
 *           This was not found in the previous memory leak testing as that    *
 *           problem was related to stopping/re-starting threads when using    *
 *           smpnice=1.  This is unrelated, but similar, and has been around   *
 *           a long time.                                                      *
 *                                                                             *
 *   22.8    Modified material imbalance fix from Tracy included.  This        *
 *           produced an immediate +7 Elo improvement, and additional tuning   *
 *           is under way.  Fix to GenerateChecks().  This code had bugs a few *
 *           weeks back and they were fixed, but the fixes were somehow lost   *
 *           during copying files among multiple machines.  The fixes are now  *
 *           back in and properly saved.                                       *
 *                                                                             *
 *   22.9    More eval tuning producing another +10 Elo gain.  Curmv[n] was    *
 *           "overloaded" in that it was used to obtain the next move for a    *
 *           parallel thread and was also used to pass back a "fail high" move *
 *           to store in a "LOWER" hash table entry.  This led to some error   *
 *           messages internal to Crafty that could possibly cause problems.   *
 *           There is now a second variable "cutmove" used to pass the move    *
 *           back to eliminate race conditions.  Hash.c modified extensively   *
 *           to improve readability as well as to eliminate duplicated code.   *
 *           Internal iterative deepening code removed.  No measurable benefit *
 *           in real game testing led to removal since it is simpler without   *
 *           the code.  EvaluateMaterialDynamic() also removed.  This was code *
 *           that implemented ideas suggested by IM Larry Kaufman, but careful *
 *           testing showed absolutely no effect on game results.  Again, we   *
 *           chose "simpler is better" and removed it, as no tuning attempts   *
 *           helped for this code.  Nasty pawn hashing bug fix, something that *
 *           has been around for years.  This was essentially the same sort of *
 *           bug that the "lockless hashing algorithm" addressed for the main  *
 *           hash table, where out-of-order memory writes could produce a hash *
 *           signature and the 64 bit word with score and best move which did  *
 *           not "go together".  The same thing happens in pawn hashing,       *
 *           except that an entry is 32 bytes rather than 16, giving even      *
 *           higher probability of an entry that contains mismatched pieces.   *
 *           In the best case, we just got a bad score.  In the worst case,    *
 *           this could cause a program crash since some of the data might be  *
 *           invalid, yet it can be used in ways that produce impossible array *
 *           subscripts that would cause (very rarely) a segmentation fault.   *
 *           The solution was to do the same lockless hashing algorithm where  *
 *           the key is XORed with the other three 64 bit words when the entry *
 *           is stored, then XORed with them again when we try to match.  If   *
 *           the entry is mismatched, the signature will not match anything    *
 *           and we simply will not use the bad data and do a normal pawn      *
 *           evaluation to compute valid values.                               *
 *                                                                             *
 *    23.0   Essentially a cleaned up 22.9 version.  Comments have been        *
 *           reviewed to make sure they are consistent with what is actually   *
 *           done in the program.  Major change is that the random numbers     *
 *           used to produce the Zobrist hash signature are now statically     *
 *           initialized which eliminates a source of compatibility issues     *
 *           where a different stream of random numbers is produced if an      *
 *           architecture has some feature that changes the generator, such    *
 *           as a case on an older 30/36 bit word machine.  The issue with     *
 *           this change is that the old binary books are not compatible and   *
 *           need to be re-created with the current random numbers.  The       *
 *           "lockless hash table" idea is back in.  It was removed because    *
 *           the move from the hash table is recognized as illegal when this   *
 *           is appropriate, and no longer causes crashes.  However, the above *
 *           pawn hash issue showed that this happens enough that it is better *
 *           to avoid any error at all, including the score, for safety.  We   *
 *           made a significant change to the parallel search split logic in   *
 *           this version.  We now use a different test to limit how near the  *
 *           tips we split.  This test measures how large the sub-tree is for  *
 *           the first move at any possible split point, and requires that     *
 *           this be at least some minimum number of nodes before a split can  *
 *           be considered at this node.  The older approach, which based this *
 *           decsion on remaining search depth at a node led to some cases     *
 *           where the parallel search overhead was excessively high, or even  *
 *           excessively low (when we chose to not split frequently enough).   *
 *           This version appears to work well on a variety of platforms, even *
 *           though NUMA architectures may well need additional tuning of this *
 *           paramenter (smpsn) as well as (smpgroup) to try to contain most   *
 *           splits on a single NUMA node where memory is local.  I attempted  *
 *           to automate this entire process, and tune for all sorts of plat-  *
 *           forms, but nothing worked for the general case, which leaves the  *
 *           current approach.  When I converted back to threads from          *
 *           processes, I forgot to restore the alignment for the hash/pawn-   *
 *           hash tables.  The normal hash table needs to be on a 16 byte      *
 *           boundary, which normally happens automatically, but pawn hash     *
 *           entries should be on a 32 byte boundary to align them properly in *
 *           cache to avoid splitting an entry across two cache blocks and     *
 *           hurting performance.  New rook/bishop cache introduced to limit   *
 *           overhead caused by mobility calculations.  If the ranks/files the *
 *           rook is on are the same as the last time we evaluated a rook on   *
 *           this specific square, we can reuse the mobility score with no     *
 *           calculation required.  The code for "rook behind passed pawns"    *
 *           was moved to EvaluatePassedPawns() so that it is only done when   *
 *           there is a passed pawn on the board, not just when rooks are      *
 *           present.  Book learning has been greatly cleaned up and           *
 *           simplified.  The old "result learning" (which used the game       *
 *           result to modify the book) and "book learning" (which used the    *
 *           first N search scores to modify the book) were redundant, since   *
 *           result learning would overwrite whatever book learning did.  The  *
 *           new approach uses the game result (if available) to update the    *
 *           book database when the program exits or starts a new game.  If    *
 *           a result is not available, it will then rely on the previous      *
 *           search results so that it has some idea of whether this was a     *
 *           good opening or not, even if the game was not completed.  Minor   *
 *           LMR bug in SearchRoot() could do a PVS fail-high research using   *
 *           the wrong depth (off by -1) because of the LMR reduction that had *
 *           been set.  The normal search module had this correct, but the     *
 *           SearchRoot() module did not.  EvaluateDevelopment() was turned    *
 *           off for a side after castling.  This caused a problem in that we  *
 *           do things like checking for a knight blocking the C-pawn in queen *
 *           pawn openings.  Unfortunately, the program could either block the *
 *           pawn and then castle, which removed the blocked pawn penalty, or  *
 *           it could castle first and then block the pawn, making it more     *
 *           difficult to develop the queen-side.  We now enable this code     *
 *           always and never disable it.  This disable was done years ago     *
 *           when the castling evaluation of Crafty would scan the move list   *
 *           to see if Crafty had castled, when it noticed castling was no     *
 *           longer possible.  Once it had castled, we disabled this to avoid  *
 *           the lengthy loop and the overhead it caused.  Today the test is   *
 *           quite cheap anyway, and I measured no speed difference with it on *
 *           or off, to speak of.  Now we realize that the knight in front of  *
 *           the C-pawn is bad and needs to either not go there, or else move  *
 *           out of the way.                                                   *
 *                                                                             *
 *    23.1   Xboard protocol support slightly modified so that draw results    *
 *           are now sent after the move that causes the draw.  They were      *
 *           always sent before a move if the position prior to the move was   *
 *           drawn, but they were also sent just before playing a move to work *
 *           around a xboard protocol race condition where I can send a move,  *
 *           and then a draw claim (xboard 'result string') and the GUI sees   *
 *           my move, relays it to my opponent, and gets an instant reply that *
 *           it then sees before my draw claim.  After making this move and    *
 *           forwarding it to me, it now thinks the draw claim is invalid.     *
 *           slight tweak to queen material value and the way our bishop pair  *
 *           scoring is done.  The old razoring code has been removed.  It is  *
 *           redundant with LMR, and it had the unwanted side-effect of        *
 *           reducing a few of the moves two plies.  The futility pruning has  *
 *           been modified to work at the last N plies.  We have an array of   *
 *           pruning margins (tuned on the cluster) where anytime the depth is *
 *           less than "pruning_depth" we try the futility test.  If the test  *
 *           succeeds, that move is discarded and not searched at all.  Move   *
 *           ordering code modified slightly to call SEE() fewer times if the  *
 *           goodness of the capture can still be accurately assessed without  *
 *           the call.  Hash table has been changed to use a bucket of 4       *
 *           entries similar to a 4-way set associative cache.  When a store   *
 *           is attempted, we replace the least useful entry (see hash.c for   *
 *           details).  Additionally the hash table is forced to a 64 byte     *
 *           boundary alignment so that a bucket aligns on the start of a      *
 *           cache line for efficiency.  The old approach used 3 entries per   *
 *           bucket, the Belle two-table approach, which caused 1/2 of the     *
 *           cache probes to result in two cache line reads rather than just   *
 *           one.  Slight modification to "time overflow" logic.  Now, if the  *
 *           score drops on the iteration where we reach the normal time       *
 *           allocation, Crafty will continue to search.  Previously the score *
 *           had to drop by 1/4 pawn, but cluster testing has shown that this  *
 *           change is better.  Final bit of old rotated bitboard logic        *
 *           removed.  We had two bitboards, RooksQueens and BishopsQueens     *
 *           that were updated in MakeMove() and UnmakeMove().  It turned out  *
 *           to be faster to just OR the needed piece bitboards together since *
 *           they were infrequently used in the new "magic" approach, which    *
 *           allowed me to remove them completely from the position structure  *
 *           and make/unmake.  Net result was a percent or two faster search   *
 *           overall.  Old bug fixed related to EGTB usage.  The Edwards       *
 *           format did not include en passant pawn captures, so it was        *
 *           necessary to avoid probing any position where both sides had a    *
 *           pawn and there was any possibility of an en passant capture (one  *
 *           pawn on original square, enemy pawn anywhere on either adjacent   *
 *           file).  The Nalimov tables consider en passant correctly, but     *
 *           somehow this old code was either left in iterate.c or else added  *
 *           back in by accident.  It is now no longer present.  Minor changes *
 *           (suggested by J. Cleveland on CCC) that avoids trying a null-move *
 *           search when remaining depth == 1, and which saves some effort by  *
 *           remembering, when a node fails low, the first move searched.      *
 *           This move then gets stored in the hash table as the "best move".  *
 *           While this might be wrong, it has a chance of being right and     *
 *           when it is good enough to cause a cutoff, we can avoid a move     *
 *           generation which saves a bit of time.  Fixed a significant bug in *
 *           EvaluateWinningChances() where it was using a global variable     *
 *           "wtm" which tells who is to move in the real game, not at the     *
 *           current position in the treee.  This value  is used for tempo     *
 *           calculations to determine if the losing king (in a K + rook-pawn  *
 *           ending (with or without wrong bishop)) can reach the queening     *
 *           square before the winning side's king can block acccess.  This    *
 *           would randomly make the tempo calculation off by one, so that the *
 *           score could bounce from draw to win and back as the game          *
 *           progresses, since about 1/2 the time the wtm  value is wrong.  I  *
 *           simply passed the current wtm in as a formal parameter to solve   *
 *           this (a good example of why having a global variable and a formal *
 *           argument paramenter using the same name is a bad idea.)  In this  *
 *           same general area, EvaluateDraws() could set the score to         *
 *           DrawScore, which was somewhat "iffy".  I changed this to simply   *
 *           determine if the side that ahead is score has any realistic       *
 *           winning chances.  If not, I divide the score by 10 rather than    *
 *           setting it to the absolute drawscore.  This has the same effect,  *
 *           but does let the evaluation guide the search to better moves when *
 *           it is convinced all of them lead to draws.  This version is about *
 *           +100 Elo stronger than 23.0 based on cluster testing results.     *
 *                                                                             *
 *    23.2   Two changes related to draw handling.  First, the 50-move draw    *
 *           rule is tricky.  It is possible that the move on the 100th ply    *
 *           after the last non-reversible move might not be a draw, even if   *
 *           it is reversible itself, because it might deliver mate.  In this  *
 *           specific case, the mate will end the game as a win.  This has     *
 *           been fixed in Crafty to match this specific rule exception.  Also *
 *           draws by "insufficient material" have been changed to match the   *
 *           FIDE rules which say that mate can't be possible, even with worst *
 *           possible play by the opponent.  Crafty would claim a draw in a    *
 *           simple KN vs KN position, which is incorrect.  Even though        *
 *           neither side can force mate, mate is possible and so the position *
 *           is not a draw by FIDE rules.  Mobility scoring changed for        *
 *           sliding pieces.  Now the mobility scores are pre-computed and     *
 *           stored in a table that is addressed by the "magic number move     *
 *           generation idea".  This completely eliminates the computational   *
 *           cost of the mobility scoring since all of the scores are pre-     *
 *           computed before the game starts.  This was a modest speed         *
 *           improvement but really made the code simpler and smaller.  Change *
 *           to lazy eval cutoff code to improve accuracy.  BookUP() had a     *
 *           minor bug that caused it to not report how many moves were not    *
 *           included because of the "maxply" limit.  This has been fixed also *
 *           so that it now reports the correct value.  New xboard "cores" and *
 *           "memory" command support added.  Code to malloc() both was also   *
 *           rewritten completely to clean it up and simplify things.  In an   *
 *           effort to avoid confusion, there is one caveat here.  If your     *
 *           .craftyrc/crafty.rc file has an option to set the number of       *
 *           threads (mt=n/smpnt=n), then the "cores" option from xboard is    *
 *           automatically disabled so that the .craftyrc option effectively   *
 *           overrides any potential cores setting.  If you set hash or hashp  *
 *           in the .craftyrc/crafty.rc file, then the "memory" option from    *
 *           xboard is automatically disabled, for the same reason.  In short, *
 *           you can let xboard set the number of threads and memory usage     *
 *           limit, or you can set them in your .craftyrc/crafty.rc file.  But *
 *           if you use the .craftyrc/crafty.rc file to set either, then the   *
 *           corresponding xboard command will be disabled.                    *
 *                                                                             *
 *    23.3   Null-move search restriction changed to allow null-move searches  *
 *           at any node where the side on move has at least one piece of any  *
 *           type.  Minor bug in ValidMove() fixed to catch "backward" pawn    *
 *           moves and flag them as illegal.  This sometimes caused an error   *
 *           when annotating games and annotating for both sides.  The killer  *
 *           move array could have "backward" moves due to flipping sides back *
 *           and forth, which would cause some odd PV displays.  Small change  *
 *           to "reduce-at-root".  We no longer reduce moves that are flagged  *
 *           as "do not search in parallel".  Check extension modified so that *
 *           if "SEE" says the check is unsafe, the extension is not done.  We *
 *           found this to be worth about +10 Elo.  We also now reduce any     *
 *           capture move that appears in the "REMAINING_MOVES" phase since    *
 *           they can only appear there if SEE returns a score indicating loss *
 *           of material.  We now reduce a bit more aggressively, reducing by` *
 *           2 plies once we have searched at least 4 moves at any ply.  I     *
 *           tried going to 3 on very late moves, but could not find any case  *
 *           where this was better, even limiting it to near the root or other *
 *           ideas.  But reducing by 2 plies after the at least 2 moves are    *
 *           searched was an improvement.  Minor change is that the first move *
 *           is never reduced.  It is possible that there is no hash move, no  *
 *           non-losing capture, and no killer move.  That drops us into the   *
 *           REMAINING_MOVES phase which could reduce the first move searched, *
 *           which was not intended.  Very minor tweak, but a tweak all the    *
 *           same.                                                             *
 *                                                                             *
 *    23.4   Bug in hash implementation fixed.  It was possible to get a hash  *
 *           hit at ply=2, and alter the ply=1 PV when it should be left with  *
 *           no change.  This could cause Crafty to display one move as best   *
 *           and play another move entirely.  Usually this move was OK, but it *
 *           could, on occasion, be an outright blunder.  This has been fixed. *
 *           The search.c code has been re-written to eliminate SearchRoot()   *
 *           entirely, which simplifies the code.  The only duplication is in  *
 *           SearchParallel() which would be messier to eliminate.  Ditto for  *
 *           quiesce.c, which now only has Quiesce() and QuiesceEvasions().    *
 *           The old QuiesceChecks() has been combined with Quiesce, again to  *
 *           eliminate duplication and simplify the code.  Stupid bug in code  *
 *           that handles time-out.  One place checked the wrong variable and  *
 *           could cause a thread to attempt to output a PV after the search   *
 *           was in the process of timing out.  That thread could back up an   *
 *           incomplete/bogus search result to the root in rare occasions,     *
 *           which would / could result in Crafty kibitzing one move but       *
 *           playing a different move.  On occasion, the move played could be  *
 *           a horrible blunder.  Minor bug caused StoreTransRef() to lose a   *
 *           best move when overwriting an old position with a null-move       *
 *           search result.  Minor change by Tracy to lazy evaluation cutoff   *
 *           to speed up evaluation somewhat.  Old "Trojan Horse" attack       *
 *           detection was removed.  At today's depths, it was no longer       *
 *           needed.  New hash idea stores the PV for an EXACT hash entry in a *
 *           separate hash table.  When an EXACT hit happens, this PV can be   *
 *           added to the incomplete PV we have so far so that we have the     *
 *           exact path that leads to the backed up score.  New "phash" (path  *
 *           hash) command to set the number of entries in this path hash      *
 *           table.  For longer searches, a larger table avoids path table     *
 *           collisions which will produce those short paths that end in <HT>. *
 *           If <HT> appears in too many PVs, phash should be increased.  The  *
 *           "Trojan Horse" code has been completely removed, which also       *
 *           resulted in the removal of the last bit of "pre-processing code"  *
 *           in preeval.c, so it has been completely removed as well.  Current *
 *           search depths are such that the Trojan Horse code is simply not   *
 *           needed any longer.  A minor bug in TimeSet() fixed where on rare  *
 *           occasions, near the end of a time control, time_limit could be    *
 *           larger than the max time allowed (absolute_time_limit).  We never *
 *           check against this limit until we exceed the nominal time limit.  *
 *           Cleanup on the draw by repetition code to greatly simplify the    *
 *           code as well as speed it up.                                      *
 *                                                                             *
 *    23.5   Several pieces of code cleanup, both for readability and speed.   *
 *           We are now using stdint.h, which lets us specific the exact size  *
 *           of an integer value which gets rid of the int vs long issues that *
 *           exist between MSVC and the rest of the world on X86_64.  We still *
 *           use things like "int" if we want to let the compiler choose the   *
 *           most efficient size, but when we need a specific number of bits,  *
 *           such as 64, we use a specific type (uint64_t for 64 bits).  Minor *
 *           change to forward pruning that does not toss out passed pawn      *
 *           moves if they are advanced enough (compared to remaining depth)   *
 *           that they might be worth searching.  Cleanup to passed pawn eval  *
 *           code to help efficiency and readability.  New options to the      *
 *           display command.  "display nothing" turns all output off except   *
 *           for the move Crafty chooses to play.  "display everything" will   *
 *           produce a veritable flood of information before it makes a move.  *
 *           Cleanup of personality code to fix some values that were not      *
 *           included, as well as clean up the formatting for simplicity.      *
 *                                                                             *
 *    23.6   Minor tweak to "adaptive hash" code + a fix to the usage warning  *
 *           that failed to explain how many parameters are required.  New way *
 *           of timing the search, replacing the old "easy move" code that was *
 *           simply too ineffective.  Now Crafty computes a "difficulty" level *
 *           after each iteration.  If the best move doesn't change, this      *
 *           level is reduced by 10% of the current value, until it reaches    *
 *           60% where it stops dropping.  If the best move changes during an  *
 *           iteration, it adjusts in one of two ways.  If the current         *
 *           difficulty level is less than 100%, it reverts to 100% + the      *
 *           number of different best moves minus 1 times 20%.  If the current *
 *           difficulty level is already >= 100% it is set to 80% of the       *
 *           current value + (again) the number of different best moves - 1    *
 *           times 20%.  Repeated changes can run this up to 180% max.  As the *
 *           search progresses this difficulty level represents the percentage *
 *           of the nominal target time limit it should use.  It still tries   *
 *           to complete the current iteration before quitting, so this limit  *
 *           is a lower bound on the time it will use.  Restored an old idea   *
 *           from earlier Crafty versions (and even Cray Blitz), that of       *
 *           trying the killers from two plies earlier in the tree, once the   *
 *           killers for the current ply have been tried.  Was a +10 Elo gain, *
 *           added to about +10 for the new time control logic.  Old fail-high *
 *           restriction removed.  At one point in time, a fail-high on the    *
 *           null-window search at the root would cause problems.  Crafty was  *
 *           modified so that the fail-high was ignored if the re-search       *
 *           failed low.  Removing this produced an 8 Elo gain.                *
 *                                                                             *
 *    23.7   Minor fix to time check code.  Was particularly broken at very    *
 *           low skill level settings, but it had a small impact everywhere.   *
 *           Some simplification with the reduction code, and how moves are    *
 *           counted as they are searched, which would not count any moves     *
 *           that were pruned, which could delay triggering reductions at a    *
 *           ply.  Fixed significant killer move bug that would only surface   *
 *           during a parallel search.  NextMove (remaining moves phase) culls *
 *           killer moves as it selects, because they have already been tried. *
 *           Unfortunately, in a parallel search, the killers could get        *
 *           modified by other threads, which could erroneously cause a move   *
 *           to be excluded that had not been searched.  I discovered this bug *
 *           on wac #266 where Crafty normally finds a mate at depth=11, but   *
 *           a parallel search would often miss the mate completely.  Minor    *
 *           fix to new "difficulty" time management.  It was possible for a   *
 *           move to look "easy" (several iterations without finding a new     *
 *           best move) but it could fail low at the beginning of the next     *
 *           iteration.  Difficulty would be reduced due to not changing the   *
 *           best move at previous iterations, so the search could time out    *
 *           quicker than expected.  Simple fix was to reset difficulty to     *
 *           100% on a fail low, which makes sense anyway if it was supposed   *
 *           to be "easy" but the score is mysteriously dropping anyway.       *
 *                                                                             *
 *    23.8   MAXPLY changed to 128, which increases the max length of the PV's *
 *           that can be displayed.  The hash path stuff works so well that it *
 *           often STILL has PVs with <HT> on the end, after 64 moves are      *
 *           displayed.  While this can still probably be reached, it should   *
 *           be much less frequent.  This does mean the search can go for 128  *
 *           iterations, rather than the old 64 limit, of course.  Bug in      *
 *           Search() that failed to update the PV on an EGTB hit, which would *
 *           cause the hashed PV to contain illegal moves.  When Crafty then   *
 *           tried to display this PV, it would promptly crash.                *
 *                                                                             *
 *    24.0   Major changes to portability/platform specific code.  Crafty now  *
 *           supports Unix and Windows platforms.  All the other spaghetti     *
 *           code has been removed, with an effort to make the code readable.  *
 *           Couple of bugs in EvaluateWinningChances() fixed, one in          *
 *           particular that makes the krp vs kr draw detection unreachable.   *
 *           strcpy() replaced with memmove() to fix problems with Apple OS X  *
 *           Mavericks where strcpy() with operands that overlap now causes an *
 *           application to abort on the spot.  Bug in Search() that caused an *
 *           inefficiency in the parallel search.  At some point the way moves *
 *           are counted within a ply was changed, which changed the split     *
 *           algorithm unintentionally.  The original intent was to search     *
 *           just one move and then allow splits.  The bug changed this to     *
 *           search TWO moves before splitting is allowed, which slowed things *
 *           down quite a bit.  thread[i] is now an array of structures so     *
 *           that the thread pointers are separated from each other to fit     *
 *           into separate cache blocks, this avoids excessive cache traffic   *
 *           since they get changed regularly and were sitting in a single     *
 *           cache block with 8 cpus on 64 bit architectures.  Bug in new      *
 *           "difficulty" time usage code would let the program run up against *
 *           "absolute_time_limit" before stopping the search, even if we      *
 *           finished an iteration using beyond the normal target.  This       *
 *           really burned a lot of unnecessary time.  I had previously fixed  *
 *           the PVS window fail high (at the root) to force such a move to be *
 *           played in the game.  One unfortunate oversight however was that   *
 *           when splitting at the root, N different processors could fail     *
 *           high on N different moves, and they were searching those in       *
 *           parallel.  I've modified this so that the PVS fail high at the    *
 *           root exits from Search() (after stopping other busy threads) and  *
 *           then returns to Iterate() which will print the fail-high notice   *
 *           and re-start the search with all threads searching just one fail  *
 *           high move to get a score quicker.  Fail-high/fail-low code clean- *
 *           up.  In particular, the "delta" value to increment beta or        *
 *           decrement alpha is now two variables, so that an early fail-low   *
 *           won't increment the delta value and then the subsequent (hope-    *
 *           fully) fail-high starts off with a bad increment and jumps beta   *
 *           too quickly.  All fail-highs at the root return to Iterate(),     *
 *           even the PVS null-window fail-highs.  This re-starts the search   *
 *           with all processors working on that one move to get it resolved   *
 *           much quicker.  Other minor fixes such as when failing low on the  *
 *           first move, we pop out of search and go back to Iterate() to      *
 *           lower alpha and start a new search.  Unfortunately, after the     *
 *           first move is searched, a parallel split at the root would occur, *
 *           only to be instantly aborted so that we could back out of Search()*
 *           and then re-start.  Wasted the split time unnecessarily although  *
 *           it was not a huge amount of time.  Another simplification to the  *
 *           repetition-detection code while chasing a parallel search bug     *
 *           was missing repetitions.                                          *
 *                                                                             *
 *    24.1   LMR reductions changed to allow a more dynamic reduction amount   *
 *           rather than just 1 or 2.  An array LMR_reductions[depth][moves]   *
 *           is initialized at start-up and sets the reduction amount for a    *
 *           specific depth remaining (larger reduction with more depth left)  *
 *           and the total moves searched at this node (again a larger         *
 *           reduction as more moves are searched.)  This can easily be        *
 *           changed with the new "lmr" command (help lmr for details).  The   *
 *           old "noise" stuff has been changed.  Now, rather than noise       *
 *           specifying the number of nodes that have to be searched before    *
 *           any output is displayed (PV, fail high, etc) it now specifies a   *
 *           time that must pass before the first output is produced.  This    *
 *           can still be displayed with noise=0, otherwise noise=n says no    *
 *           output until n seconds have passed (n can be a fraction of a      *
 *           second if wanted.)  I restored the old adaptive null-move code,   *
 *           but changed the reduction (used to be 2 to 3 depending on the     *
 *           depth remaining) so that it is 3 + depth / 6.  For each 6 plies   *
 *           of remaining depth, we reduce by another ply, with no real bound  *
 *           other than the max depth we can reasonably reach.  The "6" in     *
 *           the above can be changed with the personality command or the new  *
 *           null m n command.  When the changes to noise were made, Iterate() *
 *           was also changed so that if the search terminates for any reason  *
 *           and no PV was displayed, whether because the noise limit was not  *
 *           satisfied or this search did not produce a PV because it started  *
 *           at an excessively deep search depth, Crafty now always displays   *
 *           at least one PV in the log file to show how the game is going to  *
 *           continue.  One case where this was an issue was where Crafty did  *
 *           a LONG ponder search because the opponent took an excessive       *
 *           amount of time to make a move.  If it finishes (say) a 30 ply     *
 *           search while pondering, when the opponent moves, Crafty will move *
 *           instantly, but when it starts the next search, we start pondering *
 *           at iteration 29, which might take a long time to finish.  But we  *
 *           do still have the PV from the last search (the 30 ply one) and    *
 *           main() thoughtfully removed the first two moves (the move played  *
 *           and the move we are now pondering, so we always have something to *
 *           display, and now we no longer terminate a search with no output   *
 *           (PV, time, etc) at all.  Generation II of the parallel split code *
 *           (see Thread() in the thread.c source file comments for specifics) *
 *           that is a lighter-weight split/copy plus the individual threads   *
 *           do most of the copying rather than the thread that initiates the  *
 *           split.  More work on the skill command.  For each 10 units the    *
 *           skill level is reduced, the search speed is reduced by 50%.       *
 *           Additionally the null-move and LMR reduction values are also      *
 *           ramped down so that by the time skill drops below 10, there are   *
 *           no reductions left.                                               *
 *                                                                             *
 *    24.2   Bug in SetTime() fixed.  The absolute time limit was set way too  *
 *           large in sudden death games (games with no secondary time control *
 *           to add time on the clock) with an increment.  It was intended to  *
 *           allow the search to use up to 5x the normal target time, unless   *
 *           that was larger than 1/2 of the total time remaining, but some-   *
 *           where along the way that 5x was removed and it always set the     *
 *           absolute time limit to 1/2 the remaining clock, which would burn  *
 *           clock time way too quickly.  Complete re-factor of Search() to    *
 *           take the main loop and move that to a new procedure               *
 *           SearchMoveList() to eliminate the duplicated search code between  *
 *           Search() and SearchParallel() which has been replaced by          *
 *           SearchMoveList().  New addition to NextMove().  It was cleaned up *
 *           to eliminate the old NextEvasion() code since one was a sub-set   *
 *           of the other.  A minor change to limit the NPS impact on history  *
 *           ordering.  We do not do history ordering within 6 plies of a      *
 *           terminal node, and we only try to order 1/2 of the moves before   *
 *           giving up and assuming this is an ALL node where ordering does    *
 *           not matter.                                                       *
 *                                                                             *
 *    25.0   Complete re-factor of pawn evaluation code.  There were too many  *
 *           overlapping terms that made tuning difficult.  Now a pawn is      *
 *           classified as one specific class, there is no overlap between     *
 *           classes, which simplifies the code significantly.  The code is    *
 *           now easier to understand and modify.  In addition, the passed     *
 *           pawn evaluation was rewritten and consolidates all the passed     *
 *           pawn evaluation in one place.  The evaluation used to add a bonus *
 *           for rooks behind passed pawns in rook scoring, blockading some-   *
 *           where else, etc.  All of this was moved to the passed pawn code   *
 *           to make it easier to understand and modify.  A limited version of *
 *           late move pruning (LMP) is used in the last two plies.  Once a    *
 *           set number of moves have been searched with no fail high, non-    *
 *           interesting moves are simply skipped in a way similar to futility *
 *           pruning.  This version also contains a major rewrite of the       *
 *           parallel search code, now referred to as Generation II.  It has a *
 *           more lightweight split algorithm, that costs the parent MUCH less *
 *           effort to split the search.  The key is that now the individual   *
 *           "helper" threads do all the work, allocating a split block,       *
 *           copying the data from the parent, etc., rather than the parent    *
 *           doing it all.  Gen II based on the DTS "late-join" idea so that a *
 *           thread will try to join existing split points before it goes to   *
 *           the idle wait loop waiting for some other thread to split with    *
 *           it.  In fact, this is now the basis for the new split method      *
 *           where the parent simply creates a split point by allocating a     *
 *           split block for itself, and then continuing the search, after the *
 *           parent split block is marked as "joinable".  Now any idle threads *
 *           just "jump in" without the parent doing anything else, which      *
 *           means that currently idle threads will "join" this split block if *
 *           they are in the "wait-for-work" spin loop, and threads that be-   *
 *           come idle also join in exactly the same way.  This is MUCH more   *
 *           efficient, and also significantly reduces the number of split     *
 *           blocks needed during the search.  We also now pre-split the       *
 *           search when we are reasonably close to the root of the tree,      *
 *           which is called a "gratuitous split.  This leaves joinable split  *
 *           points laying around so that whenever a thread becomes idle, it   *
 *           can join in at these pre-existing split points immediately.  We   *
 *           now use a much more conservative approach when dealing with fail  *
 *           highs at the root.  Since LMR and such have introduced greater    *
 *           levels of search instability, we no longer trust a fail-high at   *
 *           the root if it fails low on the re-search.  We maintain the last  *
 *           score returned for every root move, along with the PV.  Either an *
 *           exact score or the bound score that was returned.  At the end of  *
 *           the iteration, we sort the root move list using the backed-up     *
 *           score as the sort key, and we play the move with the best score.  *
 *           This solves a particularly ugly issue where we get a score for    *
 *           the first move, then another move fails high, but then fails low  *
 *           and the re-search produces a score that is actually WORSE than    *
 *           the original best move.  We still see that, but we always play    *
 *           the best move now.  One other efficiency trick is that when the   *
 *           above happens, the search would tend to be less efficient since   *
 *           the best score for that fail-high/fail-low move is actually worse *
 *           than the best move/score found so far.  If this happens, the      *
 *           score is restored to the original best move score (in Search())   *
 *           so that we continue searching with a good lower bound, not having *
 *           to deal with moves that would fail high with this worse value,    *
 *           but not with the original best move's value.  Minor change to     *
 *           history counters that now rely on a "saturating counter" idea.  I *
 *           wanted to avoid the aging idea, and it seemed to not be so clear  *
 *           that preferring history moves by the depth at which they were     *
 *           good was the way to go.  I returned to a history counter idea I   *
 *           tested around 2005 but discarded, namely using a saturating       *
 *           counter.  The idea is that a center value (at present 1024)       *
 *           represents a zero score.  Decrementing it makes it worse,         *
 *           incrementing it makes it better.  But to make it saturate at      *
 *           either end, I only reduce the counter by a fraction of its        *
 *           distance from the saturation point so that once it gets to either *
 *           extreme value, it will not be modified further avoiding wrap-     *
 *           around.  This basic idea was originally reported by Mark Winands  *
 *           in 2005.  It seems to provide better results (slightly) on very   *
 *           deep searches.  One impetus for this was an intent to fold this   *
 *           into a move so that I could sort the moves rather than doing the  *
 *           selection approach I currently use.  However, this had a bad      *
 *           effect on testing, since history information is dynamic and is    *
 *           constantly changing, between two moves at the same ply in fact.   *
 *           The sort fixed the history counters to the value at the start of  *
 *           that ply.  This was discarded after testing, but the history      *
 *           counter based on the saturating counter idea seemed to be OK and  *
 *           was left in even though it produced minimal Elo gain during       *
 *           testing.  Change to the way moves are counted, to add a little    *
 *           more consistency to LMR.  Now Next*() returns an order number     *
 *           that starts with 1 and monotonically increases, this order number *
 *           is used for LMR and such decisions that vary things based on how  *
 *           far down the move list something occurs.  Root move counting was  *
 *           particularly problematic with parallel searching, now things are  *
 *           at least "more consistent".  The only negative impact is that now *
 *           the move counter gets incremented even for illegal moves, but     *
 *           testing showed this was a no-change change with one thread, and   *
 *           the consistency with multiple threads made it useful.  New method *
 *           to automatically tune SMP parameters.  The command is autotune    *
 *           and "help autotune" will explain how to run it.  Added the        *
 *           "counter-move" heuristic for move ordering (Jos Uiterwijk, JICCA) *
 *           which simply remembers a fail high move and the move at the       *
 *           previous ply.  If the hash, captures or killer moves don't result *
 *           in a fail high, this move is tried next.  No significant cost,    *
 *           seems to reduce tree size noticeably.  Added a follow-up idea     *
 *           based on the same idea, except we pair a move that fails high     *
 *           with the move two plies back, introducing a sort of "connection"  *
 *           between them.  This is a sort of "plan" idea where the first move *
 *           of the pair enables the second move to fail high.  The benefit is *
 *           that this introduces yet another pair of good moves that get      *
 *           ordered before history moves, and is therefore not subject to     *
 *           reduction.  I have been unable to come up with a reference for    *
 *           this idea, but I believe I first saw it somewhere around the time *
 *           Fruit showed up, I am thinking perhaps in the JICCA/JICGA.  Any   *
 *           reference would be appreciated.  Minor change to the way the PV   *
 *           and fail-hi/fail-low moves are displayed when pondering.  Crafty  *
 *           now adds the ponder move to the front of the PV enclosed in ( )   *
 *           so that it is always visible in console mode.  The depths are     *
 *           reaching such extreme numbers the ponder move scrolls off the top *
 *           of the screen when running in console mode or when "tail -f" is   *
 *           used to watch the log file while a game is in progress.  This is  *
 *           a bit trickier than you might think since Crafty displays the     *
 *           game move numbers in the PV.  Penalty for pawns on same color as  *
 *           bishop now only applies when there is one bishop.                 *
 *                                                                             *
 *    25.0.1 Cleanup of NextMove() plus a minor ordering bug fix that would    *
 *           skip counter moves at ply = 2. Added NUMA code to force the hash  *
 *           tables to be spread across the numa nodes as equally as possible  *
 *           rather than all of the data sitting on just onenode.  This makes  *
 *           one specific user policy important.  BEFORE you set the hash size *
 *           for any of the four hash tables, you should ALWAYS set the max    *
 *           threads limit first, so that the NUMA trick works correctly.  Of  *
 *           course, if you do not use -DAFFINITY this is all irrelevant.  The *
 *           -DNUMA option has been removed.  I no longer use any libnuma      *
 *           routines.  A new "smpnuma" command is now used to enable/disable  *
 *           NUMA mode (which really only affects how the hash tables are      *
 *           cleared, all the other NUMA code works just fine no matter        *
 *           whether this is enabled or disabled.  Fixed a bug with the xboard *
 *           memory command that could overflow and cause preposterous malloc  *
 *           requests.                                                         *
 *                                                                             *
 *******************************************************************************
 */
int main(int argc, char **argv) {
  TREE *tree;
  FILE *personality;
  int move, readstat, value = 0, i, v, result, draw_type;
  char announce[128];

#if defined(UNIX)
  char path[1024];
  struct passwd *pwd;
#else
  char crafty_rc_file_spec[FILENAME_MAX];
#endif
/* Collect environmental variables */
  char *directory_spec = getenv("CRAFTY_BOOK_PATH");

  if (directory_spec)
    strncpy(book_path, directory_spec, sizeof book_path);
  directory_spec = getenv("CRAFTY_LOG_PATH");
  if (directory_spec)
    strncpy(log_path, directory_spec, sizeof log_path);
  directory_spec = getenv("CRAFTY_TB_PATH");
  if (directory_spec)
    strncpy(tb_path, directory_spec, sizeof tb_path);
  directory_spec = getenv("CRAFTY_RC_PATH");
  if (directory_spec)
    strncpy(rc_path, directory_spec, sizeof rc_path);
  if (getenv("CRAFTY_XBOARD")) {
    Print(-1, "feature done=0\n");
    xboard_done = 0;
  } else if (argc > 1 && !strcmp(argv[1], "xboard")) {
    Print(-1, "feature done=0\n");
    xboard_done = 0;
  }
/*
 ************************************************************
 *                                                          *
 *  First, parse the command-line options and pick off the  *
 *  ones that need to be handled before any initialization  *
 *  is attempted (mainly path commands at present.)         *
 *                                                          *
 ************************************************************
 */
  AlignedMalloc((void *) ((void *) &tree), 2048, (size_t) sizeof(TREE));
  block[0] = tree;
  memset((void *) block[0], 0, sizeof(TREE));
  tree->ply = 1;
  input_stream = stdin;
  for (i = 0; i < 512; i++)
    args[i] = (char *) malloc(256);
  if (argc > 1) {
    for (i = 1; i < argc; i++) {
      if (strstr(argv[i], "path") || strstr(argv[i], "log") ||
          strstr(argv[1], "affinity")) {
        strcpy(buffer, argv[i]);
        result = Option(tree);
        if (result == 0)
          Print(2048, "ERROR \"%s\" is unknown command-line option\n",
              buffer);
        display = tree->position;
      }
    }
  }
/*
 ************************************************************
 *                                                          *
 *  Now, read the crafty.rc/.craftyrc initialization file   *
 *  and process the commands that need to be handled prior  *
 *  to initializing things (path commands).                 *
 *                                                          *
 ************************************************************
 */
#if defined(UNIX)
  input_stream = fopen(".craftyrc", "r");
  if (!input_stream)
    if ((pwd = getpwuid(getuid()))) {
      sprintf(path, "%s/.craftyrc", pwd->pw_dir);
      input_stream = fopen(path, "r");
    }
  if (input_stream)
#else
  sprintf(crafty_rc_file_spec, "%s/crafty.rc", rc_path);
  if ((input_stream = fopen(crafty_rc_file_spec, "r")))
#endif
    while (1) {
      readstat = Read(1, buffer);
      if (readstat < 0)
        break;
      if (!strstr(buffer, "path"))
        continue;
      result = Option(tree);
      if (result == 0)
        Print(2048, "ERROR \"%s\" is unknown rc-file option\n", buffer);
      if (input_stream == stdin)
        break;
    }
/*
 ************************************************************
 *                                                          *
 *   Initialize all data arrays and chess board.            *
 *                                                          *
 ************************************************************
 */
  Initialize();
/*
 ************************************************************
 *                                                          *
 *  Now, parse the command-line options and pick off the    *
 *  ones that need to be handled after initialization is    *
 *  completed.                                              *
 *                                                          *
 ************************************************************
 */
  if (argc > 1) {
    for (i = 1; i < argc; i++)
      if (strcmp(argv[i], "c"))
        if (!strstr(argv[i], "path")) {
          if (strlen(argv[i]) > 255)
            Print(-1, "ERROR ignoring token %s, 255 character max\n",
                argv[i]);
          else {
            strcpy(buffer, argv[i]);
            Print(32, "(info) command line option \"%s\"\n", buffer);
            result = Option(tree);
            if (result == 0)
              Print(2048, "ERROR \"%s\" is unknown command-line option\n",
                  buffer);
          }
        }
  }
  display = tree->position;
  initialized = 1;
  move_actually_played = 0;
/*
 ************************************************************
 *                                                          *
 *  Next, read the crafty.rc/.craftyrc initialization file  *
 *  and process the commands that need to be handled after  *
 *  engine initialization has been completed.               *
 *                                                          *
 ************************************************************
 */
#if defined(UNIX)
  input_stream = fopen(".craftyrc", "r");
  if (!input_stream)
    if ((pwd = getpwuid(getuid()))) {
      sprintf(path, "%s/.craftyrc", pwd->pw_dir);
      input_stream = fopen(path, "r");
    }
  if (input_stream)
#else
  sprintf(crafty_rc_file_spec, "%s/crafty.rc", rc_path);
  if ((input_stream = fopen(crafty_rc_file_spec, "r")))
#endif
    while (1) {
      readstat = Read(1, buffer);
      if (readstat < 0)
        break;
      if (strstr(buffer, "path"))
        continue;
      result = Option(tree);
      if (result == 0)
        Print(2048, "ERROR \"%s\" is unknown rc-file option\n", buffer);
      if (input_stream == stdin)
        break;
    }
  input_stream = stdin;
#if defined(UNIX)
  if (xboard)
    signal(SIGINT, SIG_IGN);
#endif
  Print(32, "\nCrafty v%s (%d cpus)\n\n", version, Max(smp_max_threads, 1));
  NewGame(1);
/*
 ************************************************************
 *                                                          *
 *  Check to see if we can find a "crafty.cpf" personality  *
 *  file which contains the default personality settings to *
 *  be used unless overridden by the user.                  *
 *                                                          *
 ************************************************************
 */
  if ((personality = fopen("crafty.cpf", "r"))) {
    fclose(personality);
    Print(-1, "using default personality file \"crafty.cpf\"\n");
    sprintf(buffer, "personality load crafty.cpf");
    Option(tree);
  }
/*
 ************************************************************
 *                                                          *
 *  This is the "main loop" that never ends unless the user *
 *  tells Crafty to "quit".  We read commands/moves,        *
 *  execute them, and when a move is entered we change      *
 *  sides and execute a search to find a reply.  We repeat  *
 *  this until the game ends or the opponent gets tired and *
 *  tells us to terminate the engine.                       *
 *                                                          *
 *  Prompt user and read input string for processing.  As   *
 *  long as Option() returns a non-zero value, continue     *
 *  reading lines and calling Option().  When Option()      *
 *  fails to recogize a command, then try InputMove() to    *
 *  determine if this is a legal move.                      *
 *                                                          *
 *  While we are waiting on a move, we call Ponder() which  *
 *  will find a move that it assumes the opponent will      *
 *  make, and then it will call Iterate() to find a reply   *
 *  for that move while we are waiting to see what is       *
 *  actually played in the game.  Ponder() will return one  *
 *  of the following "results" (stored in "presult"):       *
 *                                                          *
 *  (0) This indicates that Ponder() did not run, either    *
 *      because pondering is disabled, or we are not in a   *
 *      state where pondering is allowed, such as using the *
 *      xboard "force" command to set up a game that will   *
 *      be continued.                                       *
 *                                                          *
 *  (1) This indicates that we pondered a move, the         *
 *      opponent actually played this move, and we were     *
 *      able to complete a normal search for the proper     *
 *      amount of time and have a move ready to use.        *
 *                                                          *
 *  (2) This indicates that we pondered a move, but that    *
 *      for some reason, we did not need to continue until  *
 *      time ran out.  For example, we found a forced mate  *
 *      and further searching is not needed.  The search is *
 *      not "in progress" but we still have a valid move    *
 *      to play here.                                       *
 *                                                          *
 *  (3) We pondered, but the opponent either played a       *
 *      different move, or else entered a command that      *
 *      forces us to unwind the search so that the command  *
 *      can be executed.  In this case, we will re-start    *
 *      pondering, otherwise we make the correct move and   *
 *      then start a normal search.                         *
 *                                                          *
 ************************************************************
 */
/*
 ************************************************************
 *                                                          *
 *  From this point forward, we are in a state where it is  *
 *                                                          *
 *             O P P O N E N T ' S turn to move.            *
 *                                                          *
 ************************************************************
 */
  while (1) {
    presult = 0;
    do {
      if (new_game)
        NewGame(0);
      opponent_start_time = ReadClock();
      input_status = 0;
      display = tree->position;
      move = 0;
      presult = 0;
      if (xboard_done == 0 && xboard) {
        xboard_done = 1;
        Print(-1, "feature done=1\n");
      }
      do {
        if (presult != 2)
          presult = 0;
        result = 0;
        if (pong) {
          Print(-1, "pong %d\n", pong);
          pong = 0;
        }
        display = tree->position;
        if (presult != 2 && (move_number != 1 || !game_wtm))
          presult = Ponder(game_wtm);
        if (presult == 1)
          value = last_root_value;
        else if (presult == 2)
          value = ponder_value;
        if (presult == 0 || presult == 2) {
          if (!xboard) {
            printf("%s(%d): ", SideToMove(game_wtm), move_number);
            fflush(stdout);
          }
          readstat = Read(1, buffer);
          if (log_file)
            fprintf(log_file, "%s(%d): %s\n", SideToMove(game_wtm),
                move_number, buffer);
          if (readstat < 0 && input_stream == stdin) {
            strcpy(buffer, "end");
            Option(tree);
          }
        }
        if (presult == 1)
          break;
        opponent_end_time = ReadClock();
        result = Option(tree);
        if (result == 0) {
          nargs = ReadParse(buffer, args, " \t;");
          move = InputMove(tree, 0, game_wtm, 0, 0, args[0]);
          result = !move;
          if (move)
            last_pv.path[1] = 0;
        } else {
          input_status = 0;
          if (result == 3)
            presult = 0;
        }
      } while (result > 0);
      if (presult == 1)
        move = ponder_move;
/*
 ************************************************************
 *                                                          *
 *  We have a move.  Make the move (returned by InputMove)  *
 *  and then change the side on move (wtm).                 *
 *                                                          *
 ************************************************************
 */
      if (result == 0) {
        fseek(history_file, ((move_number - 1) * 2 + 1 - game_wtm) * 10,
            SEEK_SET);
        fprintf(history_file, "%9s\n", OutputMove(tree, 0, game_wtm, move));
        MakeMoveRoot(tree, game_wtm, move);
        tree->curmv[0] = move;
        time_used_opponent = opponent_end_time - opponent_start_time;
        if (!force)
          Print(1, "              time used: %s\n",
              DisplayTime(time_used_opponent));
        TimeAdjust(game_wtm, time_used_opponent);
        game_wtm = Flip(game_wtm);
        if (game_wtm)
          move_number++;
        move_actually_played = 1;
        last_opponent_move = move;
/*
 ************************************************************
 *                                                          *
 *  From this point forward, we are in a state where it is  *
 *                                                          *
 *              C R A F T Y ' S turn to move.               *
 *                                                          *
 ************************************************************
 */
/*
 ************************************************************
 *                                                          *
 *  We have made the indicated move, before we do a search  *
 *  we need to determine if the present position is a draw  *
 *  by rule.  If so, Crafty allowed it to happen and must   *
 *  be satisfied with a draw, so we will claim it and end   *
 *  the current game.                                       *
 *                                                          *
 ************************************************************
 */
        if ((draw_type = Repeat3x(tree)) == 1) {
          Print(1, "I claim a draw by 3-fold repetition.\n");
          value = DrawScore(game_wtm);
          if (xboard)
            Print(-1, "1/2-1/2 {Drawn by 3-fold repetition}\n");
        }
        if (draw_type == 2) {
          Print(1, "I claim a draw by the 50 move rule.\n");
          value = DrawScore(game_wtm);
          if (xboard)
            Print(-1, "1/2-1/2 {Drawn by 50-move rule}\n");
        }
        if (Drawn(tree, last_search_value) == 2) {
          Print(1, "I claim a draw due to insufficient material.\n");
          if (xboard)
            Print(-1, "1/2-1/2 {Insufficient material}\n");
        }
      } else {
        tree->status[1] = tree->status[0];
        presult = 0;
      }
#if defined(DEBUG)
      ValidatePosition(tree, 0, move, "Main(1)");
#endif
    } while (force);
/*
 ************************************************************
 *                                                          *
 *  Now call Iterate() to compute a move for the current    *
 *  position.  (Note this is not done if Ponder() has al-   *
 *  ready computed a move.)                                 *
 *                                                          *
 ************************************************************
 */
    crafty_is_white = game_wtm;
    if (presult == 2) {
      if (From(ponder_move) == From(move) && To(ponder_move) == To(move)
          && Piece(ponder_move) == Piece(move)
          && Captured(ponder_move) == Captured(move)
          && Promote(ponder_move) == Promote(move)) {
        presult = 1;
        if (!book_move)
          predicted++;
      } else
        presult = 0;
    }
    ponder_move = 0;
    thinking = 1;
    if (presult != 1) {
      strcpy(kibitz_text, "n/a");
      last_pv.pathd = 0;
      last_pv.pathl = 0;
      display = tree->position;
      value = Iterate(game_wtm, think, 0);
    }
/*
 ************************************************************
 *                                                          *
 *  We've now completed a search and need to handle a       *
 *  pending draw offer based on what the search found.      *
 *                                                          *
 *  When we get a draw offer, we make a note, but we do not *
 *  accept it until after we have a chance to see what      *
 *  happens after making the opponent's move that came with *
 *  the draw offer.  If he played a blunder, we are not     *
 *  going to mistakenly accept a draw when we are now       *
 *  winning.  We make this decision to accept or decline    *
 *  since we have completed as search and now have a real   *
 *  score.                                                  *
 *                                                          *
 ************************************************************
 */
    if (draw_offer_pending) {
      int drawsc = abs_draw_score;

      draw_offer_pending = 0;
      if (move_number < 40 || !accept_draws)
        drawsc = -300;
      if (value <= drawsc && (tc_increment != 0 ||
              tc_time_remaining[Flip(game_wtm)] >= 1000)) {
        if (xboard)
          Print(-1, "offer draw\n");
        else {
          Print(1, "Draw accepted.\n");
          if (audible_alarm)
            printf("%c", audible_alarm);
          if (speech) {
            strcpy(announce, "./speak ");
            strcat(announce, "Drawaccept");
            v = system(announce);
            if (v != 0)
              perror("main() system() error: ");
          }
        }
        Print(-1, "1/2-1/2 {Draw agreed}\n");
        strcpy(pgn_result, "1/2-1/2");
      } else {
        if (!xboard) {
          Print(1, "Draw declined.\n");
          if (speech) {
            strcpy(announce, "./speak ");
            strcat(announce, "Drawdecline");
            v = system(announce);
            if (v != 0)
              perror("main() system() error: ");
          }
        }
      }
    }
/*
 ************************************************************
 *                                                          *
 *  If the last_pv.path is null, then we were either        *
 *  checkmated or stalemated.  We need to determine which   *
 *  and end the game appropriately.                         *
 *                                                          *
 *  If we do have a PV, we will also check to see if it     *
 *  leads to mate and make the proper announcement if so.   *
 *                                                          *
 ************************************************************
 */
    last_pv = tree->pv[0];
    last_value = value;
    if (MateScore(last_value))
      last_mate_score = last_value;
    thinking = 0;
    if (!last_pv.pathl) {
      if (value == -MATE + 1) {
        over = 1;
        if (game_wtm) {
          Print(-1, "0-1 {Black mates}\n");
          strcpy(pgn_result, "0-1");
        } else {
          Print(-1, "1-0 {White mates}\n");
          strcpy(pgn_result, "1-0");
        }
        if (speech) {
          strcpy(announce, "./speak ");
          strcat(announce, "Checkmate");
          v = system(announce);
          if (v != 0)
            perror("main() system() error: ");
        }
      } else {
        over = 1;
        if (!xboard) {
          Print(1, "stalemate\n");
          if (speech) {
            strcpy(announce, "./speak ");
            strcat(announce, "Stalemate");
            v = system(announce);
            if (v != 0)
              perror("main() system() error: ");
          }
        } else
          Print(-1, "1/2-1/2 {stalemate}\n");
      }
    } else {
      if (value > 32000 && value < MATE - 2) {
        Print(1, "\nmate in %d moves.\n\n", (MATE - value) / 2);
        Kibitz(1, game_wtm, 0, 0, (MATE - value) / 2, tree->nodes_searched, 0,
            0, " ");
      } else if (-value > 32000 && -value < MATE - 1) {
        Print(1, "\nmated in %d moves.\n\n", (MATE + value) / 2);
        Kibitz(1, game_wtm, 0, 0, -(MATE + value) / 2, tree->nodes_searched,
            0, 0, " ");
      }
/*
 ************************************************************
 *                                                          *
 *  See if we want to offer a draw based on the recent      *
 *  scores that have been returned.  See resign.c for more  *
 *  details, but this is where we offer a draw, or resign,  *
 *  if appropriate.  This has nothing to do with claiming a *
 *  draw by rule, which is done later.                      *
 *                                                          *
 ************************************************************
 */
      tree->status[MAXPLY] = tree->status[0];
      ResignOrDraw(tree, value);
/*
 ************************************************************
 *                                                          *
 *  Now output the move chosen by the search, and the       *
 *  "result" string if this move checkmates our opponent.   *
 *                                                          *
 ************************************************************
 */
      if (speech) {
        char *moveptr = OutputMove(tree, 0, game_wtm, last_pv.path[1]);

        strcpy(announce, "./speak ");
        strcat(announce, moveptr);
        strcat(announce, " &");
        v = system(announce);
        if (v != 0)
          perror("main() system() error: ");
      }
      if (!xboard && audible_alarm)
        printf("%c", audible_alarm);
      Print(1, "%s(%d): %s\n", SideToMove(game_wtm), move_number,
          OutputMove(tree, 0, game_wtm, last_pv.path[1]));
      if (xboard)
        printf("move %s\n", OutputMove(tree, 0, game_wtm, last_pv.path[1]));
      fflush(stdout);
      if (value == MATE - 2) {
        if (game_wtm) {
          Print(-1, "1-0 {White mates}\n");
          strcpy(pgn_result, "1-0");
        } else {
          Print(-1, "0-1 {Black mates}\n");
          strcpy(pgn_result, "0-1");
        }
      }
      time_used = program_end_time - program_start_time;
      Print(1, "              time used: %s\n", DisplayTime(time_used));
      TimeAdjust(game_wtm, time_used);
      fseek(history_file, ((move_number - 1) * 2 + 1 - game_wtm) * 10,
          SEEK_SET);
      fprintf(history_file, "%9s\n", OutputMove(tree, 0, game_wtm,
              last_pv.path[1]));
      last_search_value = value;
      if (kibitz) {
        if (kibitz_depth)
          Kibitz(2, game_wtm, kibitz_depth, end_time - start_time, value,
              tree->nodes_searched, busy_percent, tree->egtb_hits,
              kibitz_text);
        else
          Kibitz(4, game_wtm, 0, 0, 0, 0, 0, 0, kibitz_text);
      }
      MakeMoveRoot(tree, game_wtm, last_pv.path[1]);
      tree->curmv[0] = move;
/*
 ************************************************************
 *                                                          *
 *  From this point forward, we are in a state where it is  *
 *                                                          *
 *          O P P O N E N T ' S turn to move.               *
 *                                                          *
 *  We have made the indicated move, we need to determine   *
 *  if the present position is a draw by rule.  If so, we   *
 *  need to send the appropriate game result to xboard      *
 *  and/or inform the operator/opponent.                    *
 *                                                          *
 ************************************************************
 */
      game_wtm = Flip(game_wtm);
      if (game_wtm)
        move_number++;
      move_actually_played = 1;
      if ((draw_type = Repeat3x(tree)) == 1) {
        Print(1, "I claim a draw by 3-fold repetition after my move.\n");
        if (xboard)
          Print(-1, "1/2-1/2 {Drawn by 3-fold repetition}\n");
        value = DrawScore(game_wtm);
      }
      if (draw_type == 2 && last_search_value < 32000) {
        Print(1, "I claim a draw by the 50 move rule after my move.\n");
        if (xboard)
          Print(-1, "1/2-1/2 {Drawn by 50-move rule}\n");
        value = DrawScore(game_wtm);
      }
      if (Drawn(tree, last_search_value) == 2) {
        Print(1,
            "I claim a draw due to insufficient material after my move.\n");
        if (xboard)
          Print(-1, "1/2-1/2 {Insufficient material}\n");
      }
#if !defined(TEST)
      if (time_limit > 300)
#endif
        if (log_file)
          DisplayChessBoard(log_file, tree->position);
/*
 ************************************************************
 *                                                          *
 *  Save the ponder_move from the current principal         *
 *  variation, then shift it left two moves to use as the   *
 *  starting point for the next search.  Adjust the depth   *
 *  to start the next search at the right iteration.        *
 *                                                          *
 ************************************************************
 */
      if (last_pv.pathl > 2 && VerifyMove(tree, 0, game_wtm, last_pv.path[2])) {
        ponder_move = last_pv.path[2];
        for (i = 1; i < (int) last_pv.pathl - 2; i++)
          last_pv.path[i] = last_pv.path[i + 2];
        last_pv.pathl = (last_pv.pathl > 2) ? last_pv.pathl - 2 : 0;
        last_pv.pathd -= 2;
        if (last_pv.pathd > last_pv.pathl)
          last_pv.pathd = last_pv.pathl;
        if (last_pv.pathl == 0)
          last_pv.pathd = 0;
        tree->pv[0] = last_pv;
      } else {
        last_pv.pathd = 0;
        last_pv.pathl = 0;
        ponder_move = 0;
        tree->pv[0] = last_pv;
      }
    }
#if defined(TEST)
    strcpy(buffer, "score");
    Option(tree);
#endif
    if ((i = GameOver(game_wtm))) {
      if (i == 1)
        Print(-1, "1/2-1/2 {stalemate}\n");
    }
    if (book_move) {
      moves_out_of_book = 0;
      predicted++;
      if (ponder_move)
        sprintf(book_hint, "%s", OutputMove(tree, 0, game_wtm, ponder_move));
    } else
      moves_out_of_book++;
#if defined(DEBUG)
    ValidatePosition(tree, 0, last_pv.path[1], "Main(2)");
#endif
/*
 ************************************************************
 *                                                          *
 *  Now execute LearnValue() to record the scores for the   *
 *  first N searches out of book.  see learn.c for details  *
 *  on how this is used and when.                           *
 *                                                          *
 ************************************************************
 */
    if (learning && moves_out_of_book && !learn_value)
      LearnValue(last_value, last_pv.pathd + 2);
    if (learn_positions_count < 63) {
      learn_seekto[learn_positions_count] = book_learn_seekto;
      learn_key[learn_positions_count] = book_learn_key;
      learn_nmoves[learn_positions_count++] = book_learn_nmoves;
    }
    if (mode == tournament_mode) {
      strcpy(buffer, "clock");
      Option(tree);
      Print(32, "if clocks are wrong, use 'settc' command to adjust them\n");
    }
  }
}