Stockfish 1.3 rc1

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
Do not razor after a null move
2026-05-20 14:27:45 +00:00 · 2009-04-30 09:18:20 +02:00 · 2009-04-30 08:55:38 +02:00 · 2009-04-29 16:01:57 +02:00 · 2009-04-28 09:00:09 +02:00 · 2009-04-28 08:47:26 +02:00
61 changed files with 8290 additions and 8287 deletions
@@ -1,21 +1,14 @@
 1. Introduction
 ---------------

-Glaurung is a free UCI chess engine.  It is not a complete chess
-program, but requires some UCI compatible GUI (like XBoard with
-PolyGlot, eboard, José, Arena, Sigma Chess, Shredder, Chess Partner,
-or Fritz) in order to be used comfortably.  Read the documentation for
-your GUI of choice for information about how to use Glaurung with your
-GUI.
+Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is
+not a complete chess program, but requires some UCI compatible GUI
+(like XBoard with PolyGlot, eboard, Jos�, Arena, Sigma Chess, Shredder,
+Chess Partner, or Fritz) in order to be used comfortably.  Read the
+documentation for your GUI of choice for information about how to use
+Stockfish with your GUI.

-Glaurung 2 is a completely rewritten version of Glaurung.  Apart from
-the parallel search code, almost no code is shared with Glaurung
-1.2.1, the previous stable version.  The new program is clearly
-stronger than the old, but has a less attractive style of play,
-because there are still a few major holes in its evaluation function
-(most notably space and development).
-
-This version of Glaurung supports up to 8 CPUs, but has not been
+This version of Stockfish supports up to 8 CPUs, but has not been
 tested thoroughly with more than 2.  The program tries to detect the
 number of CPUs on your computer and set the number of search threads
 accordingly, but please be aware that the detection is not always
@@ -27,7 +20,7 @@ cores on your computer.
 2. Files
 --------

-This distribution of Glaurung consists of the following files:
+This distribution of Stockfish consists of the following files:

  * Readme.txt, the file you are currently reading.

@@ -35,284 +28,63 @@ This distribution of Glaurung consists of the following files:
    License.

  * src/, a subdirectory containing the full source code, including a
-    Makefile that can be used to compile Glaurung on Unix-like
-    systems.  For further information about how to compile Glaurung
+    Makefile that can be used to compile Stockfish on Unix-like
+    systems.  For further information about how to compile Stockfish
    yourself, read section 4 below.

-  * MacOSX/, a subdirectory containing excutables for Apple Macintosh
-    computers running Mac OS X 10.4 (Tiger) and newer.  There are two
-    executables, one for OS X 10.4, and one for OS X 10.5.  The
-    executable for OS X 10.4 will work in 10.5 as well, but the one
-    for 10.5 is faster.
-
-  * LinuxX86/, a subdirectory containing 32-bit and 64-bit x86 GNU/Linux
-    executables.
-
-  * Windows/, a subdirectory containing 32-bit and 64-bit Windows
-    executables.
-
-  * polyglot.ini, for using Glaurung with Fabien Letouzey's PolyGlot
+  * polyglot.ini, for using Stockfish with Fabien Letouzey's PolyGlot
    adapter.


 3. Opening books
 ----------------

-This version of Glaurung has experimental support for PolyGlot opening
-books.  For information about how to create such books, consult the
+This version of Stockfish has experimental support for PolyGlot opening
+books. For information about how to create such books, consult the
 PolyGlot documentation.  The book file can be selected by setting the
 UCI parameter "Book File".

-A book file contributed by Salvo Spitaleri can be found on the
-Glaurung web page.


 4. Compiling it yourself
 ------------------------

 On Unix-like systems, it should usually be possible to compile
-Glaurung directly from the source code with the included Makefile.
+Stockfish directly from the source code with the included Makefile.
 The exception is computer with big-endian CPUs, like PowerPC
-Macintoshes.  Some of the bitboard routines in the current version of
-Glaurung are endianness-sensitive, and won't work on a big-endian CPU.
+Macintoshes. Some of the bitboard routines in the current version of
+Stockfish are endianness-sensitive, and won't work on a big-endian CPU.
 Ensuring that the line with #define USE_32BIT_ATTACKS" near the top
 of bitboard.h is commented out should solve this problem.
 Commenting out the line with "#define USE_32BIT_ATTACKS" near the

-There is also a problem with compiling Glaurung on certain 64-bit 
-systems, regardless of the endianness.  If Glaurung segfaults 
-immediately after startup, try to comment out the line with 
+There is also a problem with compiling Stockfish on certain 64-bit
+systems, regardless of the endianness.  If Stockfish segfaults
+immediately after startup, try to comment out the line with
 "#define USE_FOLDED_BITSCAN" near the beginning of bitboard.h and
 recompile.

-Finally, even if Glaurung does work without any changes on your
+Finally, even if Stockfish does work without any changes on your
 computer, it might be possible to improve the performance by changing
 some of the #define directives in bitboard.h.  The default settings
 are optimized for 64-bit CPUs.  On 32-bit CPUs, it is probably better
 to switch on USE_32BIT_ATTACKS, and to use BITCOUNT_SWAR_32 instead of
 BITCOUNT_SWAR_64.  For computers with very little memory (like
 handheld devices), it is possible to conserve memory by defining
-USE_COMPACT_ROOK_ATTACKS. 
-
-
-
-5. History
----------
-
-2007-05-06: Glaurung 2 - epsilon
--------------------------------
-
-The first public release, and the first version of my new program
-which is able to match the old Glaurung 1.2.1 on a single CPU.  Lots
-of features and chess knowledge is still missing.
-
-2007-05-10: Glaurung 2 - epsilon/2
----------------------------------
-
-This version is very close to 2 - epsilon.  The major changes are:
-
-  * A number of compatibility problems which appeared when trying to
-    compile Glaurung 2 - epsilon on various operating systems and CPUs
-    have been solved.
-
-  * Fixed a major bug in the detection of rooks trapped inside a
-    friendly king.
-
-  * Added knowledge about several types of drawn endgames.
-
-  * Fixed a few FRC related bugs.  FRC now works, but because of
-    serious holes in the evaluation function the program plays very
-    badly.
-
-  * A slightly more sophisticated king safety evaluation.
-
-2007-06-07: Glaurung 2 - epsilon/3
----------------------------------
-
-The first public version with support for multiple CPUs.  Unless you
-have a dual-core (or better) computer, use Glaurung with a PolyGlot
-book, or runs games with ponder on, you may want to skip this version,
-which is almost certainly no stronger than 2 - epsilon/2 when running
-on a single CPU.  The main changes compared to the previous version
-are:
-
-  * Parallel search, with support for 1-4 CPUs.  The program currently
-    always allocates a separate pawn hash table and material hash
-    table for four threads, which is a pure waste of RAM if your
-    computer has just a single CPU.  This will be fixed in a future
-    version.
-
-  * Fixed a bug in book randomization.  When using Polyglot books, the
-    previous version would always select exactly the same move in the
-    same position after a restart of the program.  Thanks to Pavel
-    Háse for pointing this out.
-
-  * Fixed a UCI pondering bug: Glaurung no longer instantly prints its
-    best move when the maximum depth is reached during a ponder
-    search, as the previous version did.  According to the UCI
-    protocol, it is not allowed to print the best move before the
-    engine has received the "stop" or "quit" command.
-
-  * Additional search information:  The new version displays hash
-    saturation and the current line(s) of search.
-
-  * Several minor bug fixes and optimizations in the search and
-    evaluation. 
-
-2007-06-08: Glaurung 2 - epsilon/4
----------------------------------
-
-A bugfix release, with only a single important change:
-
-   * Fixed a very serious pondering bug.  As pointed out by Marc
-     Lacrosse, the previous version would lose on time in almost every
-     single game with pondering enabled.  The new version handles
-     pondering correctly (or so I hope).  When playing with ponder
-     off, the new version is identical to version 2 - epsilon/3.
-
-2007-06-25: Glaurung 2 - epsilon/5
----------------------------------
-
-Another minor update, including the following improvements and bug
-fixes:
-
-   * As Werner Schüle discovered, the previous version would sometimes
-     stop thinking and lose on time right before delivering checkmate
-     (which is of course a very unfortunate moment to lose on time).
-     I haven't been able to reproduce Werner's problem on my computer
-     (probably because I run a different OS), but I have fixed the bug
-     which I suspect caused the time losses.  I hope the time losses
-     will no longer occur with 2 - epsilon/5.
-
-   * The program is now slightly less resource-hungry on computers
-     with less than 4 CPU cores: The previous version would always
-     allocated separate pawn and material hash tables for four
-     threads, even when running on a single-core CPU.  The new version
-     only allocates pawn and material hash tables for the threads
-     which are actually used.
-
-   * A minor reorganization of the memory layout has made the parallel
-     search about 10% more efficient (at least on my computer, but the
-     results are likely to vary considerably on different systems).
-
-   * The Intel Mac OS X binary is much faster than before, thanks to
-     the Intel C++ compiler (previous versions were compiled with
-     GCC).
-
-   * A few other very minor bug fixes and enhancements.
-
-2007-11-21: Glaurung 2.0
------------------------
-
-The first stable (or so I hope) and feature-complete version of
-Glaurung 2.  The following are the main changes compared to the
-previous version:
-
-   * The license has been changed from GPL version 2 to GPL version 3.
-
-   * MultiPV mode.
-
-   * Support for the "searchmoves" option in the UCI "go" command.
-     This means that it is possible to ask Glaurung to exclude some
-     moves from its analysis, or to restrict its analysis to just a
-     handful of moves selected by the user.  This feature must also be
-     supported by the GUI under which Glaurung is run.  Glaurung's own
-     GUI does currently not support this feature.
-
-   * Chess960 support now works.  The program still plays this game 
-     very badly, because of lack of opening knowledge.
-
-   * Much more aggressive pruning in the last few plies of the main
-     search.
-
-   * Somewhat better scaling on multi-CPU systems, and support for up
-     to 8 CPUs.
-
-   * Lots of new UCI parameters.
-
-   * Improved time managment, especially in games with pondering on 
-     (i.e. when the engine is allowed to think when it's the
-     opponent's turn to move).
-
-   * Some evaluation improvements, and some new basic endgame
-     patterns.
-
-   * The program should no longer crash if the game lasts longer than
-     1000 plies.
- 
-   * Many minor bug fixes and other tiny improvements throughout the
-     code.  
- 
-   * More generously commented code, and numerous cosmetic changes in
-     coding style.
-
-2007-11-22: Glaurung 2.0.1
--------------------------
-
-   * Fixed (or so I hope) a bug which would occasionally cause one of
-     the search threads to get stuck forever in its idle loop.
-
-2008-05-14: Glaurung 2.1
------------------------
-
-This version contains far too many changes to list them all, but most
-of them are minor and cosmetic.  The most important and noticable
-changes are a lot of new UCI parameters, and many improvements in the
-evaluation function.  The highlights are:
-
-   * Extensive changes in the evaluation function.  The addition of
-     king safety is the most important improvement, but there are also
-     numerous little improvements elsewhere in the evaluation.  There
-     is still much work left to do in the evaluation function, though.
-     Space and development are still missing, and the tuning is likely
-     to be very poor.  Currently, the program is optimized for an
-     entertaining style rather than maximum strength.
-
-   * More accurate forward pruning.  The previous version used the
-     null move refutation move to improve the pruning accuracy by
-     means of a very simple trick: It did not allow pruning of any
-     moves with the piece captured by the null move refutation move.
-     In Glaurung 2.1, this has been enhanced: It does not allow
-     pruning of moves which defend the destination square of the null
-     move refutation move, nor of moves which block the ray of the
-     piece in the case that the moving piece in the null move
-     refutation move is a slider.
-
-   * More conservative use of LMR at PV nodes.  The previous version
-     searched the first 6 moves with full depth, 2.1 by default
-     searches the first 14 moves with full depth (but there is a new
-     UCI parameter for configuring this).  I am not at all sure
-     whether this is an improvement.  More thorough testing is
-     required. 
-
-   * Feedback from the evaluation to the search.  The search passes an
-     object of type 'EvalInfo' to the eval, and the eval fills this
-     struct with various potentially useful information (like the sets
-     of squares attacked by each piece type, the middle game and
-     endgame components of the eval, etc.).  At the moment, almost
-     none of this information is actually used by the search.  The
-     only exception is that the evaluation function is now used to
-     adjust the futility pruning margin in the quiescence search.
-
-   * Less extensions.  This hurts the programs performance a lot in most
-     test suites, but I hope it improves the branching factor in deep
-     searches.
-
-   * A very long list of new UCI parameters, especially for tuning the
-     evaluation. 
+USE_COMPACT_ROOK_ATTACKS.


 6. Terms of use
 ---------------

-Glaurung is free, and distributed under the GNU General Public License
+Stockfish is free, and distributed under the GNU General Public License
 (GPL).  Essentially, this means that you are free to do almost exactly
 what you want with the program, including distributing it among your
 friends, making it available for download from your web site, selling
 it (either by itself or as part of some bigger software package), or
 using it as the starting point for a software project of your own.

-The only real limitation is that whenever you distribute Glaurung in
+The only real limitation is that whenever you distribute Stockfish in
 some way, you must always include the full source code, or a pointer
 to where the source code can be found.  If you make any changes to the
 source code, these changes must also be made available under the GPL.
@@ -324,5 +96,4 @@ Copying.txt.
 7. Feedback
 -----------

-The author's e-mail address is tord@glaurungchess.com
-
+The author's e-mail address is mcostalba@gmail.com
@@ -1,14 +1,15 @@
-# Glaurung, a UCI chess playing engine.
+# Stockfish, a UCI chess playing engine derived from Glaurung 2.1
 # Copyright (C) 2004-2007 Tord Romstad
+# Copyright (C) 2008 Marco Costalba

-# This file is part of Glaurung.
+# This file is part of Stockfish.
 #
-# Glaurung is free software: you can redistribute it and/or modify
+# Stockfish is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
-# Glaurung is distributed in the hope that it will be useful,
+# Stockfish is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
@@ -21,11 +22,11 @@
 ### Files
 ###

-EXE = glaurung
+EXE = stockfish

-OBJS = bitboard.o color.o pawns.o material.o endgame.o evaluate.o main.o \
+OBJS = bitboard.o pawns.o material.o endgame.o evaluate.o main.o \
 	misc.o move.o movegen.o history.o movepick.o search.o piece.o \
-	position.o square.o direction.o tt.o value.o uci.o ucioption.o \
+	position.o direction.o tt.o value.o uci.o ucioption.o \
 	mersenne.o book.o bitbase.o san.o benchmark.o


@@ -35,17 +36,17 @@ OBJS = bitboard.o color.o pawns.o material.o endgame.o evaluate.o main.o \

 all: $(EXE) .depend

-clean: 
-	$(RM) *.o .depend glaurung
+clean:
+	$(RM) *.o .depend stockfish


 ###
 ### Compiler:
 ###

-CXX = g++
+# CXX = g++
 # CXX = g++-4.2
-# CXX = icpc
+CXX = icpc


 ###
@@ -78,7 +79,11 @@ CXXFLAGS += -Wall -g
 # General optimization flags.  Note that -O2 might be faster than -O3 on some
 # systems; this requires testing.

-CXXFLAGS += -O3 -fno-exceptions -fomit-frame-pointer -fno-rtti -fstrict-aliasing
+CXXFLAGS += -O3 -fno-exceptions -fomit-frame-pointer -fno-rtti -fno-strict-aliasing
+
+# Disable most annoying warnings for the Intel C++ compiler
+
+CXXFLAGS += -wd383,869,981


 # Compiler optimization flags for the Intel C++ compiler in Mac OS X:
@@ -88,16 +93,16 @@ CXXFLAGS += -O3 -fno-exceptions -fomit-frame-pointer -fno-rtti -fstrict-aliasing

 # Profiler guided optimization with the Intel C++ compiler.  To use it, first
 # create the directory ./profdata if it does not already exist, and delete its
-# contents if it does exist.  Then compile with -prof_gen, and run the 
-# resulting binary for a while (for instance, do ./glaurung bench 128 1, and
-# wait 15 minutes for the benchmark to complete).  Then do a 'make clean', and 
+# contents if it does exist.  Then compile with -prof_gen, and run the
+# resulting binary for a while (for instance, do ./stockfish bench 128 1, and
+# wait 15 minutes for the benchmark to complete).  Then do a 'make clean', and
 # recompile with -prof_use.

-# CXXFLAGS += -prof_gen -prof_dir ./profdata
+# CXXFLAGS += -prof_gen -prof_dir profdata
 # CXXFLAGS += -prof_use -prof_dir ./profdata


-# Profiler guided optimization with GCC.  I've never been able to make this 
+# Profiler guided optimization with GCC.  I've never been able to make this
 # work.

 # CXXFLAGS += -fprofile-generate
@@ -125,7 +130,7 @@ LDFLAGS += -lm -lpthread
 # LDFLAGS += -arch x86_64


-# Backwards compatibility with Mac OS X 10.4 when compiling under 10.5 with 
+# Backwards compatibility with Mac OS X 10.4 when compiling under 10.5 with
 # GCC 4.0.  I haven't found a way to make it work with GCC 4.2.

 # CXXFLAGS += -isysroot /Developer/SDKs/MacOSX10.4u.sdk
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -20,6 +21,9 @@
 ////
 //// Includes
 ////
+#include <fstream>
+#include <sstream>
+#include <vector>

 #include "benchmark.h"
 #include "search.h"
@@ -31,7 +35,8 @@
 //// Variables
 ////

-const std::string BenchmarkPositions[15] = {
+const std::string BenchmarkPositions[] = {
+  "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
  "r4rk1/1b2qppp/p1n1p3/1p6/1b1PN3/3BRN2/PP3PPP/R2Q2K1 b - - 7 16",
  "4r1k1/ppq3pp/3b4/2pP4/2Q1p3/4B1P1/PP5P/R5K1 b - - 0 20",
  "4rrk1/pp1n3p/3q2pQ/2p1pb2/2PP4/2P3N1/P2B2PP/4RRK1 b - - 7 19",
@@ -48,44 +53,99 @@ const std::string BenchmarkPositions[15] = {
  "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b  - 3 22",
  "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26"
 };
-  
+

 ////
 //// Functions
 ////

-/// benchmark() runs a simple benchmark by letting Glaurung analyze 15
-/// positions for 60 seconds each.  There are two parameters; the
-/// transposition table size and the number of search threads that should
-/// be used.  The analysis is written to a file named bench.txt.
+/// benchmark() runs a simple benchmark by letting Stockfish analyze a set
+/// of positions for a given time each.  There are four parameters; the
+/// transposition table size, the number of search threads that should
+/// be used, the time in seconds spent for each position (optional, default
+/// is 60) and an optional file name where to look for positions in fen
+/// format (default are the BenchmarkPositions defined above).
+/// The analysis is written to a file named bench.txt.

-void benchmark(const std::string &ttSize, const std::string &threads) {
-  Position pos;
-  Move moves[1] = {MOVE_NONE};
-  int i;
+void benchmark(const std::string& commandLine) {

-  i = atoi(ttSize.c_str());
-  if(i < 4 || i > 1024) {
-    std::cerr << "The hash table size must be between 4 and 1024" << std::endl;
-    exit(EXIT_FAILURE);
+  std::istringstream csVal(commandLine);
+  std::istringstream csStr(commandLine);
+  std::string ttSize, threads, fileName, limitType;
+  int val, secsPerPos, maxDepth, maxNodes;
+
+  csStr >> ttSize;
+  csVal >> val;
+  if (val < 4 || val > 1024)
+  {
+      std::cerr << "The hash table size must be between 4 and 1024" << std::endl;
+      exit(EXIT_FAILURE);
  }
-
-  i = atoi(threads.c_str());
-  if(i < 1 || i > THREAD_MAX) {
-    std::cerr << "The number of threads must be between 1 and " << THREAD_MAX
-              << std::endl;
-    exit(EXIT_FAILURE);
+  csStr >> threads;
+  csVal >> val;
+  if (val < 1 || val > THREAD_MAX)
+  {
+      std::cerr << "The number of threads must be between 1 and " << THREAD_MAX
+                << std::endl;
+      exit(EXIT_FAILURE);
  }
-  
  set_option_value("Hash", ttSize);
  set_option_value("Threads", threads);
  set_option_value("OwnBook", "false");
  set_option_value("Use Search Log", "true");
  set_option_value("Search Log Filename", "bench.txt");

-  for(i = 0; i < 15; i++) {
-    pos.from_fen(BenchmarkPositions[i]);
-    think(pos, true, false, 0, 0, 0, 0, 0, 60000, moves);
+  csVal >> val;
+  csVal >> fileName;
+  csVal >> limitType;
+
+  secsPerPos = maxDepth = maxNodes = 0;
+
+  if (limitType == "time")
+      secsPerPos = val * 1000;
+  else if (limitType == "depth")
+      maxDepth = val;
+  else
+      maxNodes = val;
+
+  std::vector<std::string> positions;
+
+  if (fileName != "default")
+  {
+      std::ifstream fenFile(fileName.c_str());
+      if (!fenFile.is_open())
+      {
+          std::cerr << "Unable to open positions file " << fileName
+                    << std::endl;
+          exit(EXIT_FAILURE);
+      }
+      std::string pos;
+      while (fenFile.good())
+      {
+          std::getline(fenFile, pos);
+          if (!pos.empty())
+              positions.push_back(pos);
+      }
+      fenFile.close();
+  } else
+      for (int i = 0; i < 16; i++)
+          positions.push_back(std::string(BenchmarkPositions[i]));
+
+  int startTime = get_system_time();
+  std::vector<std::string>::iterator it;
+  int cnt = 1;
+  int64_t totalNodes = 0;
+  for (it = positions.begin(); it != positions.end(); ++it, ++cnt)
+  {
+      Move moves[1] = {MOVE_NONE};
+      int dummy[2] = {0, 0};
+      Position pos(*it);
+      std::cout << "\nProcessing position " << cnt << '/' << positions.size() << std::endl << std::endl;
+      think(pos, true, false, 0, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves);
+      totalNodes += nodes_searched();
  }
-    
+  std::cout << "\nProcessing time (ms) " << get_system_time() - startTime << std::endl
+            << "Nodes searched " << totalNodes << std::endl
+            << "Press any key to exit" << std::endl;
+  std::cin >> fileName;
 }
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -31,7 +32,6 @@
 //// Prototypes
 ////

-extern void benchmark(const std::string &ttSize, const std::string &threads);
-
+extern void benchmark(const std::string& commandLine);

 #endif // !defined(BENCHMARK_H_INCLUDED)
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -52,11 +53,11 @@ namespace {
    Bitboard wk_attacks() const;
    Bitboard bk_attacks() const;
    Bitboard pawn_attacks() const;
-    
+
    Square whiteKingSquare, blackKingSquare, pawnSquare;
    Color sideToMove;
  };
-    
+

  Result *Bitbase;
  const int IndexMax = 2*24*64*64;
@@ -68,7 +69,7 @@ namespace {
  Result classify_btm(const KPKPosition &p);
  int compute_index(Square wksq, Square bksq, Square psq, Color stm);
  int compress_result(Result r);
-  
+
 }


@@ -88,7 +89,8 @@ void generate_kpk_bitbase(uint8_t bitbase[]) {
  int i, j, b;
  for(i = 0; i < 24576; i++) {
    for(b = 0, j = 0; j < 8; b |= (compress_result(Bitbase[8*i+j]) << j), j++);
-    bitbase[i] = b;
+    assert(b == int(uint8_t(b)));
+    bitbase[i] = (uint8_t)b;
  }

  // Release allocated memory:
@@ -112,7 +114,7 @@ namespace {
    return compute_index(whiteKingSquare, blackKingSquare, pawnSquare,
                         sideToMove);
  }
-    
+

  bool KPKPosition::is_legal() const {
    if(whiteKingSquare == pawnSquare || whiteKingSquare == blackKingSquare ||
@@ -136,7 +138,7 @@ namespace {
    if(sideToMove == BLACK) {
      Bitboard wka = this->wk_attacks();
      Bitboard bka = this->bk_attacks();
-    
+
      // Case 1: Stalemate
      if((bka & ~(wka | this->pawn_attacks())) == EmptyBoardBB)
        return true;
@@ -165,7 +167,7 @@ namespace {
      (square_distance(blackKingSquare, pawnSquare+DELTA_N) > 1 ||
       bit_is_set(this->wk_attacks(), pawnSquare+DELTA_N));
  }
-    
+

  Bitboard KPKPosition::wk_attacks() const {
    return StepAttackBB[WK][whiteKingSquare];
@@ -203,7 +205,7 @@ namespace {
  bool next_iteration() {
    KPKPosition p;
    int previousUnknownCount = UnknownCount;
-    
+
    for(int i = 0; i < IndexMax; i++)
      if(Bitbase[i] == RESULT_UNKNOWN) {
        p.from_index(i);
@@ -230,7 +232,7 @@ namespace {
    bool unknownFound = false;
    Bitboard b;
    Square s;
-    
+
    // King moves
    b = p.wk_attacks();
    while(b) {
@@ -259,14 +261,14 @@ namespace {
                                   BLACK)]) {
      case RESULT_LOSS:
        return RESULT_WIN;
-        
+
      case RESULT_UNKNOWN:
        unknownFound = true;
        break;
-          
+
      case RESULT_DRAW: case RESULT_INVALID:
        break;
-        
+
      default:
        assert(false);
      }
@@ -278,20 +280,20 @@ namespace {
                                     BLACK)]) {
        case RESULT_LOSS:
          return RESULT_WIN;
-          
+
        case RESULT_UNKNOWN:
          unknownFound = true;
          break;
-          
+
        case RESULT_DRAW: case RESULT_INVALID:
          break;
-          
+
        default:
          assert(false);
        }
      }
    }
-    
+
    return unknownFound? RESULT_UNKNOWN : RESULT_DRAW;
  }

@@ -344,5 +346,5 @@ namespace {
  int compress_result(Result r) {
    return (r == RESULT_WIN || r == RESULT_LOSS)? 1 : 0;
  }
-      
-}  
+
+}
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -21,70 +22,22 @@
 //// Includes
 ////

+#ifdef _MSC_VER
+    #include <intrin.h>
+    #ifdef _WIN64
+        #pragma intrinsic(_BitScanForward64)
+    #else
+        #pragma intrinsic(_BitScanForward)
+    #endif
+    #define USING_INTRINSICS
+#endif
+
 #include <iostream>

 #include "bitboard.h"
 #include "direction.h"


-////
-//// Constants and variables
-////
-
-const Bitboard SquaresByColorBB[2] = {BlackSquaresBB, WhiteSquaresBB};
-
-const Bitboard FileBB[8] = {
-  FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB
-};
-
-const Bitboard NeighboringFilesBB[8] = {
-  FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB, 
-  FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB
-};
-
-const Bitboard ThisAndNeighboringFilesBB[8] = {
-  FileABB|FileBBB, FileABB|FileBBB|FileCBB,
-  FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB,
-  FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB,
-  FileFBB|FileGBB|FileHBB, FileGBB|FileHBB
-};  
-
-const Bitboard RankBB[8] = {
-  Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
-};
-
-const Bitboard RelativeRankBB[2][8] = {
-  {
-    Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
-  },
-  {
-    Rank8BB, Rank7BB, Rank6BB, Rank5BB, Rank4BB, Rank3BB, Rank2BB, Rank1BB
-  }
-};
-
-const Bitboard InFrontBB[2][8] = {
-  {
-    Rank2BB | Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank6BB | Rank7BB | Rank8BB,
-    Rank7BB | Rank8BB,
-    Rank8BB,
-    EmptyBoardBB
-  },
-  {
-    EmptyBoardBB,
-    Rank1BB,
-    Rank2BB | Rank1BB,
-    Rank3BB | Rank2BB | Rank1BB,
-    Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank7BB | Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB
-  }
-};
-
 #if defined(USE_COMPACT_ROOK_ATTACKS)

 Bitboard RankAttacks[8][64], FileAttacks[8][64];
@@ -126,27 +79,27 @@ const int RShift[64] = {
 #else // if defined(USE_32BIT_ATTACKS)

 const uint64_t RMult[64] = {
-  0xa8002c000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL, 
-  0x380180080141000ULL, 0x1a00060008211044ULL, 0x410001000a0c0008ULL, 
-  0x9500060004008100ULL, 0x100024284a20700ULL, 0x802140008000ULL, 
-  0x80c01002a00840ULL, 0x402004282011020ULL, 0x9862000820420050ULL, 
-  0x1001448011100ULL, 0x6432800200800400ULL, 0x40100010002000cULL, 
-  0x2800d0010c080ULL, 0x90c0008000803042ULL, 0x4010004000200041ULL, 
-  0x3010010200040ULL, 0xa40828028001000ULL, 0x123010008000430ULL, 
-  0x24008004020080ULL, 0x60040001104802ULL, 0x582200028400d1ULL, 
-  0x4000802080044000ULL, 0x408208200420308ULL, 0x610038080102000ULL, 
-  0x3601000900100020ULL, 0x80080040180ULL, 0xc2020080040080ULL, 
-  0x80084400100102ULL, 0x4022408200014401ULL, 0x40052040800082ULL, 
-  0xb08200280804000ULL, 0x8a80a008801000ULL, 0x4000480080801000ULL, 
-  0x911808800801401ULL, 0x822a003002001894ULL, 0x401068091400108aULL, 
-  0x4a10a00004cULL, 0x2000800640008024ULL, 0x1486408102020020ULL, 
-  0x100a000d50041ULL, 0x810050020b0020ULL, 0x204000800808004ULL, 
-  0x20048100a000cULL, 0x112000831020004ULL, 0x9000040810002ULL, 
-  0x440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL, 
-  0x4b824a2010010100ULL, 0x4080801810c0080ULL, 0x400802a0080ULL, 
-  0x8224080110026400ULL, 0x40002c4104088200ULL, 0x1002100104a0282ULL, 
-  0x1208400811048021ULL, 0x3201014a40d02001ULL, 0x5100019200501ULL, 
-  0x101000208001005ULL, 0x2008450080702ULL, 0x1002080301d00cULL, 
+  0xa8002c000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL,
+  0x380180080141000ULL, 0x1a00060008211044ULL, 0x410001000a0c0008ULL,
+  0x9500060004008100ULL, 0x100024284a20700ULL, 0x802140008000ULL,
+  0x80c01002a00840ULL, 0x402004282011020ULL, 0x9862000820420050ULL,
+  0x1001448011100ULL, 0x6432800200800400ULL, 0x40100010002000cULL,
+  0x2800d0010c080ULL, 0x90c0008000803042ULL, 0x4010004000200041ULL,
+  0x3010010200040ULL, 0xa40828028001000ULL, 0x123010008000430ULL,
+  0x24008004020080ULL, 0x60040001104802ULL, 0x582200028400d1ULL,
+  0x4000802080044000ULL, 0x408208200420308ULL, 0x610038080102000ULL,
+  0x3601000900100020ULL, 0x80080040180ULL, 0xc2020080040080ULL,
+  0x80084400100102ULL, 0x4022408200014401ULL, 0x40052040800082ULL,
+  0xb08200280804000ULL, 0x8a80a008801000ULL, 0x4000480080801000ULL,
+  0x911808800801401ULL, 0x822a003002001894ULL, 0x401068091400108aULL,
+  0x4a10a00004cULL, 0x2000800640008024ULL, 0x1486408102020020ULL,
+  0x100a000d50041ULL, 0x810050020b0020ULL, 0x204000800808004ULL,
+  0x20048100a000cULL, 0x112000831020004ULL, 0x9000040810002ULL,
+  0x440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL,
+  0x4b824a2010010100ULL, 0x4080801810c0080ULL, 0x400802a0080ULL,
+  0x8224080110026400ULL, 0x40002c4104088200ULL, 0x1002100104a0282ULL,
+  0x1208400811048021ULL, 0x3201014a40d02001ULL, 0x5100019200501ULL,
+  0x101000208001005ULL, 0x2008450080702ULL, 0x1002080301d00cULL,
  0x410201ce5c030092ULL
 };

@@ -190,7 +143,7 @@ const uint64_t BMult[64] = {
  0x881c7c67fcbfc4f6ULL, 0x47ca41e7e440d423ULL, 0xeb0c88112048d004ULL,
  0x51c60e04359aef1aULL, 0x1aa1fe0e957a5554ULL, 0xdd9448db4f5e3104ULL,
  0xdc01f6dca4bebbdcULL,
-}; 
+};

 const int BShift[64] = {
  26, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 27, 27,
@@ -202,27 +155,27 @@ const int BShift[64] = {
 #else // if defined(USE_32BIT_ATTACKS)

 const uint64_t BMult[64] = {
-  0x440049104032280ULL, 0x1021023c82008040ULL, 0x404040082000048ULL, 
-  0x48c4440084048090ULL, 0x2801104026490000ULL, 0x4100880442040800ULL, 
-  0x181011002e06040ULL, 0x9101004104200e00ULL, 0x1240848848310401ULL, 
-  0x2000142828050024ULL, 0x1004024d5000ULL, 0x102044400800200ULL, 
-  0x8108108820112000ULL, 0xa880818210c00046ULL, 0x4008008801082000ULL, 
-  0x60882404049400ULL, 0x104402004240810ULL, 0xa002084250200ULL, 
-  0x100b0880801100ULL, 0x4080201220101ULL, 0x44008080a00000ULL, 
-  0x202200842000ULL, 0x5006004882d00808ULL, 0x200045080802ULL, 
-  0x86100020200601ULL, 0xa802080a20112c02ULL, 0x80411218080900ULL, 
-  0x200a0880080a0ULL, 0x9a01010000104000ULL, 0x28008003100080ULL, 
-  0x211021004480417ULL, 0x401004188220806ULL, 0x825051400c2006ULL, 
-  0x140c0210943000ULL, 0x242800300080ULL, 0xc2208120080200ULL, 
-  0x2430008200002200ULL, 0x1010100112008040ULL, 0x8141050100020842ULL, 
-  0x822081014405ULL, 0x800c049e40400804ULL, 0x4a0404028a000820ULL, 
-  0x22060201041200ULL, 0x360904200840801ULL, 0x881a08208800400ULL, 
-  0x60202c00400420ULL, 0x1204440086061400ULL, 0x8184042804040ULL, 
-  0x64040315300400ULL, 0xc01008801090a00ULL, 0x808010401140c00ULL, 
-  0x4004830c2020040ULL, 0x80005002020054ULL, 0x40000c14481a0490ULL, 
-  0x10500101042048ULL, 0x1010100200424000ULL, 0x640901901040ULL, 
-  0xa0201014840ULL, 0x840082aa011002ULL, 0x10010840084240aULL, 
-  0x420400810420608ULL, 0x8d40230408102100ULL, 0x4a00200612222409ULL, 
+  0x440049104032280ULL, 0x1021023c82008040ULL, 0x404040082000048ULL,
+  0x48c4440084048090ULL, 0x2801104026490000ULL, 0x4100880442040800ULL,
+  0x181011002e06040ULL, 0x9101004104200e00ULL, 0x1240848848310401ULL,
+  0x2000142828050024ULL, 0x1004024d5000ULL, 0x102044400800200ULL,
+  0x8108108820112000ULL, 0xa880818210c00046ULL, 0x4008008801082000ULL,
+  0x60882404049400ULL, 0x104402004240810ULL, 0xa002084250200ULL,
+  0x100b0880801100ULL, 0x4080201220101ULL, 0x44008080a00000ULL,
+  0x202200842000ULL, 0x5006004882d00808ULL, 0x200045080802ULL,
+  0x86100020200601ULL, 0xa802080a20112c02ULL, 0x80411218080900ULL,
+  0x200a0880080a0ULL, 0x9a01010000104000ULL, 0x28008003100080ULL,
+  0x211021004480417ULL, 0x401004188220806ULL, 0x825051400c2006ULL,
+  0x140c0210943000ULL, 0x242800300080ULL, 0xc2208120080200ULL,
+  0x2430008200002200ULL, 0x1010100112008040ULL, 0x8141050100020842ULL,
+  0x822081014405ULL, 0x800c049e40400804ULL, 0x4a0404028a000820ULL,
+  0x22060201041200ULL, 0x360904200840801ULL, 0x881a08208800400ULL,
+  0x60202c00400420ULL, 0x1204440086061400ULL, 0x8184042804040ULL,
+  0x64040315300400ULL, 0xc01008801090a00ULL, 0x808010401140c00ULL,
+  0x4004830c2020040ULL, 0x80005002020054ULL, 0x40000c14481a0490ULL,
+  0x10500101042048ULL, 0x1010100200424000ULL, 0x640901901040ULL,
+  0xa0201014840ULL, 0x840082aa011002ULL, 0x10010840084240aULL,
+  0x420400810420608ULL, 0x8d40230408102100ULL, 0x4a00200612222409ULL,
  0xa08520292120600ULL
 };

@@ -239,8 +192,8 @@ Bitboard BMask[64];
 int BAttackIndex[64];
 Bitboard BAttacks[0x1480];

-Bitboard SetMaskBB[64];
-Bitboard ClearMaskBB[64];
+Bitboard SetMaskBB[65];
+Bitboard ClearMaskBB[65];

 Bitboard StepAttackBB[16][64];
 Bitboard RayBB[64][8];
@@ -259,6 +212,7 @@ Bitboard QueenPseudoAttacks[64];
 ////

 namespace {
+
  void init_masks();
  void init_ray_bitboards();
  void init_attacks();
@@ -274,7 +228,7 @@ namespace {
 #if defined(USE_COMPACT_ROOK_ATTACKS)
  void init_file_and_rank_attacks();
 #endif
-};
+}


 ////
@@ -320,9 +274,9 @@ void init_bitboards() {
 #if defined(USE_FOLDED_BITSCAN)

 static const int BitTable[64] = {
-  63, 30, 3, 32, 25, 41, 22, 33, 15, 50, 42, 13, 11, 53, 19, 34, 61, 29, 2, 
-  51, 21, 43, 45, 10, 18, 47, 1, 54, 9, 57, 0, 35, 62, 31, 40, 4, 49, 5, 52, 
-  26, 60, 6, 23, 44, 46, 27, 56, 16, 7, 39, 48, 24, 59, 14, 12, 55, 38, 28, 
+  63, 30, 3, 32, 25, 41, 22, 33, 15, 50, 42, 13, 11, 53, 19, 34, 61, 29, 2,
+  51, 21, 43, 45, 10, 18, 47, 1, 54, 9, 57, 0, 35, 62, 31, 40, 4, 49, 5, 52,
+  26, 60, 6, 23, 44, 46, 27, 56, 16, 7, 39, 48, 24, 59, 14, 12, 55, 38, 28,
  58, 20, 37, 17, 36, 8
 };

@@ -339,6 +293,43 @@ Square first_1(Bitboard b) {
 /// pop_1st_bit() finds and clears the least significant nonzero bit in a
 /// nonzero bitboard.

+#if defined(USE_32BIT_ATTACKS)
+
+// Use type-punning
+union b_union {
+
+    Bitboard b;
+    struct {
+        uint32_t l;
+        uint32_t h;
+    };
+};
+
+// WARNING: Needs -fno-strict-aliasing compiler option
+Square pop_1st_bit(Bitboard *bb) {
+
+  b_union u;
+  uint32_t b;
+
+  u.b = *bb;
+
+  if (u.l)
+  {
+      b = u.l;
+      *((uint32_t*)bb) = b & (b - 1);
+      b ^= (b - 1);
+  }
+  else
+  {
+      b = u.h;
+      *((uint32_t*)bb+1) = b & (b - 1); // Little endian only?
+      b = ~(b ^ (b - 1));
+  }
+  return Square(BitTable[(b * 0x783a9b23) >> 26]);
+}
+
+#else
+
 Square pop_1st_bit(Bitboard *b) {
  Bitboard bb = *b ^ (*b - 1);
  uint32_t fold = int(bb) ^ int(bb >> 32);
@@ -346,6 +337,8 @@ Square pop_1st_bit(Bitboard *b) {
  return Square(BitTable[(fold * 0x783a9b23) >> 26]);
 }

+#endif
+
 #else

 static const int BitTable[64] = {
@@ -369,7 +362,7 @@ Square first_1(Bitboard b) {
 Square pop_1st_bit(Bitboard *b) {
  Bitboard bb = *b;
  *b &= (*b - 1);
-  return Square(BitTable[((bb & -bb) * 0x218a392cd3d5dbfULL) >> 58]); 
+  return Square(BitTable[((bb & -bb) * 0x218a392cd3d5dbfULL) >> 58]);
 }

 #endif // defined(USE_FOLDED_BITSCAN)
@@ -383,6 +376,8 @@ namespace {
  // be necessary to touch any of them.

  void init_masks() {
+    SetMaskBB[SQ_NONE] = 0ULL;
+    ClearMaskBB[SQ_NONE] = ~SetMaskBB[SQ_NONE];
    for(Square s = SQ_A1; s <= SQ_H8; s++) {
      SetMaskBB[s] = (1ULL << s);
      ClearMaskBB[s] = ~SetMaskBB[s];
@@ -398,7 +393,7 @@ namespace {

  void init_ray_bitboards() {
    int d[8] = {1, -1, 16, -16, 17, -17, 15, -15};
-    for(int i = 0; i < 128; i = i + 9 & ~8) {
+    for(int i = 0; i < 128; i = (i + 9) & ~8) {
      for(int j = 0; j < 8; j++) {
        RayBB[(i&7)|((i>>4)<<3)][j] = EmptyBoardBB;
        for(int k = i + d[j]; (k & 0x88) == 0; k += d[j])
@@ -417,7 +412,7 @@ namespace {
      {-7,-9,0}, {17,15,10,6,-6,-10,-15,-17}, {9,7,-7,-9,0}, {8,1,-1,-8,0},
      {9,7,-7,-9,8,1,-1,-8}, {9,7,-7,-9,8,1,-1,-8}
    };
-    
+
    for(i = 0; i < 64; i++) {
      for(j = 0; j <= int(BK); j++) {
        StepAttackBB[j][i] = EmptyBoardBB;
@@ -483,14 +478,21 @@ namespace {
    Bitboard b;
    for(i = 0; i < 64; i++) {
      attackIndex[i] = index;
-      mask[i] = sliding_attacks(i, 0ULL, 4, deltas, 1, 6, 1, 6);      
+      mask[i] = sliding_attacks(i, 0ULL, 4, deltas, 1, 6, 1, 6);
+
+#if defined(USE_32BIT_ATTACKS)
+      j = (1 << (32 - shift[i]));
+#else
      j = (1 << (64 - shift[i]));
+#endif
+
      for(k = 0; k < j; k++) {
+
 #if defined(USE_32BIT_ATTACKS)
        b = index_to_bitboard(k, mask[i]);
-        attacks[index + 
-                 (unsigned(int(b) * int(mult[i]) ^ 
-                           int(b >> 32) * int(mult[i] >> 32)) 
+        attacks[index +
+                 (unsigned(int(b) * int(mult[i]) ^
+                           int(b >> 32) * int(mult[i] >> 32))
                  >> shift[i])] =
          sliding_attacks(i, b, 4, deltas);
 #else
@@ -502,7 +504,7 @@ namespace {
      index += j;
    }
  }
-  
+

  void init_pseudo_attacks() {
    Square s;
@@ -537,5 +539,5 @@ namespace {
    }
  }
 #endif // defined(USE_COMPACT_ROOK_ATTACKS)
-    
+
 }
@@ -1,17 +1,19 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -25,15 +27,37 @@
 //// Defines
 ////

+// Comment following define if you prefer manually adjust
+// platform macros defined below
+#define AUTO_CONFIGURATION
+
+// Quiet a warning on Intel compiler
+#if !defined(__SIZEOF_INT__ )
+#define __SIZEOF_INT__ 0
+#endif
+
+// Check for 64 bits for different compilers: Intel, MSVC and gcc
+#if defined(__x86_64) || defined(_WIN64) || (__SIZEOF_INT__ > 4)
+#define IS_64BIT
+#endif
+
+#if !defined(AUTO_CONFIGURATION) || defined(IS_64BIT)
+
 //#define USE_COMPACT_ROOK_ATTACKS
-//#define USE_32BIT_ATTACKS 
+//#define USE_32BIT_ATTACKS
 #define USE_FOLDED_BITSCAN

 #define BITCOUNT_SWAR_64
 //#define BITCOUNT_SWAR_32
 //#define BITCOUNT_LOOP

+#else

+#define USE_32BIT_ATTACKS
+#define USE_FOLDED_BITSCAN
+#define BITCOUNT_SWAR_32
+
+#endif

 ////
 //// Includes
@@ -60,8 +84,7 @@ const Bitboard EmptyBoardBB = 0ULL;

 const Bitboard WhiteSquaresBB = 0x55AA55AA55AA55AAULL;
 const Bitboard BlackSquaresBB = 0xAA55AA55AA55AA55ULL;
-
-extern const Bitboard SquaresByColorBB[2];
+const Bitboard SquaresByColorBB[2] = { BlackSquaresBB, WhiteSquaresBB };

 const Bitboard FileABB = 0x0101010101010101ULL;
 const Bitboard FileBBB = 0x0202020202020202ULL;
@@ -72,9 +95,21 @@ const Bitboard FileFBB = 0x2020202020202020ULL;
 const Bitboard FileGBB = 0x4040404040404040ULL;
 const Bitboard FileHBB = 0x8080808080808080ULL;

-extern const Bitboard FileBB[8];
-extern const Bitboard NeighboringFilesBB[8];
-extern const Bitboard ThisAndNeighboringFilesBB[8];  
+const Bitboard FileBB[8] = {
+  FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB
+};
+
+const Bitboard NeighboringFilesBB[8] = {
+  FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB,
+  FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB
+};
+
+const Bitboard ThisAndNeighboringFilesBB[8] = {
+  FileABB|FileBBB, FileABB|FileBBB|FileCBB,
+  FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB,
+  FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB,
+  FileFBB|FileGBB|FileHBB, FileGBB|FileHBB
+};

 const Bitboard Rank1BB = 0xFFULL;
 const Bitboard Rank2BB = 0xFF00ULL;
@@ -85,12 +120,38 @@ const Bitboard Rank6BB = 0xFF0000000000ULL;
 const Bitboard Rank7BB = 0xFF000000000000ULL;
 const Bitboard Rank8BB = 0xFF00000000000000ULL;

-extern const Bitboard RankBB[8];
-extern const Bitboard RelativeRankBB[2][8];
-extern const Bitboard InFrontBB[2][8];
+const Bitboard RankBB[8] = {
+  Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
+};

-extern Bitboard SetMaskBB[64];
-extern Bitboard ClearMaskBB[64];
+const Bitboard RelativeRankBB[2][8] = {
+  { Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB },
+  { Rank8BB, Rank7BB, Rank6BB, Rank5BB, Rank4BB, Rank3BB, Rank2BB, Rank1BB }
+};
+
+const Bitboard InFrontBB[2][8] = {
+  { Rank2BB | Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank6BB | Rank7BB | Rank8BB,
+    Rank7BB | Rank8BB,
+    Rank8BB,
+    EmptyBoardBB
+  },
+  { EmptyBoardBB,
+    Rank1BB,
+    Rank2BB | Rank1BB,
+    Rank3BB | Rank2BB | Rank1BB,
+    Rank4BB | Rank3BB | Rank2BB | Rank1BB,
+    Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
+    Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
+    Rank7BB | Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB
+  }
+};
+
+extern Bitboard SetMaskBB[65];
+extern Bitboard ClearMaskBB[65];

 extern Bitboard StepAttackBB[16][64];
 extern Bitboard RayBB[64][8];
@@ -100,16 +161,20 @@ extern Bitboard PassedPawnMask[2][64];
 extern Bitboard OutpostMask[2][64];

 #if defined(USE_COMPACT_ROOK_ATTACKS)
+
 extern Bitboard RankAttacks[8][64], FileAttacks[8][64];
+
 #else
+
 extern const uint64_t RMult[64];
 extern const int RShift[64];
 extern Bitboard RMask[64];
 extern int RAttackIndex[64];
 extern Bitboard RAttacks[0x19000];
+
 #endif // defined(USE_COMPACT_ROOK_ATTACKS)

-extern const uint64_t BMult[64]; 
+extern const uint64_t BMult[64];
 extern const int BShift[64];
 extern Bitboard BMask[64];
 extern int BAttackIndex[64];
@@ -124,29 +189,19 @@ extern Bitboard QueenPseudoAttacks[64];
 //// Inline functions
 ////

-/// Functions for testing whether a given bit is set in a bitboard, and for 
+/// Functions for testing whether a given bit is set in a bitboard, and for
 /// setting and clearing bits.

-inline Bitboard set_mask_bb(Square s) {
-  //  return 1ULL << s;
-  return SetMaskBB[s];
-}
-
-inline Bitboard clear_mask_bb(Square s) {
-  //  return ~set_mask_bb(s);
-  return ClearMaskBB[s];
-}
-
 inline Bitboard bit_is_set(Bitboard b, Square s) {
-  return b & set_mask_bb(s);
+  return b & SetMaskBB[s];
 }

 inline void set_bit(Bitboard *b, Square s) {
-  *b |= set_mask_bb(s);
+  *b |= SetMaskBB[s];
 }

 inline void clear_bit(Bitboard *b, Square s) {
-  *b &= clear_mask_bb(s);
+  *b &= ClearMaskBB[s];
 }


@@ -181,7 +236,7 @@ inline Bitboard neighboring_files_bb(File f) {
 inline Bitboard neighboring_files_bb(Square s) {
  return neighboring_files_bb(square_file(s));
 }
-  
+

 /// this_and_neighboring_files_bb takes a file or a square as input, and
 /// returns a bitboard representing all squares on the given and neighboring
@@ -198,7 +253,7 @@ inline Bitboard this_and_neighboring_files_bb(Square s) {

 /// relative_rank_bb() takes a color and a rank as input, and returns a bitboard
 /// representing all squares on the given rank from the given color's point of
-/// view.  For instance, relative_rank_bb(WHITE, 7) gives all squares on the
+/// view. For instance, relative_rank_bb(WHITE, 7) gives all squares on the
 /// 7th rank, while relative_rank_bb(BLACK, 7) gives all squares on the 2nd
 /// rank.

@@ -222,6 +277,19 @@ inline Bitboard in_front_bb(Color c, Square s) {
 }


+/// behind_bb() takes a color and a rank or square as input, and returns a
+/// bitboard representing all the squares on all ranks behind of the rank
+/// (or square), from the given color's point of view.
+
+inline Bitboard behind_bb(Color c, Rank r) {
+  return InFrontBB[opposite_color(c)][r];
+}
+
+inline Bitboard behind_bb(Color c, Square s) {
+  return in_front_bb(opposite_color(c), square_rank(s));
+}
+
+
 /// ray_bb() gives a bitboard representing all squares along the ray in a
 /// given direction from a given square.

@@ -256,9 +324,9 @@ inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {

 inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
  Bitboard b = blockers & RMask[s];
-  return RAttacks[RAttackIndex[s] + 
+  return RAttacks[RAttackIndex[s] +
                  (unsigned(int(b) * int(RMult[s]) ^
-                            int(b >> 32) * int(RMult[s] >> 32)) 
+                            int(b >> 32) * int(RMult[s] >> 32))
                   >> RShift[s])];
 }

@@ -275,9 +343,9 @@ inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {

 inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
  Bitboard b = blockers & BMask[s];
-  return BAttacks[BAttackIndex[s] + 
+  return BAttacks[BAttackIndex[s] +
                  (unsigned(int(b) * int(BMult[s]) ^
-                            int(b >> 32) * int(BMult[s] >> 32)) 
+                            int(b >> 32) * int(BMult[s] >> 32))
                   >> BShift[s])];
 }

@@ -305,9 +373,9 @@ inline Bitboard squares_between(Square s1, Square s2) {
 }


-/// squares_in_front_of takes a color and a square as input, and returns a 
+/// squares_in_front_of takes a color and a square as input, and returns a
 /// bitboard representing all squares along the line in front of the square,
-/// from the point of view of the given color.  For instance, 
+/// from the point of view of the given color.  For instance,
 /// squares_in_front_of(BLACK, SQ_E4) returns a bitboard with the squares
 /// e3, e2 and e1 set.

@@ -324,8 +392,8 @@ inline Bitboard squares_behind(Color c, Square s) {
 }


-/// passed_pawn_mask takes a color and a square as input, and returns a 
-/// bitboard mask which can be used to test if a pawn of the given color on 
+/// passed_pawn_mask takes a color and a square as input, and returns a
+/// bitboard mask which can be used to test if a pawn of the given color on
 /// the given square is a passed pawn.

 inline Bitboard passed_pawn_mask(Color c, Square s) {
@@ -342,7 +410,7 @@ inline Bitboard outpost_mask(Color c, Square s) {
 }


-/// isolated_pawn_mask takes a square as input, and returns a bitboard mask 
+/// isolated_pawn_mask takes a square as input, and returns a bitboard mask
 /// which can be used to test whether a pawn on the given square is isolated.

 inline Bitboard isolated_pawn_mask(Square s) {
@@ -368,24 +436,25 @@ inline int count_1s_max_15(Bitboard b) {

 inline int count_1s(Bitboard b) {
  unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v = v - ((v >> 1) & 0x55555555);
-  w = w - ((w >> 1) & 0x55555555);
-  v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
-  w = (w & 0x33333333) + ((w >> 2) & 0x33333333);
-  v = (v + (v >> 4)) & 0x0F0F0F0F;
-  w = (w + (w >> 4)) & 0x0F0F0F0F;
-  v = ((v+w) * 0x01010101) >> 24; // mul is fast on amd procs
-  return int(v);
+  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
+  w -= (w >> 1) & 0x55555555;
+  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+  v = ((v >> 4) + v) & 0x0F0F0F0F; // 0-8 in 8 bits
+  v += (((w >> 4) + w) & 0x0F0F0F0F);  // 0-16 in 8 bits
+  v *= 0x01010101; // mul is fast on amd procs
+  return int(v >> 24);
 }

 inline int count_1s_max_15(Bitboard b) {
  unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v = v - ((v >> 1) & 0x55555555);
-  w = w - ((w >> 1) & 0x55555555);
-  v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
-  w = (w & 0x33333333) + ((w >> 2) & 0x33333333);
-  v = ((v+w) * 0x11111111) >> 28;
-  return int(v);
+  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
+  w -= (w >> 1) & 0x55555555;
+  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+  v += w; // 0-8 in 4 bits
+  v *= 0x11111111;
+  return int(v >> 28);
 }

 #elif defined(BITCOUNT_SWAR_64)
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -29,7 +30,6 @@
 ////

 #include <cassert>
-#include <cstdio>

 #include "book.h"
 #include "mersenne.h"
@@ -317,30 +317,31 @@ namespace {


  /// Indices to the Random64[] array
-  
+
  const int RandomPiece = 0;
  const int RandomCastle = 768;
  const int RandomEnPassant = 772;
  const int RandomTurn = 780;

-  
+
  /// Convert pieces to the range 0..1
-  
+
  const int PieceTo12[] = {
    0, 0, 2, 4, 6, 8, 10, 0, 0, 1, 3, 5, 7, 9, 11
  };


  /// Prototypes
-  
+
  uint64_t book_key(const Position &pos);
  uint64_t book_piece_key(Piece p, Square s);
  uint64_t book_castle_key(const Position &pos);
  uint64_t book_ep_key(const Position &pos);
  uint64_t book_color_key(const Position &pos);

-  uint64_t read_integer(FILE *file, int size);
-
+  uint16_t read_integer16(std::ifstream& file);
+  uint64_t read_integer64(std::ifstream& file);
+  uint64_t read_integer(std::ifstream& file, int size);
 }


@@ -351,27 +352,26 @@ namespace {

 /// Constructor

-Book::Book() {
-  bookFile = NULL;
-  bookSize = 0;
-}
+Book::Book() : bookSize(0) {}


 /// Book::open() opens a book file with a given file name.

 void Book::open(const std::string &fName) {
+
  fileName = fName;
-  bookFile = fopen(fileName.c_str(), "rb");
-  if(bookFile != NULL) {
-    if(fseek(bookFile, 0, SEEK_END) == -1) {
+  bookFile.open(fileName.c_str(), std::ifstream::in | std::ifstream::binary);
+  if (!bookFile.is_open())
+      return;
+
+  bookFile.seekg(0, std::ios::end);
+  bookSize = bookFile.tellg() / 16;
+  bookFile.seekg(0, std::ios::beg);
+
+  if (!bookFile.good())
+  {
      std::cerr << "Failed to open book file " << fileName << std::endl;
      exit(EXIT_FAILURE);
-    }
-    bookSize = ftell(bookFile) / 16;
-    if(bookSize == -1) {
-      std::cerr << "Failed to open book file " << fileName << std::endl;
-      exit(EXIT_FAILURE);
-    }
  }
 }

@@ -379,17 +379,17 @@ void Book::open(const std::string &fName) {
 /// Book::close() closes the currently open book file.

 void Book::close() {
-  if(bookFile != NULL && fclose(bookFile) == EOF) {
-    std::cerr << "Failed to close book file" << std::endl;
-    exit(EXIT_FAILURE);
-  }
+
+  if (bookFile.is_open())
+      bookFile.close();
 }


 /// Book::is_open() tests whether a book file has been opened.

 bool Book::is_open() const {
-  return bookFile != NULL && bookSize != 0;
+
+  return bookFile.is_open() && bookSize != 0;
 }


@@ -397,9 +397,10 @@ bool Book::is_open() const {
 /// or the empty string if no book is open.

 const std::string Book::file_name() const {
-  return this->is_open()? fileName : "";
+
+  return bookFile.is_open() ? fileName : "";
 }
-  
+

 /// Book::get_move() gets a book move for a given position.  Returns
 /// MOVE_NONE if no book move is found.
@@ -476,19 +477,21 @@ int Book::find_key(uint64_t key) const {
 /// file.  The book entry is copied to the first input parameter.

 void Book::read_entry(BookEntry& entry, int n) const {
-  assert(n >= 0 && n < bookSize);
-  assert(bookFile != NULL);

-  if(fseek(bookFile, n*16, SEEK_SET) == -1) {
+  assert(n >= 0 && n < bookSize);
+  assert(bookFile.is_open());
+
+  bookFile.seekg(n*16, std::ios_base::beg);
+  if (!bookFile.good())
+  {
    std::cerr << "Failed to read book entry at index " << n << std::endl;
    exit(EXIT_FAILURE);
  }
-
-  entry.key = read_integer(bookFile, 8);
-  entry.move = read_integer(bookFile, 2);
-  entry.count = read_integer(bookFile, 2);
-  entry.n = read_integer(bookFile, 2);
-  entry.sum = read_integer(bookFile, 2);
+  entry.key = read_integer64(bookFile);
+  entry.move = read_integer16(bookFile);
+  entry.count = read_integer16(bookFile);
+  entry.n = read_integer16(bookFile);
+  entry.sum = read_integer16(bookFile);
 }


@@ -521,7 +524,7 @@ namespace {

    return result;
  }
-        
+

  uint64_t book_piece_key(Piece p, Square s) {
    return Random64[RandomPiece + (PieceTo12[int(p)]^1)*64 + int(s)];
@@ -542,37 +545,48 @@ namespace {
    return result;
  }

-  
+
  uint64_t book_ep_key(const Position &pos) {
    return (pos.ep_square() == SQ_NONE)?
      0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())];
  }

-  
+
  uint64_t book_color_key(const Position &pos) {
    return (pos.side_to_move() == WHITE)? Random64[RandomTurn] : 0ULL;
  }
-  

-  uint64_t read_integer(FILE *file, int size) {
-    uint64_t n = 0ULL;;
-    int i;
-    int b;

-    assert(file != NULL);
-    assert(size > 0 && size <= 8);
+  uint16_t read_integer16(std::ifstream& file) {

-    for(i = 0; i < size; i++) {
-      b = fgetc(file);
-      if(b == EOF) {
+    uint64_t n = read_integer(file, 2);
+    assert(n == (uint16_t)n);
+    return (uint16_t)n;
+  }
+
+
+  uint64_t read_integer64(std::ifstream& file) {
+
+    return read_integer(file, 8);
+  }
+
+
+  uint64_t read_integer(std::ifstream& file, int size) {
+
+    char buf[8];
+    file.read(buf, size);
+
+    if (!file.good())
+    {
        std::cerr << "Failed to read " << size << " bytes from book file"
                  << std::endl;
        exit(EXIT_FAILURE);
-      }
-      assert(b >= 0 && b < 256);
-      n = (n << 8) | b;
    }
+    // Numbers are stored in little endian format
+    uint64_t n = 0ULL;
+    for (int i = 0; i < size; i++)
+        n = (n << 8) + (unsigned char)buf[i];
+
    return n;
  }
-
 }
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -32,6 +33,7 @@
 //// Includes
 ////

+#include <fstream>
 #include <string>

 #include "move.h"
@@ -74,7 +76,7 @@ private:
  void read_entry(BookEntry &entry, int n) const;

  std::string fileName;
-  FILE *bookFile;
+  mutable std::ifstream bookFile;
  int bookSize;
 };

@@ -1,35 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include "color.h"
-
-
-////
-//// Functions
-////
-
-/// color_is_ok(), for debugging:
-
-bool color_is_ok(Color c) {
-  return c == WHITE || c == BLACK;
-}
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -20,20 +21,14 @@
 #if !defined(COLOR_H_INCLUDED)
 #define COLOR_H_INCLUDED

-////
-//// Includes
-////
-
-#include "misc.h"
-

 ////
 //// Types
 ////

 enum Color {
-  WHITE, 
-  BLACK, 
+  WHITE,
+  BLACK,
  COLOR_NONE
 };

@@ -43,18 +38,14 @@ enum Color {
 ////

 inline Color operator+ (Color c, int i) { return Color(int(c) + i); }
-inline void operator++ (Color &c, int i) { c = Color(int(c) + 1); }
+inline void operator++ (Color &c, int) { c = Color(int(c) + 1); }

 inline Color opposite_color(Color c) {
  return Color(int(c) ^ 1);
 }

-
-////
-//// Prototypes
-////
-
-extern bool color_is_ok(Color c);
-
+inline bool color_is_ok(Color c) {
+  return c == WHITE || c == BLACK;
+}

 #endif // !defined(COLOR_H_INCLUDED)
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -37,8 +38,8 @@ enum Direction {
 };

 enum SignedDirection {
-  SIGNED_DIR_E = 0, SIGNED_DIR_W = 1,
-  SIGNED_DIR_N = 2, SIGNED_DIR_S = 3,
+  SIGNED_DIR_E  = 0, SIGNED_DIR_W  = 1,
+  SIGNED_DIR_N  = 2, SIGNED_DIR_S  = 3,
  SIGNED_DIR_NE = 4, SIGNED_DIR_SW = 5,
  SIGNED_DIR_NW = 6, SIGNED_DIR_SE = 7,
  SIGNED_DIR_NONE = 8
@@ -57,9 +58,11 @@ extern uint8_t SignedDirectionTable[64][64];
 //// Inline functions
 ////

-inline void operator++ (Direction &d, int) { d = Direction(int(d) + 1); }
+inline void operator++ (Direction& d, int) {
+  d = Direction(int(d) + 1);
+}

-inline void operator++ (SignedDirection &d, int) {
+inline void operator++ (SignedDirection& d, int) {
  d = SignedDirection(int(d) + 1);
 }

@@ -71,6 +74,13 @@ inline SignedDirection signed_direction_between_squares(Square s1, Square s2) {
  return SignedDirection(SignedDirectionTable[s1][s2]);
 }

+inline int direction_is_diagonal(Square s1, Square s2) {
+  return DirectionTable[s1][s2] & 2;
+}
+
+inline bool direction_is_straight(Square s1, Square s2) {
+  return DirectionTable[s1][s2] < 2;
+}

 ////
 //// Prototypes
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -33,149 +34,61 @@
 //// Types
 ////

-/// Abstract base class for all special endgame evaluation functions:
+enum EndgameType {

-class EndgameEvaluationFunction {
+    // Evaluation functions
+    KXK,   // Generic "mate lone king" eval
+    KBNK,  // KBN vs K
+    KPK,   // KP vs K
+    KRKP,  // KR vs KP
+    KRKB,  // KR vs KB
+    KRKN,  // KR vs KN
+    KQKR,  // KQ vs KR
+    KBBKN, // KBB vs KN
+    KmmKm, // K and two minors vs K and one or two minors
+
+    // Scaling functions
+    KBPK,    // KBP vs K
+    KQKRP,   // KQ vs KRP
+    KRPKR,   // KRP vs KR
+    KRPPKRP, // KRPP vs KRP
+    KPsK,    // King and pawns vs king
+    KBPKB,   // KBP vs KB
+    KBPPKB,  // KBPP vs KB
+    KBPKN,   // KBP vs KN
+    KNPK,    // KNP vs K
+    KPKP     // KP vs KP
+};
+
+/// Template abstract base class for all special endgame functions
+
+template<typename T>
+class EndgameFunctionBase {
 public:
-  EndgameEvaluationFunction(Color c);
-  virtual ~EndgameEvaluationFunction() { }
-
-  virtual Value apply(const Position &pos) =0;
+  EndgameFunctionBase(Color c) : strongerSide(c) { weakerSide = opposite_color(strongerSide); }
+  virtual ~EndgameFunctionBase() {}
+  virtual T apply(const Position&) = 0;

 protected:
  Color strongerSide, weakerSide;
 };

+typedef EndgameFunctionBase<Value> EndgameEvaluationFunctionBase;
+typedef EndgameFunctionBase<ScaleFactor> EndgameScalingFunctionBase;

-/// Subclasses for various concrete endgames:

-// Generic "mate lone king" eval:
-class KXKEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KXKEvaluationFunction(Color c);
-  Value apply(const Position &pos);
+/// Templates subclass for various concrete endgames
+
+template<EndgameType>
+struct EvaluationFunction : public EndgameEvaluationFunctionBase {
+  explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {}
+  Value apply(const Position&);
 };

-// KBN vs K:
-class KBNKEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KBNKEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KP vs K:
-class KPKEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KPKEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KP:
-class KRKPEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKPEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KB:
-class KRKBEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKBEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KN:
-class KRKNEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKNEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KQ vs KR:
-class KQKREvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KQKREvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-
-/// Abstract base class for all evaluation scaling functions:
-
-class ScalingFunction {
-public:
-  ScalingFunction(Color c);
-  virtual ~ScalingFunction() { }
-
-  virtual ScaleFactor apply(const Position &pos) =0;
-
-protected:
-  Color strongerSide, weakerSide;
-};
-
-
-/// Subclasses for various concrete endgames:
-
-// KBP vs K:
-class KBPKScalingFunction : public ScalingFunction {
-public:
-  KBPKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KQ vs KRP:
-class KQKRPScalingFunction: public ScalingFunction {
-public:
-  KQKRPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KRP vs KR:
-class KRPKRScalingFunction : public ScalingFunction {
-public:
-  KRPKRScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KRPP vs KRP:
-class KRPPKRPScalingFunction : public ScalingFunction {
-public:
-  KRPPKRPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// King and pawns vs king:
-class KPsKScalingFunction : public ScalingFunction {
-public:
-  KPsKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KBP vs KB:
-class KBPKBScalingFunction : public ScalingFunction {
-public:
-  KBPKBScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KBP vs KN:
-class KBPKNScalingFunction : public ScalingFunction {
-public:
-  KBPKNScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KNP vs K:
-class KNPKScalingFunction : public ScalingFunction {
-public:
-  KNPKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KP vs KP:
-class KPKPScalingFunction : public ScalingFunction {
-public:
-  KPKPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
+template<EndgameType>
+struct ScalingFunction : public EndgameScalingFunctionBase {
+  explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {}
+  ScaleFactor apply(const Position&);
 };


@@ -183,54 +96,26 @@ public:
 //// Constants and variables
 ////

-// Generic "mate lone king" eval:
-extern KXKEvaluationFunction EvaluateKXK, EvaluateKKX;
-
-// KBN vs K:
-extern KBNKEvaluationFunction EvaluateKBNK, EvaluateKKBN;
-
-// KP vs K:
-extern KPKEvaluationFunction EvaluateKPK, EvaluateKKP;
-
-// KR vs KP:
-extern KRKPEvaluationFunction EvaluateKRKP, EvaluateKPKR;
-
-// KR vs KB:
-extern KRKBEvaluationFunction EvaluateKRKB, EvaluateKBKR;
-
-// KR vs KN:
-extern KRKNEvaluationFunction EvaluateKRKN, EvaluateKNKR;
-
-// KQ vs KR:
-extern KQKREvaluationFunction EvaluateKQKR, EvaluateKRKQ;
-
-// KBP vs K:
-extern KBPKScalingFunction ScaleKBPK, ScaleKKBP;
-
-// KQ vs KRP:
-extern KQKRPScalingFunction ScaleKQKRP, ScaleKRPKQ;
-
-// KRP vs KR:
-extern KRPKRScalingFunction ScaleKRPKR, ScaleKRKRP;
-
-// KRPP vs KRP:
-extern KRPPKRPScalingFunction ScaleKRPPKRP, ScaleKRPKRPP;
-
-// King and pawns vs king:
-extern KPsKScalingFunction ScaleKPsK, ScaleKKPs;
-
-// KBP vs KB:
-extern KBPKBScalingFunction ScaleKBPKB, ScaleKBKBP;
-
-// KBP vs KN:
-extern KBPKNScalingFunction ScaleKBPKN, ScaleKNKBP;
-
-// KNP vs K:
-extern KNPKScalingFunction ScaleKNPK, ScaleKKNP;
-
-// KP vs KP:
-extern KPKPScalingFunction ScaleKPKPw, ScaleKPKPb;
+extern EvaluationFunction<KXK> EvaluateKXK, EvaluateKKX;       // Generic "mate lone king" eval
+extern EvaluationFunction<KBNK> EvaluateKBNK, EvaluateKKBN;    // KBN vs K
+extern EvaluationFunction<KPK> EvaluateKPK, EvaluateKKP;       // KP vs K
+extern EvaluationFunction<KRKP> EvaluateKRKP, EvaluateKPKR;    // KR vs KP
+extern EvaluationFunction<KRKB> EvaluateKRKB, EvaluateKBKR;    // KR vs KB
+extern EvaluationFunction<KRKN> EvaluateKRKN, EvaluateKNKR;    // KR vs KN
+extern EvaluationFunction<KQKR> EvaluateKQKR, EvaluateKRKQ;    // KQ vs KR
+extern EvaluationFunction<KBBKN> EvaluateKBBKN, EvaluateKNKBB; // KBB vs KN
+extern EvaluationFunction<KmmKm> EvaluateKmmKm; // K and two minors vs K and one or two minors:

+extern ScalingFunction<KBPK> ScaleKBPK, ScaleKKBP;    // KBP vs K
+extern ScalingFunction<KQKRP> ScaleKQKRP, ScaleKRPKQ; // KQ vs KRP
+extern ScalingFunction<KRPKR> ScaleKRPKR, ScaleKRKRP; // KRP vs KR
+extern ScalingFunction<KRPPKRP> ScaleKRPPKRP, ScaleKRPKRPP; // KRPP vs KRP
+extern ScalingFunction<KPsK> ScaleKPsK, ScaleKKPs;    // King and pawns vs king
+extern ScalingFunction<KBPKB> ScaleKBPKB, ScaleKBKBP; // KBP vs KB
+extern ScalingFunction<KBPPKB> ScaleKBPPKB, ScaleKBKBPP; // KBPP vs KB
+extern ScalingFunction<KBPKN> ScaleKBPKN, ScaleKNKBP; // KBP vs KN
+extern ScalingFunction<KNPK> ScaleKNPK, ScaleKKNP;    // KNP vs K
+extern ScalingFunction<KPKP> ScaleKPKPw, ScaleKPKPb;  // KP vs KP

 ////
 //// Prototypes
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -26,29 +27,30 @@

 #include "material.h"
 #include "pawns.h"
-#include "position.h"


 ////
 //// Types
 ////

+
 /// The EvalInfo struct contains various information computed and collected
-/// by the evaluation function.  An EvalInfo object is passed as one of the
+/// by the evaluation function. An EvalInfo object is passed as one of the
 /// arguments to the evaluation function, and the search can make use of its
 /// contents to make intelligent search decisions.
 ///
 /// At the moment, this is not utilized very much:  The only part of the
 /// EvalInfo object which is used by the search is futilityMargin.
+class Position;

 struct EvalInfo {
-  
-  // Middle game and endgame evaluations:
+
+  // Middle game and endgame evaluations
  Value mgValue, egValue;

-  // Pointers to material and pawn hash table entries:
-  MaterialInfo *mi;
-  PawnInfo *pi;
+  // Pointers to material and pawn hash table entries
+  MaterialInfo* mi;
+  PawnInfo* pi;

  // attackedBy[color][piece type] is a bitboard representing all squares
  // attacked by a given color and piece type.  attackedBy[color][0] contains
@@ -56,31 +58,32 @@ struct EvalInfo {
  Bitboard attackedBy[2][8];
  Bitboard attacked_by(Color c) const { return attackedBy[c][0]; }
  Bitboard attacked_by(Color c, PieceType pt) const { return attackedBy[c][pt]; }
-  // attackZone[color] is the zone around the enemy king which is considered
+
+  // kingZone[color] is the zone around the enemy king which is considered
  // by the king safety evaluation.  This consists of the squares directly
  // adjacent to the king, and the three (or two, for a king on an edge file)
  // squares two ranks in front of the king.  For instance, if black's king
-  // is on g8, attackZone[WHITE] is a bitboard containing the squares f8, h8,
+  // is on g8, kingZone[WHITE] is a bitboard containing the squares f8, h8,
  // f7, g7, h7, f6, g6 and h6.
-  Bitboard attackZone[2];
+  Bitboard kingZone[2];

-  // attackCount[color] is the number of pieces of the given color which
-  // attack a square adjacent to the enemy king.
-  int attackCount[2];
+  // kingAttackersCount[color] is the number of pieces of the given color
+  // which attack a square in the kingZone of the enemy king.
+  int kingAttackersCount[2];

-  // attackWeight[color] is the sum of the "weight" of the pieces of the given
-  // color which attack a square adjacent to the enemy king.  The weights of
-  // the individual piece types are given by the variables QueenAttackWeight,
-  // RookAttackWeight, BishopAttackWeight and KnightAttackWeight in
-  // evaluate.cpp.
-  int attackWeight[2];
+  // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
+  // given color which attack a square in the kingZone of the enemy king. The
+  // weights of the individual piece types are given by the variables
+  // QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
+  // KnightAttackWeight in evaluate.cpp
+  int kingAttackersWeight[2];

-  // attacked[color] is the number of enemy piece attacks to squares directly
-  // adjacent to the king of the given color.  Pieces which attack more
-  // than one square are counted multiple times.  For instance, if black's
+  // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares
+  // directly adjacent to the king of the given color. Pieces which attack
+  // more than one square are counted multiple times. For instance, if black's
  // king is on g8 and there's a white knight on g5, this knight adds
-  // 2 to attacked[BLACK].
-  int attacked[2];
+  // 2 to kingAdjacentZoneAttacksCount[BLACK].
+  int kingAdjacentZoneAttacksCount[2];

  // mateThreat[color] is a move for the given side which gives a direct mate.
  Move mateThreat[2];
@@ -89,7 +92,7 @@ struct EvalInfo {
  Value mgMobility, egMobility;

  // Extra futility margin.  This is added to the standard futility margin
-  // in the quiescence search.  
+  // in the quiescence search.
  Value futilityMargin;
 };

@@ -98,8 +101,8 @@ struct EvalInfo {
 //// Prototypes
 ////

-extern Value evaluate(const Position &pos, EvalInfo &ei, int threadID);
-extern Value quick_evaluate(const Position &pos);
+extern Value evaluate(const Position& pos, EvalInfo& ei, int threadID);
+extern Value quick_evaluate(const Position& pos);
 extern void init_eval(int threads);
 extern void quit_eval();
 extern void read_weights(Color sideToMove);
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -22,6 +23,7 @@
 ////

 #include <cassert>
+#include <cstring>

 #include "history.h"

@@ -90,7 +92,7 @@ int History::move_ordering_score(Piece p, Move m) const {


 /// History::ok_to_prune() decides whether a move has been sufficiently
-/// unsuccessful that it makes sense to prune it entirely. 
+/// unsuccessful that it makes sense to prune it entirely.

 bool History::ok_to_prune(Piece p, Move m, Depth d) const {
  assert(piece_is_ok(p));
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -86,7 +87,7 @@ typedef pthread_mutex_t Lock;
 #else


-#  include <windows.h>
+#include <windows.h>

 typedef CRITICAL_SECTION Lock;
 #  define lock_init(x, y) InitializeCriticalSection(x)
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -21,7 +22,6 @@
 //// Includes
 ////

-#include <cstdlib>
 #include <iostream>

 #include "benchmark.h"
@@ -39,53 +39,55 @@
 #include "uci.h"
 #include "ucioption.h"

+using std::string;

-//// 
+////
 //// Functions
 ////

 int main(int argc, char *argv[]) {

  // Disable IO buffering
-  setbuf(stdin, NULL);
-  setbuf(stdout, NULL);
  std::cout.rdbuf()->pubsetbuf(NULL, 0);
  std::cin.rdbuf()->pubsetbuf(NULL, 0);

  // Initialization
-
  init_mersenne();
  init_direction_table();
  init_bitboards();
  init_uci_options();
  Position::init_zobrist();
  Position::init_piece_square_tables();
-  MaterialInfo::init();
  MovePicker::init_phase_table();
  init_eval(1);
  init_bitbases();
  init_threads();

  // Make random number generation less deterministic, for book moves
-  int i = abs(get_system_time() % 10000);
-  for(int j = 0; j < i; j++)
-    genrand_int32();
+  for (int i = abs(get_system_time() % 10000); i > 0; i--)
+      genrand_int32();

  // Process command line arguments
-  if(argc >= 2) {
-    if(std::string(argv[1]) == "bench") {
-      if(argc != 4) {
-        std::cout << "Usage: glaurung bench <hash> <threads>" << std::endl;
+  if (argc >= 2 && string(argv[1]) == "bench")
+  {
+      if (argc < 4 || argc > 7)
+      {
+        std::cout << "Usage: stockfish bench <hash size> <threads> "
+                  << "[time = 60s] [fen positions file = default] "
+                  << "[time, depth or node limited = time]"
+                  << std::endl;
        exit(0);
      }
-      benchmark(std::string(argv[2]), std::string(argv[3]));
+      string time = argc > 4 ? argv[4] : "60";
+      string fen = argc > 5 ? argv[5] : "default";
+      string lim = argc > 6 ? argv[6] : "time";
+      benchmark(string(argv[2]) + " " + string(argv[3]) + " " + time + " " + fen + " " + lim);
      return 0;
-    }
  }

  // Print copyright notice
-  std::cout << engine_name() << ".  "
-            << "Copyright (C) 2004-2008 Tord Romstad."
+  std::cout << engine_name() << ".  Copyright (C) "
+            << "2004-2008 Tord Romstad, Marco Costalba. "
            << std::endl;

  // Enter UCI mode
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -22,6 +23,9 @@
 ////

 #include <cassert>
+#include <cstring>
+#include <sstream>
+#include <map>

 #include "material.h"

@@ -32,23 +36,41 @@

 namespace {

-  const Value BishopPairMidgameBonus = Value(100);
-  const Value BishopPairEndgameBonus = Value(100);
+  const Value BishopPairMidgameBonus = Value(109);
+  const Value BishopPairEndgameBonus = Value(97);

-  Key KPKMaterialKey, KKPMaterialKey;
-  Key KBNKMaterialKey, KKBNMaterialKey;
-  Key KRKPMaterialKey, KPKRMaterialKey;
-  Key KRKBMaterialKey, KBKRMaterialKey;
-  Key KRKNMaterialKey, KNKRMaterialKey;
-  Key KQKRMaterialKey, KRKQMaterialKey;
-  Key KRPKRMaterialKey, KRKRPMaterialKey;
-  Key KRPPKRPMaterialKey, KRPKRPPMaterialKey;
  Key KNNKMaterialKey, KKNNMaterialKey;
-  Key KBPKBMaterialKey, KBKBPMaterialKey;
-  Key KBPKNMaterialKey, KNKBPMaterialKey;
-  Key KNPKMaterialKey, KKNPMaterialKey;
-  Key KPKPMaterialKey;

+}
+
+////
+//// Classes
+////
+
+
+/// See header for a class description. It is declared here to avoid
+/// to include <map> in the header file.
+
+class EndgameFunctions {
+
+public:
+  EndgameFunctions();
+  EndgameEvaluationFunctionBase* getEEF(Key key) const;
+  EndgameScalingFunctionBase* getESF(Key key, Color* c) const;
+
+private:
+  void add(const std::string& keyCode, EndgameEvaluationFunctionBase* f);
+  void add(const std::string& keyCode, Color c, EndgameScalingFunctionBase* f);
+  Key buildKey(const std::string& keyCode);
+
+  struct ScalingInfo
+  {
+      Color col;
+      EndgameScalingFunctionBase* fun;
+  };
+
+  std::map<Key, EndgameEvaluationFunctionBase*> EEFmap;
+  std::map<Key, ScalingInfo> ESFmap;
 };


@@ -56,115 +78,30 @@ namespace {
 //// Functions
 ////

-/// MaterialInfo::init() is called during program initialization.  It 
-/// precomputes material hash keys for a few basic endgames, in order
-/// to make it easy to recognize such endgames when they occur.

-void MaterialInfo::init() {
-  KPKMaterialKey = Position::zobMaterial[WHITE][PAWN][1];
-  KKPMaterialKey = Position::zobMaterial[BLACK][PAWN][1];
-  KBNKMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[WHITE][KNIGHT][1];
-  KKBNMaterialKey =
-    Position::zobMaterial[BLACK][BISHOP][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][1];
-  KRKPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KPKRMaterialKey =
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKBMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1];
-  KBKRMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKNMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][1];
-  KNKRMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KQKRMaterialKey =
-    Position::zobMaterial[WHITE][QUEEN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKQMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][QUEEN][1];
-  KRPKRMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKRPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KRPPKRPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[WHITE][PAWN][2] ^
-    Position::zobMaterial[BLACK][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KRPKRPPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1] ^
-    Position::zobMaterial[BLACK][PAWN][2];
-  KNNKMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[WHITE][KNIGHT][2];
-  KKNNMaterialKey =
-    Position::zobMaterial[BLACK][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][2];
-  KBPKBMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1];
-  KBKBPMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KBPKNMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][1];
-  KNKBPMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KNPKMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[WHITE][PAWN][1];
-  KKNPMaterialKey =
-    Position::zobMaterial[BLACK][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KPKPMaterialKey =
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-}
+/// Constructor for the MaterialInfoTable class

+MaterialInfoTable::MaterialInfoTable(unsigned int numOfEntries) {

-/// Constructor for the MaterialInfoTable class.
-
-MaterialInfoTable::MaterialInfoTable(unsigned numOfEntries) {
  size = numOfEntries;
  entries = new MaterialInfo[size];
-  if(entries == NULL) {
-    std::cerr << "Failed to allocate " << (numOfEntries * sizeof(MaterialInfo))
-              << " bytes for material hash table." << std::endl;
-    exit(EXIT_FAILURE);
+  funcs = new EndgameFunctions();
+  if (!entries || !funcs)
+  {
+      std::cerr << "Failed to allocate " << (numOfEntries * sizeof(MaterialInfo))
+                << " bytes for material hash table." << std::endl;
+      exit(EXIT_FAILURE);
  }
-  this->clear();
+  clear();
 }


-/// Destructor for the MaterialInfoTable class.
+/// Destructor for the MaterialInfoTable class

 MaterialInfoTable::~MaterialInfoTable() {
+
  delete [] entries;
+  delete funcs;
 }


@@ -172,6 +109,7 @@ MaterialInfoTable::~MaterialInfoTable() {
 /// all entries to 0.

 void MaterialInfoTable::clear() {
+
  memset(entries, 0, size * sizeof(MaterialInfo));
 }

@@ -179,228 +117,285 @@ void MaterialInfoTable::clear() {
 /// MaterialInfoTable::get_material_info() takes a position object as input,
 /// computes or looks up a MaterialInfo object, and returns a pointer to it.
 /// If the material configuration is not already present in the table, it
-/// is stored there, so we don't have to recompute everything when the 
+/// is stored there, so we don't have to recompute everything when the
 /// same material configuration occurs again.

-MaterialInfo *MaterialInfoTable::get_material_info(const Position &pos) {
+MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
+
  Key key = pos.get_material_key();
  int index = key & (size - 1);
-  MaterialInfo *mi = entries + index;
+  MaterialInfo* mi = entries + index;

-  // If mi->key matches the position's material hash key, it means that we 
+  // If mi->key matches the position's material hash key, it means that we
  // have analysed this material configuration before, and we can simply
-  // return the information we found the last time instead of recomputing it:
-  if(mi->key == key)
-    return mi;
+  // return the information we found the last time instead of recomputing it.
+  if (mi->key == key)
+      return mi;

-  // Clear the MaterialInfo object, and set its key:
+  // Clear the MaterialInfo object, and set its key
  mi->clear();
  mi->key = key;

-  // A special case before looking for a specialized evaluation function:
-  // KNN vs K is a draw:
-  if(key == KNNKMaterialKey || key == KKNNMaterialKey) {
-    mi->factor[WHITE] = mi->factor[BLACK] = 0;
-    return mi;
+  // A special case before looking for a specialized evaluation function
+  // KNN vs K is a draw.
+  if (key == KNNKMaterialKey || key == KKNNMaterialKey)
+  {
+      mi->factor[WHITE] = mi->factor[BLACK] = 0;
+      return mi;
  }

  // Let's look if we have a specialized evaluation function for this
-  // particular material configuration:
-  if(key == KPKMaterialKey) {
-    mi->evaluationFunction = &EvaluateKPK;
-    return mi;
+  // particular material configuration. First we look for a fixed
+  // configuration one, then a generic one if previous search failed.
+  if ((mi->evaluationFunction = funcs->getEEF(key)) != NULL)
+      return mi;
+
+  else if (   pos.non_pawn_material(BLACK) == Value(0)
+           && pos.piece_count(BLACK, PAWN) == 0
+           && pos.non_pawn_material(WHITE) >= RookValueEndgame)
+  {
+      mi->evaluationFunction = &EvaluateKXK;
+      return mi;
  }
-  else if(key == KKPMaterialKey) {
-    mi->evaluationFunction = &EvaluateKKP;
-    return mi;
+  else if (   pos.non_pawn_material(WHITE) == Value(0)
+           && pos.piece_count(WHITE, PAWN) == 0
+           && pos.non_pawn_material(BLACK) >= RookValueEndgame)
+  {
+      mi->evaluationFunction = &EvaluateKKX;
+      return mi;
  }
-  else if(key == KBNKMaterialKey) {
-    mi->evaluationFunction = &EvaluateKBNK;
-    return mi;
-  }
-  else if(key == KKBNMaterialKey) {
-    mi->evaluationFunction = &EvaluateKKBN;
-    return mi;
-  }
-  else if(key == KRKPMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKP;
-    return mi;
-  }
-  else if(key == KPKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKPKR;
-    return mi;
-  }
-  else if(key == KRKBMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKB;
-    return mi;
-  }
-  else if(key == KBKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKBKR;
-    return mi;
-  }
-  else if(key == KRKNMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKN;
-    return mi;
-  }
-  else if(key == KNKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKNKR;
-    return mi;
-  }
-  else if(key == KQKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKQKR;
-    return mi;
-  }
-  else if(key == KRKQMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKQ;
-    return mi;
-  }
-  else if(pos.non_pawn_material(BLACK) == Value(0) &&
-          pos.pawn_count(BLACK) == 0 &&
-          pos.non_pawn_material(WHITE) >= RookValueEndgame) {
-    mi->evaluationFunction = &EvaluateKXK;
-    return mi;
-  }
-  else if(pos.non_pawn_material(WHITE) == Value(0) &&
-          pos.pawn_count(WHITE) == 0 &&
-          pos.non_pawn_material(BLACK) >= RookValueEndgame) {
-    mi->evaluationFunction = &EvaluateKKX;
-    return mi;
+  else if (   pos.pawns() == EmptyBoardBB
+           && pos.rooks() == EmptyBoardBB
+           && pos.queens() == EmptyBoardBB)
+  {
+      // Minor piece endgame with at least one minor piece per side,
+      // and no pawns.
+      assert(pos.knights(WHITE) | pos.bishops(WHITE));
+      assert(pos.knights(BLACK) | pos.bishops(BLACK));
+
+      if (   pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2
+          && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2)
+      {
+          mi->evaluationFunction = &EvaluateKmmKm;
+          return mi;
+      }
  }

  // OK, we didn't find any special evaluation function for the current
-  // material configuration.  Is there a suitable scaling function?
+  // material configuration. Is there a suitable scaling function?
  //
  // The code below is rather messy, and it could easily get worse later,
  // if we decide to add more special cases.  We face problems when there
  // are several conflicting applicable scaling functions and we need to
  // decide which one to use.
-
-  if(key == KRPKRMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKRPKR;
-    return mi;
-  }
-  if(key == KRKRPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKRKRP;
-    return mi;
-  }
-  if(key == KRPPKRPMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKRPPKRP;
-    return mi;
-  }
-  else if(key == KRPKRPPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKRPKRPP;
-    return mi;
-  }
-  if(key == KBPKBMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKBPKB;
-    return mi;
-  }
-  if(key == KBKBPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKBKBP;
-    return mi;
-  }
-  if(key == KBPKNMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKBPKN;
-    return mi;
-  }
-  if(key == KNKBPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKNKBP;
-    return mi;
-  }
-  if(key == KNPKMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKNPK;
-    return mi;
-  }
-  if(key == KKNPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKKNP;
-    return mi;
-  }
-
-  if(pos.non_pawn_material(WHITE) == BishopValueMidgame &&
-     pos.bishop_count(WHITE) == 1 && pos.pawn_count(WHITE) >= 1)
-    mi->scalingFunction[WHITE] = &ScaleKBPK;
-  if(pos.non_pawn_material(BLACK) == BishopValueMidgame &&
-     pos.bishop_count(BLACK) == 1 && pos.pawn_count(BLACK) >= 1)
-    mi->scalingFunction[BLACK] = &ScaleKKBP;
-
-  if(pos.pawn_count(WHITE) == 0 &&
-     pos.non_pawn_material(WHITE) == QueenValueMidgame &&
-     pos.queen_count(WHITE) == 1 &&
-     pos.rook_count(BLACK) == 1 && pos.pawn_count(BLACK) >= 1)
-    mi->scalingFunction[WHITE] = &ScaleKQKRP;
-  else if(pos.pawn_count(BLACK) == 0 &&
-          pos.non_pawn_material(BLACK) == QueenValueMidgame &&
-          pos.queen_count(BLACK) == 1 &&
-          pos.rook_count(WHITE) == 1 && pos.pawn_count(WHITE) >= 1)
-    mi->scalingFunction[BLACK] = &ScaleKRPKQ;
-
-  if(pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0)) {
-    if(pos.pawn_count(BLACK) == 0) {
-      assert(pos.pawn_count(WHITE) >= 2);
-      mi->scalingFunction[WHITE] = &ScaleKPsK;
-    }
-    else if(pos.pawn_count(WHITE) == 0) {
-      assert(pos.pawn_count(BLACK) >= 2);
-      mi->scalingFunction[BLACK] = &ScaleKKPs;
-    }
-    else if(pos.pawn_count(WHITE) == 1 && pos.pawn_count(BLACK) == 1) {
-      mi->scalingFunction[WHITE] = &ScaleKPKPw;
-      mi->scalingFunction[BLACK] = &ScaleKPKPb;
-    }
-  }
-
-  // Evaluate the material balance.
-  
  Color c;
-  int sign;
-  Value egValue = Value(0), mgValue = Value(0);
-  
-  for(c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign) {
+  EndgameScalingFunctionBase* sf;

-    // No pawns makes it difficult to win, even with a material advantage:
-    if(pos.pawn_count(c) == 0 &&
-       pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c))
-       <= BishopValueMidgame) {
-      if(pos.non_pawn_material(c) == pos.non_pawn_material(opposite_color(c)))
-        mi->factor[c] = 0;
-      else if(pos.non_pawn_material(c) < RookValueMidgame)
-        mi->factor[c] = 0;
-      else {
-        switch(pos.bishop_count(c)) {
-        case 2:
-          mi->factor[c] = 32; break;
-        case 1:
-          mi->factor[c] = 12; break;
-        case 0:
-          mi->factor[c] = 6; break;
-        }
+  if ((sf = funcs->getESF(key, &c)) != NULL)
+  {
+      mi->scalingFunction[c] = sf;
+      return mi;
+  }
+
+  if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
+      && pos.piece_count(WHITE, BISHOP) == 1
+      && pos.piece_count(WHITE, PAWN) >= 1)
+      mi->scalingFunction[WHITE] = &ScaleKBPK;
+
+  if (   pos.non_pawn_material(BLACK) == BishopValueMidgame
+      && pos.piece_count(BLACK, BISHOP) == 1
+      && pos.piece_count(BLACK, PAWN) >= 1)
+      mi->scalingFunction[BLACK] = &ScaleKKBP;
+
+  if (   pos.piece_count(WHITE, PAWN) == 0
+      && pos.non_pawn_material(WHITE) == QueenValueMidgame
+      && pos.piece_count(WHITE, QUEEN) == 1
+      && pos.piece_count(BLACK, ROOK) == 1
+      && pos.piece_count(BLACK, PAWN) >= 1)
+      mi->scalingFunction[WHITE] = &ScaleKQKRP;
+
+  else if (   pos.piece_count(BLACK, PAWN) == 0
+           && pos.non_pawn_material(BLACK) == QueenValueMidgame
+           && pos.piece_count(BLACK, QUEEN) == 1
+           && pos.piece_count(WHITE, ROOK) == 1
+           && pos.piece_count(WHITE, PAWN) >= 1)
+      mi->scalingFunction[BLACK] = &ScaleKRPKQ;
+
+  if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0))
+  {
+      if (pos.piece_count(BLACK, PAWN) == 0)
+      {
+          assert(pos.piece_count(WHITE, PAWN) >= 2);
+          mi->scalingFunction[WHITE] = &ScaleKPsK;
      }
-    }
-    
-    // Bishop pair:
-    if(pos.bishop_count(c) >= 2) {
-      mgValue += sign * BishopPairMidgameBonus;
-      egValue += sign * BishopPairEndgameBonus;
+      else if (pos.piece_count(WHITE, PAWN) == 0)
+      {
+          assert(pos.piece_count(BLACK, PAWN) >= 2);
+          mi->scalingFunction[BLACK] = &ScaleKKPs;
+      }
+      else if (pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1)
+      {
+          mi->scalingFunction[WHITE] = &ScaleKPKPw;
+          mi->scalingFunction[BLACK] = &ScaleKPKPb;
+      }
+  }
+
+  // Compute the space weight
+  if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >=
+      2*QueenValueMidgame + 4*RookValueMidgame + 2*KnightValueMidgame)
+  {
+      int minorPieceCount =  pos.piece_count(WHITE, KNIGHT)
+                           + pos.piece_count(BLACK, KNIGHT)
+                           + pos.piece_count(WHITE, BISHOP)
+                           + pos.piece_count(BLACK, BISHOP);
+
+      mi->spaceWeight = minorPieceCount * minorPieceCount;
+  }
+
+  // Evaluate the material balance
+
+  int sign;
+  Value egValue = Value(0);
+  Value mgValue = Value(0);
+
+  for (c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign)
+  {
+    // No pawns makes it difficult to win, even with a material advantage
+    if (   pos.piece_count(c, PAWN) == 0
+        && pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c)) <= BishopValueMidgame)
+    {
+        if (   pos.non_pawn_material(c) == pos.non_pawn_material(opposite_color(c))
+            || pos.non_pawn_material(c) < RookValueMidgame)
+            mi->factor[c] = 0;
+        else
+        {
+            switch (pos.piece_count(c, BISHOP)) {
+            case 2:
+                mi->factor[c] = 32;
+                break;
+            case 1:
+                mi->factor[c] = 12;
+                break;
+            case 0:
+                mi->factor[c] = 6;
+                break;
+            }
+        }
    }

-    // Knights are stronger when there are many pawns on the board.  The 
+    // Bishop pair
+    if (pos.piece_count(c, BISHOP) >= 2)
+    {
+        mgValue += sign * BishopPairMidgameBonus;
+        egValue += sign * BishopPairEndgameBonus;
+    }
+
+    // Knights are stronger when there are many pawns on the board.  The
    // formula is taken from Larry Kaufman's paper "The Evaluation of Material
-    // Imbalances in Chess": 
+    // Imbalances in Chess":
    // http://mywebpages.comcast.net/danheisman/Articles/evaluation_of_material_imbalance.htm
-    mgValue += sign * Value(pos.knight_count(c)*(pos.pawn_count(c)-5)*16);
-    egValue += sign * Value(pos.knight_count(c)*(pos.pawn_count(c)-5)*16);
+    mgValue += sign * Value(pos.piece_count(c, KNIGHT)*(pos.piece_count(c, PAWN)-5)*16);
+    egValue += sign * Value(pos.piece_count(c, KNIGHT)*(pos.piece_count(c, PAWN)-5)*16);

    // Redundancy of major pieces, again based on Kaufman's paper:
-    if(pos.rook_count(c) >= 1) {
-      Value v = Value((pos.rook_count(c) - 1) * 32 + pos.queen_count(c) * 16);
-      mgValue -= sign * v;
-      egValue -= sign * v;
+    if (pos.piece_count(c, ROOK) >= 1)
+    {
+        Value v = Value((pos.piece_count(c, ROOK) - 1) * 32 + pos.piece_count(c, QUEEN) * 16);
+        mgValue -= sign * v;
+        egValue -= sign * v;
    }
-      
  }
-
  mi->mgValue = int16_t(mgValue);
  mi->egValue = int16_t(egValue);
-
  return mi;
 }
+
+
+/// EndgameFunctions member definitions. This class is used to store the maps
+/// of end game and scaling functions that MaterialInfoTable will query for
+/// each key. The maps are constant and are populated only at construction,
+/// but are per-thread instead of globals to avoid expensive locks.
+
+EndgameFunctions::EndgameFunctions() {
+
+  KNNKMaterialKey = buildKey("KNNK");
+  KKNNMaterialKey = buildKey("KKNN");
+
+  add("KPK",   &EvaluateKPK);
+  add("KKP",   &EvaluateKKP);
+  add("KBNK",  &EvaluateKBNK);
+  add("KKBN",  &EvaluateKKBN);
+  add("KRKP",  &EvaluateKRKP);
+  add("KPKR",  &EvaluateKPKR);
+  add("KRKB",  &EvaluateKRKB);
+  add("KBKR",  &EvaluateKBKR);
+  add("KRKN",  &EvaluateKRKN);
+  add("KNKR",  &EvaluateKNKR);
+  add("KQKR",  &EvaluateKQKR);
+  add("KRKQ",  &EvaluateKRKQ);
+  add("KBBKN", &EvaluateKBBKN);
+  add("KNKBB", &EvaluateKNKBB);
+
+  add("KNPK",    WHITE, &ScaleKNPK);
+  add("KKNP",    BLACK, &ScaleKKNP);
+  add("KRPKR",   WHITE, &ScaleKRPKR);
+  add("KRKRP",   BLACK, &ScaleKRKRP);
+  add("KBPKB",   WHITE, &ScaleKBPKB);
+  add("KBKBP",   BLACK, &ScaleKBKBP);
+  add("KBPPKB",  WHITE, &ScaleKBPPKB);
+  add("KBKBPP",  BLACK, &ScaleKBKBPP);
+  add("KBPKN",   WHITE, &ScaleKBPKN);
+  add("KNKBP",   BLACK, &ScaleKNKBP);
+  add("KRPPKRP", WHITE, &ScaleKRPPKRP);
+  add("KRPKRPP", BLACK, &ScaleKRPKRPP);
+  add("KRPPKRP", WHITE, &ScaleKRPPKRP);
+  add("KRPKRPP", BLACK, &ScaleKRPKRPP);
+}
+
+Key EndgameFunctions::buildKey(const std::string& keyCode) {
+
+    assert(keyCode.length() > 0 && keyCode[0] == 'K');
+    assert(keyCode.length() < 8);
+
+    std::stringstream s;
+    bool upcase = false;
+
+    // Build up a fen substring with the given pieces, note
+    // that the fen string could be of an illegal position.
+    for (size_t i = 0; i < keyCode.length(); i++)
+    {
+        if (keyCode[i] == 'K')
+            upcase = !upcase;
+
+        s << char(upcase? toupper(keyCode[i]) : tolower(keyCode[i]));
+    }
+    s << 8 - keyCode.length() << "/8/8/8/8/8/8/8 w -";
+    return Position(s.str()).get_material_key();
+}
+
+void EndgameFunctions::add(const std::string& keyCode, EndgameEvaluationFunctionBase* f) {
+
+  EEFmap.insert(std::pair<Key, EndgameEvaluationFunctionBase*>(buildKey(keyCode), f));
+}
+
+void EndgameFunctions::add(const std::string& keyCode, Color c, EndgameScalingFunctionBase* f) {
+
+  ScalingInfo s = {c, f};
+  ESFmap.insert(std::pair<Key, ScalingInfo>(buildKey(keyCode), s));
+}
+
+EndgameEvaluationFunctionBase* EndgameFunctions::getEEF(Key key) const {
+
+  std::map<Key, EndgameEvaluationFunctionBase*>::const_iterator it(EEFmap.find(key));
+  return (it != EEFmap.end() ? it->second : NULL);
+}
+
+EndgameScalingFunctionBase* EndgameFunctions::getESF(Key key, Color* c) const {
+
+  std::map<Key, ScalingInfo>::const_iterator it(ESFmap.find(key));
+  if (it == ESFmap.end())
+      return NULL;
+
+  *c = it->second.col;
+  return it->second.fun;
+}
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -34,7 +35,7 @@
 ////

 /// MaterialInfo is a class which contains various information about a
-/// material configuration.  It contains a material balance evaluation,
+/// material configuration. It contains a material balance evaluation,
 /// a function pointer to a special endgame evaluation function (which in
 /// most cases is NULL, meaning that the standard evaluation function will
 /// be used), and "scale factors" for black and white.
@@ -50,27 +51,35 @@ class MaterialInfo {
 public:
  Value mg_value() const;
  Value eg_value() const;
-  ScaleFactor scale_factor(const Position &pos, Color c) const;
+  ScaleFactor scale_factor(const Position& pos, Color c) const;
+  int space_weight() const;
  bool specialized_eval_exists() const;
-  Value evaluate(const Position &pos) const;
-
-  static void init();
+  Value evaluate(const Position& pos) const;

 private:
  void clear();
-  
+
  Key key;
  int16_t mgValue;
  int16_t egValue;
  uint8_t factor[2];
-  EndgameEvaluationFunction *evaluationFunction;
-  ScalingFunction *scalingFunction[2];
+  EndgameEvaluationFunctionBase* evaluationFunction;
+  EndgameScalingFunctionBase* scalingFunction[2];
+  int spaceWeight;
 };


-/// The MaterialInfoTable class represents a pawn hash table.  It is basically
+/// EndgameFunctions class stores the endgame evaluation functions std::map.
+/// Because STL library is not thread safe even for read access, the maps,
+/// although with identical content, are replicated for each thread. This
+/// is faster then using locks with an unique set of global maps.
+
+class EndgameFunctions;
+
+
+/// The MaterialInfoTable class represents a pawn hash table. It is basically
 /// just an array of MaterialInfo objects and a few methods for accessing these
-/// objects.  The most important method is get_material_info, which looks up a
+/// objects. The most important method is get_material_info, which looks up a
 /// position in the table and returns a pointer to a MaterialInfo object.

 class MaterialInfoTable {
@@ -79,11 +88,12 @@ public:
  MaterialInfoTable(unsigned numOfEntries);
  ~MaterialInfoTable();
  void clear();
-  MaterialInfo *get_material_info(const Position &pos);
+  MaterialInfo* get_material_info(const Position& pos);

 private:
  unsigned size;
-  MaterialInfo *entries;
+  MaterialInfo* entries;
+  EndgameFunctions* funcs;
 };


@@ -95,10 +105,12 @@ private:
 /// material balance evaluation for the middle game and the endgame.

 inline Value MaterialInfo::mg_value() const {
+
  return Value(mgValue);
 }

 inline Value MaterialInfo::eg_value() const {
+
  return Value(egValue);
 }

@@ -107,8 +119,10 @@ inline Value MaterialInfo::eg_value() const {
 /// with all slots at their default values.

 inline void MaterialInfo::clear() {
+
  mgValue = egValue = 0;
  factor[WHITE] = factor[BLACK] = uint8_t(SCALE_FACTOR_NORMAL);
+  spaceWeight = 0;
  evaluationFunction = NULL;
  scalingFunction[WHITE] = scalingFunction[BLACK] = NULL;
 }
@@ -117,35 +131,47 @@ inline void MaterialInfo::clear() {
 /// MaterialInfo::scale_factor takes a position and a color as input, and
 /// returns a scale factor for the given color.  We have to provide the
 /// position in addition to the color, because the scale factor need not
-/// be a constant:  It can also be a function which should be applied to
-/// the position.  For instance, in KBP vs K endgames, a scaling function
+/// to be a constant: It can also be a function which should be applied to
+/// the position. For instance, in KBP vs K endgames, a scaling function
 /// which checks for draws with rook pawns and wrong-colored bishops.

-inline ScaleFactor MaterialInfo::scale_factor(const Position &pos, Color c)
-  const {
-  if(scalingFunction[c] != NULL) {
-    ScaleFactor sf = scalingFunction[c]->apply(pos);
-    if(sf != SCALE_FACTOR_NONE)
-      return sf;
+inline ScaleFactor MaterialInfo::scale_factor(const Position& pos, Color c) const {
+
+  if (scalingFunction[c] != NULL)
+  {
+      ScaleFactor sf = scalingFunction[c]->apply(pos);
+      if (sf != SCALE_FACTOR_NONE)
+          return sf;
  }
  return ScaleFactor(factor[c]);
 }


+/// MaterialInfo::space_weight() simply returns the weight for the space
+/// evaluation for this material configuration.
+
+inline int MaterialInfo::space_weight() const {
+
+  return spaceWeight;
+}
+
+
 /// MaterialInfo::specialized_eval_exists decides whether there is a
 /// specialized evaluation function for the current material configuration,
 /// or if the normal evaluation function should be used.

 inline bool MaterialInfo::specialized_eval_exists() const {
+
  return evaluationFunction != NULL;
 }


-/// MaterialInfo::evaluate applies a specialized evaluation function to a
-/// given position object.  It should only be called when
-/// this->specialized_eval_exists() returns 'true'.
+/// MaterialInfo::evaluate applies a specialized evaluation function
+/// to a given position object.  It should only be called when
+/// specialized_eval_exists() returns 'true'.
+
+inline Value MaterialInfo::evaluate(const Position& pos) const {

-inline Value MaterialInfo::evaluate(const Position &pos) const {
  return evaluationFunction->apply(pos);
 }

@@ -1,12 +1,12 @@
-/* 
+/*
   A C-program for MT19937, with initialization improved 2002/1/26.
   Coded by Takuji Nishimura and Makoto Matsumoto.

-   Before using, initialize the state by using init_genrand(seed)  
+   Before using, initialize the state by using init_genrand(seed)
   or init_by_array(init_key, key_length).

   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
-   All rights reserved.                          
+   All rights reserved.

   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
@@ -19,8 +19,8 @@
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.

-     3. The names of its contributors may not be used to endorse or promote 
-        products derived from this software without specific prior written 
+     3. The names of its contributors may not be used to endorse or promote
+        products derived from this software without specific prior written
        permission.

   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
@@ -42,8 +42,9 @@
 */

 #include "types.h"
+#include "mersenne.h"

-/* Period parameters */  
+/* Period parameters */
 #define N 624
 #define M 397
 #define MATRIX_A 0x9908b0dfUL   /* constant vector a */
@@ -54,12 +55,12 @@ static unsigned long mt[N]; /* the array for the state vector  */
 static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */

 /* initializes mt[N] with a seed */
-void init_genrand(unsigned long s)
+static void init_genrand(unsigned long s)
 {
    mt[0]= s & 0xffffffffUL;
    for (mti=1; mti<N; mti++) {
-        mt[mti] = 
-            (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti); 
+        mt[mti] =
+            (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
        /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
        /* In the previous versions, MSBs of the seed affect   */
        /* only MSBs of the array mt[].                        */
@@ -73,7 +74,7 @@ void init_genrand(unsigned long s)
 /* init_key is the array for initializing keys */
 /* key_length is its length */
 /* slight change for C++, 2004/2/26 */
-void init_by_array(unsigned long init_key[], int key_length)
+static void init_by_array(unsigned long init_key[], int key_length)
 {
    int i, j, k;
    init_genrand(19650218UL);
@@ -95,7 +96,7 @@ void init_by_array(unsigned long init_key[], int key_length)
        if (i>=N) { mt[0] = mt[N-1]; i=1; }
    }

-    mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */ 
+    mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
 }

 /* generates a random number on [0,0xffffffff]-interval */
@@ -123,7 +124,7 @@ uint32_t genrand_int32(void) {

    mti = 0;
  }
-  
+
  y = mt[mti++];

  /* Tempering */
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -28,51 +29,153 @@
 #  include <unistd.h>

 #else
+/*
+   (c) Copyright 1992 Eric Backus

+   This software may be used freely so long as this copyright notice is
+   left intact. There is no warrantee on this software.
+*/
 #  include <windows.h>
 #  include <time.h>
 #  include "dos.h"
-int gettimeofday(struct timeval * tp, struct timezone * tzp);
+static int gettimeofday(struct timeval* tp, struct timezone*)
+{
+    SYSTEMTIME systime;
+
+    if (tp)
+    {
+        struct tm tmrec;
+        time_t theTime = time(NULL);
+
+        tmrec = *localtime(&theTime);
+        tp->tv_sec = mktime(&tmrec);
+        GetLocalTime(&systime); /* system time */
+
+        tp->tv_usec = systime.wMilliseconds * 1000;
+    }
+    return 0;
+}

 #endif

+#include <cassert>
 #include <cstdio>
 #include <iomanip>
+#include <iostream>
 #include <sstream>

 #include "misc.h"

+using namespace std;

-//// 
+/// Version number. If this is left empty, the current date (in the format
+/// YYMMDD) is used as a version number.
+
+static const string EngineVersion = "1.3rc1";
+static const string AppName = "Stockfish";
+static const string AppTag  = "";
+
+
+////
+//// Variables
+////
+
+long dbg_cnt0 = 0;
+long dbg_cnt1 = 0;
+
+bool dbg_show_mean = false;
+bool dbg_show_hit_rate = false;
+
+
+////
 //// Functions
 ////

-/// engine_name() returns the full name of the current Glaurung version.
-/// This will be either "Glaurung YYMMDD" (where YYMMDD is the date when the
-/// program was compiled) or "Glaurung <version number>", depending on whether
+void dbg_hit_on(bool b) {
+
+    assert(!dbg_show_mean);
+    dbg_show_hit_rate = true;
+    dbg_cnt0++;
+    if (b)
+        dbg_cnt1++;
+}
+
+void dbg_hit_on_c(bool c, bool b) {
+
+    if (c)
+        dbg_hit_on(b);
+}
+
+void dbg_before() {
+
+    assert(!dbg_show_mean);
+    dbg_show_hit_rate = true;
+    dbg_cnt0++;
+}
+
+void dbg_after() {
+
+    assert(!dbg_show_mean);
+    dbg_show_hit_rate = true;
+    dbg_cnt1++;
+}
+
+void dbg_mean_of(int v) {
+
+    assert(!dbg_show_hit_rate);
+    dbg_show_mean = true;
+    dbg_cnt0++;
+    dbg_cnt1 += v;
+}
+
+void dbg_print_hit_rate() {
+
+  cout << "Total " << dbg_cnt0 << " Hit " << dbg_cnt1
+       << " hit rate (%) " << (dbg_cnt1*100)/(dbg_cnt0 ? dbg_cnt0 : 1) << endl;
+}
+
+void dbg_print_mean() {
+
+  cout << "Total " << dbg_cnt0 << " Mean "
+       << (float)dbg_cnt1 / (dbg_cnt0 ? dbg_cnt0 : 1) << endl;
+}
+
+void dbg_print_hit_rate(ofstream& logFile) {
+
+  logFile << "Total " << dbg_cnt0 << " Hit " << dbg_cnt1
+          << " hit rate (%) " << (dbg_cnt1*100)/(dbg_cnt0 ? dbg_cnt0 : 1) << endl;
+}
+
+void dbg_print_mean(ofstream& logFile) {
+
+  logFile << "Total " << dbg_cnt0 << " Mean "
+          << (float)dbg_cnt1 / (dbg_cnt0 ? dbg_cnt0 : 1) << endl;
+}
+
+/// engine_name() returns the full name of the current Stockfish version.
+/// This will be either "Stockfish YYMMDD" (where YYMMDD is the date when the
+/// program was compiled) or "Stockfish <version number>", depending on whether
 /// the constant EngineVersion (defined in misc.h) is empty.

-const std::string engine_name() {
-  if(EngineVersion == "") {
-    static const char monthNames[12][4] = {
-      "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
-    };
-    const char *dateString = __DATE__;
-    std::stringstream s;
-    int month = 0, day = 0;
-    
-    for(int i = 0; i < 12; i++)
-      if(strncmp(dateString, monthNames[i], 3) == 0)
-        month = i + 1;
-    day = atoi(dateString+4);
-    
-    s << "Glaurung " << (dateString+9) << std::setfill('0') << std::setw(2)
-      << month << std::setfill('0') << std::setw(2) << day;
-    
-    return s.str();
-  }
-  else
-    return "Glaurung " + EngineVersion;
+const string engine_name() {
+
+  if (!EngineVersion.empty())
+      return "Stockfish " + EngineVersion;
+
+  string date(__DATE__); // From compiler, format is "Sep 21 2008"
+  string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
+
+  size_t mon = 1 + months.find(date.substr(0, 3)) / 4;
+
+  stringstream s;
+  string day = (date[4] == ' ' ? date.substr(5, 1) : date.substr(4, 2));
+
+  string name = AppName + " " + AppTag + " ";
+
+  s << name << date.substr(date.length() - 2) << setfill('0')
+    << setw(2) << mon << setw(2) << day;
+
+  return s.str();
 }


@@ -82,7 +185,7 @@ const std::string engine_name() {
 int get_system_time() {
  struct timeval t;
  gettimeofday(&t, NULL);
-  return t.tv_sec*1000 + t.tv_usec/1000; 
+  return t.tv_sec*1000 + t.tv_usec/1000;
 }


@@ -120,14 +223,14 @@ int Bioskey()
 {
  fd_set          readfds;
  struct timeval  timeout;
-  
+
  FD_ZERO(&readfds);
  FD_SET(fileno(stdin), &readfds);
  /* Set to timeout immediately */
  timeout.tv_sec = 0;
  timeout.tv_usec = 0;
  select(16, &readfds, 0, 0, &timeout);
-  
+
  return (FD_ISSET(fileno(stdin), &readfds));
 }

@@ -162,8 +265,24 @@ int Bioskey()
            return 1;
        return dw;
    } else {
+        // Count the number of unread input records, including keyboard,
+        // mouse, and window-resizing input records.
        GetNumberOfConsoleInputEvents(inh, &dw);
-        return dw <= 1 ? 0 : dw;
+        if (dw <= 0)
+            return 0;
+
+        // Read data from console without removing it from the buffer
+        INPUT_RECORD rec[256];
+        DWORD recCnt;
+        if (!PeekConsoleInput(inh, rec, Min(dw, 256), &recCnt))
+            return 0;
+
+        // Search for at least one keyboard event
+        for (DWORD i = 0; i < recCnt; i++)
+            if (rec[i].EventType == KEY_EVENT)
+                return 1;
+
+        return 0;
    }
 }
 #endif
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -25,20 +26,10 @@
 //// Includes
 ////

+#include <fstream>
 #include <string>


-////
-//// Constants
-////
-
-
-/// Version number.  If this is left empty, the current date (in the format
-/// YYMMDD) is used as a version number.
-
-const std::string EngineVersion = "2.1";
-
-
 ////
 //// Macros
 ////
@@ -56,5 +47,24 @@ extern int get_system_time();
 extern int cpu_count();
 extern int Bioskey();

+////
+//// Debug
+////
+
+extern bool dbg_show_mean;
+extern bool dbg_show_hit_rate;
+
+extern long dbg_cnt0;
+extern long dbg_cnt1;
+
+extern void dbg_hit_on(bool b);
+extern void dbg_hit_on_c(bool c, bool b);
+extern void dbg_before();
+extern void dbg_after();
+extern void dbg_mean_of(int v);
+extern void dbg_print_hit_rate();
+extern void dbg_print_mean();
+extern void dbg_print_hit_rate(std::ofstream& logFile);
+extern void dbg_print_mean(std::ofstream& logFile);

 #endif // !defined(MISC_H_INCLUDED)
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -35,65 +36,70 @@

 /// move_from_string() takes a position and a string as input, and attempts to
 /// convert the string to a move, using simple coordinate notation (g1f3,
-/// a7a8q, etc.).  In order to correctly parse en passant captures and castling
-/// moves, we need the position.  This function is not robust, and expects that
+/// a7a8q, etc.). In order to correctly parse en passant captures and castling
+/// moves, we need the position. This function is not robust, and expects that
 /// the input move is legal and correctly formatted.

-Move move_from_string(const Position &pos, const std::string &str) {
+Move move_from_string(const Position& pos, const std::string& str) {
+
  Square from, to;
  Piece piece;
  Color us = pos.side_to_move();

-  if(str.length() < 4) return MOVE_NONE;
+  if (str.length() < 4)
+      return MOVE_NONE;

-  // Read the from and to squares:
+  // Read the from and to squares
  from = square_from_string(str.substr(0, 2));
  to = square_from_string(str.substr(2, 4));

-  // Find the moving piece:
+  // Find the moving piece
  piece = pos.piece_on(from);

  // If the string has more than 4 characters, try to interpret the 5th
-  // character as a promotion:
-  if(type_of_piece(piece) == PAWN && str.length() >= 5) {
-    switch(str[4]) {
-    case 'n': case 'N': 
-      return make_promotion_move(from, to, KNIGHT);
-    case 'b': case 'B':
-      return make_promotion_move(from, to, BISHOP);
-    case 'r': case 'R':
-      return make_promotion_move(from, to, ROOK);
-    case 'q': case 'Q':
-      return make_promotion_move(from, to, QUEEN);
+  // character as a promotion
+  if (type_of_piece(piece) == PAWN && str.length() > 4)
+  {
+      switch (tolower(str[4])) {
+      case 'n':
+          return make_promotion_move(from, to, KNIGHT);
+      case 'b':
+          return make_promotion_move(from, to, BISHOP);
+      case 'r':
+          return make_promotion_move(from, to, ROOK);
+      case 'q':
+          return make_promotion_move(from, to, QUEEN);
    }
  }

-  if(piece == king_of_color(us)) {
-    // Is this a castling move?  A king move is assumed to be a castling
-    // move if the destination square is occupied by a friendly rook, or
-    // if the distance between the source and destination squares is more
-    // than 1.
-    if(pos.piece_on(to) == rook_of_color(us))
-      return make_castle_move(from, to);
-    else if(square_distance(from, to) > 1) {
-      // This is a castling move, but we have to translate it to the
-      // internal "king captures rook" representation.
-      SquareDelta delta = (to > from)? DELTA_E : DELTA_W;
-      Square s;
-      for(s = from + delta;
-          pawn_rank(us, s) == RANK_1 && pos.piece_on(s) != rook_of_color(us);
-          s += delta);
-      if(pawn_rank(us, s) == RANK_1 && pos.piece_on(s) == rook_of_color(us))
-        return make_castle_move(from, s);
-    }
-  }
-  else if(piece == pawn_of_color(us)) {
-    // En passant move?  We assume that a pawn move is an en passant move
-    // without further testing if the destination square is epSquare.
-    if(to == pos.ep_square())
-      return make_ep_move(from, to);
-  }
+  if (piece == piece_of_color_and_type(us, KING))
+  {
+      // Is this a castling move? A king move is assumed to be a castling
+      // move if the destination square is occupied by a friendly rook, or
+      // if the distance between the source and destination squares is more
+      // than 1.
+      if (pos.piece_on(to) == piece_of_color_and_type(us, ROOK))
+          return make_castle_move(from, to);

+      else if (square_distance(from, to) > 1)
+      {
+          // This is a castling move, but we have to translate it to the
+          // internal "king captures rook" representation.
+          SquareDelta delta = (to > from ? DELTA_E : DELTA_W);
+          Square s = from + delta;
+          while (relative_rank(us, s) == RANK_1 && pos.piece_on(s) != piece_of_color_and_type(us, ROOK))
+              s += delta;
+
+          return (relative_rank(us, s) == RANK_1 ? make_castle_move(from, s) : MOVE_NONE);
+      }
+  }
+  else if (piece == piece_of_color_and_type(us, PAWN))
+  {
+      // En passant move? We assume that a pawn move is an en passant move
+      // without further testing if the destination square is epSquare.
+      if (to == pos.ep_square())
+          return make_ep_move(from, to);
+  }
  return make_move(from, to);
 }

@@ -104,30 +110,28 @@ Move move_from_string(const Position &pos, const std::string &str) {
 /// Chess960 mode.

 const std::string move_to_string(Move move) {
-  std::string str;

-  if(move == MOVE_NONE)
-    str = "(none)";
-  else if(move == MOVE_NULL)
-    str = "0000";
-  else {
-    if(!Chess960) {
-      if(move_from(move) == SQ_E1 && move_is_short_castle(move)) {
-        str = "e1g1"; return str;
+  std::string str;
+  Square from = move_from(move);
+  Square to = move_to(move);
+
+  if (move == MOVE_NONE)
+      str = "(none)";
+  else if (move == MOVE_NULL)
+      str = "0000";
+  else
+  {
+      if (!Chess960)
+      {
+          if (move_is_short_castle(move))
+              return (from == SQ_E1 ? "e1g1" : "e8g8");
+
+          if (move_is_long_castle(move))
+              return (from == SQ_E1 ? "e1c1" : "e8c8");
      }
-      else if(move_from(move) == SQ_E1 && move_is_long_castle(move)) {
-        str = "e1c1"; return str;
-      }
-      if(move_from(move) == SQ_E8 && move_is_short_castle(move)) {
-        str = "e8g8"; return str;
-      }
-      else if(move_from(move) == SQ_E8 && move_is_long_castle(move)) {
-        str = "e8c8"; return str;
-      }
-    }
-    str = square_to_string(move_from(move)) + square_to_string(move_to(move));
-    if(move_promotion(move))
-      str += piece_type_to_char(move_promotion(move), false);
+      str = square_to_string(from) + square_to_string(to);
+      if (move_promotion(move))
+          str += piece_type_to_char(move_promotion(move), false);
  }
  return str;
 }
@@ -135,7 +139,8 @@ const std::string move_to_string(Move move) {

 /// Overload the << operator, to make it easier to print moves.

-std::ostream &operator << (std::ostream &os, Move m) {
+std::ostream &operator << (std::ostream& os, Move m) {
+
  return os << move_to_string(m);
 }

@@ -143,5 +148,6 @@ std::ostream &operator << (std::ostream &os, Move m) {
 /// move_is_ok(), for debugging.

 bool move_is_ok(Move m) {
+
  return square_is_ok(move_from(m)) && square_is_ok(move_to(m));
 }
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -37,10 +38,22 @@

 class Position;

+/// A move needs 17 bits to be stored
+///
+/// bit  0- 5: destination square (from 0 to 63)
+/// bit  6-11: origin square (from 0 to 63)
+/// bit 12-14: promotion piece type
+/// bit    15: en passant flag
+/// bit    16: castle flag
+///
+/// Special cases are MOVE_NONE and MOVE_NULL. We can sneak these in
+/// because in any normal move destination square is always different
+/// from origin square while MOVE_NONE and MOVE_NULL have the same
+/// origin and destination square, 0 and 1 respectively.
+
 enum Move {
  MOVE_NONE = 0,
-  MOVE_NULL = 65, 
-  MOVE_MAX = 0xFFFFFF
+  MOVE_NULL = 65
 };


@@ -55,11 +68,11 @@ struct MoveStack {
 ////

 inline Square move_from(Move m) {
-  return Square((int(m) >> 6) & 077);
+  return Square((int(m) >> 6) & 0x3F);
 }

 inline Square move_to(Move m) {
-  return Square(m & 077);
+  return Square(m & 0x3F);
 }

 inline PieceType move_promotion(Move m) {
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -31,12 +32,12 @@
 //// Prototypes
 ////

-extern int generate_captures(const Position &pos, MoveStack *mlist);
-extern int generate_noncaptures(const Position &pos, MoveStack *mlist);
-extern int generate_checks(const Position &pos, MoveStack *mlist, Bitboard dc);
-extern int generate_evasions(const Position &pos, MoveStack *mlist);
-extern int generate_legal_moves(const Position &pos, MoveStack *mlist);
-extern Move generate_move_if_legal(const Position &pos, Move m,
-                                   Bitboard pinned);
+extern int generate_captures(const Position& pos, MoveStack* mlist);
+extern int generate_noncaptures(const Position& pos, MoveStack* mlist);
+extern int generate_non_capture_checks(const Position& pos, MoveStack* mlist, Bitboard dc);
+extern int generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pinned);
+extern int generate_legal_moves(const Position& pos, MoveStack* mlist);
+extern bool move_is_legal(const Position& pos, const Move m, Bitboard pinned);
+

 #endif // !defined(MOVEGEN_H_INCLUDED)
@@ -1,17 +1,19 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -24,6 +26,7 @@
 #include <cassert>

 #include "history.h"
+#include "evaluate.h"
 #include "movegen.h"
 #include "movepick.h"
 #include "search.h"
@@ -36,26 +39,9 @@

 namespace {

-  /// Types
-
-  enum MovegenPhase {
-    PH_TT_MOVE,        // Transposition table move
-    PH_MATE_KILLER,    // Mate killer from the current ply
-    PH_GOOD_CAPTURES,  // Queen promotions and captures with SEE values >= 0
-    PH_BAD_CAPTURES,   // Queen promotions and captures with SEE valuse <= 0
-    PH_KILLER_1,       // Killer move 1 from the current ply (not used yet).
-    PH_KILLER_2,       // Killer move 2 from the current ply (not used yet).
-    PH_NONCAPTURES,    // Non-captures and underpromotions
-    PH_EVASIONS,       // Check evasions
-    PH_QCAPTURES,      // Captures in quiescence search
-    PH_QCHECKS,        // Checks in quiescence search
-    PH_STOP
-  };
-
-
  /// Variables

-  MovegenPhase PhaseTable[32];
+  MovePicker::MovegenPhase PhaseTable[32];
  int MainSearchPhaseIndex;
  int EvasionsPhaseIndex;
  int QsearchWithChecksPhaseIndex;
@@ -76,30 +62,31 @@ namespace {
 /// search captures, promotions and some checks) and about how important good
 /// move ordering is at the current node.

-MovePicker::MovePicker(Position &p, bool pvnode, Move ttm, Move mk,
-                       Move k1, Move k2, Depth dpth) {
-  pos = &p;
-  pvNode = pvnode;
+MovePicker::MovePicker(const Position& p, bool pv, Move ttm,
+                       const SearchStack& ss, Depth d) : pos(p) {
+  pvNode = pv;
  ttMove = ttm;
-  mateKiller = (mk == ttm)? MOVE_NONE : mk;
-  killer1 = k1;
-  killer2 = k2;
-  depth = dpth;
+  mateKiller = (ss.mateKiller == ttm)? MOVE_NONE : ss.mateKiller;
+  killer1 = ss.killers[0];
+  killer2 = ss.killers[1];
+  depth = d;
  movesPicked = 0;
  numOfMoves = 0;
  numOfBadCaptures = 0;
-  dc = p.discovered_check_candidates(p.side_to_move());

-  if(p.is_check())
-    phaseIndex = EvasionsPhaseIndex;
-  else if(depth > Depth(0))
-    phaseIndex = MainSearchPhaseIndex;
-  else if(depth == Depth(0))
-    phaseIndex = QsearchWithChecksPhaseIndex;
+  if (p.is_check())
+      phaseIndex = EvasionsPhaseIndex;
+  else if (depth > Depth(0))
+      phaseIndex = MainSearchPhaseIndex;
+  else if (depth == Depth(0))
+      phaseIndex = QsearchWithChecksPhaseIndex;
  else
-    phaseIndex = QsearchWithoutChecksPhaseIndex;
+      phaseIndex = QsearchWithoutChecksPhaseIndex;

-  pinned = p.pinned_pieces(p.side_to_move());
+  Color us = pos.side_to_move();
+
+  dc = p.discovered_check_candidates(us);
+  pinned = p.pinned_pieces(us);

  finished = false;
 }
@@ -110,92 +97,84 @@ MovePicker::MovePicker(Position &p, bool pvnode, Move ttm, Move mk,
 /// are no more moves left of the types we are interested in.

 Move MovePicker::get_next_move() {
+
  Move move;

-  while(true) {
+  while (true)
+  {
    // If we already have a list of generated moves, pick the best move from
-    // the list, and return it:
-    move = this->pick_move_from_list();
-    if(move != MOVE_NONE) {
-      assert(move_is_ok(move));
-      return move;
+    // the list, and return it.
+    move = pick_move_from_list();
+    if (move != MOVE_NONE)
+    {
+        assert(move_is_ok(move));
+        return move;
    }

-    // Next phase:
+    // Next phase
    phaseIndex++;
-    switch(PhaseTable[phaseIndex]) {
+    switch (PhaseTable[phaseIndex]) {

    case PH_TT_MOVE:
-      if(ttMove != MOVE_NONE) {
-        assert(move_is_ok(ttMove));
-        Move m = generate_move_if_legal(*pos, ttMove, pinned);
-        if(m != MOVE_NONE) {
-          assert(m == ttMove);
-          return m;
+        if (ttMove != MOVE_NONE)
+        {
+            assert(move_is_ok(ttMove));
+            if (move_is_legal(pos, ttMove, pinned))
+                return ttMove;
        }
-      }
-      break;
+        break;

    case PH_MATE_KILLER:
-      if(mateKiller != MOVE_NONE) {
-        assert(move_is_ok(mateKiller));
-        Move m = generate_move_if_legal(*pos, mateKiller, pinned);
-        if(m != MOVE_NONE) {
-          assert(m == mateKiller);
-          return m;
+        if (mateKiller != MOVE_NONE)
+        {
+            assert(move_is_ok(mateKiller));
+            if (move_is_legal(pos, mateKiller, pinned))
+                return mateKiller;
        }
-      }
-      break;
+        break;

    case PH_GOOD_CAPTURES:
-      // pinned = pos->pinned_pieces(pos->side_to_move());
-      numOfMoves = generate_captures(*pos, moves);
-      this->score_captures();
-      movesPicked = 0;
-      break;
+        numOfMoves = generate_captures(pos, moves);
+        score_captures();
+        movesPicked = 0;
+        break;

    case PH_BAD_CAPTURES:
-      badCapturesPicked = 0;
-      break;
+        movesPicked = 0;
+        break;

    case PH_NONCAPTURES:
-      numOfMoves = generate_noncaptures(*pos, moves);
-      this->score_noncaptures();
-      movesPicked = 0;
-      break;
+        numOfMoves = generate_noncaptures(pos, moves);
+        score_noncaptures();
+        movesPicked = 0;
+        break;

    case PH_EVASIONS:
-      assert(pos->is_check());
-      // pinned = pos->pinned_pieces(pos->side_to_move());
-      numOfMoves = generate_evasions(*pos, moves);
-      this->score_evasions();
-      movesPicked = 0;
-      break;
+        assert(pos.is_check());
+        numOfMoves = generate_evasions(pos, moves, pinned);
+        score_evasions();
+        movesPicked = 0;
+        break;

    case PH_QCAPTURES:
-      // pinned = pos->pinned_pieces(pos->side_to_move());
-      numOfMoves = generate_captures(*pos, moves);
-      this->score_qcaptures();
-      movesPicked = 0;
-      break;
+        numOfMoves = generate_captures(pos, moves);
+        score_qcaptures();
+        movesPicked = 0;
+        break;

    case PH_QCHECKS:
-      numOfMoves = generate_checks(*pos, moves, dc);
-      movesPicked = 0;
-      break;
+        numOfMoves = generate_non_capture_checks(pos, moves, dc);
+        movesPicked = 0;
+        break;

    case PH_STOP:
-      return MOVE_NONE;
+        return MOVE_NONE;

    default:
-      assert(false);
-      return MOVE_NONE;
+        assert(false);
+        return MOVE_NONE;
    }
  }
-
-  assert(false);
-
-  return MOVE_NONE;
 }


@@ -203,37 +182,26 @@ Move MovePicker::get_next_move() {
 /// prevent multiple threads from picking the same move at a split point.

 Move MovePicker::get_next_move(Lock &lock) {
-   Move m;

   lock_grab(&lock);
-   if(finished) {
-     lock_release(&lock);
-     return MOVE_NONE;
+   if (finished)
+   {
+       lock_release(&lock);
+       return MOVE_NONE;
   }
-   m = this->get_next_move();
-   if(m == MOVE_NONE)
-     finished = true;
+   Move m = get_next_move();
+   if (m == MOVE_NONE)
+       finished = true;
+
   lock_release(&lock);
-   
   return m;
 }

- 
-/// MovePicker::number_of_moves() simply returns the numOfMoves member
-/// variable.  It is intended to be used in positions where the side to move
-/// is in check, for detecting checkmates or situations where there is only
-/// a single reply to check.
-
-int MovePicker::number_of_moves() const {
-  return numOfMoves;
-}
-

 /// MovePicker::score_captures(), MovePicker::score_noncaptures(),
 /// MovePicker::score_evasions() and MovePicker::score_qcaptures() assign a
 /// numerical move ordering score to each move in a move list.  The moves
-/// with highest scores will be picked first by
-/// MovePicker::pick_move_from_list().
+/// with highest scores will be picked first by pick_move_from_list().

 void MovePicker::score_captures() {
  // Winning and equal captures in the main search are ordered by MVV/LVA.
@@ -242,235 +210,234 @@ void MovePicker::score_captures() {
  // capture, capturing a more valuable (but sufficiently defended) piece
  // first usually doesn't hurt.  The opponent will have to recapture, and
  // the hanging piece will still be hanging (except in the unusual cases
-  // where it is possible to recapture with the hanging piece).  Exchanging
+  // where it is possible to recapture with the hanging piece). Exchanging
  // big pieces before capturing a hanging piece probably helps to reduce
  // the subtree size.
-  for(int i = 0; i < numOfMoves; i++) {
-    int seeValue = pos->see(moves[i].move);
-    if(seeValue >= 0) {
-      if(move_promotion(moves[i].move))
-        moves[i].score = QueenValueMidgame;
-      else 
-        moves[i].score =
-          int(pos->midgame_value_of_piece_on(move_to(moves[i].move))) -
-          int(pos->type_of_piece_on(move_from(moves[i].move)));
-    }
-    else
-      moves[i].score = seeValue;
-        
+  // While scoring captures it moves all captures with negative SEE values
+  // to the badCaptures[] array.
+  Move m;
+  int seeValue;
+
+  for (int i = 0; i < numOfMoves; i++)
+  {
+      m = moves[i].move;
+      seeValue = pos.see(m);
+      if (seeValue >= 0)
+      {
+          if (move_promotion(m))
+              moves[i].score = QueenValueMidgame;
+          else
+              moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
+                              -int(pos.type_of_piece_on(move_from(m)));
+      }
+      else
+      {
+          // Losing capture, move it to the badCaptures[] array
+          assert(numOfBadCaptures < 63);
+          moves[i].score = seeValue;
+          badCaptures[numOfBadCaptures++] = moves[i];
+          moves[i--] = moves[--numOfMoves];
+      }
  }
 }

 void MovePicker::score_noncaptures() {
-  for(int i = 0; i < numOfMoves; i++) {
-    Move m = moves[i].move;
-    if(m == killer1)
-      moves[i].score = HistoryMax + 2;
-    else if(m == killer2)
-      moves[i].score = HistoryMax + 1;
-    else
-      moves[i].score = H.move_ordering_score(pos->piece_on(move_from(m)), m);
+  // First score by history, when no history is available then use
+  // piece/square tables values. This seems to be better then a
+  // random choice when we don't have an history for any move.
+  Move m;
+  int hs;
+
+  for (int i = 0; i < numOfMoves; i++)
+  {
+      m = moves[i].move;
+
+      if (m == killer1)
+          hs = HistoryMax + 2;
+      else if (m == killer2)
+          hs = HistoryMax + 1;
+      else
+          hs = H.move_ordering_score(pos.piece_on(move_from(m)), m);
+
+      // Ensure history is always preferred to pst
+      if (hs > 0)
+          hs += 1000;
+
+      // pst based scoring
+      moves[i].score = hs + pos.mg_pst_delta(m);
  }
 }

 void MovePicker::score_evasions() {
-  for(int i = 0; i < numOfMoves; i++) {
-    Move m = moves[i].move;
-    if(m == ttMove)
-      moves[i].score = 2*HistoryMax;
-    else if(!pos->square_is_empty(move_to(m))) {
-      int seeScore = pos->see(m);
-      moves[i].score = (seeScore >= 0)? seeScore + HistoryMax : seeScore;
-    }
-    else
-      moves[i].score = H.move_ordering_score(pos->piece_on(move_from(m)), m);
+
+  for (int i = 0; i < numOfMoves; i++)
+  {
+      Move m = moves[i].move;
+      if (m == ttMove)
+          moves[i].score = 2*HistoryMax;
+      else if (!pos.square_is_empty(move_to(m)))
+      {
+          int seeScore = pos.see(m);
+          moves[i].score = (seeScore >= 0)? seeScore + HistoryMax : seeScore;
+      } else
+          moves[i].score = H.move_ordering_score(pos.piece_on(move_from(m)), m);
  }
 }

 void MovePicker::score_qcaptures() {
-  // Use MVV/LVA ordering.
-  for(int i = 0; i < numOfMoves; i++) {
-    Move m = moves[i].move;
-    if(move_promotion(m))
-      moves[i].score = QueenValueMidgame;
-    else
-      moves[i].score =
-        int(pos->midgame_value_of_piece_on(move_to(m))) -
-        int(pos->midgame_value_of_piece_on(move_to(m))) / 64;
+
+  // Use MVV/LVA ordering
+  for (int i = 0; i < numOfMoves; i++)
+  {
+      Move m = moves[i].move;
+      if (move_promotion(m))
+          moves[i].score = QueenValueMidgame;
+      else
+          moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
+                          -int(pos.type_of_piece_on(move_from(m)));
  }
 }


+/// find_best_index() loops across the moves and returns index of
+/// the highest scored one.
+
+int MovePicker::find_best_index() const {
+
+  assert(movesPicked < numOfMoves);
+
+  int bestIndex = movesPicked;
+  int bestScore = moves[movesPicked].score;
+
+  for (int i = movesPicked + 1; i < numOfMoves; i++)
+      if (moves[i].score > bestScore)
+      {
+          bestIndex = i;
+          bestScore = moves[i].score;
+      }
+  return bestIndex;
+}
+
+
 /// MovePicker::pick_move_from_list() picks the move with the biggest score
 /// from a list of generated moves (moves[] or badCaptures[], depending on
 /// the current move generation phase).  It takes care not to return the
 /// transposition table move if that has already been serched previously.
-/// While picking captures in the PH_GOOD_CAPTURES phase (i.e. while picking
-/// non-losing captures in the main search), it moves all captures with
-/// negative SEE values to the badCaptures[] array.

 Move MovePicker::pick_move_from_list() {
-  int bestScore = -10000000;
+
  int bestIndex;
  Move move;

-  switch(PhaseTable[phaseIndex]) {
+  switch (PhaseTable[phaseIndex]) {

  case PH_GOOD_CAPTURES:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      bestIndex = -1;
-      for(int i = movesPicked; i < numOfMoves; i++) {
-        if(moves[i].score < 0) {
-          // Losing capture, move it to the badCaptures[] array
-          assert(numOfBadCaptures < 63);
-          badCaptures[numOfBadCaptures++] = moves[i];
-          moves[i--] = moves[--numOfMoves];
-        }
-        else if(moves[i].score > bestScore) {
-          bestIndex = i;
-          bestScore = moves[i].score;
-        }
+      assert(!pos.is_check());
+      assert(movesPicked >= 0);
+
+      while (movesPicked < numOfMoves)
+      {
+          bestIndex = find_best_index();
+          move = moves[bestIndex].move;
+          moves[bestIndex] = moves[movesPicked++];
+          if (   move != ttMove
+              && move != mateKiller
+              && pos.pl_move_is_legal(move, pinned))
+              return move;
      }
-      if(bestIndex != -1) { // Found a good capture
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-        move = moves[movesPicked++].move;
-        if(move != ttMove && move != mateKiller &&
-           pos->move_is_legal(move, pinned))
-          return move;
-      }
-    }
-    break;
+      break;

  case PH_NONCAPTURES:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
+      assert(!pos.is_check());
+      assert(movesPicked >= 0);

-      // If this is a PV node or we have only picked a few moves, scan
-      // the entire move list for the best move.  If many moves have already
-      // been searched and it is not a PV node, we are probably failing low
-      // anyway, so we just pick the first move from the list.
-      if(pvNode || movesPicked < 12) {
-        bestIndex = -1;
-        for(int i = movesPicked; i < numOfMoves; i++)
-          if(moves[i].score > bestScore) {
-            bestIndex = i;
-            bestScore = moves[i].score;
-          }
+      while (movesPicked < numOfMoves)
+      {
+          // If this is a PV node or we have only picked a few moves, scan
+          // the entire move list for the best move.  If many moves have already
+          // been searched and it is not a PV node, we are probably failing low
+          // anyway, so we just pick the first move from the list.
+          bestIndex = (pvNode || movesPicked < 12) ? find_best_index() : movesPicked;
+          move = moves[bestIndex].move;
+          moves[bestIndex] = moves[movesPicked++];
+          if (   move != ttMove
+              && move != mateKiller
+              && pos.pl_move_is_legal(move, pinned))
+              return move;
      }
-      else
-        bestIndex = movesPicked;
-
-      if(bestIndex != -1) {
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-        move = moves[movesPicked++].move;
-        if(move != ttMove && move != mateKiller &&
-           pos->move_is_legal(move, pinned))
-          return move;
-      }
-    }
-    break;
+      break;

  case PH_EVASIONS:
-    assert(pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      bestIndex = -1;
-      for(int i = movesPicked; i < numOfMoves; i++)
-        if(moves[i].score > bestScore) {
-          bestIndex = i;
-          bestScore = moves[i].score;
-        }
+      assert(pos.is_check());
+      assert(movesPicked >= 0);

-      if(bestIndex != -1) {
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-        move = moves[movesPicked++].move;
-        return move;
-      }
+      while (movesPicked < numOfMoves)
+      {
+          bestIndex = find_best_index();
+          move = moves[bestIndex].move;
+          moves[bestIndex] = moves[movesPicked++];
+          return move;
    }
    break;

  case PH_BAD_CAPTURES:
-    assert(!pos->is_check());
-    assert(badCapturesPicked >= 0);
-    // It's probably a good idea to use SEE move ordering here, instead
-    // of just picking the first move.  FIXME
-    while(badCapturesPicked < numOfBadCaptures) {
-      move = badCaptures[badCapturesPicked++].move;
-      if(move != ttMove && move != mateKiller && 
-         pos->move_is_legal(move, pinned))
-        return move;
-    }
-    break;
+      assert(!pos.is_check());
+      assert(movesPicked >= 0);
+      // It's probably a good idea to use SEE move ordering here, instead
+      // of just picking the first move.  FIXME
+      while (movesPicked < numOfBadCaptures)
+      {
+          move = badCaptures[movesPicked++].move;
+          if (   move != ttMove
+              && move != mateKiller
+              && pos.pl_move_is_legal(move, pinned))
+              return move;
+      }
+      break;

  case PH_QCAPTURES:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      if(movesPicked < 4) {
-        bestIndex = -1;
-        for(int i = movesPicked; i < numOfMoves; i++)
-          if(moves[i].score > bestScore) {
-            bestIndex = i;
-            bestScore = moves[i].score;
-          }
+      assert(!pos.is_check());
+      assert(movesPicked >= 0);
+      while (movesPicked < numOfMoves)
+      {
+          bestIndex = (movesPicked < 4 ? find_best_index() : movesPicked);
+          move = moves[bestIndex].move;
+          moves[bestIndex] = moves[movesPicked++];
+          // Maybe postpone the legality check until after futility pruning?
+          if (   move != ttMove
+              && pos.pl_move_is_legal(move, pinned))
+              return move;
      }
-      else
-        bestIndex = movesPicked;
-
-      if(bestIndex != -1) {
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-
-        move = moves[movesPicked++].move;
-        // Remember to change the line below if we decide to hash the qsearch!
-        // Maybe also postpone the legality check until after futility pruning?
-        if(/* move != ttMove && */ pos->move_is_legal(move, pinned))
-          return move;
-      }
-    }
-    break;
+      break;

  case PH_QCHECKS:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    // Perhaps we should do something better than just picking the first
-    // move here?  FIXME
-    while(movesPicked < numOfMoves) {
-      move = moves[movesPicked++].move;
-      // Remember to change the line below if we decide to hash the qsearch!
-      if(/* move != ttMove && */ pos->move_is_legal(move, pinned))
-        return move;
-    }
-    break;
+      assert(!pos.is_check());
+      assert(movesPicked >= 0);
+      // Perhaps we should do something better than just picking the first
+      // move here?  FIXME
+      while (movesPicked < numOfMoves)
+      {
+          move = moves[movesPicked++].move;
+          if (   move != ttMove
+              && pos.pl_move_is_legal(move, pinned))
+              return move;
+      }
+      break;

  default:
-    break;
+      break;
  }
-
  return MOVE_NONE;
 }


 /// MovePicker::init_phase_table() initializes the PhaseTable[],
 /// MainSearchPhaseIndex, EvasionPhaseIndex, QsearchWithChecksPhaseIndex
-/// and QsearchWithoutChecksPhaseIndex variables.  It is only called once
-/// during program startup, and never again while the program is running.
+/// and QsearchWithoutChecksPhaseIndex. It is only called once during
+/// program startup, and never again while the program is running.

 void MovePicker::init_phase_table() {
+
  int i = 0;

  // Main search
@@ -492,12 +459,14 @@ void MovePicker::init_phase_table() {

  // Quiescence search with checks
  QsearchWithChecksPhaseIndex = i - 1;
+  PhaseTable[i++] = PH_TT_MOVE;
  PhaseTable[i++] = PH_QCAPTURES;
  PhaseTable[i++] = PH_QCHECKS;
  PhaseTable[i++] = PH_STOP;

  // Quiescence search without checks
  QsearchWithoutChecksPhaseIndex = i - 1;
+  PhaseTable[i++] = PH_TT_MOVE;
  PhaseTable[i++] = PH_QCAPTURES;
  PhaseTable[i++] = PH_STOP;
 }
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -33,6 +34,9 @@
 //// Types
 ////

+struct EvalInfo;
+struct SearchStack;
+
 /// MovePicker is a class which is used to pick one legal move at a time from
 /// the current position.  It is initialized with a Position object and a few
 /// moves we have reason to believe are good.  The most important method is
@@ -43,14 +47,30 @@

 class MovePicker {

+  MovePicker& operator=(const MovePicker&); // Silence a warning under MSVC
+
 public:
-  MovePicker(Position &p, bool pvnode, Move ttm, Move mk, Move k1, Move k2,
-             Depth dpth);
+
+  enum MovegenPhase {
+    PH_TT_MOVE,        // Transposition table move
+    PH_MATE_KILLER,    // Mate killer from the current ply
+    PH_GOOD_CAPTURES,  // Queen promotions and captures with SEE values >= 0
+    PH_BAD_CAPTURES,   // Queen promotions and captures with SEE values < 0
+    PH_KILLER_1,       // Killer move 1 from the current ply (not used yet).
+    PH_KILLER_2,       // Killer move 2 from the current ply (not used yet).
+    PH_NONCAPTURES,    // Non-captures and underpromotions
+    PH_EVASIONS,       // Check evasions
+    PH_QCAPTURES,      // Captures in quiescence search
+    PH_QCHECKS,        // Checks in quiescence search
+    PH_STOP
+  };
+
+  MovePicker(const Position& p, bool pvnode, Move ttm, const SearchStack& ss, Depth d);
  Move get_next_move();
  Move get_next_move(Lock &lock);
  int number_of_moves() const;
  int current_move_score() const;
-  Bitboard discovered_check_candidates();
+  Bitboard discovered_check_candidates() const;

  static void init_phase_table();

@@ -60,8 +80,9 @@ private:
  void score_evasions();
  void score_qcaptures();
  Move pick_move_from_list();
-  
-  Position *pos;
+  int find_best_index() const;
+
+  const Position& pos;
  Move ttMove, mateKiller, killer1, killer2;
  Bitboard pinned, dc;
  MoveStack moves[256], badCaptures[64];
@@ -69,7 +90,7 @@ private:
  Depth depth;
  int phaseIndex;
  int numOfMoves, numOfBadCaptures;
-  int movesPicked, badCapturesPicked;
+  int movesPicked;
  bool finished;
 };

@@ -78,11 +99,20 @@ private:
 //// Inline functions
 ////

+/// MovePicker::number_of_moves() simply returns the numOfMoves member
+/// variable. It is intended to be used in positions where the side to move
+/// is in check, for detecting checkmates or situations where there is only
+/// a single reply to check.
+
+inline int MovePicker::number_of_moves() const {
+  return numOfMoves;
+}
+
 /// MovePicker::discovered_check_candidates() returns a bitboard containing
 /// all pieces which can possibly give discovered check.  This bitboard is
 /// computed by the constructor function.

-inline Bitboard MovePicker::discovered_check_candidates() {
+inline Bitboard MovePicker::discovered_check_candidates() const {
  return dc;
 }

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -22,8 +23,10 @@
 ////

 #include <cassert>
+#include <cstring>

 #include "pawns.h"
+#include "position.h"


 ////
@@ -70,13 +73,13 @@ namespace {
    Value(32), Value(32), Value(32), Value(28)
  };

-  // Pawn chain membership bonus by file, middle game. 
+  // Pawn chain membership bonus by file, middle game.
  const Value ChainMidgameBonus[8] = {
    Value(14), Value(16), Value(17), Value(18),
    Value(18), Value(17), Value(16), Value(14)
  };

-  // Pawn chain membership bonus by file, endgame. 
+  // Pawn chain membership bonus by file, endgame.
  const Value ChainEndgameBonus[8] = {
    Value(16), Value(16), Value(16), Value(16),
    Value(16), Value(16), Value(16), Value(16)
@@ -84,50 +87,45 @@ namespace {

  // Candidate passed pawn bonus by rank, middle game.
  const Value CandidateMidgameBonus[8] = {
-    Value(0), Value(12), Value(12), Value(20),
-    Value(40), Value(90), Value(0), Value(0)
+    Value( 0), Value(12), Value(12), Value(20),
+    Value(40), Value(90), Value( 0), Value( 0)
  };

  // Candidate passed pawn bonus by rank, endgame.
  const Value CandidateEndgameBonus[8] = {
-    Value(0), Value(24), Value(24), Value(40),
-    Value(80), Value(180), Value(0), Value(0)
+    Value( 0), Value(24), Value(24), Value(40),
+    Value(80), Value(180), Value(0), Value( 0)
  };

-  // Evaluate pawn storms?
-  const bool EvaluatePawnStorms = true;
-
  // Pawn storm tables for positions with opposite castling:
  const int QStormTable[64] = {
-    0, 0, 0, 0, 0, 0, 0, 0,
-    -22, -22, -22, -13, -4, 0, 0, 0,
-    -4, -9, -9, -9, -4, 0, 0, 0,
+    0,  0,  0,  0, 0, 0, 0, 0,
+  -22,-22,-22,-13,-4, 0, 0, 0,
+   -4, -9, -9, -9,-4, 0, 0, 0,
    9, 18, 22, 18, 9, 0, 0, 0,
-    22, 31, 31, 22, 0, 0, 0, 0,
-    31, 40, 40, 31, 0, 0, 0, 0,
-    31, 40, 40, 31, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0
+   22, 31, 31, 22, 0, 0, 0, 0,
+   31, 40, 40, 31, 0, 0, 0, 0,
+   31, 40, 40, 31, 0, 0, 0, 0,
+    0,  0,  0,  0, 0, 0, 0, 0
  };
-  
+
  const int KStormTable[64] = {
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, -4, -13, -22, -27, -27,
-    0, 0, 0, -4, -9, -13, -18, -18,
-    0, 0, 0, 0, 9, 9, 9, 9,
-    0, 0, 0, 0, 9, 18, 27, 27,
-    0, 0, 0, 0, 9, 27, 40, 36,
-    0, 0, 0, 0, 0, 31, 40, 31,
-    0, 0, 0, 0, 0, 0, 0, 0
+    0, 0, 0, 0,  0,  0,  0,  0,
+    0, 0, 0,-4,-13,-22,-27,-27,
+    0, 0, 0,-4, -9,-13,-18,-18,
+    0, 0, 0, 0,  9,  9,  9,  9,
+    0, 0, 0, 0,  9, 18, 27, 27,
+    0, 0, 0, 0,  9, 27, 40, 36,
+    0, 0, 0, 0,  0, 31, 40, 31,
+    0, 0, 0, 0,  0,  0,  0,  0
  };

-  // Pawn storm open file bonuses by file:
-  const int KStormOpenFileBonus[8] = {
-    45, 45, 30, 0, 0, 0, 0, 0
-  };
+  // Pawn storm open file bonuses by file
+  const int16_t KStormOpenFileBonus[8] = { 45, 45, 30, 0, 0, 0, 0, 0 };
+  const int16_t QStormOpenFileBonus[8] = { 0, 0, 0, 0, 0, 30, 45, 30 };

-  const int QStormOpenFileBonus[8] = {
-    0, 0, 0, 0, 0, 30, 45, 30
-  };
+  // Pawn storm lever bonuses by file
+  const int StormLeverBonus[8] = { 20, 20, 10, 0, 0, 10, 20, 20 };

 }

@@ -139,14 +137,16 @@ namespace {
 /// Constructor

 PawnInfoTable::PawnInfoTable(unsigned numOfEntries) {
+
  size = numOfEntries;
  entries = new PawnInfo[size];
-  if(entries == NULL) {
-    std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
-              << " bytes for pawn hash table." << std::endl;
-    exit(EXIT_FAILURE);
+  if (entries == NULL)
+  {
+      std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
+                << " bytes for pawn hash table." << std::endl;
+      exit(EXIT_FAILURE);
  }
-  this->clear();
+  clear();
 }


@@ -166,220 +166,231 @@ void PawnInfoTable::clear() {


 /// PawnInfoTable::get_pawn_info() takes a position object as input, computes
-/// a PawnInfo object, and returns a pointer to it.  The result is also 
+/// a PawnInfo object, and returns a pointer to it.  The result is also
 /// stored in a hash table, so we don't have to recompute everything when
 /// the same pawn structure occurs again.

 PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
+
  assert(pos.is_ok());

  Key key = pos.get_pawn_key();
  int index = int(key & (size - 1));
  PawnInfo *pi = entries + index;

-  // If pi->key matches the position's pawn hash key, it means that we 
+  // If pi->key matches the position's pawn hash key, it means that we
  // have analysed this pawn structure before, and we can simply return the
-  // information we found the last time instead of recomputing it:
-  if(pi->key == key)
-    return pi;
+  // information we found the last time instead of recomputing it
+  if (pi->key == key)
+      return pi;

-  // Clear the PawnInfo object, and set the key:
+  // Clear the PawnInfo object, and set the key
  pi->clear();
  pi->key = key;

  Value mgValue[2] = {Value(0), Value(0)};
  Value egValue[2] = {Value(0), Value(0)};

-  // Loop through the pawns for both colors:
-  for(Color us = WHITE; us <= BLACK; us++) {
+  // Loop through the pawns for both colors
+  for (Color us = WHITE; us <= BLACK; us++)
+  {
    Color them = opposite_color(us);
    Bitboard ourPawns = pos.pawns(us);
    Bitboard theirPawns = pos.pawns(them);
    Bitboard pawns = ourPawns;
+    int bonus;

-    // Initialize pawn storm scores by giving bonuses for open files:
-    if(EvaluatePawnStorms)
-      for(File f = FILE_A; f <= FILE_H; f++)
-        if(pos.file_is_half_open(us, f)) {
-          pi->ksStormValue[us] += KStormOpenFileBonus[f];
-          pi->qsStormValue[us] += QStormOpenFileBonus[f];
+    // Initialize pawn storm scores by giving bonuses for open files
+    for (File f = FILE_A; f <= FILE_H; f++)
+        if (pos.file_is_half_open(us, f))
+        {
+            pi->ksStormValue[us] += KStormOpenFileBonus[f];
+            pi->qsStormValue[us] += QStormOpenFileBonus[f];
        }

-    // Loop through all pawns of the current color and score each pawn:
-    while(pawns) {
-      Square s = pop_1st_bit(&pawns);
-      File f = square_file(s);
-      Rank r = square_rank(s);
-      bool passed, doubled, isolated, backward, chain, candidate;
-      int bonus;
+    // Loop through all pawns of the current color and score each pawn
+    while (pawns)
+    {
+        bool passed, doubled, isolated, backward, chain, candidate;
+        Square s = pop_1st_bit(&pawns);
+        File f = square_file(s);
+        Rank r = square_rank(s);

-      assert(pos.piece_on(s) == pawn_of_color(us));
+        assert(pos.piece_on(s) == piece_of_color_and_type(us, PAWN));

-      // The file containing the pawn is not half open:
-      pi->halfOpenFiles[us] &= ~(1 << f);
+        // The file containing the pawn is not half open
+        pi->halfOpenFiles[us] &= ~(1 << f);

-      // Passed, isolated or doubled pawn?
-      passed = pos.pawn_is_passed(us, s);
-      isolated = pos.pawn_is_isolated(us, s);
-      doubled = pos.pawn_is_doubled(us, s);
+        // Passed, isolated or doubled pawn?
+        passed = pos.pawn_is_passed(us, s);
+        isolated = pos.pawn_is_isolated(us, s);
+        doubled = pos.pawn_is_doubled(us, s);

-      if(EvaluatePawnStorms) {
        // We calculate kingside and queenside pawn storm
-        // scores for both colors.  These are used when evaluating
+        // scores for both colors. These are used when evaluating
        // middle game positions with opposite side castling.
        //
        // Each pawn is given a base score given by a piece square table
-        // (KStormTable[] or QStormTable[]).  This score is increased if
-        // there are enemy pawns on adjacent files in front of the pawn.
-        // This is because we want to be able to open files against the
-        // enemy king, and to avoid blocking the pawn structure (e.g. white
-        // pawns on h6, g5, black pawns on h7, g6, f7).
-        
-        // Kingside pawn storms:
+        // (KStormTable[] or QStormTable[]). Pawns which seem to have good
+        // chances of creating an open file by exchanging itself against an
+        // enemy pawn on an adjacent file gets an additional bonus.
+
+        // Kingside pawn storms
        bonus = KStormTable[relative_square(us, s)];
-        if(bonus > 0 && outpost_mask(us, s) & theirPawns) {
-          switch(f) {
-
-          case FILE_F:
-            bonus += bonus / 4;
-            break;
-
-          case FILE_G:
-            bonus += bonus / 2 + bonus / 4;
-            break;
-
-          case FILE_H:
-            bonus += bonus / 2;
-            break;
-
-          default:
-            break;
-          }
+        if (f >= FILE_F)
+        {
+            Bitboard b = outpost_mask(us, s) & theirPawns & (FileFBB | FileGBB | FileHBB);
+            while (b)
+            {
+                Square s2 = pop_1st_bit(&b);
+                if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
+                {
+                    // The enemy pawn has no pawn beside itself, which makes it
+                    // particularly vulnerable. Big bonus, especially against a
+                    // weakness on the rook file.
+                    if (square_file(s2) == FILE_H)
+                        bonus += 4*StormLeverBonus[f] - 8*square_distance(s, s2);
+                    else
+                        bonus += 2*StormLeverBonus[f] - 4*square_distance(s, s2);
+                } else
+                    // There is at least one enemy pawn beside the enemy pawn we look
+                    // at, which means that the pawn has somewhat better chances of
+                    // defending itself by advancing. Smaller bonus.
+                    bonus += StormLeverBonus[f] - 2*square_distance(s, s2);
+            }
        }
        pi->ksStormValue[us] += bonus;

-        // Queenside pawn storms:
+        // Queenside pawn storms
        bonus = QStormTable[relative_square(us, s)];
-        if(bonus > 0 && passed_pawn_mask(us, s) & theirPawns) {
-          switch(f) {
-
-          case FILE_A:
-            bonus += bonus / 2;
-            break;
-
-          case FILE_B:
-            bonus += bonus / 2 + bonus / 4;
-            break;
-
-          case FILE_C:
-            bonus += bonus / 2;
-            break;
-
-          default:
-            break;
-          }
+        if (f <= FILE_C)
+        {
+            Bitboard b = outpost_mask(us, s) & theirPawns & (FileABB | FileBBB | FileCBB);
+            while (b)
+            {
+                Square s2 = pop_1st_bit(&b);
+                if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
+                {
+                    // The enemy pawn has no pawn beside itself, which makes it
+                    // particularly vulnerable. Big bonus, especially against a
+                    // weakness on the rook file.
+                    if (square_file(s2) == FILE_A)
+                        bonus += 4*StormLeverBonus[f] - 16*square_distance(s, s2);
+                    else
+                        bonus += 2*StormLeverBonus[f] - 8*square_distance(s, s2);
+                } else
+                    // There is at least one enemy pawn beside the enemy pawn we look
+                    // at, which means that the pawn has somewhat better chances of
+                    // defending itself by advancing. Smaller bonus.
+                    bonus += StormLeverBonus[f] - 4*square_distance(s, s2);
+            }
        }
        pi->qsStormValue[us] += bonus;
-      }
-      
-      // Member of a pawn chain?  We could speed up the test a little by 
-      // introducing an array of masks indexed by color and square for doing
-      // the test, but because everything is hashed, it probably won't make
-      // any noticable difference.
-      chain = (us == WHITE)?
-        (ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r-1))) :
-        (ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r+1)));

+        // Member of a pawn chain (but not the backward one)? We could speed up
+        // the test a little by introducing an array of masks indexed by color
+        // and square for doing the test, but because everything is hashed,
+        // it probably won't make any noticable difference.
+        chain =  ourPawns
+               & neighboring_files_bb(f)
+               & (rank_bb(r) | rank_bb(r - (us == WHITE ? 1 : -1)));

-      // Test for backward pawn.
-
-      // If the pawn is isolated, passed, or member of a pawn chain, it cannot
-      // be backward:
-      if(passed || isolated || chain)
-        backward = false;
-      // If the pawn can capture an enemy pawn, it's not backward:
-      else if(pos.pawn_attacks(us, s) & theirPawns)
-        backward = false;
-      // Check for friendly pawns behind on neighboring files:
-      else if(ourPawns & in_front_bb(them, r) & neighboring_files_bb(f))
-        backward = false;
-      else {
-        // We now know that there is no friendly pawns beside or behind this
-        // pawn on neighboring files.  We now check whether the pawn is
-        // backward by looking in the forward direction on the neighboring
-        // files, and seeing whether we meet a friendly or an enemy pawn first.
-        Bitboard b;
-        if(us == WHITE) {
-          for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b<<=8);
-          backward = (b | (b << 8)) & theirPawns;
+        // Test for backward pawn
+        //
+        // If the pawn is passed, isolated, or member of a pawn chain
+        // it cannot be backward. If can capture an enemy pawn or if
+        // there are friendly pawns behind on neighboring files it cannot
+        // be backward either.
+        if (   passed
+            || isolated
+            || chain
+            || (pos.pawn_attacks(us, s) & theirPawns)
+            || (ourPawns & behind_bb(us, r) & neighboring_files_bb(f)))
+            backward = false;
+        else
+        {
+            // We now know that there are no friendly pawns beside or behind this
+            // pawn on neighboring files. We now check whether the pawn is
+            // backward by looking in the forward direction on the neighboring
+            // files, and seeing whether we meet a friendly or an enemy pawn first.
+            Bitboard b;
+            if (us == WHITE)
+            {
+                for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b <<= 8);
+                backward = (b | (b << 8)) & theirPawns;
+            }
+            else
+            {
+                for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b >>= 8);
+                backward = (b | (b >> 8)) & theirPawns;
+            }
        }
-        else {
-          for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b>>=8);
-          backward = (b | (b >> 8)) & theirPawns;
+
+        // Test for candidate passed pawn
+        candidate =    !passed
+                     && pos.file_is_half_open(them, f)
+                     && (  count_1s_max_15(neighboring_files_bb(f) & (behind_bb(us, r) | rank_bb(r)) & ourPawns)
+                         - count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r)              & theirPawns)
+                         >= 0);
+
+        // In order to prevent doubled passed pawns from receiving a too big
+        // bonus, only the frontmost passed pawn on each file is considered as
+        // a true passed pawn.
+        if (passed && (ourPawns & squares_in_front_of(us, s)))
+        {
+            // candidate = true;
+            passed = false;
        }
-      }

-      // Test for candidate passed pawn.
-      candidate =
-        (!passed && pos.file_is_half_open(them, f) &&
-         count_1s_max_15(neighboring_files_bb(f)
-                         & (in_front_bb(them, r) | rank_bb(r))
-                         & ourPawns)
-         - count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r)
-                           & theirPawns)
-         >= 0);
-
-      // In order to prevent doubled passed pawns from receiving a too big
-      // bonus, only the frontmost passed pawn on each file is considered as
-      // a true passed pawn.
-      if(passed && (ourPawns & squares_in_front_of(us, s))) {
-        // candidate = true;
-        passed = false;
-      }
-
-      // Score this pawn:
-      Value mv = Value(0), ev = Value(0);
-      if(isolated) {
-        mv -= IsolatedPawnMidgamePenalty[f];
-        ev -= IsolatedPawnEndgamePenalty[f];
-        if(pos.file_is_half_open(them, f)) {
-          mv -= IsolatedPawnMidgamePenalty[f] / 2;
-          ev -= IsolatedPawnEndgamePenalty[f] / 2;
+        // Score this pawn
+        Value mv = Value(0), ev = Value(0);
+        if (isolated)
+        {
+            mv -= IsolatedPawnMidgamePenalty[f];
+            ev -= IsolatedPawnEndgamePenalty[f];
+            if (pos.file_is_half_open(them, f))
+            {
+                mv -= IsolatedPawnMidgamePenalty[f] / 2;
+                ev -= IsolatedPawnEndgamePenalty[f] / 2;
+            }
        }
-      }
-      if(doubled)  {
-        mv -= DoubledPawnMidgamePenalty[f];
-        ev -= DoubledPawnEndgamePenalty[f];
-      }
-      if(backward)  {
-        mv -= BackwardPawnMidgamePenalty[f];
-        ev -= BackwardPawnEndgamePenalty[f];
-        if(pos.file_is_half_open(them, f)) {
-          mv -= BackwardPawnMidgamePenalty[f] / 2;
-          ev -= BackwardPawnEndgamePenalty[f] / 2;
+        if (doubled)
+        {
+            mv -= DoubledPawnMidgamePenalty[f];
+            ev -= DoubledPawnEndgamePenalty[f];
+        }
+        if (backward)
+        {
+            mv -= BackwardPawnMidgamePenalty[f];
+            ev -= BackwardPawnEndgamePenalty[f];
+            if (pos.file_is_half_open(them, f))
+            {
+                mv -= BackwardPawnMidgamePenalty[f] / 2;
+                ev -= BackwardPawnEndgamePenalty[f] / 2;
+            }
+        }
+        if (chain)
+        {
+            mv += ChainMidgameBonus[f];
+            ev += ChainEndgameBonus[f];
+        }
+        if (candidate)
+        {
+            mv += CandidateMidgameBonus[relative_rank(us, s)];
+            ev += CandidateEndgameBonus[relative_rank(us, s)];
        }
-      }
-      if(chain) {
-        mv += ChainMidgameBonus[f];
-        ev += ChainEndgameBonus[f];
-      }
-      if(candidate) {
-        mv += CandidateMidgameBonus[pawn_rank(us, s)];
-        ev += CandidateEndgameBonus[pawn_rank(us, s)];
-      }

-      mgValue[us] += mv;
-      egValue[us] += ev;
-        
-      // If the pawn is passed, set the square of the pawn in the passedPawns
-      // bitboard:
-      if(passed)
-        set_bit(&(pi->passedPawns), s);
-    }
-  }
+        mgValue[us] += mv;
+        egValue[us] += ev;
+
+        // If the pawn is passed, set the square of the pawn in the passedPawns
+        // bitboard
+        if (passed)
+            set_bit(&(pi->passedPawns), s);
+    } // while(pawns)
+  } // for(colors)

  pi->mgValue = int16_t(mgValue[WHITE] - mgValue[BLACK]);
  pi->egValue = int16_t(egValue[WHITE] - egValue[BLACK]);
-
  return pi;
 }
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -24,19 +25,20 @@
 //// Includes
 ////

-#include "position.h"
-
+#include "bitboard.h"
+#include "value.h"

 ////
 //// Types
 ////

-/// PawnInfo is a class which contains various information about a pawn 
+/// PawnInfo is a class which contains various information about a pawn
 /// structure.  Currently, it only includes a middle game and an end game
 /// pawn structure evaluation, and a bitboard of passed pawns.  We may want
 /// to add further information in the future.  A lookup to the pawn hash table
 /// (performed by calling the get_pawn_info method in a PawnInfoTable object)
 /// returns a pointer to a PawnInfo object.
+class Position;

 class PawnInfo {

@@ -48,9 +50,9 @@ public:
  Value kingside_storm_value(Color c) const;
  Value queenside_storm_value(Color c) const;
  Bitboard passed_pawns() const;
-  bool file_is_half_open(Color c, File f) const;
-  bool has_open_file_to_left(Color c, File f) const;
-  bool has_open_file_to_right(Color c, File f) const;
+  int file_is_half_open(Color c, File f) const;
+  int has_open_file_to_left(Color c, File f) const;
+  int has_open_file_to_right(Color c, File f) const;

 private:
  void clear();
@@ -58,7 +60,7 @@ private:
  Key key;
  Bitboard passedPawns;
  int16_t mgValue, egValue;
-  int8_t ksStormValue[2], qsStormValue[2];
+  int16_t ksStormValue[2], qsStormValue[2];
  uint8_t halfOpenFiles[2];
 };

@@ -74,11 +76,11 @@ public:
  PawnInfoTable(unsigned numOfEntries);
  ~PawnInfoTable();
  void clear();
-  PawnInfo *get_pawn_info(const Position &pos);
+  PawnInfo* get_pawn_info(const Position& pos);

 private:
  unsigned size;
-  PawnInfo *entries;
+  PawnInfo* entries;
 };


@@ -106,21 +108,22 @@ inline Value PawnInfo::queenside_storm_value(Color c) const {
  return Value(qsStormValue[c]);
 }

-inline bool PawnInfo::file_is_half_open(Color c, File f) const {
+inline int PawnInfo::file_is_half_open(Color c, File f) const {
  return (halfOpenFiles[c] & (1 << int(f)));
 }

-inline bool PawnInfo::has_open_file_to_left(Color c, File f) const {
+inline int PawnInfo::has_open_file_to_left(Color c, File f) const {
  return halfOpenFiles[c] & ((1 << int(f)) - 1);
 }

-inline bool PawnInfo::has_open_file_to_right(Color c, File f) const {
+inline int PawnInfo::has_open_file_to_right(Color c, File f) const {
  return halfOpenFiles[c] & ~((1 << int(f+1)) - 1);
 }

 inline void PawnInfo::clear() {
-  mgValue = egValue = 0;
+
  passedPawns = EmptyBoardBB;
+  mgValue = egValue = 0;
  ksStormValue[WHITE] = ksStormValue[BLACK] = 0;
  qsStormValue[WHITE] = qsStormValue[BLACK] = 0;
  halfOpenFiles[WHITE] = halfOpenFiles[BLACK] = 0xFF;
@@ -1,33 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(PHASE_H_INCLUDED)
-#define PHASE_H_INCLUDED
-
-////
-//// Types
-////
-
-enum Phase {
-  PHASE_ENDGAME = 0,
-  PHASE_MIDGAME = 128
-};
-
-
-#endif // !defined(PHASE_H_INCLUDED)
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -21,74 +22,28 @@
 //// Includes
 ////

-#include <cstring>
+#include <string>

 #include "piece.h"

-
-////
-//// Constants and variables
-////
-
-const int SlidingArray[18] = {
-  0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0
-};
-
-const SquareDelta Directions[16][16] = {
-  {DELTA_ZERO},
-  {DELTA_NW, DELTA_NE, DELTA_ZERO},
-  {DELTA_SSW, DELTA_SSE, DELTA_SWW, DELTA_SEE,
-   DELTA_NWW, DELTA_NEE, DELTA_NNW, DELTA_NNE, DELTA_ZERO},
-  {DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_ZERO},
-  {DELTA_ZERO},
-  {DELTA_SW, DELTA_SE, DELTA_ZERO},
-  {DELTA_SSW, DELTA_SSE, DELTA_SWW, DELTA_SEE,
-   DELTA_NWW, DELTA_NEE, DELTA_NNW, DELTA_NNE, DELTA_ZERO},
-  {DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-};   
-
-const SquareDelta PawnPush[2] = {
-  DELTA_N, DELTA_S
-};
-
+using namespace std;

 ////
 //// Functions
 ////

-/// Translating piece types to/from English piece letters:
+/// Translating piece types to/from English piece letters

-static const char PieceChars[] = " pnbrqk";
+static const string PieceChars(" pnbrqk PNBRQK");

-char piece_type_to_char(PieceType pt, bool upcase = false) {
-  return upcase? toupper(PieceChars[pt]) : PieceChars[pt];
+char piece_type_to_char(PieceType pt, bool upcase) {
+
+  return PieceChars[pt + upcase * 7];
 }

 PieceType piece_type_from_char(char c) {
-  const char *ch = strchr(PieceChars, tolower(c));
-  return ch? PieceType(ch - PieceChars) : NO_PIECE_TYPE;
-}
-
-
-/// piece_is_ok() and piece_type_is_ok(), for debugging:
-
-bool piece_is_ok(Piece pc) {
-  return
-    piece_type_is_ok(type_of_piece(pc)) &&
-    color_is_ok(color_of_piece(pc));
-}
-
-bool piece_type_is_ok(PieceType pc) {
-  return pc >= PAWN && pc <= KING;
+
+  size_t idx = PieceChars.find(c);
+
+  return idx != string::npos ? PieceType(idx % 7) : NO_PIECE_TYPE;
 }
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -20,16 +21,15 @@
 #if !defined(PIECE_H_INCLUDED)
 #define PIECE_H_INCLUDED

-//// 
+////
 //// Includes
 ////

 #include "color.h"
-#include "misc.h"
 #include "square.h"


-//// 
+////
 //// Types
 ////

@@ -46,18 +46,15 @@ enum Piece {


 ////
-//// Constants and variables
+//// Constants
 ////

-const PieceType PieceTypeMin = PAWN;
-const PieceType PieceTypeMax = KING;
-
-extern const int SlidingArray[18];
-extern const SquareDelta Directions[16][16];   
-extern const SquareDelta PawnPush[2];
+const int SlidingArray[18] = {
+  0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0
+};


-//// 
+////
 //// Inline functions
 ////

@@ -82,51 +79,33 @@ inline Piece piece_of_color_and_type(Color c, PieceType pt) {
  return Piece((int(c) << 3) | int(pt));
 }

-inline Piece pawn_of_color(Color c) {
-  return piece_of_color_and_type(c, PAWN);
-}
-
-inline Piece knight_of_color(Color c) {
-  return piece_of_color_and_type(c, KNIGHT);
-}
-
-inline Piece bishop_of_color(Color c) {
-  return piece_of_color_and_type(c, BISHOP);
-}
-
-inline Piece rook_of_color(Color c) {
-  return piece_of_color_and_type(c, ROOK);
-}
-
-inline Piece queen_of_color(Color c) {
-  return piece_of_color_and_type(c, QUEEN);
-}
-
-inline Piece king_of_color(Color c) {
-  return piece_of_color_and_type(c, KING);
-}
-
 inline int piece_is_slider(Piece p) {
  return SlidingArray[int(p)];
 }

-inline int piece_type_is_slider(PieceType pt) {
+inline int piece_is_slider(PieceType pt) {
  return SlidingArray[int(pt)];
 }

 inline SquareDelta pawn_push(Color c) {
-  return PawnPush[c];
+    return (c == WHITE ? DELTA_N : DELTA_S);
 }
-  
+
+inline bool piece_type_is_ok(PieceType pc) {
+  return pc >= PAWN && pc <= KING;
+}
+
+inline bool piece_is_ok(Piece pc) {
+  return piece_type_is_ok(type_of_piece(pc)) && color_is_ok(color_of_piece(pc));
+}
+

 ////
 //// Prototypes
 ////

-extern char piece_type_to_char(PieceType pt, bool upcase);
+extern char piece_type_to_char(PieceType pt, bool upcase = false);
 extern PieceType piece_type_from_char(char c);
-extern bool piece_is_ok(Piece pc);
-extern bool piece_type_is_ok(PieceType pt);


 #endif // !defined(PIECE_H_INCLUDED)
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -20,6 +21,18 @@
 #if !defined(POSITION_H_INCLUDED)
 #define POSITION_H_INCLUDED

+// Disable a silly and noisy warning from MSVC compiler
+#if defined(_MSC_VER)
+
+// Forcing value to bool 'true' or 'false' (performance warning)
+#pragma warning(disable: 4800)
+
+// Conditional expression is constant
+#pragma warning(disable: 4127)
+
+
+#endif
+
 ////
 //// Includes
 ////
@@ -29,7 +42,6 @@
 #include "direction.h"
 #include "move.h"
 #include "piece.h"
-#include "phase.h"
 #include "square.h"
 #include "value.h"

@@ -39,7 +51,7 @@
 ////

 /// FEN string for the initial position:
-const std::string StartPosition = 
+const std::string StartPosition =
  "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";

 /// Maximum number of plies per game (220 should be enough, because the
@@ -52,36 +64,44 @@ const int MaxGameLength = 220;
 //// Types
 ////

-/// Castle rights, encoded as bit fields:
+/// Castle rights, encoded as bit fields

 enum CastleRights {
-  NO_CASTLES = 0, 
-  WHITE_OO = 1, BLACK_OO = 2, 
-  WHITE_OOO = 4, BLACK_OOO = 8,
+  NO_CASTLES = 0,
+  WHITE_OO = 1,
+  BLACK_OO = 2,
+  WHITE_OOO = 4,
+  BLACK_OOO = 8,
  ALL_CASTLES = 15
 };

+/// Game phase
+enum Phase {
+  PHASE_ENDGAME = 0,
+  PHASE_MIDGAME = 128
+};

-/// The UndoInfo struct stores information we need to restore a Position
-/// object to its previous state when we retract a move.  Whenever a move
-/// is made on the board (by calling Position::do_move), an UndoInfo object
-/// must be passed as a parameter.  When the move is unmade (by calling
-/// Position::undo_move), the same UndoInfo object must be passed again.

-struct UndoInfo {
-  int castleRights;
-  Square epSquare;
-  Bitboard checkersBB;
+/// The StateInfo struct stores information we need to restore a Position
+/// object to its previous state when we retract a move. Whenever a move
+/// is made on the board (by calling Position::do_move), an StateInfo object
+/// must be passed as a parameter.
+
+struct StateInfo {
  Key key, pawnKey, materialKey;
-  int rule50;
-  Move lastMove;
-  PieceType capture;
+  int castleRights, rule50;
+  Square epSquare;
  Value mgValue, egValue;
+
+  PieceType capture;
+  Bitboard checkersBB;
+  Move lastMove;
+  StateInfo* previous;
 };


 /// The position data structure.  A position consists of the following data:
-///    
+///
 ///    * For each piece type, a bitboard representing the squares occupied
 ///      by pieces of that type.
 ///    * For each color, a bitboard representing the squares occupiecd by
@@ -106,17 +126,18 @@ struct UndoInfo {
 class Position {

  friend class MaterialInfo;
+  friend class EndgameFunctions;

 public:
  // Constructors
-  Position();
-  Position(const Position &pos);
-  Position(const std::string &fen);
+  Position() {};
+  Position(const Position& pos);
+  Position(const std::string& fen);

  // Text input/output
-  void from_fen(const std::string &fen);
+  void from_fen(const std::string& fen);
  const std::string to_fen() const;
-  void print() const;
+  void print(Move m = MOVE_NONE) const;

  // Copying
  void copy(const Position &pos);
@@ -161,19 +182,14 @@ public:

  // Number of pieces of each color and type
  int piece_count(Color c, PieceType pt) const;
-  int pawn_count(Color c) const;
-  int knight_count(Color c) const;
-  int bishop_count(Color c) const;
-  int rook_count(Color c) const;
-  int queen_count(Color c) const;

-  // The en passant square:
+  // The en passant square
  Square ep_square() const;

  // Current king position for each color
  Square king_square(Color c) const;

-  // Castling rights.
+  // Castling rights
  bool can_castle_kingside(Color c) const;
  bool can_castle_queenside(Color c) const;
  bool can_castle(Color c) const;
@@ -184,49 +200,40 @@ public:
  Bitboard sliding_attacks(Square s, Direction d) const;
  Bitboard ray_attacks(Square s, SignedDirection d) const;
  Bitboard pawn_attacks(Color c, Square s) const;
-  Bitboard white_pawn_attacks(Square s) const;
-  Bitboard black_pawn_attacks(Square s) const;
-  Bitboard knight_attacks(Square s) const;
-  Bitboard bishop_attacks(Square s) const;
-  Bitboard rook_attacks(Square s) const;
-  Bitboard queen_attacks(Square s) const;
-  Bitboard king_attacks(Square s) const;
+
+  template<PieceType>
+  Bitboard piece_attacks(Square s) const;

  // Bitboards for pinned pieces and discovered check candidates
  Bitboard discovered_check_candidates(Color c) const;
+  Bitboard pinned_pieces(Color c, Bitboard& p) const;
  Bitboard pinned_pieces(Color c) const;

  // Checking pieces
  Bitboard checkers() const;

-  // Piece lists:
+  // Piece lists
  Square piece_list(Color c, PieceType pt, int index) const;
-  Square pawn_list(Color c, int index) const;
-  Square knight_list(Color c, int index) const;
-  Square bishop_list(Color c, int index) const;
-  Square rook_list(Color c, int index) const;
-  Square queen_list(Color c, int index) const;

  // Attack information for a given square
  bool square_is_attacked(Square s, Color c) const;
  Bitboard attacks_to(Square s) const;
  Bitboard attacks_to(Square s, Color c) const;
  bool is_check() const;
-  bool piece_attacks_square(Square f, Square t) const;
-  bool white_pawn_attacks_square(Square f, Square t) const;
-  bool black_pawn_attacks_square(Square f, Square t) const;
-  bool knight_attacks_square(Square f, Square t) const;
-  bool bishop_attacks_square(Square f, Square t) const;
-  bool rook_attacks_square(Square f, Square t) const;
-  bool queen_attacks_square(Square f, Square t) const;
-  bool king_attacks_square(Square f, Square t) const;
+  bool pawn_attacks_square(Color c, Square f, Square t) const;
+
+  template<PieceType>
+  Bitboard piece_attacks_square(Square f, Square t) const; // Dispatch at compile-time
+
+  bool piece_attacks_square(Piece p, Square f, Square t) const; // Dispatch at run-time

  // Properties of moves
-  bool move_is_legal(Move m) const;
-  bool move_is_legal(Move m, Bitboard pinned) const;
+  bool pl_move_is_legal(Move m) const;
+  bool pl_move_is_legal(Move m, Bitboard pinned) const;
  bool move_is_check(Move m) const;
  bool move_is_check(Move m, Bitboard dcCandidates) const;
  bool move_is_capture(Move m) const;
+  bool move_is_deep_pawn_push(Move m) const;
  bool move_is_pawn_push_to_7th(Move m) const;
  bool move_is_passed_pawn_push(Move m) const;
  bool move_was_passed_pawn_push(Move m) const;
@@ -245,17 +252,17 @@ public:
  bool square_is_weak(Square s, Color c) const;

  // Doing and undoing moves
-  void backup(UndoInfo &u) const;
-  void restore(const UndoInfo &u);
-  void do_move(Move m, UndoInfo &u);
-  void do_move(Move m, UndoInfo &u, Bitboard dcCandidates);
-  void undo_move(Move m, const UndoInfo &u);
-  void do_null_move(UndoInfo &u);
-  void undo_null_move(const UndoInfo &u);
+  void setStartState(const StateInfo& st);
+  void do_move(Move m, StateInfo& st);
+  void do_move(Move m, StateInfo& st, Bitboard dcCandidates);
+  void undo_move(Move m);
+  void do_null_move(StateInfo& st);
+  void undo_null_move();

  // Static exchange evaluation
  int see(Square from, Square to) const;
  int see(Move m) const;
+  int see(Square to) const;

  // Accessing hash keys
  Key get_key() const;
@@ -267,9 +274,10 @@ public:
  Value eg_value() const;
  Value non_pawn_material(Color c) const;
  Phase game_phase() const;
+  Value mg_pst_delta(Move m) const;

  // Game termination checks
-  bool is_mate();
+  bool is_mate() const;
  bool is_draw() const;

  // Check if one side threatens a mate in one
@@ -284,15 +292,16 @@ public:

  // Reset the gamePly variable to 0
  void reset_game_ply();
-  
+
  // Position consistency check, for debugging
-  bool is_ok() const;
+  bool is_ok(int* failedStep = NULL) const;

  // Static member functions:
  static void init_zobrist();
  static void init_piece_square_tables();

 private:
+
  // Initialization helper functions (used while setting up a position)
  void clear();
  void put_piece(Piece p, Square s);
@@ -300,51 +309,57 @@ private:
  void allow_ooo(Color c);

  // Helper functions for doing and undoing moves
+  void do_capture_move(PieceType capture, Color them, Square to);
  void do_castle_move(Move m);
-  void do_promotion_move(Move m, UndoInfo &u);
+  void do_promotion_move(Move m);
  void do_ep_move(Move m);
  void undo_castle_move(Move m);
-  void undo_promotion_move(Move m, const UndoInfo &u);
+  void undo_promotion_move(Move m);
  void undo_ep_move(Move m);
  void find_checkers();

+  template<PieceType Piece>
+  void update_checkers(Bitboard* pCheckersBB, Square ksq, Square from, Square to, Bitboard dcCandidates);
+
+  template<bool FindPinned>
+  Bitboard hidden_checkers(Color c) const;
+
  // Computing hash keys from scratch (for initialization and debugging)
  Key compute_key() const;
  Key compute_pawn_key() const;
  Key compute_material_key() const;

  // Computing incremental evaluation scores and material counts
-  Value mg_pst(Color c, PieceType pt, Square s) const;
-  Value eg_pst(Color c, PieceType pt, Square s) const;
-  Value compute_mg_value() const;
-  Value compute_eg_value() const;
+  enum GamePhase {
+      MidGame,
+      EndGame
+  };
+  template<GamePhase> Value pst(Color c, PieceType pt, Square s) const;
+  template<GamePhase> Value compute_value() const;
  Value compute_non_pawn_material(Color c) const;

  // Bitboards
  Bitboard byColorBB[2], byTypeBB[8];
-  Bitboard checkersBB;

  // Board
  Piece board[64];

  // Piece counts
  int pieceCount[2][8]; // [color][pieceType]
-  
+
  // Piece lists
  Square pieceList[2][8][16]; // [color][pieceType][index]
  int index[64];

  // Other info
-  Color sideToMove;
-  int castleRights;
-  File initialKFile, initialKRFile, initialQRFile;
-  Square epSquare;
  Square kingSquare[2];
-  Move lastMove;
-  Key key, pawnKey, materialKey, history[MaxGameLength];
-  int rule50, gamePly;
-  Value mgValue, egValue;
+  Color sideToMove;
+  int gamePly;
+  Key history[MaxGameLength];
  Value npMaterial[2];
+  File initialKFile, initialKRFile, initialQRFile;
+  StateInfo startState;
+  StateInfo* st;

  // Static variables
  static int castleRightsMask[64];
@@ -367,27 +382,27 @@ inline Piece Position::piece_on(Square s) const {
 }

 inline Color Position::color_of_piece_on(Square s) const {
-  return color_of_piece(this->piece_on(s));
+  return color_of_piece(piece_on(s));
 }

 inline PieceType Position::type_of_piece_on(Square s) const {
-  return type_of_piece(this->piece_on(s));
+  return type_of_piece(piece_on(s));
 }

 inline bool Position::square_is_empty(Square s) const {
-  return this->piece_on(s) == EMPTY;
+  return piece_on(s) == EMPTY;
 }

 inline bool Position::square_is_occupied(Square s) const {
-  return !this->square_is_empty(s);
+  return !square_is_empty(s);
 }

 inline Value Position::midgame_value_of_piece_on(Square s) const {
-  return piece_value_midgame(this->piece_on(s));
+  return piece_value_midgame(piece_on(s));
 }

 inline Value Position::endgame_value_of_piece_on(Square s) const {
-  return piece_value_endgame(this->piece_on(s));
+  return piece_value_endgame(piece_on(s));
 }

 inline Color Position::side_to_move() const {
@@ -399,7 +414,7 @@ inline Bitboard Position::occupied_squares() const {
 }

 inline Bitboard Position::empty_squares() const {
-  return ~(this->occupied_squares());
+  return ~(occupied_squares());
 }

 inline Bitboard Position::pieces_of_color(Color c) const {
@@ -410,133 +425,92 @@ inline Bitboard Position::pieces_of_type(PieceType pt) const {
  return byTypeBB[pt];
 }

-inline Bitboard Position::pieces_of_color_and_type(Color c, PieceType pt)
-  const {
-  return this->pieces_of_color(c) & this->pieces_of_type(pt);
+inline Bitboard Position::pieces_of_color_and_type(Color c, PieceType pt) const {
+  return pieces_of_color(c) & pieces_of_type(pt);
 }

 inline Bitboard Position::pawns() const {
-  return this->pieces_of_type(PAWN);
+  return pieces_of_type(PAWN);
 }

 inline Bitboard Position::knights() const {
-  return this->pieces_of_type(KNIGHT);
+  return pieces_of_type(KNIGHT);
 }

 inline Bitboard Position::bishops() const {
-  return this->pieces_of_type(BISHOP);
+  return pieces_of_type(BISHOP);
 }

 inline Bitboard Position::rooks() const {
-  return this->pieces_of_type(ROOK);
+  return pieces_of_type(ROOK);
 }

 inline Bitboard Position::queens() const {
-  return this->pieces_of_type(QUEEN);
+  return pieces_of_type(QUEEN);
 }

 inline Bitboard Position::kings() const {
-  return this->pieces_of_type(KING);
+  return pieces_of_type(KING);
 }

 inline Bitboard Position::rooks_and_queens() const {
-  return this->rooks() | this->queens();
+  return rooks() | queens();
 }

 inline Bitboard Position::bishops_and_queens() const {
-  return this->bishops() | this->queens();
+  return bishops() | queens();
 }

 inline Bitboard Position::sliders() const {
-  return this->bishops() | this->queens() | this->rooks();
+  return bishops() | queens() | rooks();
 }

 inline Bitboard Position::pawns(Color c) const {
-  return this->pieces_of_color_and_type(c, PAWN);
+  return pieces_of_color_and_type(c, PAWN);
 }

 inline Bitboard Position::knights(Color c) const {
-  return this->pieces_of_color_and_type(c, KNIGHT);
+  return pieces_of_color_and_type(c, KNIGHT);
 }

 inline Bitboard Position::bishops(Color c) const {
-  return this->pieces_of_color_and_type(c, BISHOP);
+  return pieces_of_color_and_type(c, BISHOP);
 }

 inline Bitboard Position::rooks(Color c) const {
-  return this->pieces_of_color_and_type(c, ROOK);
+  return pieces_of_color_and_type(c, ROOK);
 }

 inline Bitboard Position::queens(Color c) const {
-  return this->pieces_of_color_and_type(c, QUEEN);
+  return pieces_of_color_and_type(c, QUEEN);
 }

 inline Bitboard Position::kings(Color c) const {
-  return this->pieces_of_color_and_type(c, KING);
+  return pieces_of_color_and_type(c, KING);
 }

 inline Bitboard Position::rooks_and_queens(Color c) const {
-  return this->rooks_and_queens() & this->pieces_of_color(c);
+  return rooks_and_queens() & pieces_of_color(c);
 }

 inline Bitboard Position::bishops_and_queens(Color c) const {
-  return this->bishops_and_queens() & this->pieces_of_color(c);
+  return bishops_and_queens() & pieces_of_color(c);
 }

 inline Bitboard Position::sliders_of_color(Color c) const {
-  return this->sliders() & this->pieces_of_color(c);
+  return sliders() & pieces_of_color(c);
 }

 inline int Position::piece_count(Color c, PieceType pt) const {
  return pieceCount[c][pt];
 }

-inline int Position::pawn_count(Color c) const {
-  return this->piece_count(c, PAWN);
-}
-
-inline int Position::knight_count(Color c) const {
-  return this->piece_count(c, KNIGHT);
-}
-
-inline int Position::bishop_count(Color c) const {
-  return this->piece_count(c, BISHOP);
-}
-
-inline int Position::rook_count(Color c) const {
-  return this->piece_count(c, ROOK);
-}
-
-inline int Position::queen_count(Color c) const {
-  return this->piece_count(c, QUEEN);
-}
-
 inline Square Position::piece_list(Color c, PieceType pt, int index) const {
  return pieceList[c][pt][index];
 }

-inline Square Position::pawn_list(Color c, int index) const {
-  return this->piece_list(c, PAWN, index);
-}
-
-inline Square Position::knight_list(Color c, int index) const {
-  return this->piece_list(c, KNIGHT, index);
-}
-
-inline Square Position::bishop_list(Color c, int index) const {
-  return this->piece_list(c, BISHOP, index);
-}
-
-inline Square Position::rook_list(Color c, int index) const {
-  return this->piece_list(c, ROOK, index);
-}
-
-inline Square Position::queen_list(Color c, int index) const {
-  return this->piece_list(c, QUEEN, index);
-}
-
 inline Square Position::ep_square() const {
-  return epSquare;
+  return st->epSquare;
 }

 inline Square Position::king_square(Color c) const {
@@ -544,11 +518,11 @@ inline Square Position::king_square(Color c) const {
 }

 inline bool Position::can_castle_kingside(Color side) const {
-  return castleRights & (1+int(side));
+  return st->castleRights & (1+int(side));
 }

 inline bool Position::can_castle_queenside(Color side) const {
-  return castleRights & (4+4*int(side));
+  return st->castleRights & (4+4*int(side));
 }

 inline bool Position::can_castle(Color side) const {
@@ -564,123 +538,119 @@ inline Square Position::initial_qr_square(Color c) const {
 }

 inline Bitboard Position::pawn_attacks(Color c, Square s) const {
-  return StepAttackBB[pawn_of_color(c)][s];
+  return StepAttackBB[piece_of_color_and_type(c, PAWN)][s];
 }

-inline Bitboard Position::white_pawn_attacks(Square s) const {
-  return this->pawn_attacks(WHITE, s);
+template<>
+inline Bitboard Position::piece_attacks<PAWN>(Square s) const {
+  return StepAttackBB[piece_of_color_and_type(opposite_color(sideToMove), PAWN)][s];
 }

-inline Bitboard Position::black_pawn_attacks(Square s) const {
-  return this->pawn_attacks(BLACK, s);
-}
-
-inline Bitboard Position::knight_attacks(Square s) const {
+template<>
+inline Bitboard Position::piece_attacks<KNIGHT>(Square s) const {
  return StepAttackBB[KNIGHT][s];
 }

-inline Bitboard Position::rook_attacks(Square s) const {
-  return rook_attacks_bb(s, this->occupied_squares());
+template<>
+inline Bitboard Position::piece_attacks<BISHOP>(Square s) const {
+  return bishop_attacks_bb(s, occupied_squares());
 }

-inline Bitboard Position::bishop_attacks(Square s) const {
-  return bishop_attacks_bb(s, this->occupied_squares());
+template<>
+inline Bitboard Position::piece_attacks<ROOK>(Square s) const {
+  return rook_attacks_bb(s, occupied_squares());
 }

-inline Bitboard Position::queen_attacks(Square s) const {
-  return this->rook_attacks(s) | this->bishop_attacks(s);
+template<>
+inline Bitboard Position::piece_attacks<QUEEN>(Square s) const {
+  return piece_attacks<ROOK>(s) | piece_attacks<BISHOP>(s);
 }

-inline Bitboard Position::king_attacks(Square s) const {
+template<>
+inline Bitboard Position::piece_attacks<KING>(Square s) const {
  return StepAttackBB[KING][s];
 }

 inline Bitboard Position::checkers() const {
-  return checkersBB;
+  return st->checkersBB;
 }

 inline bool Position::is_check() const {
-  return this->checkers() != EmptyBoardBB;
+  return st->checkersBB != EmptyBoardBB;
 }

-inline bool Position::white_pawn_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->white_pawn_attacks(f), t);
+inline bool Position::pawn_attacks_square(Color c, Square f, Square t) const {
+  return bit_is_set(pawn_attacks(c, f), t);
 }

-inline bool Position::black_pawn_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->black_pawn_attacks(f), t);
+template<PieceType Piece>
+Bitboard Position::piece_attacks_square(Square f, Square t) const {
+  return bit_is_set(piece_attacks<Piece>(f), t);
 }

-inline bool Position::knight_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->knight_attacks(f), t);
+inline Bitboard Position::attacks_to(Square s, Color c) const {
+
+  return attacks_to(s) & pieces_of_color(c);
 }

-inline bool Position::bishop_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->bishop_attacks(f), t);
-}
+inline bool Position::square_is_attacked(Square s, Color c) const {

-inline bool Position::rook_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->rook_attacks(f), t);
-}
-
-inline bool Position::queen_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->queen_attacks(f), t);
-}
-
-inline bool Position::king_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->king_attacks(f), t);
+  return attacks_to(s, c) != EmptyBoardBB;
 }

 inline bool Position::pawn_is_passed(Color c, Square s) const {
-  return !(this->pawns(opposite_color(c)) & passed_pawn_mask(c, s));
+  return !(pawns(opposite_color(c)) & passed_pawn_mask(c, s));
 }

 inline bool Position::pawn_is_isolated(Color c, Square s) const {
-  return !(this->pawns(c) & neighboring_files_bb(s));
+  return !(pawns(c) & neighboring_files_bb(s));
 }

 inline bool Position::pawn_is_doubled(Color c, Square s) const {
-  return this->pawns(c) & squares_behind(c, s);
+  return pawns(c) & squares_behind(c, s);
 }

 inline bool Position::file_is_open(File f) const {
-  return !(this->pawns() & file_bb(f));
+  return !(pawns() & file_bb(f));
 }

 inline bool Position::file_is_half_open(Color c, File f) const {
-  return !(this->pawns(c) & file_bb(f));
+  return !(pawns(c) & file_bb(f));
 }

 inline bool Position::square_is_weak(Square s, Color c) const {
-  return !(this->pawns(c) & outpost_mask(opposite_color(c), s));
+  return !(pawns(c) & outpost_mask(opposite_color(c), s));
 }
-                                
+
 inline Key Position::get_key() const {
-  return key;
+  return st->key;
 }

 inline Key Position::get_pawn_key() const {
-  return pawnKey;
+  return st->pawnKey;
 }

 inline Key Position::get_material_key() const {
-  return materialKey;
+  return st->materialKey;
 }

-inline Value Position::mg_pst(Color c, PieceType pt, Square s) const {
-  return MgPieceSquareTable[piece_of_color_and_type(c, pt)][s];
+template<Position::GamePhase Phase>
+inline Value Position::pst(Color c, PieceType pt, Square s) const {
+  return (Phase == MidGame ? MgPieceSquareTable[piece_of_color_and_type(c, pt)][s]
+                           : EgPieceSquareTable[piece_of_color_and_type(c, pt)][s]);
 }

-inline Value Position::eg_pst(Color c, PieceType pt, Square s) const {
-  return EgPieceSquareTable[piece_of_color_and_type(c, pt)][s];
+inline Value Position::mg_pst_delta(Move m) const {
+  return MgPieceSquareTable[piece_on(move_from(m))][move_to(m)]
+        -MgPieceSquareTable[piece_on(move_from(m))][move_from(m)];
 }

 inline Value Position::mg_value() const {
-  return mgValue;
+  return st->mgValue;
 }

 inline Value Position::eg_value() const {
-  return egValue;
+  return st->egValue;
 }

 inline Value Position::non_pawn_material(Color c) const {
@@ -689,58 +659,73 @@ inline Value Position::non_pawn_material(Color c) const {

 inline Phase Position::game_phase() const {

-  // The purpose of the Value(325) terms below is to make sure the difference
-  // between MidgameLimit and EndgameLimit is a power of 2, which should make
-  // the division at the end of the function a bit faster.
+  // Values modified by Joona Kiiski
+  static const Value MidgameLimit = Value(15713);
+  static const Value EndgameLimit = Value(4428);

-  static const Value MidgameLimit =
-    2*QueenValueMidgame+2*RookValueMidgame+6*BishopValueMidgame+Value(325);
-  static const Value EndgameLimit = 4*RookValueMidgame-Value(325);
-  Value npm = this->non_pawn_material(WHITE) + this->non_pawn_material(BLACK);
-  
-  if(npm >= MidgameLimit)
-    return PHASE_MIDGAME;
+  Value npm = non_pawn_material(WHITE) + non_pawn_material(BLACK);
+
+  if (npm >= MidgameLimit)
+      return PHASE_MIDGAME;
  else if(npm <= EndgameLimit)
-    return PHASE_ENDGAME;
+      return PHASE_ENDGAME;
  else
-    return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
+      return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
+}
+
+inline bool Position::move_is_deep_pawn_push(Move m) const {
+
+  Color c = side_to_move();
+  return   piece_on(move_from(m)) == piece_of_color_and_type(c, PAWN)
+        && relative_rank(c, move_to(m)) > RANK_4;
 }

 inline bool Position::move_is_pawn_push_to_7th(Move m) const {
-  Color c = this->side_to_move();
-  return 
-    this->piece_on(move_from(m)) == pawn_of_color(c) &&
-    pawn_rank(c, move_to(m)) == RANK_7;
+
+  Color c = side_to_move();
+  return   piece_on(move_from(m)) == piece_of_color_and_type(c, PAWN)
+        && relative_rank(c, move_to(m)) == RANK_7;
 }

 inline bool Position::move_is_passed_pawn_push(Move m) const {
-  Color c = this->side_to_move();
-  return 
-    this->piece_on(move_from(m)) == pawn_of_color(c) &&
-    this->pawn_is_passed(c, move_to(m));
+
+  Color c = side_to_move();
+  return   piece_on(move_from(m)) == piece_of_color_and_type(c, PAWN)
+        && pawn_is_passed(c, move_to(m));
 }
- 
+
 inline bool Position::move_was_passed_pawn_push(Move m) const {
-  Color c = opposite_color(this->side_to_move());
-  return 
-    this->piece_on(move_to(m)) == pawn_of_color(c) &&
-    this->pawn_is_passed(c, move_to(m));
+
+  Color c = opposite_color(side_to_move());
+  return   piece_on(move_to(m)) == piece_of_color_and_type(c, PAWN)
+        && pawn_is_passed(c, move_to(m));
 }

 inline int Position::rule_50_counter() const {
-  return rule50;
+
+  return st->rule50;
 }

 inline bool Position::opposite_colored_bishops() const {
-  return
-    this->bishop_count(WHITE) == 1 && this->bishop_count(BLACK) == 1 &&
-    square_color(this->bishop_list(WHITE, 0)) !=
-    square_color(this->bishop_list(BLACK, 0));
+
+  return   piece_count(WHITE, BISHOP) == 1
+        && piece_count(BLACK, BISHOP) == 1
+        && square_color(piece_list(WHITE, BISHOP, 0)) != square_color(piece_list(BLACK, BISHOP, 0));
 }

 inline bool Position::has_pawn_on_7th(Color c) const {
-  return this->pawns(c) & relative_rank_bb(c, RANK_7);
+
+  return pawns(c) & relative_rank_bb(c, RANK_7);
+}
+
+inline bool Position::move_is_capture(Move m) const {
+
+  // Move must not be MOVE_NONE !
+
+  return (   !square_is_empty(move_to(m))
+          && (color_of_piece_on(move_to(m)) != color_of_piece_on(move_from(m)))
+         )
+         || move_is_ep(m);
 }
-                        

 #endif // !defined(POSITION_H_INCLUDED)
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -24,139 +25,162 @@
 //// Includes
 ////

-#include "position.h"
+#include "value.h"


 ////
 //// Variables
 ////

+static const Value MP = PawnValueMidgame;
+static const Value MK = KnightValueMidgame;
+static const Value MB = BishopValueMidgame;
+static const Value MR = RookValueMidgame;
+static const Value MQ = QueenValueMidgame;
+
 static const int MgPST[][64] = {
  { },
-  { // Pawn
-    0, 0, 0, 0, 0, 0, 0, 0,
-    166, 192, 204, 216, 216, 204, 192, 166,
-    166, 192, 210, 242, 242, 210, 192, 166, 
-    166, 192, 220, 268, 268, 220, 192, 166, 
-    166, 192, 220, 242, 242, 220, 192, 166, 
-    166, 192, 210, 216, 216, 210, 192, 166, 
-    166, 192, 204, 216, 216, 204, 192, 166, 
-    0, 0, 0, 0, 0, 0, 0, 0
-  }, 
-  { // Knight
-    704, 730, 756, 768, 768, 756, 730, 704, 
-    743, 768, 794, 807, 807, 794, 768, 743, 
-    781, 807, 832, 844, 844, 832, 807, 781, 
-    807, 832, 857, 870, 870, 857, 832, 807, 
-    820, 844, 870, 883, 883, 870, 844, 820, 
-    820, 844, 870, 883, 883, 870, 844, 820, 
-    781, 807, 832, 844, 844, 832, 807, 781, 
-    650, 768, 794, 807, 807, 794, 768, 650
-  }, 
-  { // Bishop
-    786, 786, 792, 797, 797, 792, 786, 786, 
-    812, 832, 827, 832, 832, 827, 832, 812, 
-    817, 827, 842, 837, 837, 842, 827, 817, 
-    822, 832, 837, 852, 852, 837, 832, 822, 
-    822, 832, 837, 852, 852, 837, 832, 822, 
-    817, 827, 842, 837, 837, 842, 827, 817, 
-    812, 832, 827, 832, 832, 827, 832, 812, 
-    812, 812, 817, 822, 822, 817, 812, 812
-  }, 
-  { // Rook
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267
-  }, 
-  { // Queen
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560
-  }, 
-  { // King
-    302, 328, 276, 225, 225, 276, 328, 302, 
-    276, 302, 251, 200, 200, 251, 302, 276, 
-    225, 251, 200, 149, 149, 200, 251, 225, 
-    200, 225, 175, 124, 124, 175, 225, 200, 
-    175, 200, 149, 98, 98, 149, 200, 175, 
-    149, 175, 124, 72, 72, 124, 175, 149, 
-    124, 149, 98, 47, 47, 98, 149, 124, 
-    98, 124, 72, 21, 21, 72, 124, 98, 
+  {// Pawn
+   // A      B      C      D      E      F      G      H
+        0,     0,     0,     0,     0,     0,     0,     0,
+    MP-38, MP-12, MP- 0, MP+12, MP+12, MP- 0, MP-12, MP-38,
+    MP-38, MP-12, MP+ 6, MP+38, MP+38, MP+ 6, MP-12, MP-38,
+    MP-38, MP-12, MP+16, MP+64, MP+64, MP+16, MP-12, MP-38,
+    MP-38, MP-12, MP+16, MP+38, MP+38, MP+16, MP-12, MP-38,
+    MP-38, MP-12, MP+ 6, MP+12, MP+12, MP+ 6, MP-12, MP-38,
+    MP-38, MP-12, MP- 0, MP+12, MP+12, MP- 0, MP-12, MP-38,
+        0,     0,     0,     0,     0,     0,     0,     0
+  },
+  {// Knight
+   //  A      B       C      D      E      F      G       H
+    MK-128, MK-102, MK-76, MK-64, MK-64, MK-76, MK-102, MK-128,
+    MK- 89, MK- 64, MK-38, MK-25, MK-25, MK-38, MK- 64, MK- 89,
+    MK- 51, MK- 25, MK- 0, MK+12, MK+12, MK- 0, MK- 25, MK- 51,
+    MK- 25, MK-  0, MK+25, MK+38, MK+38, MK+25, MK-  0, MK- 25,
+    MK- 12, MK+ 12, MK+38, MK+51, MK+51, MK+38, MK+ 12, MK- 12,
+    MK- 12, MK+ 12, MK+38, MK+51, MK+51, MK+38, MK+ 12, MK- 12,
+    MK- 51, MK- 25, MK- 0, MK+12, MK+12, MK- 0, MK- 25, MK- 51,
+    MK-182, MK- 64, MK-38, MK-25, MK-25, MK-38, MK- 64, MK-182
+  },
+  {// Bishop
+   // A      B      C      D      E      F      G      H
+    MB-46, MB-46, MB-40, MB-35, MB-35, MB-40, MB-46, MB-46,
+    MB-20, MB- 0, MB- 5, MB- 0, MB- 0, MB- 5, MB- 0, MB-20,
+    MB-15, MB- 5, MB+10, MB+ 5, MB+ 5, MB+10, MB- 5, MB-15,
+    MB-10, MB- 0, MB+ 5, MB+20, MB+20, MB+ 5, MB- 0, MB-10,
+    MB-10, MB- 0, MB+ 5, MB+20, MB+20, MB+ 5, MB- 0, MB-10,
+    MB-15, MB- 5, MB+10, MB+ 5, MB+ 5, MB+10, MB- 5, MB-15,
+    MB-20, MB- 0, MB- 5, MB- 0, MB- 0, MB- 5, MB- 0, MB-20,
+    MB-20, MB-20, MB-15, MB-10, MB-10, MB-15, MB-20, MB-20
+  },
+  {// Rook
+   // A      B      C     D     E     F     G      H
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18
+  },
+  {// Queen
+   //A   B   C   D   E   F   G   H
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ
+  },
+  {// King
+   //A    B    C    D    E    F    G    H
+    302, 328, 276, 225, 225, 276, 328, 302,
+    276, 302, 251, 200, 200, 251, 302, 276,
+    225, 251, 200, 149, 149, 200, 251, 225,
+    200, 225, 175, 124, 124, 175, 225, 200,
+    175, 200, 149,  98,  98, 149, 200, 175,
+    149, 175, 124,  72,  72, 124, 175, 149,
+    124, 149,  98,  47,  47,  98, 149, 124,
+     98, 124,  72,  21,  21,  72, 124,  98
  }
 };

+static const Value EP = PawnValueEndgame;
+static const Value EK = KnightValueEndgame;
+static const Value EB = BishopValueEndgame;
+static const Value ER = RookValueEndgame;
+static const Value EQ = QueenValueEndgame;

 static const int EgPST[][64] = {
  { },
-  { // Pawn
-    0, 0, 0, 0, 0, 0, 0, 0, 
-    256, 256, 256, 256, 256, 256, 256, 256, 
-    256, 256, 256, 256, 256, 256, 256, 256, 
-    256, 256, 256, 256, 256, 256, 256, 256, 
-    256, 256, 256, 256, 256, 256, 256, 256, 
-    256, 256, 256, 256, 256, 256, 256, 256, 
-    256, 256, 256, 256, 256, 256, 256, 256, 
-    0, 0, 0, 0, 0, 0, 0, 0
+  {// Pawn
+   //A   B   C   D   E   F   G   H
+     0,  0,  0,  0,  0,  0,  0,  0,
+    EP, EP, EP, EP, EP, EP, EP, EP,
+    EP, EP, EP, EP, EP, EP, EP, EP,
+    EP, EP, EP, EP, EP, EP, EP, EP,
+    EP, EP, EP, EP, EP, EP, EP, EP,
+    EP, EP, EP, EP, EP, EP, EP, EP,
+    EP, EP, EP, EP, EP, EP, EP, EP,
+     0,  0,  0,  0,  0,  0,  0,  0
  },
-  { // Knight
-    730, 756, 781, 794, 794, 781, 756, 730, 
-    756, 781, 807, 820, 820, 807, 781, 756, 
-    781, 807, 832, 844, 844, 832, 807, 781, 
-    794, 820, 844, 857, 857, 844, 820, 794, 
-    794, 820, 844, 857, 857, 844, 820, 794, 
-    781, 807, 832, 844, 844, 832, 807, 781, 
-    756, 781, 807, 820, 820, 807, 781, 756, 
-    730, 756, 781, 794, 794, 781, 756, 730
+  {// Knight
+   // A       B      C      D      E      F      G      H
+    EK-102, EK-76, EK-51, EK-38, EK-38, EK-51, EK-76, EK-102,
+    EK- 76, EK-51, EK-25, EK-12, EK-12, EK-25, EK-51, EK-76,
+    EK- 51, EK-25, EK- 0, EK+12, EK+12, EK- 0, EK-25, EK-51,
+    EK- 38, EK-12, EK+12, EK+25, EK+25, EK+12, EK-12, EK-38,
+    EK- 38, EK-12, EK+12, EK+25, EK+25, EK+12, EK-12, EK-38,
+    EK- 51, EK-25, EK- 0, EK+12, EK+12, EK- 0, EK-25, EK-51,
+    EK- 76, EK-51, EK-25, EK-12, EK-12, EK-25, EK-51, EK-76,
+    EK-102, EK-76, EK-51, EK-38, EK-38, EK-51, EK-76, EK-102
  },
-  { // Bishop
-    786, 802, 809, 817, 817, 809, 802, 786, 
-    802, 817, 825, 832, 832, 825, 817, 802, 
-    809, 825, 832, 839, 839, 832, 825, 809, 
-    817, 832, 839, 847, 847, 839, 832, 817, 
-    817, 832, 839, 847, 847, 839, 832, 817, 
-    809, 825, 832, 839, 839, 832, 825, 809, 
-    802, 817, 825, 832, 832, 825, 817, 802, 
-    786, 802, 809, 817, 817, 809, 802, 786
+  {// Bishop
+   // A      B      C      D      E      F      G      H
+    EB-46, EB-30, EB-23, EB-15, EB-15, EB-23, EB-30, EB-46,
+    EB-30, EB-15, EB- 7, EB- 0, EB- 0, EB- 7, EB-15, EB-30,
+    EB-23, EB- 7, EB- 0, EB+ 7, EB+ 7, EB- 0, EB- 7, EB-23,
+    EB-15, EB- 0, EB+ 7, EB+15, EB+15, EB+ 7, EB- 0, EB-15,
+    EB-15, EB- 0, EB+ 7, EB+15, EB+15, EB+ 7, EB- 0, EB-15,
+    EB-23, EB- 7, EB- 0, EB+ 7, EB+ 7, EB- 0, EB- 7, EB-23,
+    EB-30, EB-15, EB- 7, EB- 0, EB- 0, EB- 7, EB-15, EB-30,
+    EB-46, EB-30, EB-23, EB-15, EB-15, EB-23, EB-30, EB-46
  },
-  { // Rook
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282
+  {// Rook
+   // A     B     C     D     E     F     G     H
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3
  },
-  { // Queen
-    2499, 2520, 2530, 2540, 2540, 2530, 2520, 2499, 
-    2520, 2540, 2550, 2560, 2560, 2550, 2540, 2520, 
-    2530, 2550, 2560, 2570, 2570, 2560, 2550, 2530, 
-    2540, 2560, 2570, 2580, 2580, 2570, 2560, 2540, 
-    2540, 2560, 2570, 2580, 2580, 2570, 2560, 2540, 
-    2530, 2550, 2560, 2570, 2570, 2560, 2550, 2530, 
-    2520, 2540, 2550, 2560, 2560, 2550, 2540, 2520, 
-    2499, 2520, 2530, 2540, 2540, 2530, 2520, 2499
+  {// Queen
+   // A      B      C      D      E      F      G      H
+    EQ-61, EQ-40, EQ-30, EQ-20, EQ-20, EQ-30, EQ-40, EQ-61,
+    EQ-40, EQ-20, EQ-10, EQ- 0, EQ- 0, EQ-10, EQ-20, EQ-40,
+    EQ-30, EQ-10, EQ- 0, EQ+10, EQ+10, EQ- 0, EQ-10, EQ-30,
+    EQ-20, EQ- 0, EQ+10, EQ+20, EQ+20, EQ+10, EQ- 0, EQ-20,
+    EQ-20, EQ- 0, EQ+10, EQ+20, EQ+20, EQ+10, EQ- 0, EQ-20,
+    EQ-30, EQ-10, EQ- 0, EQ+10, EQ+10, EQ- 0, EQ-10, EQ-30,
+    EQ-40, EQ-20, EQ-10, EQ- 0, EQ- 0, EQ-10, EQ-20, EQ-40,
+    EQ-61, EQ-40, EQ-30, EQ-20, EQ-20, EQ-30, EQ-40, EQ-61
  },
-  { // King
-    16, 78, 108, 139, 139, 108, 78, 16, 
-    78, 139, 170, 200, 200, 170, 139, 78, 
-    108, 170, 200, 230, 230, 200, 170, 108, 
-    139, 200, 230, 261, 261, 230, 200, 139, 
-    139, 200, 230, 261, 261, 230, 200, 139, 
-    108, 170, 200, 230, 230, 200, 170, 108, 
-    78, 139, 170, 200, 200, 170, 139, 78, 
-    16, 78, 108, 139, 139, 108, 78, 16
+  {// King
+   //A    B    C    D    E    F    G    H
+     16,  78, 108, 139, 139, 108,  78,  16,
+     78, 139, 170, 200, 200, 170, 139,  78,
+    108, 170, 200, 230, 230, 200, 170, 108,
+    139, 200, 230, 261, 261, 230, 200, 139,
+    139, 200, 230, 261, 261, 230, 200, 139,
+    108, 170, 200, 230, 230, 200, 170, 108,
+     78, 139, 170, 200, 200, 170, 139,  78,
+     16,  78, 108, 139, 139, 108,  78,  16
  }
 };

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -30,6 +31,7 @@
 #include "movepick.h"
 #include "san.h"

+extern SearchStack EmptySearchStack;

 ////
 //// Local definitions
@@ -48,8 +50,8 @@ namespace {


  /// Functions
-  
-  Ambiguity move_ambiguity(Position &pos, Move m);
+
+  Ambiguity move_ambiguity(const Position& pos, Move m);
  const std::string time_string(int milliseconds);
  const std::string score_string(Value v);
 }
@@ -60,206 +62,227 @@ namespace {
 ////

 /// move_to_san() takes a position and a move as input, where it is assumed
-/// that the move is a legal move from the position.  The return value is
+/// that the move is a legal move from the position. The return value is
 /// a string containing the move in short algebraic notation.

-const std::string move_to_san(Position &pos, Move m) {
-  std::string str;
+const std::string move_to_san(const Position& pos, Move m) {

  assert(pos.is_ok());
  assert(move_is_ok(m));

-  if(m == MOVE_NONE) {
-    str = "(none)";
-    return str;
-  }
-  else if(m == MOVE_NULL) {
-    str = "(null)";
-    return str;
-  }
-  else if(move_is_long_castle(m))
-    str = "O-O-O";
-  else if(move_is_short_castle(m))
-    str = "O-O";
-  else {
-    Square from, to;
-    Piece pc;
+  Square from, to;
+  PieceType pt;

-    from = move_from(m);
-    to = move_to(m);
-    pc = pos.piece_on(move_from(m));
+  from = move_from(m);
+  to = move_to(m);
+  pt = type_of_piece(pos.piece_on(move_from(m)));

-    str = "";
+  std::string san = "";

-    if(type_of_piece(pc) == PAWN) {
-      if(pos.move_is_capture(m))
-        str += file_to_char(square_file(move_from(m)));
-    }
-    else {
-      str += piece_type_to_char(type_of_piece(pc), true);
-
-      Ambiguity amb = move_ambiguity(pos, m);
-      switch(amb) {
-
-      case AMBIGUITY_NONE:
-        break;
-
-      case AMBIGUITY_FILE:
-        str += file_to_char(square_file(from));
-        break;
-
-      case AMBIGUITY_RANK:
-        str += rank_to_char(square_rank(from));
-        break;
-
-      case AMBIGUITY_BOTH:
-        str += square_to_string(from);
-        break;
-
-      default:
-        assert(false);
+  if (m == MOVE_NONE)
+      return "(none)";
+  else if (m == MOVE_NULL)
+      return "(null)";
+  else if (move_is_long_castle(m) || (int(to - from) == -2 && pt == KING))
+      san = "O-O-O";
+  else if (move_is_short_castle(m) || (int(to - from) == 2 && pt == KING))
+      san = "O-O";
+  else
+  {
+      if (pt != PAWN)
+      {
+          san += piece_type_to_char(pt, true);
+          switch (move_ambiguity(pos, m)) {
+          case AMBIGUITY_NONE:
+            break;
+          case AMBIGUITY_FILE:
+            san += file_to_char(square_file(from));
+            break;
+          case AMBIGUITY_RANK:
+            san += rank_to_char(square_rank(from));
+            break;
+          case AMBIGUITY_BOTH:
+            san += square_to_string(from);
+            break;
+          default:
+            assert(false);
+          }
+      }
+      if (pos.move_is_capture(m))
+      {
+          if (pt == PAWN)
+              san += file_to_char(square_file(move_from(m)));
+          san += "x";
+      }
+      san += square_to_string(move_to(m));
+      if (move_promotion(m))
+      {
+          san += '=';
+          san += piece_type_to_char(move_promotion(m), true);
      }
-    }
-
-    if(pos.move_is_capture(m))
-      str += "x";
-
-    str += square_to_string(move_to(m));
-
-    if(move_promotion(m)) {
-      str += "=";
-      str += piece_type_to_char(move_promotion(m), true);
-    }
  }
-
  // Is the move check?  We don't use pos.move_is_check(m) here, because
  // Position::move_is_check doesn't detect all checks (not castling moves,
  // promotions and en passant captures).
-  UndoInfo u;
-  pos.do_move(m, u);
-  if(pos.is_check())
-    str += pos.is_mate()? "#" : "+";
-  pos.undo_move(m, u);
+  StateInfo st;
+  Position p(pos);
+  p.do_move(m, st);
+  if (p.is_check())
+      san += p.is_mate()? "#" : "+";

-  return str;
+  return san;
 }


 /// move_from_san() takes a position and a string as input, and tries to
-/// interpret the string as a move in short algebraic notation.  On success,
+/// interpret the string as a move in short algebraic notation. On success,
 /// the move is returned.  On failure (i.e. if the string is unparsable, or
 /// if the move is illegal or ambiguous), MOVE_NONE is returned.

-Move move_from_san(Position &pos, const std::string &movestr) {
+Move move_from_san(const Position& pos, const std::string& movestr) {
+
  assert(pos.is_ok());
-  
-  MovePicker mp = MovePicker(pos, false, MOVE_NONE, MOVE_NONE, MOVE_NONE,
-                             MOVE_NONE, OnePly);
+
+  MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);

  // Castling moves
-  if(movestr == "O-O-O") {
-    Move m;
-    while((m = mp.get_next_move()) != MOVE_NONE)
-      if(move_is_long_castle(m) && pos.move_is_legal(m))
-        return m;
-    return MOVE_NONE;
-  }
-  else if(movestr == "O-O") {
-    Move m;
-    while((m = mp.get_next_move()) != MOVE_NONE)
-      if(move_is_short_castle(m) && pos.move_is_legal(m))
-        return m;
-    return MOVE_NONE;
-  }
+  if (movestr == "O-O-O" || movestr == "O-O-O+")
+  {
+      Move m;
+      while ((m = mp.get_next_move()) != MOVE_NONE)
+          if (move_is_long_castle(m) && pos.pl_move_is_legal(m))
+              return m;

-  // Normal moves
-  const char *cstr = movestr.c_str();
-  const char *c;
-  char *cc;
-  char str[10];
-  int i;
-
-  // Initialize str[] by making a copy of movestr with the characters
-  // 'x', '=', '+' and '#' removed.  
-  cc = str;
-  for(i=0, c=cstr; i<10 && *c!='\0' && *c!='\n' && *c!=' '; i++, c++)
-    if(!strchr("x=+#", *c)) {
-      *cc = strchr("nrq", *c)? toupper(*c) : *c;
-      cc++;
-    }
-  *cc = '\0';
-
-  int left = 0, right = strlen(str) - 1;
-  PieceType pt = NO_PIECE_TYPE, promotion;
-  Square to;
-  File fromFile = FILE_NONE;
-  Rank fromRank = RANK_NONE;
-
-  // Promotion?
-  if(strchr("BNRQ", str[right])) {
-    promotion = piece_type_from_char(str[right]);
-    right--;
-  }
-  else
-    promotion = NO_PIECE_TYPE;
-
-  // Find the moving piece:
-  if(left < right) {
-    if(strchr("BNRQK", str[left])) {
-      pt = piece_type_from_char(str[left]);
-      left++;
-    }
-    else
-      pt = PAWN;
-  }
-
-  // Find the to square:
-  if(left < right) {
-    if(str[right] < '1' || str[right] > '8' ||
-       str[right-1] < 'a' || str[right-1] > 'h')
      return MOVE_NONE;
-    to = make_square(file_from_char(str[right-1]), rank_from_char(str[right]));
-    right -= 2;
  }
-  else
+  else if (movestr == "O-O" || movestr == "O-O+")
+  {
+      Move m;
+      while ((m = mp.get_next_move()) != MOVE_NONE)
+          if (move_is_short_castle(m) && pos.pl_move_is_legal(m))
+              return m;
+
    return MOVE_NONE;
-
-  // Find the file and/or rank of the from square:
-  if(left <= right) {
-    if(strchr("abcdefgh", str[left])) {
-      fromFile = file_from_char(str[left]);
-      left++;
-    }
-    if(strchr("12345678", str[left]))
-      fromRank = rank_from_char(str[left]);
  }

-  // Look for a matching move:
+  // Normal moves. We use a simple FSM to parse the san string.
+  enum { START, TO_FILE, TO_RANK, PROMOTION_OR_CHECK, PROMOTION, CHECK, END };
+  static const std::string pieceLetters = "KQRBN";
+  PieceType pt = NO_PIECE_TYPE, promotion = NO_PIECE_TYPE;
+  File fromFile = FILE_NONE, toFile = FILE_NONE;
+  Rank fromRank = RANK_NONE, toRank = RANK_NONE;
+  Square to;
+  int state = START;
+
+  for (size_t i = 0; i < movestr.length(); i++)
+  {
+      char type, c = movestr[i];
+      if (pieceLetters.find(c) != std::string::npos)
+          type = 'P';
+      else if (c >= 'a' && c <= 'h')
+          type = 'F';
+      else if (c >= '1' && c <= '8')
+          type = 'R';
+      else
+          type = c;
+
+      switch (type) {
+      case 'P':
+          if (state == START)
+          {
+              pt = piece_type_from_char(c);
+              state = TO_FILE;
+          }
+          else if (state == PROMOTION)
+          {
+              promotion = piece_type_from_char(c);
+              state = (i < movestr.length() - 1) ? CHECK : END;
+          }
+          else
+              return MOVE_NONE;
+          break;
+      case 'F':
+          if (state == START)
+          {
+              pt = PAWN;
+              fromFile = toFile = file_from_char(c);
+              state = TO_RANK;
+          }
+          else if (state == TO_FILE)
+          {
+              toFile = file_from_char(c);
+              state = TO_RANK;
+          }
+          else if (state == TO_RANK && toFile != FILE_NONE)
+          {
+              // Previous file was for disambiguation
+              fromFile = toFile;
+              toFile = file_from_char(c);
+          }
+          else
+              return MOVE_NONE;
+          break;
+      case 'R':
+          if (state == TO_RANK)
+          {
+              toRank = rank_from_char(c);
+              state = (i < movestr.length() - 1) ? PROMOTION_OR_CHECK : END;
+          }
+          else if (state == TO_FILE && fromRank == RANK_NONE)
+          {
+              // It's a disambiguation rank instead of a file
+              fromRank = rank_from_char(c);
+          }
+          else
+              return MOVE_NONE;
+          break;
+      case 'x': case 'X':
+          if (state == TO_RANK)
+          {
+              // Previous file was for disambiguation, or it's a pawn capture
+              fromFile = toFile;
+              state = TO_FILE;
+          }
+          else if (state != TO_FILE)
+              return MOVE_NONE;
+          break;
+      case '=':
+          if (state == PROMOTION_OR_CHECK)
+              state = PROMOTION;
+          else
+              return MOVE_NONE;
+          break;
+      case '+': case '#':
+          if (state == PROMOTION_OR_CHECK || state == CHECK)
+              state = END;
+          else
+              return MOVE_NONE;
+          break;
+      default:
+          return MOVE_NONE;
+          break;
+      }
+  }
+
+  if (state != END)
+      return MOVE_NONE;
+
+  // Look for a matching move
  Move m, move = MOVE_NONE;
+  to = make_square(toFile, toRank);
  int matches = 0;
-  
-  while((m = mp.get_next_move()) != MOVE_NONE) {
-    bool match = true;
-    if(pos.type_of_piece_on(move_from(m)) != pt)
-      match = false;
-    else if(move_to(m) != to)
-      match = false;
-    else if(move_promotion(m) != promotion)
-      match = false;
-    else if(fromFile != FILE_NONE && fromFile != square_file(move_from(m)))
-      match = false;
-    else if(fromRank != RANK_NONE && fromRank != square_rank(move_from(m)))
-      match = false;
-    if(match) {
-      move = m;
-      matches++;
-    }
-  }
-  
-  if(matches == 1)
-    return move;
-  else
-    return MOVE_NONE;
+
+  while ((m = mp.get_next_move()) != MOVE_NONE)
+      if (   pos.type_of_piece_on(move_from(m)) == pt
+          && move_to(m) == to
+          && move_promotion(m) == promotion
+          && (fromFile == FILE_NONE || fromFile == square_file(move_from(m)))
+          && (fromRank == RANK_NONE || fromRank == square_rank(move_from(m))))
+      {
+          move = m;
+          matches++;
+      }
+  return (matches == 1 ? move : MOVE_NONE);
 }


@@ -270,34 +293,31 @@ Move move_from_san(Position &pos, const std::string &movestr) {
 /// length of 80 characters.  After a line break, 'startColumn' spaces are
 /// inserted at the beginning of the new line.

-const std::string line_to_san(const Position &pos, Move line[], int startColumn,
-                              bool breakLines) {
-  Position p = Position(pos);
-  UndoInfo u;
+const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines) {
+
+  StateInfo st;
  std::stringstream s;
  std::string moveStr;
-  int length, maxLength;
+  size_t length = 0;
+  size_t maxLength = 80 - startColumn;
+  Position p(pos);

-  length = 0;
-  maxLength = 80 - startColumn;
+  for (int i = 0; line[i] != MOVE_NONE; i++)
+  {
+      moveStr = move_to_san(p, line[i]);
+      length += moveStr.length() + 1;
+      if (breakLines && length > maxLength)
+      {
+          s << '\n' << std::setw(startColumn) << ' ';
+          length = moveStr.length() + 1;
+      }
+      s << moveStr << ' ';

-  for(int i = 0; line[i] != MOVE_NONE; i++) {
-    moveStr = move_to_san(p, line[i]);
-    length += moveStr.length() + 1;
-    if(breakLines && length > maxLength) {
-      s << "\n";
-      for(int j = 0; j < startColumn; j++)
-        s << " ";
-      length = moveStr.length() + 1;
-    }
-    s << moveStr << " ";
-
-    if(line[i] == MOVE_NULL)
-      p.do_null_move(u);
-    else
-      p.do_move(line[i], u);
+      if (line[i] == MOVE_NULL)
+          p.do_null_move(st);
+      else
+          p.do_move(line[i], st);
  }
-
  return s.str();
 }

@@ -306,26 +326,26 @@ const std::string line_to_san(const Position &pos, Move line[], int startColumn,
 /// It is used to write search information to the log file (which is created
 /// when the UCI parameter "Use Search Log" is "true").

-const std::string pretty_pv(const Position &pos, int time, int depth,
+const std::string pretty_pv(const Position& pos, int time, int depth,
                            uint64_t nodes, Value score, Move pv[]) {
  std::stringstream s;

  // Depth
-  s << std::setw(2) << std::setfill(' ') << depth << "  ";
+  s << std::setw(2) << depth << "  ";

  // Score
  s << std::setw(8) << score_string(score);

  // Time
-  s << std::setw(8) << std::setfill(' ') << time_string(time) << " ";
+  s << std::setw(8) << time_string(time) << " ";

  // Nodes
-  if(nodes < 1000000ULL)
-    s << std::setw(8) << std::setfill(' ') << nodes << " ";
-  else if(nodes < 1000000000ULL)
-    s << std::setw(7) << std::setfill(' ') << nodes/1000ULL << 'k' << " ";
+  if (nodes < 1000000ULL)
+    s << std::setw(8) << nodes << " ";
+  else if (nodes < 1000000000ULL)
+    s << std::setw(7) << nodes/1000ULL << 'k' << " ";
  else
-    s << std::setw(7) << std::setfill(' ') << nodes/1000000ULL << 'M' << " ";
+    s << std::setw(7) << nodes/1000000ULL << 'M' << " ";

  // PV
  s << line_to_san(pos, pv, 30, true);
@@ -336,82 +356,80 @@ const std::string pretty_pv(const Position &pos, int time, int depth,

 namespace {

-  Ambiguity move_ambiguity(Position &pos, Move m) {
-    Square from, to;
-    Piece pc;
+  Ambiguity move_ambiguity(const Position& pos, Move m) {

-    from = move_from(m);
-    to = move_to(m);
-    pc = pos.piece_on(from);
+    Square from = move_from(m);
+    Square to = move_to(m);
+    Piece pc = pos.piece_on(from);

    // King moves are never ambiguous, because there is never two kings of
    // the same color.
-    if(type_of_piece(pc) == KING)
-      return AMBIGUITY_NONE;
+    if (type_of_piece(pc) == KING)
+        return AMBIGUITY_NONE;

-    MovePicker mp = MovePicker(pos, false, MOVE_NONE, MOVE_NONE, MOVE_NONE,
-                               MOVE_NONE, OnePly);
+    MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
    Move mv, moveList[8];
-    int i, j, n;

-    n = 0;
-    while((mv = mp.get_next_move()) != MOVE_NONE)
-      if(move_to(mv) == to && pos.piece_on(move_from(mv)) == pc
-         && pos.move_is_legal(mv))
-        moveList[n++] = mv;
-    if(n == 1)
-      return AMBIGUITY_NONE;
+    int n = 0;
+    while ((mv = mp.get_next_move()) != MOVE_NONE)
+        if (move_to(mv) == to && pos.piece_on(move_from(mv)) == pc && pos.pl_move_is_legal(mv))
+            moveList[n++] = mv;

-    j = 0;
-    for(i = 0; i < n; i++)
-      if(square_file(move_from(moveList[i])) == square_file(from))
-        j++;
-    if(j == 1)
-      return AMBIGUITY_FILE;
+    if (n == 1)
+        return AMBIGUITY_NONE;

-    j = 0;
-    for(i = 0; i < n; i++)
-      if(square_rank(move_from(moveList[i])) == square_rank(from))
-        j++;
-    if(j == 1)
-      return AMBIGUITY_RANK;
+    int f = 0, r = 0;
+    for (int i = 0; i < n; i++)
+    {
+        if (square_file(move_from(moveList[i])) == square_file(from))
+            f++;
+
+        if (square_rank(move_from(moveList[i])) == square_rank(from))
+            r++;
+    }
+    if (f == 1)
+        return AMBIGUITY_FILE;
+
+    if (r == 1)
+        return AMBIGUITY_RANK;

    return AMBIGUITY_BOTH;
  }


  const std::string time_string(int milliseconds) {
+
    std::stringstream s;
+    s << std::setfill('0');

-    int hours = milliseconds / (1000 * 60 * 60);
-    int minutes = (milliseconds - hours*1000*60*60) / (60*1000);
-    int seconds = (milliseconds - hours*1000*60*60 - minutes*60*1000) / 1000;
+    int hours = milliseconds / (1000*60*60);
+    int minutes = (milliseconds - hours*1000*60*60) / (1000*60);
+    int seconds = (milliseconds - hours*1000*60*60 - minutes*1000*60) / 1000;

-    if(hours)
-      s << hours << ':';
-    s << std::setw(2) << std::setfill('0') << minutes << ':';
-    s << std::setw(2) << std::setfill('0') << seconds;
-    
+    if (hours)
+        s << hours << ':';
+
+    s << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
    return s.str();
  }


  const std::string score_string(Value v) {
+
    std::stringstream s;

-    if(abs(v) >= VALUE_MATE - 200) {
-      if(v < 0)
-        s << "-#" << (VALUE_MATE + v) / 2;
-      else
+    if (v >= VALUE_MATE - 200)
        s << "#" << (VALUE_MATE - v + 1) / 2;
-    }
-    else {
-      float floatScore = float(v) / float(PawnValueMidgame);
-      if(v >= 0)
-        s << '+';
-      s << std::setprecision(2) << std::fixed << floatScore;
+    else if(v <= -VALUE_MATE + 200)
+        s << "-#" << (VALUE_MATE + v) / 2;
+    else
+    {
+        float floatScore = float(v) / float(PawnValueMidgame);
+        if (v >= 0)
+            s << '+';
+
+        s << std::setprecision(2) << std::fixed << floatScore;
    }
    return s.str();
  }
-  
 }
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -35,12 +36,9 @@
 //// Prototypes
 ////

-extern const std::string move_to_san(Position &pos, Move m);
-extern Move move_from_san(Position &pos, const std::string &str);
-extern const std::string line_to_san(const Position &pos, Move line[],
-                                     int startColumn, bool breakLines);
-extern const std::string pretty_pv(const Position &pos, int time, int depth,
-                                   uint64_t nodes, Value score, Move pv[]);
-
+extern const std::string move_to_san(const Position& pos, Move m);
+extern Move move_from_san(const Position& pos, const std::string& str);
+extern const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines);
+extern const std::string pretty_pv(const Position& pos, int time, int depth, uint64_t nodes, Value score, Move pv[]);

 #endif // !defined(SAN_H_INCLUDED)
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -24,7 +25,6 @@
 //// Includes
 ////

-#include "types.h"
 #include "depth.h"
 #include "history.h"
 #include "lock.h"
@@ -40,6 +40,7 @@

 const int PLY_MAX = 100;
 const int PLY_MAX_PLUS_2 = 102;
+const int KILLER_MAX = 2;


 ////
@@ -54,10 +55,13 @@ const int PLY_MAX_PLUS_2 = 102;
 struct SearchStack {
  Move pv[PLY_MAX];
  Move currentMove;
-  Value currentMoveCaptureValue;
-  Move mateKiller, killer1, killer2;
+  Move mateKiller;
  Move threatMove;
+  Move killers[KILLER_MAX];
  Depth reduction;
+
+  void init(int ply);
+  void initKillers();
 };


@@ -65,14 +69,13 @@ struct SearchStack {
 //// Global variables
 ////

+extern SearchStack EmptySearchStack;
 extern TranspositionTable TT;
-
 extern int ActiveThreads;
-
 extern Lock SMPLock;

 // Perhaps better to make H local, and pass as parameter to MovePicker?
-extern History H;  
+extern History H;


 ////
@@ -81,9 +84,9 @@ extern History H;

 extern void init_threads();
 extern void stop_threads();
-extern void think(const Position &pos, bool infinite, bool ponder, int time,
-                  int increment, int movesToGo, int maxDepth, int maxNodes,
-                  int maxTime, Move searchMoves[]);
+extern void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
+                  int time[], int increment[], int movesToGo, int maxDepth,
+                  int maxNodes, int maxTime, Move searchMoves[]);
 extern int64_t nodes_searched();


@@ -1,85 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include <cassert>
-#include <cstdio>
-#include <string>
-
-#include "square.h"
-
-
-////
-//// Functions
-////
-
-
-/// Translating files, ranks and squares to/from characters and strings:
-
-File file_from_char(char c) {
-  return File(c - 'a') + FILE_A;
-}
-
-
-char file_to_char(File f) {
-  return char(f - FILE_A) + 'a';
-}
-
-
-Rank rank_from_char(char c) {
-  return Rank(c - '1') + RANK_1;
-}
-
-
-char rank_to_char(Rank r) {
-  return char(r - RANK_1) + '1';
-}
-
-
-Square square_from_string(const std::string &str) {
-  return make_square(file_from_char(str[0]), rank_from_char(str[1]));
-}
-
-
-const std::string square_to_string(Square s) {
-  std::string str;
-  str += file_to_char(square_file(s));
-  str += rank_to_char(square_rank(s));
-  return str;
-}
-
-
-/// file_is_ok(), rank_is_ok() and square_is_ok(), for debugging:
-
-bool file_is_ok(File f) {
-  return f >= FILE_A && f <= FILE_H;
-}
-
-
-bool rank_is_ok(Rank r) {
-  return r >= RANK_1 && r <= RANK_8;
-}
-
-
-bool square_is_ok(Square s) {
-  return file_is_ok(square_file(s)) && rank_is_ok(square_rank(s));
-}
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -24,6 +25,7 @@
 //// Includes
 ////

+#include <cstdlib> // for abs()
 #include <string>

 #include "color.h"
@@ -44,7 +46,7 @@ enum Square {
  SQ_A7, SQ_B7, SQ_C7, SQ_D7, SQ_E7, SQ_F7, SQ_G7, SQ_H7,
  SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8,
  SQ_NONE
-}; 
+};

 enum File {
  FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, FILE_NONE
@@ -71,7 +73,7 @@ const int FlipMask = 070;
 const int FlopMask = 07;


-//// 
+////
 //// Inline functions
 ////

@@ -129,7 +131,7 @@ inline Square relative_square(Color c, Square s) {
  return Square(int(s) ^ (int(c) * FlipMask));
 }

-inline Rank pawn_rank(Color c, Square s) {
+inline Rank relative_rank(Color c, Square s) {
  return square_rank(relative_square(c, s));
 }

@@ -157,21 +159,43 @@ inline int square_distance(Square s1, Square s2) {
  return Max(file_distance(s1, s2), rank_distance(s1, s2));
 }

+inline File file_from_char(char c) {
+  return File(c - 'a') + FILE_A;
+}

-//// 
-//// Prototypes
-////
+inline char file_to_char(File f) {
+  return char(f - FILE_A + int('a'));
+}

-extern File file_from_char(char c);
-extern char file_to_char(File f);
-extern Rank rank_from_char(char c);
-extern char rank_to_char(Rank r);
-extern Square square_from_string(const std::string &str);
-extern const std::string square_to_string(Square s);
+inline Rank rank_from_char(char c) {
+  return Rank(c - '1') + RANK_1;
+}

-extern bool file_is_ok(File f);
-extern bool rank_is_ok(Rank r);
-extern bool square_is_ok(Square s);
+inline char rank_to_char(Rank r) {
+  return char(r - RANK_1 + int('1'));
+}

+inline Square square_from_string(const std::string& str) {
+  return make_square(file_from_char(str[0]), rank_from_char(str[1]));
+}
+
+inline const std::string square_to_string(Square s) {
+  std::string str;
+  str += file_to_char(square_file(s));
+  str += rank_to_char(square_rank(s));
+  return str;
+}
+
+inline bool file_is_ok(File f) {
+  return f >= FILE_A && f <= FILE_H;
+}
+
+inline bool rank_is_ok(Rank r) {
+  return r >= RANK_1 && r <= RANK_8;
+}
+
+inline bool square_is_ok(Square s) {
+  return file_is_ok(square_file(s)) && rank_is_ok(square_rank(s));
+}

 #endif // !defined(SQUARE_H_INCLUDED)
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -1,28 +0,0 @@
-/*
-   (c) Copyright 1992 Eric Backus
-
-   This software may be used freely so long as this copyright notice is
-   left intact.  There is no warrantee on this software.
- */
-#include <windows.h>
-#include <time.h>
-#include "dos.h"
-
-
-int             gettimeofday(struct timeval * tp, struct timezone * tzp)
-{
-    SYSTEMTIME      systime;
-
-    if (tp) {
-        struct tm       tmrec;
-        time_t          theTime = time(NULL);
-
-
-        tmrec = *localtime(&theTime);
-        tp->tv_sec = mktime(&tmrec);
-        GetLocalTime(&systime); /* system time */
-
-        tp->tv_usec = systime.wMilliseconds * 1000;
-    }
-    return 0;
-}
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -23,6 +24,7 @@

 #include <cassert>
 #include <cmath>
+#include <cstring>

 #include "tt.h"

@@ -31,20 +33,15 @@
 //// Functions
 ////

-/// Constructor
+TranspositionTable::TranspositionTable() {

-TranspositionTable::TranspositionTable(unsigned mbSize) {
-  size = 0;
-  generation = 0;
-  writes = 0;
+  size = writes = 0;
  entries = 0;
-  this->set_size(mbSize);
+  generation = 0;
 }

-
-/// Destructor
-
 TranspositionTable::~TranspositionTable() {
+
  delete [] entries;
 }

@@ -53,128 +50,137 @@ TranspositionTable::~TranspositionTable() {
 /// measured in megabytes.

 void TranspositionTable::set_size(unsigned mbSize) {
-  unsigned newSize;

-  assert(mbSize >= 4 && mbSize <= 1024);
+  assert(mbSize >= 4 && mbSize <= 4096);

-  for(newSize = 1024; newSize * 4 * (sizeof(TTEntry)) <= (mbSize << 20);
-      newSize *= 2);
-  newSize /= 2;
+  unsigned newSize = 1024;

-  if(newSize != size) {
-    size = newSize;
-    delete [] entries;
-    entries = new TTEntry[size * 4];
-    if(entries == NULL) {
-      std::cerr << "Failed to allocate " << mbSize
-                << " MB for transposition table."
-                << std::endl;
-      exit(EXIT_FAILURE);
-    }
-    this->clear();
+  // We store a cluster of 4 TTEntry for each position and newSize is
+  // the maximum number of storable positions
+  while ((2 * newSize) * 4 * (sizeof(TTEntry)) <= (mbSize << 20))
+      newSize *= 2;
+
+  if (newSize != size)
+  {
+      size = newSize;
+      delete [] entries;
+      entries = new TTEntry[size * 4];
+      if (!entries)
+      {
+          std::cerr << "Failed to allocate " << mbSize
+                    << " MB for transposition table." << std::endl;
+          exit(EXIT_FAILURE);
+      }
+      clear();
  }
 }


 /// TranspositionTable::clear overwrites the entire transposition table
-/// with zeroes.  It is called whenever the table is resized, or when the
+/// with zeroes. It is called whenever the table is resized, or when the
 /// user asks the program to clear the table (from the UCI interface).
 /// Perhaps we should also clear it when the "ucinewgame" command is recieved?

 void TranspositionTable::clear() {
+
  memset(entries, 0, size * 4 * sizeof(TTEntry));
 }


 /// TranspositionTable::store writes a new entry containing a position,
 /// a value, a value type, a search depth, and a best move to the
-/// transposition table.  The transposition table is organized in clusters
-/// of four TTEntry objects, and when a new entry is written, it replaces
-/// the least valuable of the four entries in a cluster.  A TTEntry t1 is
+/// transposition table. Transposition table is organized in clusters of
+/// four TTEntry objects, and when a new entry is written, it replaces
+/// the least valuable of the four entries in a cluster. A TTEntry t1 is
 /// considered to be more valuable than a TTEntry t2 if t1 is from the
 /// current search and t2 is from a previous search, or if the depth of t1
-/// is bigger than the depth of t2.
+/// is bigger than the depth of t2. A TTEntry of type VALUE_TYPE_EVAL
+/// never replaces another entry for the same position.
+
+void TranspositionTable::store(const Position& p, Value v, ValueType t, Depth d, Move m) {

-void TranspositionTable::store(const Position &pos, Value v, Depth d,
-                               Move m, ValueType type) {
  TTEntry *tte, *replace;

-  tte = replace = entries + int(pos.get_key() & (size - 1)) * 4;
-  for(int i = 0; i < 4; i++) {
-    if((tte+i)->key() == pos.get_key()) {
-      if(m == MOVE_NONE)
-        m = (tte+i)->move();
-      *(tte+i) = TTEntry(pos.get_key(), v, type, d, m, generation);
-      return;
-    }
-    if(replace->generation() == generation) {
-      if((tte+i)->generation() != generation ||
-         (tte+i)->depth() < replace->depth())
-        replace = tte+i;
-    }
-    else if((tte+i)->generation() != generation &&
-            (tte+i)->depth() < replace->depth())
-      replace = tte+i;
+  tte = replace = first_entry(p);
+  for (int i = 0; i < 4; i++, tte++)
+  {
+      if (!tte->key() || tte->key() == p.get_key()) // empty or overwrite old
+      {
+          // Do not overwrite when new type is VALUE_TYPE_EVAL
+          if (tte->key() && t == VALUE_TYPE_EVAL)
+              return;
+
+          if (m == MOVE_NONE)
+              m = tte->move();
+
+          *tte = TTEntry(p.get_key(), v, t, d, m, generation);
+          return;
+      }
+      else if (i == 0)  // replace would be a no-op in this common case
+          continue;
+
+      int c1 = (replace->generation() == generation ?  2 : 0);
+      int c2 = (tte->generation() == generation ? -2 : 0);
+      int c3 = (tte->depth() < replace->depth() ?  1 : 0);
+
+      if (c1 + c2 + c3 > 0)
+          replace = tte;
  }
-  *replace = TTEntry(pos.get_key(), v, type, d, m, generation);
+  *replace = TTEntry(p.get_key(), v, t, d, m, generation);
  writes++;
 }


 /// TranspositionTable::retrieve looks up the current position in the
-/// transposition table, and extracts the value, value type, depth and
-/// best move if the position is found.  The return value is true if
-/// the position is found, and false if it isn't.
+/// transposition table. Returns a pointer to the TTEntry or NULL
+/// if position is not found.

-bool TranspositionTable::retrieve(const Position &pos, Value *value,
-                                  Depth *d, Move *move,
-                                  ValueType *type) const {
-  TTEntry *tte;
-  bool found = false;
+TTEntry* TranspositionTable::retrieve(const Position& pos) const {

-  tte = entries + int(pos.get_key() & (size - 1)) * 4;
-  for(int i = 0; i < 4 && !found ; i++)
-    if((tte+i)->key() == pos.get_key()) {
-      tte = tte + i;
-      found = true;
-    }
-  if(!found) {
-    *move = MOVE_NONE;
-    return false;
-  }
+  TTEntry *tte = first_entry(pos);

-  *value = tte->value();
-  *type = tte->type();
-  *d = tte->depth();
-  *move = tte->move();
+  for (int i = 0; i < 4; i++, tte++)
+      if (tte->key() == pos.get_key())
+          return tte;

-  return true;
+  return NULL;
 }


+/// TranspositionTable::first_entry returns a pointer to the first
+/// entry of a cluster given a position.
+
+inline TTEntry* TranspositionTable::first_entry(const Position& pos) const {
+
+  return entries + (int(pos.get_key() & (size - 1)) << 2);
+}
+
 /// TranspositionTable::new_search() is called at the beginning of every new
-/// search.  It increments the "generation" variable, which is used to
+/// search. It increments the "generation" variable, which is used to
 /// distinguish transposition table entries from previous searches from
 /// entries from the current search.

 void TranspositionTable::new_search() {
+
  generation++;
  writes = 0;
 }


-/// TranspositionTable::insert_pv() is called at the end of a search 
-/// iteration, and inserts the PV back into the PV.  This makes sure the
-/// old PV moves are searched first, even if the old TT entries have been
-/// overwritten.
+/// TranspositionTable::insert_pv() is called at the end of a search
+/// iteration, and inserts the PV back into the PV. This makes sure
+/// the old PV moves are searched first, even if the old TT entries
+/// have been overwritten.

-void TranspositionTable::insert_pv(const Position &pos, Move pv[]) {
-  UndoInfo u;
+void TranspositionTable::insert_pv(const Position& pos, Move pv[]) {
+
+  StateInfo st;
  Position p(pos);

-  for(int i = 0; pv[i] != MOVE_NONE; i++) {
-    this->store(p, VALUE_NONE, Depth(0), pv[i], VALUE_TYPE_NONE);
-    p.do_move(pv[i], u);
+  for (int i = 0; pv[i] != MOVE_NONE; i++)
+  {
+      store(p, VALUE_NONE, VALUE_TYPE_NONE, Depth(-127*OnePly), pv[i]);
+      p.do_move(pv[i], st);
  }
 }

@@ -183,48 +189,8 @@ void TranspositionTable::insert_pv(const Position &pos, Move pv[]) {
 /// entries which have received at least one write during the current search.
 /// It is used to display the "info hashfull ..." information in UCI.

-int TranspositionTable::full() {
+int TranspositionTable::full() const {
+
  double N = double(size) * 4.0;
  return int(1000 * (1 - exp(writes * log(1.0 - 1.0/N))));
 }
-
-
-/// Constructors
-
-TTEntry::TTEntry() {
-}
-
-TTEntry::TTEntry(Key k, Value v, ValueType t, Depth d, Move m,
-                 int generation) {
-  key_ = k;
-  data = (m & 0x7FFFF) | (t << 20) | (generation << 23);
-  value_ = v;
-  depth_ = int16_t(d);
-}
-
-
-/// Functions for extracting data from TTEntry objects.
-
-Key TTEntry::key() const {
-  return key_;
-}
-
-Depth TTEntry::depth() const {
-  return Depth(depth_);
-}
-
-Move TTEntry::move() const {
-  return Move(data & 0x7FFFF);
-}
-
-Value TTEntry::value() const {
-  return Value(value_);
-}
-
-ValueType TTEntry::type() const {
-  return ValueType((data >> 20) & 3);
-}
-
-int TTEntry::generation() const {
-  return (data >> 23);
-}
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -33,28 +34,44 @@
 //// Types
 ////

-/// The TTEntry class is the class of transposition table entries.
+/// The TTEntry class is the class of transposition table entries
+///
+/// A TTEntry needs 128 bits to be stored
+///
+/// bit    0-63: key
+/// bit   64-95: data
+/// bit  96-111: value
+/// bit 112-127: depth
+///
+/// the 32 bits of the data field are so defined
+///
+/// bit  0-16: move
+/// bit 17-19: not used
+/// bit 20-22: value type
+/// bit 23-31: generation

 class TTEntry {

 public:
-  TTEntry();
-  TTEntry(Key k, Value v, ValueType t, Depth d, Move m, int generation);
-  Key key() const;
-  Depth depth() const;
-  Move move() const;
-  Value value() const;
-  ValueType type() const;
-  int generation() const;
+  TTEntry() {}
+  TTEntry(Key k, Value v, ValueType t, Depth d, Move m, int generation)
+        : key_ (k), data((m & 0x1FFFF) | (t << 20) | (generation << 23)),
+          value_(int16_t(v)), depth_(int16_t(d)) {}

-private:  
+  Key key() const { return key_; }
+  Depth depth() const { return Depth(depth_); }
+  Move move() const { return Move(data & 0x1FFFF); }
+  Value value() const { return Value(value_); }
+  ValueType type() const { return ValueType((data >> 20) & 7); }
+  int generation() const { return (data >> 23); }
+
+private:
  Key key_;
  uint32_t data;
  int16_t value_;
  int16_t depth_;
 };

-
 /// The transposition table class.  This is basically just a huge array
 /// containing TTEntry objects, and a few methods for writing new entries
 /// and reading new ones.
@@ -62,31 +79,22 @@ private:
 class TranspositionTable {

 public:
-  TranspositionTable(unsigned mbSize);
+  TranspositionTable();
  ~TranspositionTable();
  void set_size(unsigned mbSize);
  void clear();
-  void store(const Position &pos, Value v, Depth d, Move m, ValueType type);
-  bool retrieve(const Position &pos, Value *value, Depth *d, Move *move,
-                ValueType *type) const;
+  void store(const Position& pos, Value v, ValueType type, Depth d, Move m);
+  TTEntry* retrieve(const Position& pos) const;
  void new_search();
-  void insert_pv(const Position &pos, Move pv[]);
-  int full();
+  void insert_pv(const Position& pos, Move pv[]);
+  int full() const;

 private:
-  unsigned size;
-  int writes;
+  inline TTEntry* first_entry(const Position& pos) const;
+
+  unsigned size, writes;
  TTEntry* entries;
  uint8_t generation;
 };

-
-////
-//// Constants and variables
-////
-
-// Default transposition table size, in megabytes:
-const int TTDefaultSize = 32;
-
-
 #endif // !defined(TT_H_INCLUDED)
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -21,7 +22,9 @@
 //// Includes
 ////

+#include <cassert>
 #include <iostream>
+#include <sstream>
 #include <string>

 #include "book.h"
@@ -42,30 +45,10 @@

 namespace {

-  // UCIInputParser is a class for parsing UCI input.  The class is
-  // very simple, and basically just consist of a constant input
-  // string and a current location in the string.  There are methods
-  // for checking if we are at the end of the line, for getting the
-  // next token (defined as any whitespace-delimited sequence of
-  // characters), and for getting the rest of the line as a single
-  // string.
-
-  class UCIInputParser {
-
-  public:
-    UCIInputParser(const std::string &line);
-    std::string get_next_token();
-    std::string get_rest_of_line();
-    bool at_end_of_line();
-
-  private:
-    const std::string &inputLine;
-    int length, currentIndex;
-
-    void skip_whitespace();
-
-  };
+  // UCIInputParser is a class for parsing UCI input.  The class
+  // is actually a string stream built on a given input string.

+  typedef std::istringstream UCIInputParser;

  // The root position.  This is set up when the user (or in practice, the GUI)
  // sends the "position" UCI command.  The root position is sent to the think()
@@ -73,7 +56,7 @@ namespace {
  Position RootPosition;

  // Local functions
-  void wait_for_command();
+  void get_command();
  void handle_command(const std::string &command);
  void set_option(UCIInputParser &uip);
  void set_position(UCIInputParser &uip);
@@ -91,8 +74,11 @@ namespace {
 /// command.

 void uci_main_loop() {
+
  RootPosition.from_fen(StartPosition);
-  while(1) wait_for_command();
+
+  while (1)
+      get_command();
 }


@@ -102,80 +88,19 @@ void uci_main_loop() {

 namespace {

-  ///
-  /// Implementation of the UCIInputParser class.
-  ///
-
-  // Constructor for the UCIInputParser class.  The constructor takes a 
-  // text string containing a single UCI command as input.
-
-  UCIInputParser::UCIInputParser(const std::string &line) : inputLine(line) {
-    this->currentIndex = 0;
-    this->length = line.length();
-  }
-
-
-  // UCIInputParser::skip_whitspace() skips any number of whitespace
-  // characters from the current location in an input string.
-
-  void UCIInputParser::skip_whitespace() {
-    while(isspace((int)(unsigned char)this->inputLine[this->currentIndex]))
-      this->currentIndex++;
-  }
-
-
-  // UCIInputParser::get_next_token() gets the next token in an UCI
-  // command.  A 'token' in an UCI command is simply any
-  // whitespace-delimited sequence of characters.
-
-  std::string UCIInputParser::get_next_token() {
-    int i, j;
-
-    this->skip_whitespace();
-    for(i = j = this->currentIndex; 
-        j < this->length && !isspace(this->inputLine[j]); 
-        j++);
-    this->currentIndex = j;
-    this->skip_whitespace();
-
-    std::string str = this->inputLine.substr(i, j - i);
-
-    return str;
-  }
-
-
-  // UCIInputParser::get_rest_of_line() returns the rest of the input
-  // line (from the current location) as a single string.
-
-  std::string UCIInputParser::get_rest_of_line() {
-    this->skip_whitespace();
-    return this->inputLine.substr(this->currentIndex, this->length);
-  }
-
-
-  // UCIInputParser::at_end_of_line() tests whether we have reached the
-  // end of the input string, i.e. if any more input remains to be
-  // parsed.
-
-  bool UCIInputParser::at_end_of_line() {
-    return this->currentIndex == this->length;
-  }
-
-
-  /// 
-  /// Other functions
-  ///
-
-
-  // wait_for_command() waits for a command from the user, and passes
-  // this command to handle_command.  wait_for_command also intercepts
+  // get_command() waits for a command from the user, and passes
+  // this command to handle_command.  get_command also intercepts
  // EOF from stdin, by translating EOF to the "quit" command.  This
-  // ensures that Glaurung exits gracefully if the GUI dies
+  // ensures that Stockfish exits gracefully if the GUI dies
  // unexpectedly.

-  void wait_for_command() {
+  void get_command() {
+
    std::string command;
-    if(!std::getline(std::cin, command)) command = "quit";
+
+    if (!std::getline(std::cin, command))
+        command = "quit";
+
    handle_command(command);
  }

@@ -184,137 +109,165 @@ namespace {
  // UCIInputParser object to parse this text string as a UCI command,
  // and calls the appropriate functions.  In addition to the UCI
  // commands, the function also supports a few debug commands.
-  
-  void handle_command(const std::string &command) {
-    UCIInputParser uip(command);
-    std::string s = uip.get_next_token();

-    if(s == "quit") {
-      OpeningBook.close();
-      stop_threads();
-      quit_eval();
-      exit(0);
+  void handle_command(const std::string &command) {
+
+    UCIInputParser uip(command);
+    std::string token;
+
+    uip >> token; // operator >> skips any whitespace
+
+    if (token == "quit")
+    {
+        OpeningBook.close();
+        stop_threads();
+        quit_eval();
+        exit(0);
    }
-    else if(s == "uci") {
-      std::cout << "id name " << engine_name() << std::endl;
-      std::cout << "id author Tord Romstad" << std::endl;
-      print_uci_options();
-      std::cout << "uciok" << std::endl;
+    else if (token == "uci")
+    {
+        std::cout << "id name " << engine_name() << std::endl
+                  << "id author Tord Romstad, Marco Costalba"
+                  << std::endl;
+        print_uci_options();
+        std::cout << "uciok" << std::endl;
    }
-    else if(s == "ucinewgame") {
-      TT.clear();
-      Position::init_piece_square_tables();
-      RootPosition.from_fen(StartPosition);
+    else if (token == "ucinewgame")
+    {
+        TT.clear();
+        Position::init_piece_square_tables();
+        RootPosition.from_fen(StartPosition);
    }
-    else if(s == "isready")
-      std::cout << "readyok" << std::endl;
-    else if(s == "position")
-      set_position(uip);
-    else if(s == "setoption")
-      set_option(uip);
-    else if(s == "go")
-      go(uip);
+    else if (token == "isready")
+        std::cout << "readyok" << std::endl;
+    else if (token == "position")
+        set_position(uip);
+    else if (token == "setoption")
+        set_option(uip);
+    else if (token == "go")
+        go(uip);

    // The remaining commands are for debugging purposes only.
    // Perhaps they should be removed later in order to reduce the
    // size of the program binary.
-    else if(s == "d")
-      RootPosition.print();
-    else if(s == "flip") {
-      Position p(RootPosition);
-      RootPosition.flipped_copy(p);
+    else if (token == "d")
+        RootPosition.print();
+    else if (token == "flip")
+    {
+        Position p(RootPosition);
+        RootPosition.flipped_copy(p);
    }
-    else if(s == "eval") {
-      EvalInfo ei;
-      std::cout << "Incremental mg: " << RootPosition.mg_value()
-                << std::endl;
-      std::cout << "Incremental eg: " << RootPosition.eg_value()
-                << std::endl;
-      std::cout << "Full eval: "
-                << evaluate(RootPosition, ei, 0)
-                << std::endl;
+    else if (token == "eval")
+    {
+        EvalInfo ei;
+        std::cout << "Incremental mg: " << RootPosition.mg_value()
+                  << std::endl;
+        std::cout << "Incremental eg: " << RootPosition.eg_value()
+                  << std::endl;
+        std::cout << "Full eval: "
+                  << evaluate(RootPosition, ei, 0)
+                  << std::endl;
    }
-    else if(s == "key") {
-      std::cout << "key: " << RootPosition.get_key()
-                << " material key: " << RootPosition.get_material_key()
-                << " pawn key: " << RootPosition.get_pawn_key()
-                << std::endl;
+    else if (token == "key")
+    {
+        std::cout << "key: " << std::hex << RootPosition.get_key()
+                  << " material key: " << RootPosition.get_material_key()
+                  << " pawn key: " << RootPosition.get_pawn_key()
+                  << std::endl;
    }
-    else {
-      std::cout << "Unknown command: " << command << std::endl;
-      while(!uip.at_end_of_line()) {
-        std::cout << uip.get_next_token() << std::endl;
-      }
+    else
+    {
+        std::cout << "Unknown command: " << command << std::endl;
+        while (!uip.eof())
+        {
+            uip >> token;
+            std::cout << token << std::endl;
+        }
    }
  }


-  // set_position() is called when Glaurung receives the "position" UCI
+  // set_position() is called when Stockfish receives the "position" UCI
  // command.  The input parameter is a UCIInputParser.  It is assumed
  // that this parser has consumed the first token of the UCI command
  // ("position"), and is ready to read the second token ("startpos"
  // or "fen", if the input is well-formed).

  void set_position(UCIInputParser &uip) {
+
    std::string token;

-    token = uip.get_next_token();
-    if(token == "startpos")
-      RootPosition.from_fen(StartPosition);
-    else if(token == "fen") {
-      std::string fen;
-      while(token != "moves" && !uip.at_end_of_line()) {
-        token = uip.get_next_token();
-        fen += token;
-        fen += ' ';
-      }
-      RootPosition.from_fen(fen);
+    uip >> token; // operator >> skips any whitespace
+
+    if (token == "startpos")
+        RootPosition.from_fen(StartPosition);
+    else if (token == "fen")
+    {
+        std::string fen;
+        while (token != "moves" && !uip.eof())
+        {
+          uip >> token;
+          fen += token;
+          fen += ' ';
+        }
+        RootPosition.from_fen(fen);
    }

-    if(!uip.at_end_of_line()) {
-      if(token != "moves")
-        token = uip.get_next_token();
-      if(token == "moves") {
-        Move move;
-        UndoInfo u;
-        while(!uip.at_end_of_line()) {
-          token = uip.get_next_token();
-          move = move_from_string(RootPosition, token);
-          RootPosition.do_move(move, u);
-          if(RootPosition.rule_50_counter() == 0)
-            RootPosition.reset_game_ply();
+    if (!uip.eof())
+    {
+        if (token != "moves")
+          uip >> token;
+        if (token == "moves")
+        {
+            Move move;
+            StateInfo st;
+            while (!uip.eof())
+            {
+                uip >> token;
+                move = move_from_string(RootPosition, token);
+                RootPosition.do_move(move, st);
+                if (RootPosition.rule_50_counter() == 0)
+                    RootPosition.reset_game_ply();
+            }
+            // Our StateInfo st is about going out of scope,
+            // so save its content before they disappear.
+            RootPosition.setStartState(st);
        }
-      }
    }
  }


-  // set_option() is called when Glaurung receives the "setoption" UCI
+  // set_option() is called when Stockfish receives the "setoption" UCI
  // command.  The input parameter is a UCIInputParser.  It is assumed
  // that this parser has consumed the first token of the UCI command
  // ("setoption"), and is ready to read the second token ("name", if
  // the input is well-formed).

  void set_option(UCIInputParser &uip) {
-    std::string token;
-    if(!uip.at_end_of_line()) {
-      token = uip.get_next_token();
-      if(token == "name" && !uip.at_end_of_line()) {
-        std::string name = uip.get_next_token();
-        std::string nextToken;
-        while(!uip.at_end_of_line()
-              && (nextToken = uip.get_next_token()) != "value")
-          name += (" " + nextToken);
-        if(nextToken == "value")
-          set_option_value(name, uip.get_rest_of_line());
-        else
-          push_button(name);
-      }
+
+    std::string token, name;
+
+    uip >> token;
+    if (token == "name")
+    {
+        uip >> name;
+        uip >> token;
+        while (!uip.eof() && token != "value")
+        {
+          name += (" " + token);
+          uip >> token;
+        }
+        if (token == "value")
+        {
+            std::getline(uip, token); // reads until end of line
+            set_option_value(name, token);
+        } else
+            push_button(name);
    }
  }


-  // go() is called when Glaurung receives the "go" UCI command.  The
+  // go() is called when Stockfish receives the "go" UCI command.  The
  // input parameter is a UCIInputParser.  It is assumed that this
  // parser has consumed the first token of the UCI command ("go"),
  // and is ready to read the second token.  The function sets the
@@ -323,69 +276,58 @@ namespace {
  // parameters.

  void go(UCIInputParser &uip) {
+
    std::string token;
-    int time[2] = {0, 0}, inc[2] = {0, 0}, movesToGo = 0, depth = 0, nodes = 0;
-    int moveTime = 0;
+
+    int time[2] = {0, 0}, inc[2] = {0, 0};
+    int movesToGo = 0, depth = 0, nodes = 0, moveTime = 0;
    bool infinite = false, ponder = false;
    Move searchMoves[500];

    searchMoves[0] = MOVE_NONE;

-    while(!uip.at_end_of_line()) {
-      token = uip.get_next_token();
+    while (!uip.eof())
+    {
+        uip >> token;

-      if(token == "infinite")
-        infinite = true;
-      else if(token == "ponder")
-        ponder = true;
-      else if(token == "wtime") {
-        if(!uip.at_end_of_line())
-          time[0] = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "btime") {
-        if(!uip.at_end_of_line())
-          time[1] = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "winc") {
-        if(!uip.at_end_of_line())
-          inc[0] = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "binc") {
-        if(!uip.at_end_of_line())
-          inc[1] = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "movestogo") {
-        if(!uip.at_end_of_line())
-          movesToGo = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "depth") {
-        if(!uip.at_end_of_line())
-          depth = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "nodes") {
-        if(!uip.at_end_of_line())
-          nodes = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "movetime") {
-        if(!uip.at_end_of_line())
-          moveTime = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "searchmoves" && !uip.at_end_of_line()) {
-        int numOfMoves = 0;
-        while(!uip.at_end_of_line()) {
-          token = uip.get_next_token();
-          searchMoves[numOfMoves++] = move_from_string(RootPosition, token);
+        if (token == "infinite")
+            infinite = true;
+        else if (token == "ponder")
+            ponder = true;
+        else if (token == "wtime")
+            uip >> time[0];
+        else if (token == "btime")
+            uip >> time[1];
+        else if (token == "winc")
+            uip >> inc[0];
+        else if (token == "binc")
+            uip >> inc[1];
+        else if (token == "movestogo")
+            uip >> movesToGo;
+        else if (token == "depth")
+            uip >> depth;
+        else if (token == "nodes")
+            uip >> nodes;
+        else if (token == "movetime")
+            uip >> moveTime;
+        else if (token == "searchmoves")
+        {
+            int numOfMoves = 0;
+            while (!uip.eof())
+            {
+                uip >> token;
+                searchMoves[numOfMoves++] = move_from_string(RootPosition, token);
+            }
+            searchMoves[numOfMoves] = MOVE_NONE;
        }
-        searchMoves[numOfMoves] = MOVE_NONE;
-      }
    }

-    if(moveTime)
-      infinite = true;  // HACK
+    if (moveTime)
+        infinite = true;  // HACK

-    think(RootPosition, infinite, ponder, time[RootPosition.side_to_move()],
-          inc[RootPosition.side_to_move()], movesToGo, depth, nodes, moveTime,
-          searchMoves);
+    assert(RootPosition.is_ok());
+
+    think(RootPosition, infinite, ponder, RootPosition.side_to_move(), time,
+          inc, movesToGo, depth, nodes, moveTime, searchMoves);
  }
-  
 }
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -21,9 +22,12 @@
 //// Includes
 ////

+#include <algorithm>
 #include <cassert>
-#include <cstdarg>
-#include <cstdio>
+#include <map>
+#include <string>
+#include <sstream>
+#include <vector>

 #include "misc.h"
 #include "thread.h"
@@ -34,7 +38,7 @@
 //// Variables
 ////

-bool Chess960 = false;
+bool Chess960;


 ////
@@ -47,93 +51,136 @@ namespace {
  /// Types
  ///

-  enum OptionType { SPIN, COMBO, CHECK, STRING, BUTTON, OPTION_TYPE_NONE};
+  enum OptionType { SPIN, COMBO, CHECK, STRING, BUTTON };
+
+  typedef std::vector<std::string> ComboValues;

  struct Option {
-    char name[50], defaultValue[300], currentValue[300];
+
+    std::string name, defaultValue, currentValue;
    OptionType type;
+    size_t idx;
    int minValue, maxValue;
-    char comboValues[8][64];
+    ComboValues comboValues;
+
+    Option();
+    Option(const char* defaultValue, OptionType = STRING);
+    Option(bool defaultValue, OptionType = CHECK);
+    Option(int defaultValue, int minValue, int maxValue);
+
+    bool operator<(const Option& o) const { return this->idx < o.idx; }
  };
-    
+
+  typedef std::map<std::string, Option> Options;
+
+  ///
+  /// Constants
+  ///
+
+  // load_defaults populates the options map with the hard
+  // coded names and default values.
+
+  void load_defaults(Options& o) {
+
+    o["Use Search Log"] = Option(false);
+    o["Search Log Filename"] = Option("SearchLog.txt");
+    o["Book File"] = Option("book.bin");
+    o["Mobility (Middle Game)"] = Option(100, 0, 200);
+    o["Mobility (Endgame)"] = Option(100, 0, 200);
+    o["Pawn Structure (Middle Game)"] = Option(100, 0, 200);
+    o["Pawn Structure (Endgame)"] = Option(100, 0, 200);
+    o["Passed Pawns (Middle Game)"] = Option(100, 0, 200);
+    o["Passed Pawns (Endgame)"] = Option(100, 0, 200);
+    o["Space"] = Option(100, 0, 200);
+    o["Aggressiveness"] = Option(100, 0, 200);
+    o["Cowardice"] = Option(100, 0, 200);
+    o["King Safety Curve"] = Option("Quadratic", COMBO);
+
+       o["King Safety Curve"].comboValues.push_back("Quadratic");
+       o["King Safety Curve"].comboValues.push_back("Linear");  /*, "From File"*/
+
+    o["King Safety Coefficient"] = Option(40, 1, 100);
+    o["King Safety X Intercept"] = Option(0, 0, 20);
+    o["King Safety Max Slope"] = Option(30, 10, 100);
+    o["King Safety Max Value"] = Option(500, 100, 1000);
+    o["Queen Contact Check Bonus"] = Option(3, 0, 8);
+    o["Queen Check Bonus"] = Option(2, 0, 4);
+    o["Rook Check Bonus"] = Option(1, 0, 4);
+    o["Bishop Check Bonus"] = Option(1, 0, 4);
+    o["Knight Check Bonus"] = Option(1, 0, 4);
+    o["Discovered Check Bonus"] = Option(3, 0, 8);
+    o["Mate Threat Bonus"] = Option(3, 0, 8);
+    o["Check Extension (PV nodes)"] = Option(2, 0, 2);
+    o["Check Extension (non-PV nodes)"] = Option(1, 0, 2);
+    o["Single Reply Extension (PV nodes)"] = Option(2, 0, 2);
+    o["Single Reply Extension (non-PV nodes)"] = Option(2, 0, 2);
+    o["Mate Threat Extension (PV nodes)"] = Option(0, 0, 2);
+    o["Mate Threat Extension (non-PV nodes)"] = Option(0, 0, 2);
+    o["Pawn Push to 7th Extension (PV nodes)"] = Option(1, 0, 2);
+    o["Pawn Push to 7th Extension (non-PV nodes)"] = Option(1, 0, 2);
+    o["Passed Pawn Extension (PV nodes)"] = Option(1, 0, 2);
+    o["Passed Pawn Extension (non-PV nodes)"] = Option(0, 0, 2);
+    o["Pawn Endgame Extension (PV nodes)"] = Option(2, 0, 2);
+    o["Pawn Endgame Extension (non-PV nodes)"] = Option(2, 0, 2);
+    o["Full Depth Moves (PV nodes)"] = Option(14, 1, 100);
+    o["Full Depth Moves (non-PV nodes)"] = Option(3, 1, 100);
+    o["Threat Depth"] = Option(5, 0, 100);
+    o["Futility Pruning (Main Search)"] = Option(true);
+    o["Futility Pruning (Quiescence Search)"] = Option(true);
+    o["LSN filtering"] = Option(false);
+    o["LSN Time Margin (sec)"] = Option(4, 1, 10);
+    o["LSN Value Margin"] = Option(200, 100, 600);
+    o["Randomness"] = Option(0, 0, 10);
+    o["Minimum Split Depth"] = Option(4, 4, 7);
+    o["Maximum Number of Threads per Split Point"] = Option(5, 4, 8);
+    o["Threads"] = Option(1, 1, 8);
+    o["Hash"] = Option(32, 4, 4096);
+    o["Clear Hash"] = Option(false, BUTTON);
+    o["Ponder"] = Option(true);
+    o["OwnBook"] = Option(true);
+    o["MultiPV"] = Option(1, 1, 500);
+    o["UCI_ShowCurrLine"] = Option(false);
+    o["UCI_Chess960"] = Option(false);
+
+    // Any option should know its name so to be easily printed
+    for (Options::iterator it = o.begin(); it != o.end(); ++it)
+        it->second.name = it->first;
+  }

  ///
  /// Variables
  ///

-  Option Options[] = {
-    { "Use Search Log", "false", "false", CHECK, 0, 0, {""} },
-    { "Search Log Filename", "SearchLog.txt", "SearchLog.txt", STRING, 0, 0, {""} },
-    { "Book File", "book.bin", "book.bin", STRING, 0, 0, {""} },
-    { "Mobility (Middle Game)", "100", "100", SPIN, 0, 200, {""} },
-    { "Mobility (Endgame)", "100", "100", SPIN, 0, 200, {""} },
-    { "Pawn Structure (Middle Game)", "100", "100", SPIN, 0, 200, {""} },
-    { "Pawn Structure (Endgame)", "100", "100", SPIN, 0, 200, {""} },
-    { "Passed Pawns (Middle Game)", "100", "100", SPIN, 0, 200, {""} },
-    { "Passed Pawns (Endgame)", "100", "100", SPIN, 0, 200, {""} },
-    { "Aggressiveness", "100", "100", SPIN, 0, 200, {""} },
-    { "Cowardice", "100", "100", SPIN, 0, 200, {""} },
-    { "King Safety Curve", "Quadratic", "Quadratic", COMBO, 0, 0,
-      { "Quadratic", "Linear" /*, "From File"*/ } },
-    { "King Safety Coefficient", "40", "40", SPIN, 1, 100 , {""} },
-    { "King Safety X Intercept", "0", "0", SPIN, 0, 20, {""} },
-    { "King Safety Max Slope", "30", "30", SPIN, 10, 100, {""} },
-    { "King Safety Max Value", "500", "500", SPIN, 100, 1000, {""} },
-    { "Queen Contact Check Bonus", "4", "4", SPIN, 0, 8, {""} },
-    { "Rook Contact Check Bonus", "2", "2", SPIN, 0, 4, {""} },
-    { "Queen Check Bonus", "2", "2", SPIN, 0, 4, {""} },
-    { "Rook Check Bonus", "1", "1", SPIN, 0, 4, {""} },
-    { "Bishop Check Bonus", "1", "1", SPIN, 0, 4, {""} },
-    { "Knight Check Bonus", "1", "1", SPIN, 0, 4, {""} },
-    { "Discovered Check Bonus", "3", "3", SPIN, 0, 8, {""} },
-    { "Mate Threat Bonus", "3", "3", SPIN, 0, 8, {""} },
-    { "Check Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Check Extension (non-PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Single Reply Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Single Reply Extension (non-PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Mate Threat Extension (PV nodes)", "0", "0", SPIN, 0, 2, {""} },
-    { "Mate Threat Extension (non-PV nodes)", "0", "0", SPIN, 0, 2, {""} },
-    { "Pawn Push to 7th Extension (PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Pawn Push to 7th Extension (non-PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Passed Pawn Extension (PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Passed Pawn Extension (non-PV nodes)", "0", "0", SPIN, 0, 2, {""} },
-    { "Pawn Endgame Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Pawn Endgame Extension (non-PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Full Depth Moves (PV nodes)", "14", "14", SPIN, 1, 100, {""} },
-    { "Full Depth Moves (non-PV nodes)", "3", "3", SPIN, 1, 100, {""} },
-    { "Threat Depth", "5", "5", SPIN, 0, 100, {""} },
-    { "Selective Plies", "7", "7", SPIN, 0, 10, {""} },
-    { "Futility Pruning (Main Search)", "true", "true", CHECK, 0, 0, {""} },
-    { "Futility Pruning (Quiescence Search)", "true", "true", CHECK, 0, 0, {""} },
-    { "Futility Margin 0", "50", "50", SPIN, 0, 1000, {""} },
-    { "Futility Margin 1", "100", "100", SPIN, 0, 1000, {""} },
-    { "Futility Margin 2", "300", "300", SPIN, 0, 1000, {""} },
-    { "Maximum Razoring Depth", "3", "3", SPIN, 0, 4, {""} },
-    { "Razoring Margin", "300", "300", SPIN, 150, 600, {""} },
-    { "Randomness", "0", "0", SPIN, 0, 10, {""} },
-    { "Minimum Split Depth", "4", "4", SPIN, 4, 7, {""} },
-    { "Maximum Number of Threads per Split Point", "5", "5", SPIN, 4, 8, {""} },
-    { "Threads", "1", "1", SPIN, 1, 8, {""} },
-    { "Hash", "32", "32", SPIN, 4, 4096, {""} },
-    { "Clear Hash", "false", "false", BUTTON, 0, 0, {""} },
-    { "Ponder", "true", "true", CHECK, 0, 0, {""} },
-    { "OwnBook", "true", "true", CHECK, 0, 0, {""} },
-    { "MultiPV", "1", "1", SPIN, 1, 500, {""} },
-    { "UCI_ShowCurrLine", "false", "false", CHECK, 0, 0, {""} },
-    { "UCI_Chess960", "false", "false", CHECK, 0, 0, {""} },
-    { "", "", "", OPTION_TYPE_NONE, 0, 0, {""}}
-  };
-    
+  Options options;

-  ///
-  /// Functions
-  ///
+  // stringify converts a value of type T to a std::string
+  template<typename T>
+  std::string stringify(const T& v) {

-  Option *option_with_name(const char *optionName);
+     std::ostringstream ss;
+     ss << v;
+     return ss.str();
+  }
+
+
+  // get_option_value implements the various get_option_value_<type>
+  // functions defined later, because only the option value
+  // type changes a template seems a proper solution.
+
+  template<typename T>
+  T get_option_value(const std::string& optionName) {
+
+      T ret = T();
+      if (options.find(optionName) == options.end())
+          return ret;
+
+      std::istringstream ss(options[optionName].currentValue);
+      ss >> ret;
+      return ret;
+  }

 }

-
 ////
 //// Functions
 ////
@@ -143,26 +190,26 @@ namespace {
 /// "Threads" parameter to the number of available CPU cores.

 void init_uci_options() {
-  Option *o;

-  o = option_with_name("Threads");
-  assert(o != NULL);
+  load_defaults(options);

  // Limit the default value of "Threads" to 7 even if we have 8 CPU cores.
  // According to Ken Dail's tests, Glaurung plays much better with 7 than
  // with 8 threads.  This is weird, but it is probably difficult to find out
  // why before I have a 8-core computer to experiment with myself.
-  sprintf(o->defaultValue, "%d", Min(cpu_count(), 7));
-  sprintf(o->currentValue, "%d", Min(cpu_count(), 7));
+  assert(options.find("Threads") != options.end());
+  assert(options.find("Minimum Split Depth") != options.end());
+
+  options["Threads"].defaultValue = stringify(Min(cpu_count(), 7));
+  options["Threads"].currentValue = stringify(Min(cpu_count(), 7));

  // Increase the minimum split depth when the number of CPUs is big.
  // It would probably be better to let this depend on the number of threads
  // instead.
-  o = option_with_name("Minimum Split Depth");
-  assert(o != NULL);
-  if(cpu_count() > 4) {
-    sprintf(o->defaultValue, "%d", 6);
-    sprintf(o->defaultValue, "%d", 6);
+  if (cpu_count() > 4)
+  {
+      options["Minimum Split Depth"].defaultValue = "6";
+      options["Minimum Split Depth"].currentValue = "6";
  }
 }

@@ -171,30 +218,51 @@ void init_uci_options() {
 /// in the format defined by the UCI protocol.

 void print_uci_options() {
+
  static const char optionTypeName[][16] = {
    "spin", "combo", "check", "string", "button"
  };
-  for(Option *o = Options; o->type != OPTION_TYPE_NONE; o++) {
-    printf("option name %s type %s", o->name, optionTypeName[o->type]);
-    if(o->type != BUTTON) {
-      printf(" default %s", o->defaultValue);
-      if(o->type == SPIN)
-        printf(" min %d max %d", o->minValue, o->maxValue);
-      else if(o->type == COMBO)
-        for(int i = 0; strlen(o->comboValues[i]) > 0; i++)
-          printf(" var %s", o->comboValues[i]);
-    }
-    printf("\n");
+
+  // Build up a vector out of the options map and sort it according to idx
+  // field, that is the chronological insertion order in options map.
+  std::vector<Option> vec;
+  for (Options::const_iterator it = options.begin(); it != options.end(); ++it)
+      vec.push_back(it->second);
+
+  std::sort(vec.begin(), vec.end());
+
+  for (std::vector<Option>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+  {
+      std::cout << "\noption name " << it->name
+                << " type "         << optionTypeName[it->type];
+
+      if (it->type == BUTTON)
+          continue;
+
+      if (it->type == CHECK)
+          std::cout << " default " << (it->defaultValue == "1" ? "true" : "false");
+      else
+          std::cout << " default " << it->defaultValue;
+
+      if (it->type == SPIN)
+          std::cout << " min " << it->minValue
+                    << " max " << it->maxValue;
+
+      else if (it->type == COMBO)
+          for (ComboValues::const_iterator itc = it->comboValues.begin();
+              itc != it->comboValues.end(); ++itc)
+              std::cout << " var " << *itc;
  }
+  std::cout << std::endl;
 }


 /// get_option_value_bool() returns the current value of a UCI parameter of
 /// type "check".

-bool get_option_value_bool(const std::string &optionName) {
-  Option *o = option_with_name(optionName.c_str());
-  return o != NULL && strcmp(o->currentValue, "true") == 0;
+bool get_option_value_bool(const std::string& optionName) {
+
+  return get_option_value<bool>(optionName);
 }


@@ -203,68 +271,79 @@ bool get_option_value_bool(const std::string &optionName) {
 /// it could also be used with a "combo" parameter, where all the available
 /// values are integers.

-int get_option_value_int(const std::string &optionName) {
-  Option *o = option_with_name(optionName.c_str());
-  return atoi(o->currentValue);
+int get_option_value_int(const std::string& optionName) {
+
+  return get_option_value<int>(optionName);
 }


 /// get_option_value_string() returns the current value of a UCI parameter as
-/// a string.  It is used with parameters of type "combo" and "string".
+/// a string. It is used with parameters of type "combo" and "string".

-const std::string get_option_value_string(const std::string &optionName) {
-  Option *o = option_with_name(optionName.c_str());
-  return o->currentValue;
+const std::string get_option_value_string(const std::string& optionName) {
+
+   return get_option_value<std::string>(optionName);
 }


-/// button_was_pressed() tests whether a UCI parameter of type "button" has
-/// been selected since the last time the function was called.
-
-bool button_was_pressed(const std::string &buttonName) {
-  if(get_option_value_bool(buttonName)) {
-    set_option_value(buttonName, "false");
-    return true;
-  }
-  else
-    return false;
-}
-
-
-/// set_option_value() inserts a new value for a UCI parameter.  Note that
+/// set_option_value() inserts a new value for a UCI parameter. Note that
 /// the function does not check that the new value is legal for the given
-/// parameter:  This is assumed to be the responsibility of the GUI.
+/// parameter: This is assumed to be the responsibility of the GUI.

-void set_option_value(const std::string &optionName,
-                      const std::string &newValue) {
-  Option *o = option_with_name(optionName.c_str());
+void set_option_value(const std::string& optionName,
+                      const std::string& newValue) {

-  if(o != NULL)
-    strcpy(o->currentValue, newValue.c_str());
+  // UCI protocol uses "true" and "false" instead of "1" and "0", so convert
+  // newValue according to standard C++ convention before to store it.
+  std::string v(newValue);
+  if (v == "true")
+      v = "1";
+  else if (v == "false")
+      v = "0";
+
+  if (options.find(optionName) != options.end())
+      options[optionName].currentValue = v;
  else
-    std::cout << "No such option: " << optionName << std::endl;
+      std::cout << "No such option: " << optionName << std::endl;
 }


 /// push_button() is used to tell the engine that a UCI parameter of type
 /// "button" has been selected:

-void push_button(const std::string &buttonName) {
+void push_button(const std::string& buttonName) {
+
  set_option_value(buttonName, "true");
 }


+/// button_was_pressed() tests whether a UCI parameter of type "button" has
+/// been selected since the last time the function was called, in this case
+/// it also resets the button.
+
+bool button_was_pressed(const std::string& buttonName) {
+
+  if (!get_option_value<bool>(buttonName))
+	  return false;
+
+  set_option_value(buttonName, "false");
+  return true;
+}
+
+
 namespace {

-  // option_with_name() tries to find a UCI option with a given
-  // name.  It returns a pointer to the UCI option or the null pointer,
-  // depending on whether an option with the given name exists.
-  
-  Option *option_with_name(const char *optionName) {
-    for(Option *o = Options; o->type != OPTION_TYPE_NONE; o++)
-      if(strcmp(o->name, optionName) == 0)
-        return o;
-    return NULL;
-  }
+  // Define constructors of Option class.
+
+  Option::Option() {} // To allow insertion in a std::map
+
+  Option::Option(const char* def, OptionType t)
+  : defaultValue(def), currentValue(def), type(t), idx(options.size()), minValue(0), maxValue(0) {}
+
+  Option::Option(bool def, OptionType t)
+  : defaultValue(stringify(def)), currentValue(stringify(def)), type(t), idx(options.size()), minValue(0), maxValue(0) {}
+
+  Option::Option(int def, int minv, int maxv)
+  : defaultValue(stringify(def)), currentValue(stringify(def)), type(SPIN), idx(options.size()), minValue(minv), maxValue(maxv) {}

 }
@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -44,7 +45,7 @@ extern bool get_option_value_bool(const std::string &optionName);
 extern int get_option_value_int(const std::string &optionName);
 extern const std::string get_option_value_string(const std::string &optionName);
 extern bool button_was_pressed(const std::string &buttonName);
-extern void set_option_value(const std::string &optionName, 
+extern void set_option_value(const std::string &optionName,
                             const std::string &newValue);
 extern void push_button(const std::string &buttonName);

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -59,7 +60,7 @@ Value value_from_tt(Value v, int ply) {
 }


-/// value_to_centipawns() converts a value from Glaurung's somewhat unusual
+/// value_to_centipawns() converts a value from Stockfish's somewhat unusual
 /// scale of pawn = 256 to the more conventional pawn = 100.

 int value_to_centipawns(Value v) {
@@ -67,7 +68,7 @@ int value_to_centipawns(Value v) {
 }


-/// value_from_centipawns() converts a centipawn value to Glaurung's internal
+/// value_from_centipawns() converts a centipawn value to Stockfish's internal
 /// evaluation scale.  It's used when reading the values of UCI options
 /// containing material values (e.g. futility pruning margins).

@@ -1,17 +1,18 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba

-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
-  
+
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -35,7 +36,8 @@ enum ValueType {
  VALUE_TYPE_NONE = 0,
  VALUE_TYPE_UPPER = 1,  // Upper bound
  VALUE_TYPE_LOWER = 2,  // Lower bound
-  VALUE_TYPE_EXACT = 3   // Exact score
+  VALUE_TYPE_EXACT = 3,  // Exact score
+  VALUE_TYPE_EVAL  = 4   // Evaluation cache
 };


@@ -57,17 +59,19 @@ enum Value {
 /// Important: If the material values are changed, one must also
 /// adjust the piece square tables, and the method game_phase() in the
 /// Position class!
+///
+/// Values modified by Joona Kiiski

-const Value PawnValueMidgame = Value(0xCC);
-const Value PawnValueEndgame = Value(0x100);
-const Value KnightValueMidgame = Value(0x340);
-const Value KnightValueEndgame = Value(0x340);
-const Value BishopValueMidgame = Value(0x340);
-const Value BishopValueEndgame = Value(0x340);
-const Value RookValueMidgame = Value(0x505);
-const Value RookValueEndgame = Value(0x505);
-const Value QueenValueMidgame = Value(0xA00);
-const Value QueenValueEndgame = Value(0xA00);
+const Value PawnValueMidgame   = Value(0x0CC);
+const Value PawnValueEndgame   = Value(0x101);
+const Value KnightValueMidgame = Value(0x332);
+const Value KnightValueEndgame = Value(0x34E);
+const Value BishopValueMidgame = Value(0x345);
+const Value BishopValueEndgame = Value(0x356);
+const Value RookValueMidgame   = Value(0x4F8);
+const Value RookValueEndgame   = Value(0x500);
+const Value QueenValueMidgame  = Value(0x9D5);
+const Value QueenValueEndgame  = Value(0x9FB);

 const Value PieceValueMidgame[17] = {
  Value(0),
@@ -91,8 +95,8 @@ const Value PieceValueEndgame[17] = {

 /// Bonus for having the side to move

-const Value TempoValueMidgame = Value(50);
-const Value TempoValueEndgame = Value(20);
+const Value TempoValueMidgame = Value(48);
+const Value TempoValueEndgame = Value(21);


 ////
@@ -120,7 +124,7 @@ inline void operator/= (Value &v, int i) { v = Value(int(v) / i); }
 inline Value value_mate_in(int ply) {
  return Value(VALUE_MATE - Value(ply));
 }
-               
+
 inline Value value_mated_in(int ply) {
  return Value(-VALUE_MATE + Value(ply));
 }