Stockfish 4

Stockfish bench signature is: 4132374
Fix crash when reaching max ply
2026-05-20 09:47:46 +00:00 · 2013-08-20 09:01:25 +02:00 · 2013-08-19 16:53:46 +02:00 · 2013-08-19 08:55:17 +02:00 · 2013-08-18 09:13:57 +02:00 · 2013-08-17 11:05:55 +02:00
45 changed files with 3414 additions and 3840 deletions
@@ -1,5 +1,4 @@
-1. Introduction
---------------
+### Overview

 Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is
 not a complete chess program and requires some UCI-compatible GUI
@@ -8,46 +7,37 @@ 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 it.

-This version of Stockfish supports up to 32 CPUs, but has not been
-tested thoroughly with more than 4.  The program tries to detect the
-number of CPUs on your computer and sets the number of search threads
-accordingly, but please be aware that the detection is not always
-correct. It is therefore recommended to inspect the value of the
-"Threads" UCI parameter, and to make sure it equals the number of CPU
-cores on your computer. If you are using more than eight threads, it is
-recommended to raise the value of the "Min Split Depth" UCI parameter to
-7.
+This version of Stockfish supports up to 64 CPUs. The engine defaults
+to one search thread it is therefore recommended to inspect the value of
+the *Threads* UCI parameter, and to make sure it equals the number of CPU
+cores on your computer.


-2. Files
--------
+### Files

 This distribution of Stockfish consists of the following files:

-  * Readme.txt, the file you are currently reading.
+  * Readme.md, the file you are currently reading.

  * Copying.txt, a text file containing the GNU General Public License.

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

  * polyglot.ini, for using Stockfish with Fabien Letouzey's PolyGlot
    adapter.


-3. Opening books
----------------
+### Opening books

 This version of Stockfish has 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 "Book File"
+documentation. The book file can be selected by setting the *Book File*
 UCI parameter.


-4. Compiling it yourself
------------------------
+### Compiling it yourself

 On Unix-like systems, it should be possible to compile Stockfish
 directly from the source code with the included Makefile.
@@ -55,17 +45,16 @@ directly from the source code with the included Makefile.
 Stockfish has support for 32 or 64-bit CPUs, the hardware POPCNT
 instruction, big-endian machines such as Power PC, and other platforms.

-In general it is recommended to run 'make help' to see a list of make
+In general it is recommended to run `make help` to see a list of make
 targets with corresponding descriptions. When not using Makefile to
 compile (for instance with Microsoft MSVC) you need to manually
-set/unset some switches in the compiler command line; see file "types.h"
+set/unset some switches in the compiler command line; see file *types.h*
 for a quick reference.


-5. Terms of use
---------------
+### Terms of use

-Stockfish 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
@@ -78,4 +67,4 @@ 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.

 For full details, read the copy of the GPL found in the file named
-Copying.txt.
+*Copying.txt*
@@ -1,4 +1,3 @@
-
 [PolyGlot]

 EngineDir = .
@@ -15,21 +14,25 @@ ResignScore = 600

 [Engine]

-Use Search Log = false
+Write Debug Log = false
+Write Search Log = false
 Search Log Filename = SearchLog.txt
 Book File = book.bin
 Best Book Move = false
-Mobility (Middle Game) = 100
+Contempt Factor = 0
+Mobility (Midgame) = 100
 Mobility (Endgame) = 100
-Passed Pawns (Middle Game) = 100
+Pawn Structure (Midgame) = 100
+Pawn Structure (Endgame) = 100
+Passed Pawns (Midgame) = 100
 Passed Pawns (Endgame) = 100
 Space = 100
 Aggressiveness = 100
 Cowardice = 100
-Min Split Depth = 4
+Min Split Depth = 0
 Max Threads per Split Point = 5
 Threads = 1
-Use Sleeping Threads = false
+Idle Threads Sleep = false
 Hash = 128
 Ponder = true
 OwnBook = false
@@ -39,5 +42,6 @@ Emergency Move Horizon = 40
 Emergency Base Time = 200
 Emergency Move Time = 70
 Minimum Thinking Time = 20
+Slow Mover = 100
 UCI_Chess960 = false
 UCI_AnalyseMode = false
@@ -1,6 +1,6 @@
 # Stockfish, a UCI chess playing engine derived from Glaurung 2.1
 # Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-# Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+# Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad
 #
 # Stockfish is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -34,8 +34,9 @@ ifeq ($(UNAME),Haiku)
 endif
 BINDIR = $(PREFIX)/bin

-### Built-in benchmark for pgo-builds
+### Built-in benchmark for pgo-builds and signature
 PGOBENCH = ./$(EXE) bench 32 1 10 default depth
+SIGNBENCH = ./$(EXE) bench

 ### Object files
 OBJS = benchmark.o bitbase.o bitboard.o book.o endgame.o evaluate.o main.o \
@@ -58,6 +59,7 @@ OBJS = benchmark.o bitbase.o bitboard.o book.o endgame.o evaluate.o main.o \
 # bsfq = yes/no       --- -DUSE_BSFQ       --- Use bsfq x86_64 asm-instruction (only
 #                                              with GCC and ICC 64-bit)
 # popcnt = yes/no     --- -DUSE_POPCNT     --- Use popcnt x86_64 asm-instruction
+# sse = yes/no        --- -msse            --- Use Intel Streaming SIMD Extensions
 #
 # Note that Makefile is space sensitive, so when adding new architectures
 # or modifying existing flags, you have to make sure there are no extra spaces
@@ -77,6 +79,7 @@ ifeq ($(ARCH),general-64)
 	prefetch = no
 	bsfq = no
 	popcnt = no
+	sse = no
 endif

 ifeq ($(ARCH),general-32)
@@ -86,6 +89,7 @@ ifeq ($(ARCH),general-32)
 	prefetch = no
 	bsfq = no
 	popcnt = no
+	sse = no
 endif

 # x86-section
@@ -96,6 +100,7 @@ ifeq ($(ARCH),x86-64)
 	prefetch = yes
 	bsfq = yes
 	popcnt = no
+	sse = yes
 endif

 ifeq ($(ARCH),x86-64-modern)
@@ -105,6 +110,7 @@ ifeq ($(ARCH),x86-64-modern)
 	prefetch = yes
 	bsfq = yes
 	popcnt = yes
+	sse = yes
 endif

 ifeq ($(ARCH),x86-32)
@@ -114,6 +120,7 @@ ifeq ($(ARCH),x86-32)
 	prefetch = yes
 	bsfq = no
 	popcnt = no
+	sse = yes
 endif

 ifeq ($(ARCH),x86-32-old)
@@ -123,6 +130,18 @@ ifeq ($(ARCH),x86-32-old)
 	prefetch = no
 	bsfq = no
 	popcnt = no
+	sse = no
+endif
+
+#arm section
+ifeq ($(ARCH),armv7)
+	arch = armv7
+	os = any
+	bits = 32
+	prefetch = yes
+	bsfq = yes
+	popcnt = no
+	sse = no
 endif

 # osx-section
@@ -133,6 +152,7 @@ ifeq ($(ARCH),osx-ppc-64)
 	prefetch = no
 	bsfq = no
 	popcnt = no
+	sse = no
 endif

 ifeq ($(ARCH),osx-ppc-32)
@@ -142,6 +162,7 @@ ifeq ($(ARCH),osx-ppc-32)
 	prefetch = no
 	bsfq = no
 	popcnt = no
+	sse = no
 endif

 ifeq ($(ARCH),osx-x86-64)
@@ -151,6 +172,7 @@ ifeq ($(ARCH),osx-x86-64)
 	prefetch = yes
 	bsfq = yes
 	popcnt = no
+	sse = yes
 endif

 ifeq ($(ARCH),osx-x86-32)
@@ -160,6 +182,7 @@ ifeq ($(ARCH),osx-x86-32)
 	prefetch = yes
 	bsfq = no
 	popcnt = no
+	sse = yes
 endif


@@ -209,7 +232,7 @@ ifeq ($(COMP),clang)
 endif

 ### 3.2 General compiler settings
-CXXFLAGS = -g -Wall -Wcast-qual -fno-exceptions -fno-rtti $(EXTRACXXFLAGS)
+CXXFLAGS = -Wall -Wcast-qual -fno-exceptions -fno-rtti $(EXTRACXXFLAGS)

 ifeq ($(comp),gcc)
 	CXXFLAGS += -ansi -pedantic -Wno-long-long -Wextra -Wshadow
@@ -220,7 +243,7 @@ ifeq ($(comp),mingw)
 endif

 ifeq ($(comp),icc)
-	CXXFLAGS += -wd383,981,1418,1419,10187,10188,11505,11503 -Wcheck -Wabi -Wdeprecated -strict-ansi
+	CXXFLAGS += -wd383,981,1418,1419,1476,10187,10188,11505,11503 -Wcheck -Wabi -Wdeprecated -strict-ansi
 endif

 ifeq ($(comp),clang)
@@ -228,12 +251,16 @@ ifeq ($(comp),clang)
 endif

 ifeq ($(os),osx)
-	CXXFLAGS += -arch $(arch)
+	CXXFLAGS += -arch $(arch) -mmacosx-version-min=10.0
 endif

 ### 3.3 General linker settings
 LDFLAGS = $(EXTRALDFLAGS)

+ifeq ($(comp),mingw)
+	LDFLAGS += -static-libstdc++ -static-libgcc
+endif
+
 ### On mingw use Windows threads, otherwise POSIX
 ifneq ($(comp),mingw)
 	# Haiku has pthreads in its libroot, so only link it in on other platforms
@@ -243,12 +270,14 @@ ifneq ($(comp),mingw)
 endif

 ifeq ($(os),osx)
-	LDFLAGS += -arch $(arch)
+	LDFLAGS += -arch $(arch) -mmacosx-version-min=10.0
 endif

 ### 3.4 Debugging
 ifeq ($(debug),no)
 	CXXFLAGS += -DNDEBUG
+else
+	CXXFLAGS += -g
 endif

 ### 3.5 Optimization
@@ -265,6 +294,10 @@ ifeq ($(optimize),yes)
 				CXXFLAGS += -mdynamic-no-pic
 			endif
 		endif
+
+		ifeq ($(arch),armv7)
+			CXXFLAGS += -fno-gcse
+		endif
 	endif

 	ifeq ($(comp),mingw)
@@ -301,8 +334,10 @@ endif

 ### 3.7 prefetch
 ifeq ($(prefetch),yes)
-	CXXFLAGS += -msse
-	DEPENDFLAGS += -msse
+	ifeq ($(sse),yes)
+		CXXFLAGS += -msse
+		DEPENDFLAGS += -msse
+	endif
 else
 	CXXFLAGS += -DNO_PREFETCH
 endif
@@ -322,6 +357,7 @@ endif
 ### needs access to the optimization flags.
 ifeq ($(comp),gcc)
 	ifeq ($(optimize),yes)
+	ifeq ($(debug),no)
 		GCC_MAJOR := `$(CXX) -dumpversion | cut -f1 -d.`
 		GCC_MINOR := `$(CXX) -dumpversion | cut -f2 -d.`
 		ifeq (1,$(shell expr \( $(GCC_MAJOR) \> 4 \) \| \( $(GCC_MAJOR) \= 4 \& $(GCC_MINOR) \>= 5 \)))
@@ -329,6 +365,7 @@ ifeq ($(comp),gcc)
 			LDFLAGS += $(CXXFLAGS)
 		endif
 	endif
+	endif
 endif

 ### ==========================================================================
@@ -343,43 +380,46 @@ help:
 	@echo ""
 	@echo "Supported targets:"
 	@echo ""
-	@echo "build                > Build unoptimized version"
-	@echo "profile-build        > Build PGO-optimized version"
-	@echo "strip                > Strip executable"
-	@echo "install              > Install executable"
-	@echo "clean                > Clean up"
-	@echo "testrun              > Make sample run"
+	@echo "build                   > Standard build"
+	@echo "signature-build         > Standard build with embedded signature"
+	@echo "profile-build           > PGO build"
+	@echo "signature-profile-build > PGO build with embedded signature"
+	@echo "strip                   > Strip executable"
+	@echo "install                 > Install executable"
+	@echo "clean                   > Clean up"
 	@echo ""
 	@echo "Supported archs:"
 	@echo ""
-	@echo "x86-64               > x86 64-bit"
-	@echo "x86-64-modern        > x86 64-bit with runtime support for popcnt instruction"
-	@echo "x86-32               > x86 32-bit excluding old hardware without SSE-support"
-	@echo "x86-32-old           > x86 32-bit including also very old hardware"
-	@echo "osx-ppc-64           > PPC-Mac OS X 64 bit"
-	@echo "osx-ppc-32           > PPC-Mac OS X 32 bit"
-	@echo "osx-x86-64           > x86-Mac OS X 64 bit"
-	@echo "osx-x86-32           > x86-Mac OS X 32 bit"
-	@echo "general-64           > unspecified 64-bit"
-	@echo "general-32           > unspecified 32-bit"
+	@echo "x86-64                  > x86 64-bit"
+	@echo "x86-64-modern           > x86 64-bit with popcnt support"
+	@echo "x86-32                  > x86 32-bit with SSE support"
+	@echo "x86-32-old              > x86 32-bit fall back for old hardware"
+	@echo "osx-ppc-64              > PPC-Mac OS X 64 bit"
+	@echo "osx-ppc-32              > PPC-Mac OS X 32 bit"
+	@echo "osx-x86-64              > x86-Mac OS X 64 bit"
+	@echo "osx-x86-32              > x86-Mac OS X 32 bit"
+	@echo "armv7                   > ARMv7 32 bit"
+	@echo "general-64              > unspecified 64-bit"
+	@echo "general-32              > unspecified 32-bit"
 	@echo ""
-	@echo "Supported comps:"
+	@echo "Supported compilers:"
 	@echo ""
-	@echo "gcc                  > Gnu compiler (default)"
-	@echo "icc                  > Intel compiler"
-	@echo "mingw                > Gnu compiler with MinGW under Windows"
-	@echo "clang                > LLVM Clang compiler"
+	@echo "gcc                     > Gnu compiler (default)"
+	@echo "mingw                   > Gnu compiler with MinGW under Windows"
+	@echo "clang                   > LLVM Clang compiler"
+	@echo "icc                     > Intel compiler"
 	@echo ""
 	@echo "Non-standard targets:"
 	@echo ""
-	@echo "make hpux           >  Compile for HP-UX. Compiler = aCC"
+	@echo "make hpux               >  Compile for HP-UX. Compiler = aCC"
 	@echo ""
 	@echo "Examples. If you don't know what to do, you likely want to run: "
 	@echo ""
-	@echo "make profile-build ARCH=x86-64    (This is for 64-bit systems)"
-	@echo "make profile-build ARCH=x86-32    (This is for 32-bit systems)"
+	@echo "make build ARCH=x86-64    (This is for 64-bit systems)"
+	@echo "make build ARCH=x86-32    (This is for 32-bit systems)"
 	@echo ""

+.PHONY: build profile-build embed-signature
 build:
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
@@ -404,6 +444,18 @@ profile-build:
 	@echo "Step 4/4. Deleting profile data ..."
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_clean)

+embed-signature:
+	@echo "Running benchmark for getting the signature ..."
+	@$(SIGNBENCH) 2>&1 | sed -n 's/Nodes searched  : \(.*\)/\/string Version\/s\/"\\(.*\\)"\/"sig-\1"\//p' > sign.txt
+	@sed -f sign.txt misc.cpp > misc2.cpp
+	@mv misc2.cpp misc.cpp
+	@rm sign.txt
+
+signature-build: build embed-signature
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
+
+signature-profile-build: build embed-signature profile-build
+
 strip:
 	strip $(EXE)

@@ -415,9 +467,6 @@ install:
 clean:
 	$(RM) $(EXE) $(EXE).exe *.o .depend *~ core bench.txt *.gcda

-testrun:
-	@$(PGOBENCH)
-
 default:
 	help

@@ -438,6 +487,7 @@ config-sanity:
 	@echo "prefetch: '$(prefetch)'"
 	@echo "bsfq: '$(bsfq)'"
 	@echo "popcnt: '$(popcnt)'"
+	@echo "sse: '$(sse)'"
 	@echo ""
 	@echo "Flags:"
 	@echo "CXX: $(CXX)"
@@ -449,12 +499,13 @@ config-sanity:
 	@test "$(debug)" = "yes" || test "$(debug)" = "no"
 	@test "$(optimize)" = "yes" || test "$(optimize)" = "no"
 	@test "$(arch)" = "any" || test "$(arch)" = "x86_64" || test "$(arch)" = "i386" || \
-	 test "$(arch)" = "ppc64" || test "$(arch)" = "ppc"
+	 test "$(arch)" = "ppc64" || test "$(arch)" = "ppc" || test "$(arch)" = "armv7"
 	@test "$(os)" = "any" || test "$(os)" = "osx"
 	@test "$(bits)" = "32" || test "$(bits)" = "64"
 	@test "$(prefetch)" = "yes" || test "$(prefetch)" = "no"
 	@test "$(bsfq)" = "yes" || test "$(bsfq)" = "no"
 	@test "$(popcnt)" = "yes" || test "$(popcnt)" = "no"
+	@test "$(sse)" = "yes" || test "$(sse)" = "no"
 	@test "$(comp)" = "gcc" || test "$(comp)" = "icc" || test "$(comp)" = "mingw" || test "$(comp)" = "clang"

 $(EXE): $(OBJS)
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -66,7 +66,7 @@ void benchmark(const Position& current, istream& is) {
  vector<string> fens;

  // Assign default values to missing arguments
-  string ttSize    = (is >> token) ? token : "128";
+  string ttSize    = (is >> token) ? token : "32";
  string threads   = (is >> token) ? token : "1";
  string limit     = (is >> token) ? token : "12";
  string fenFile   = (is >> token) ? token : "default";
@@ -82,6 +82,9 @@ void benchmark(const Position& current, istream& is) {
  else if (limitType == "nodes")
      limits.nodes = atoi(limit.c_str());

+  else if (limitType == "mate")
+      limits.mate = atoi(limit.c_str());
+
  else
      limits.depth = atoi(limit.c_str());

@@ -89,7 +92,7 @@ void benchmark(const Position& current, istream& is) {
      fens.assign(Defaults, Defaults + 16);

  else if (fenFile == "current")
-      fens.push_back(current.to_fen());
+      fens.push_back(current.fen());

  else
  {
@@ -99,7 +102,7 @@ void benchmark(const Position& current, istream& is) {
      if (!file.is_open())
      {
          cerr << "Unable to open file " << fenFile << endl;
-          exit(EXIT_FAILURE);
+          return;
      }

      while (getline(file, fen))
@@ -115,7 +118,7 @@ void benchmark(const Position& current, istream& is) {

  for (size_t i = 0; i < fens.size(); i++)
  {
-      Position pos(fens[i], Options["UCI_Chess960"], Threads.main_thread());
+      Position pos(fens[i], Options["UCI_Chess960"], Threads.main());

      cerr << "\nPosition: " << i + 1 << '/' << fens.size() << endl;

@@ -127,9 +130,9 @@ void benchmark(const Position& current, istream& is) {
      }
      else
      {
-          Threads.start_searching(pos, limits, vector<Move>(), st);
-          Threads.wait_for_search_finished();
-          nodes += Search::RootPosition.nodes_searched();
+          Threads.start_thinking(pos, limits, vector<Move>(), st);
+          Threads.wait_for_think_finished();
+          nodes += Search::RootPos.nodes_searched();
      }
  }

@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -18,12 +18,32 @@
 */

 #include <cassert>
+#include <vector>

 #include "bitboard.h"
 #include "types.h"

 namespace {

+  // The possible pawns squares are 24, the first 4 files and ranks from 2 to 7
+  const unsigned IndexMax = 2*24*64*64; // stm * psq * wksq * bksq = 196608
+
+  // Each uint32_t stores results of 32 positions, one per bit
+  uint32_t KPKBitbase[IndexMax / 32];
+
+  // A KPK bitbase index is an integer in [0, IndexMax] range
+  //
+  // Information is mapped in a way that minimizes number of iterations:
+  //
+  // bit  0- 5: white king square (from SQ_A1 to SQ_H8)
+  // bit  6-11: black king square (from SQ_A1 to SQ_H8)
+  // bit    12: side to move (WHITE or BLACK)
+  // bit 13-14: white pawn file (from FILE_A to FILE_D)
+  // bit 15-17: white pawn RANK_7 - rank (from RANK_7 - RANK_7 to RANK_7 - RANK_2)
+  unsigned index(Color us, Square bksq, Square wksq, Square psq) {
+    return wksq + (bksq << 6) + (us << 12) + (file_of(psq) << 13) + ((RANK_7 - rank_of(psq)) << 15);
+  }
+
  enum Result {
    INVALID = 0,
    UNKNOWN = 1,
@@ -35,196 +55,121 @@ namespace {

  struct KPKPosition {

-    Result classify_leaf(int idx);
-    Result classify(int idx, Result db[]);
+    operator Result() const { return res; }
+    Result classify_leaf(unsigned idx);
+    Result classify(const std::vector<KPKPosition>& db)
+    { return us == WHITE ? classify<WHITE>(db) : classify<BLACK>(db); }

  private:
-    template<Color Us> Result classify(const Result db[]) const;
+    template<Color Us> Result classify(const std::vector<KPKPosition>& db);

-    template<Color Us> Bitboard k_attacks() const {
-      return Us == WHITE ? StepAttacksBB[W_KING][wksq] : StepAttacksBB[B_KING][bksq];
-    }
-
-    Bitboard p_attacks() const { return StepAttacksBB[W_PAWN][psq]; }
-    void decode_index(int idx);
-
-    Square wksq, bksq, psq;
-    Color stm;
+    Color us;
+    Square bksq, wksq, psq;
+    Result res;
  };

-  // The possible pawns squares are 24, the first 4 files and ranks from 2 to 7
-  const int IndexMax = 2 * 24 * 64 * 64; // stm * wp_sq * wk_sq * bk_sq = 196608
-
-  // Each uint32_t stores results of 32 positions, one per bit
-  uint32_t KPKBitbase[IndexMax / 32];
-
-  int index(Square wksq, Square bksq, Square psq, Color stm);
-}
+} // namespace


-uint32_t Bitbases::probe_kpk(Square wksq, Square wpsq, Square bksq, Color stm) {
+bool Bitbases::probe_kpk(Square wksq, Square wpsq, Square bksq, Color us) {

-  int idx = index(wksq, bksq, wpsq, stm);
-  return KPKBitbase[idx / 32] & (1 << (idx & 31));
+  assert(file_of(wpsq) <= FILE_D);
+
+  unsigned idx = index(us, bksq, wksq, wpsq);
+  return KPKBitbase[idx / 32] & (1 << (idx & 0x1F));
 }


 void Bitbases::init_kpk() {

-  Result db[IndexMax];
-  KPKPosition pos;
-  int idx, bit, repeat = 1;
+  unsigned idx, repeat = 1;
+  std::vector<KPKPosition> db(IndexMax);

-  // Initialize table with known win / draw positions
+  // Initialize db with known win / draw positions
  for (idx = 0; idx < IndexMax; idx++)
-      db[idx] = pos.classify_leaf(idx);
+      db[idx].classify_leaf(idx);

-  // Iterate until all positions are classified (30 cycles needed)
+  // Iterate through the positions until no more of the unknown positions can be
+  // changed to either wins or draws (15 cycles needed).
  while (repeat)
      for (repeat = idx = 0; idx < IndexMax; idx++)
-          if (db[idx] == UNKNOWN && (db[idx] = pos.classify(idx, db)) != UNKNOWN)
+          if (db[idx] == UNKNOWN && db[idx].classify(db) != UNKNOWN)
              repeat = 1;

-  // Map 32 position results into one KPKBitbase[] entry
-  for (idx = 0; idx < IndexMax / 32; idx++)
-      for (bit = 0; bit < 32; bit++)
-          if (db[32 * idx + bit] == WIN)
-              KPKBitbase[idx] |= 1 << bit;
+  // Map 32 results into one KPKBitbase[] entry
+  for (idx = 0; idx < IndexMax; idx++)
+      if (db[idx] == WIN)
+          KPKBitbase[idx / 32] |= 1 << (idx & 0x1F);
 }


 namespace {

-  // A KPK bitbase index is an integer in [0, IndexMax] range
-  //
-  // Information is mapped in this way
-  //
-  // bit     0: side to move (WHITE or BLACK)
-  // bit  1- 6: black king square (from SQ_A1 to SQ_H8)
-  // bit  7-12: white king square (from SQ_A1 to SQ_H8)
-  // bit 13-14: white pawn file (from FILE_A to FILE_D)
-  // bit 15-17: white pawn rank - 1 (from RANK_2 - 1 to RANK_7 - 1)
+  Result KPKPosition::classify_leaf(unsigned idx) {

-  int index(Square w, Square b, Square p, Color c) {
-
-    assert(file_of(p) <= FILE_D);
-
-    return c + (b << 1) + (w << 7) + (file_of(p) << 13) + ((rank_of(p) - 1) << 15);
-  }
-
-  void KPKPosition::decode_index(int idx) {
-
-    stm  = Color(idx & 1);
-    bksq = Square((idx >> 1) & 63);
-    wksq = Square((idx >> 7) & 63);
-    psq  = File((idx >> 13) & 3) | Rank((idx >> 15) + 1);
-  }
-
-  Result KPKPosition::classify_leaf(int idx) {
-
-    decode_index(idx);
+    wksq = Square((idx >>  0) & 0x3F);
+    bksq = Square((idx >>  6) & 0x3F);
+    us   = Color ((idx >> 12) & 0x01);
+    psq  = File  ((idx >> 13) & 0x03) | Rank(RANK_7 - (idx >> 15));

    // Check if two pieces are on the same square or if a king can be captured
    if (   wksq == psq || wksq == bksq || bksq == psq
-        || (k_attacks<WHITE>() & bksq)
-        || (stm == WHITE && (p_attacks() & bksq)))
-        return INVALID;
+        || (StepAttacksBB[KING][wksq] & bksq)
+        || (us == WHITE && (StepAttacksBB[PAWN][psq] & bksq)))
+        return res = INVALID;

-    // The position is an immediate win if it is white to move and the white
-    // pawn can be promoted without getting captured.
-    if (   rank_of(psq) == RANK_7
-        && stm == WHITE
-        && wksq != psq + DELTA_N
-        && (   square_distance(bksq, psq + DELTA_N) > 1
-            ||(k_attacks<WHITE>() & (psq + DELTA_N))))
-        return WIN;
+    if (us == WHITE)
+    {
+        // Immediate win if pawn can be promoted without getting captured
+        if (   rank_of(psq) == RANK_7
+            && wksq != psq + DELTA_N
+            && (   square_distance(bksq, psq + DELTA_N) > 1
+                ||(StepAttacksBB[KING][wksq] & (psq + DELTA_N))))
+            return res = WIN;
+    }
+    // Immediate draw if is stalemate or king captures undefended pawn
+    else if (  !(StepAttacksBB[KING][bksq] & ~(StepAttacksBB[KING][wksq] | StepAttacksBB[PAWN][psq]))
+             || (StepAttacksBB[KING][bksq] & psq & ~StepAttacksBB[KING][wksq]))
+        return res = DRAW;

-    // Check for known draw positions
-    //
-    // Case 1: Stalemate
-    if (   stm == BLACK
-        && !(k_attacks<BLACK>() & ~(k_attacks<WHITE>() | p_attacks())))
-        return DRAW;
-
-    // Case 2: King can capture undefended pawn
-    if (   stm == BLACK
-        && (k_attacks<BLACK>() & psq & ~k_attacks<WHITE>()))
-        return DRAW;
-
-    // Case 3: Black king in front of white pawn
-    if (   bksq == psq + DELTA_N
-        && rank_of(psq) < RANK_7)
-        return DRAW;
-
-    // Case 4: White king in front of pawn and black has opposition
-    if (   stm == WHITE
-        && wksq == psq + DELTA_N
-        && bksq == wksq + DELTA_N + DELTA_N
-        && rank_of(psq) < RANK_5)
-        return DRAW;
-
-    // Case 5: Stalemate with rook pawn
-    if (   bksq == SQ_A8
-        && file_of(psq) == FILE_A)
-        return DRAW;
-
-    // Case 6: White king trapped on the rook file
-    if (   file_of(wksq) == FILE_A
-        && file_of(psq) == FILE_A
-        && rank_of(wksq) > rank_of(psq)
-        && bksq == wksq + 2)
-        return DRAW;
-
-    return UNKNOWN;
+    return res = UNKNOWN;
  }

  template<Color Us>
-  Result KPKPosition::classify(const Result db[]) const {
+  Result KPKPosition::classify(const std::vector<KPKPosition>& db) {

-    // White to Move: If one move leads to a position classified as RESULT_WIN,
-    // the result of the current position is RESULT_WIN. If all moves lead to
-    // positions classified as RESULT_DRAW, the current position is classified
-    // RESULT_DRAW otherwise the current position is classified as RESULT_UNKNOWN.
+    // White to Move: If one move leads to a position classified as WIN, the result
+    // of the current position is WIN. If all moves lead to positions classified
+    // as DRAW, the current position is classified DRAW otherwise the current
+    // position is classified as UNKNOWN.
    //
-    // Black to Move: If one move leads to a position classified as RESULT_DRAW,
-    // the result of the current position is RESULT_DRAW. If all moves lead to
-    // positions classified as RESULT_WIN, the position is classified RESULT_WIN.
-    // Otherwise, the current position is classified as RESULT_UNKNOWN.
+    // Black to Move: If one move leads to a position classified as DRAW, the result
+    // of the current position is DRAW. If all moves lead to positions classified
+    // as WIN, the position is classified WIN otherwise the current position is
+    // classified UNKNOWN.
+
+    const Color Them = (Us == WHITE ? BLACK : WHITE);

    Result r = INVALID;
-    Bitboard b = k_attacks<Us>();
+    Bitboard b = StepAttacksBB[KING][Us == WHITE ? wksq : bksq];

    while (b)
-    {
-        r |= Us == WHITE ? db[index(pop_lsb(&b), bksq, psq, BLACK)]
-                         : db[index(wksq, pop_lsb(&b), psq, WHITE)];
-
-        if (Us == WHITE && (r & WIN))
-            return WIN;
-
-        if (Us == BLACK && (r & DRAW))
-            return DRAW;
-    }
+        r |= Us == WHITE ? db[index(Them, bksq, pop_lsb(&b), psq)]
+                         : db[index(Them, pop_lsb(&b), wksq, psq)];

    if (Us == WHITE && rank_of(psq) < RANK_7)
    {
        Square s = psq + DELTA_N;
-        r |= db[index(wksq, bksq, s, BLACK)]; // Single push
+        r |= db[index(BLACK, bksq, wksq, s)]; // Single push

        if (rank_of(s) == RANK_3 && s != wksq && s != bksq)
-            r |= db[index(wksq, bksq, s + DELTA_N, BLACK)]; // Double push
-
-        if (r & WIN)
-            return WIN;
+            r |= db[index(BLACK, bksq, wksq, s + DELTA_N)]; // Double push
    }

-    return r & UNKNOWN ? UNKNOWN : Us == WHITE ? DRAW : WIN;
+    if (Us == WHITE)
+        return res = r & WIN  ? WIN  : r & UNKNOWN ? UNKNOWN : DRAW;
+    else
+        return res = r & DRAW ? DRAW : r & UNKNOWN ? UNKNOWN : WIN;
  }

-  Result KPKPosition::classify(int idx, Result db[]) {
-
-    decode_index(idx);
-    return stm == WHITE ? classify<WHITE>(db) : classify<BLACK>(db);
-  }
-
-}
+} // namespace
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -28,78 +28,70 @@

 CACHE_LINE_ALIGNMENT

-Bitboard RMasks[64];
-Bitboard RMagics[64];
-Bitboard* RAttacks[64];
-unsigned RShifts[64];
+Bitboard RMasks[SQUARE_NB];
+Bitboard RMagics[SQUARE_NB];
+Bitboard* RAttacks[SQUARE_NB];
+unsigned RShifts[SQUARE_NB];

-Bitboard BMasks[64];
-Bitboard BMagics[64];
-Bitboard* BAttacks[64];
-unsigned BShifts[64];
+Bitboard BMasks[SQUARE_NB];
+Bitboard BMagics[SQUARE_NB];
+Bitboard* BAttacks[SQUARE_NB];
+unsigned BShifts[SQUARE_NB];

-Bitboard SquareBB[64];
-Bitboard FileBB[8];
-Bitboard RankBB[8];
-Bitboard AdjacentFilesBB[8];
-Bitboard ThisAndAdjacentFilesBB[8];
-Bitboard InFrontBB[2][8];
-Bitboard StepAttacksBB[16][64];
-Bitboard BetweenBB[64][64];
-Bitboard DistanceRingsBB[64][8];
-Bitboard ForwardBB[2][64];
-Bitboard PassedPawnMask[2][64];
-Bitboard AttackSpanMask[2][64];
-Bitboard PseudoAttacks[6][64];
+Bitboard SquareBB[SQUARE_NB];
+Bitboard FileBB[FILE_NB];
+Bitboard RankBB[RANK_NB];
+Bitboard AdjacentFilesBB[FILE_NB];
+Bitboard InFrontBB[COLOR_NB][RANK_NB];
+Bitboard StepAttacksBB[PIECE_NB][SQUARE_NB];
+Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
+Bitboard DistanceRingsBB[SQUARE_NB][8];
+Bitboard ForwardBB[COLOR_NB][SQUARE_NB];
+Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
+Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
+Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];

-int SquareDistance[64][64];
+int SquareDistance[SQUARE_NB][SQUARE_NB];

 namespace {

  // De Bruijn sequences. See chessprogramming.wikispaces.com/BitScan
-  const uint64_t DeBruijn_64 = 0x218A392CD3D5DBFULL;
+  const uint64_t DeBruijn_64 = 0x3F79D71B4CB0A89ULL;
  const uint32_t DeBruijn_32 = 0x783A9B23;

  CACHE_LINE_ALIGNMENT

-  int BSFTable[64];
  int MS1BTable[256];
+  Square BSFTable[SQUARE_NB];
  Bitboard RTable[0x19000]; // Storage space for rook attacks
  Bitboard BTable[0x1480];  // Storage space for bishop attacks
-  uint8_t BitCount8Bit[256];

  typedef unsigned (Fn)(Square, Bitboard);

  void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
                   Bitboard masks[], unsigned shifts[], Square deltas[], Fn index);
+
+  FORCE_INLINE unsigned bsf_index(Bitboard b) {
+
+    // Matt Taylor's folding for 32 bit systems, extended to 64 bits by Kim Walisch
+    b ^= (b - 1);
+    return Is64Bit ? (b * DeBruijn_64) >> 58
+                   : ((unsigned(b) ^ unsigned(b >> 32)) * DeBruijn_32) >> 26;
+  }
 }

 /// lsb()/msb() finds the least/most significant bit in a nonzero bitboard.
 /// pop_lsb() finds and clears the least significant bit in a nonzero bitboard.

-#if !defined(USE_BSFQ)
+#ifndef USE_BSFQ

-Square lsb(Bitboard b) {
-
-  if (Is64Bit)
-      return Square(BSFTable[((b & -b) * DeBruijn_64) >> 58]);
-
-  b ^= (b - 1);
-  uint32_t fold = unsigned(b) ^ unsigned(b >> 32);
-  return Square(BSFTable[(fold * DeBruijn_32) >> 26]);
-}
+Square lsb(Bitboard b) { return BSFTable[bsf_index(b)]; }

 Square pop_lsb(Bitboard* b) {

  Bitboard bb = *b;
  *b = bb & (bb - 1);
-
-  if (Is64Bit)
-      return Square(BSFTable[((bb & -bb) * DeBruijn_64) >> 58]);
-
-  bb ^= (bb - 1);
-  uint32_t fold = unsigned(bb) ^ unsigned(bb >> 32);
-  return Square(BSFTable[(fold * DeBruijn_32) >> 26]);
+  return BSFTable[bsf_index(bb)];
 }

 Square msb(Bitboard b) {
@@ -127,10 +119,10 @@ Square msb(Bitboard b) {
      result += 8;
  }

-  return Square(result + MS1BTable[b32]);
+  return (Square)(result + MS1BTable[b32]);
 }

-#endif // !defined(USE_BSFQ)
+#endif // ifndef USE_BSFQ


 /// Bitboards::print() prints a bitboard in an easily readable format to the
@@ -162,8 +154,8 @@ void Bitboards::init() {
      while (k < (2 << i))
          MS1BTable[k++] = i;

-  for (Bitboard b = 0; b < 256; b++)
-      BitCount8Bit[b] = (uint8_t)popcount<Max15>(b);
+  for (int i = 0; i < 64; i++)
+      BSFTable[bsf_index(1ULL << i)] = Square(i);

  for (Square s = SQ_A1; s <= SQ_H8; s++)
      SquareBB[s] = 1ULL << s;
@@ -178,10 +170,7 @@ void Bitboards::init() {
  }

  for (File f = FILE_A; f <= FILE_H; f++)
-  {
      AdjacentFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
-      ThisAndAdjacentFilesBB[f] = FileBB[f] | AdjacentFilesBB[f];
-  }

  for (Rank r = RANK_1; r < RANK_8; r++)
      InFrontBB[WHITE][r] = ~(InFrontBB[BLACK][r + 1] = InFrontBB[BLACK][r] | RankBB[r]);
@@ -190,30 +179,17 @@ void Bitboards::init() {
      for (Square s = SQ_A1; s <= SQ_H8; s++)
      {
          ForwardBB[c][s]      = InFrontBB[c][rank_of(s)] & FileBB[file_of(s)];
-          PassedPawnMask[c][s] = InFrontBB[c][rank_of(s)] & ThisAndAdjacentFilesBB[file_of(s)];
-          AttackSpanMask[c][s] = InFrontBB[c][rank_of(s)] & AdjacentFilesBB[file_of(s)];
+          PawnAttackSpan[c][s] = InFrontBB[c][rank_of(s)] & AdjacentFilesBB[file_of(s)];
+          PassedPawnMask[c][s] = ForwardBB[c][s] | PawnAttackSpan[c][s];
      }

  for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
      for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
-          SquareDistance[s1][s2] = std::max(file_distance(s1, s2), rank_distance(s1, s2));
-
-  for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
-      for (int d = 1; d < 8; d++)
-          for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
-              if (SquareDistance[s1][s2] == d)
-                  DistanceRingsBB[s1][d - 1] |= s2;
-
-  for (int i = 0; i < 64; i++)
-      if (!Is64Bit) // Matt Taylor's folding trick for 32 bit systems
      {
-          Bitboard b = 1ULL << i;
-          b ^= b - 1;
-          b ^= b >> 32;
-          BSFTable[(uint32_t)(b * DeBruijn_32) >> 26] = i;
+          SquareDistance[s1][s2] = std::max(file_distance(s1, s2), rank_distance(s1, s2));
+          if (s1 != s2)
+             DistanceRingsBB[s1][SquareDistance[s1][s2] - 1] |= s2;
      }
-      else
-          BSFTable[((1ULL << i) * DeBruijn_64) >> 58] = i;

  int steps[][9] = { {}, { 7, 9 }, { 17, 15, 10, 6, -6, -10, -15, -17 },
                     {}, {}, {}, { 9, 7, -7, -9, 8, 1, -1, -8 } };
@@ -338,9 +314,9 @@ namespace {
        // until we find the one that passes the verification test.
        do {
            do magics[s] = pick_random(rk, booster);
-            while (BitCount8Bit[(magics[s] * masks[s]) >> 56] < 6);
+            while (popcount<Max15>((magics[s] * masks[s]) >> 56) < 6);

-            memset(attacks[s], 0, size * sizeof(Bitboard));
+            std::memset(attacks[s], 0, size * sizeof(Bitboard));

            // A good magic must map every possible occupancy to an index that
            // looks up the correct sliding attack in the attacks[s] database.
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -18,7 +18,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(BITBOARD_H_INCLUDED)
+#ifndef BITBOARD_H_INCLUDED
 #define BITBOARD_H_INCLUDED

 #include "types.h"
@@ -33,36 +33,56 @@ void print(Bitboard b);
 namespace Bitbases {

 void init_kpk();
-uint32_t probe_kpk(Square wksq, Square wpsq, Square bksq, Color stm);
+bool probe_kpk(Square wksq, Square wpsq, Square bksq, Color us);

 }

+const Bitboard FileABB = 0x0101010101010101ULL;
+const Bitboard FileBBB = FileABB << 1;
+const Bitboard FileCBB = FileABB << 2;
+const Bitboard FileDBB = FileABB << 3;
+const Bitboard FileEBB = FileABB << 4;
+const Bitboard FileFBB = FileABB << 5;
+const Bitboard FileGBB = FileABB << 6;
+const Bitboard FileHBB = FileABB << 7;
+
+const Bitboard Rank1BB = 0xFF;
+const Bitboard Rank2BB = Rank1BB << (8 * 1);
+const Bitboard Rank3BB = Rank1BB << (8 * 2);
+const Bitboard Rank4BB = Rank1BB << (8 * 3);
+const Bitboard Rank5BB = Rank1BB << (8 * 4);
+const Bitboard Rank6BB = Rank1BB << (8 * 5);
+const Bitboard Rank7BB = Rank1BB << (8 * 6);
+const Bitboard Rank8BB = Rank1BB << (8 * 7);
+
 CACHE_LINE_ALIGNMENT

-extern Bitboard RMasks[64];
-extern Bitboard RMagics[64];
-extern Bitboard* RAttacks[64];
-extern unsigned RShifts[64];
+extern Bitboard RMasks[SQUARE_NB];
+extern Bitboard RMagics[SQUARE_NB];
+extern Bitboard* RAttacks[SQUARE_NB];
+extern unsigned RShifts[SQUARE_NB];

-extern Bitboard BMasks[64];
-extern Bitboard BMagics[64];
-extern Bitboard* BAttacks[64];
-extern unsigned BShifts[64];
+extern Bitboard BMasks[SQUARE_NB];
+extern Bitboard BMagics[SQUARE_NB];
+extern Bitboard* BAttacks[SQUARE_NB];
+extern unsigned BShifts[SQUARE_NB];

-extern Bitboard SquareBB[64];
-extern Bitboard FileBB[8];
-extern Bitboard RankBB[8];
-extern Bitboard AdjacentFilesBB[8];
-extern Bitboard ThisAndAdjacentFilesBB[8];
-extern Bitboard InFrontBB[2][8];
-extern Bitboard StepAttacksBB[16][64];
-extern Bitboard BetweenBB[64][64];
-extern Bitboard DistanceRingsBB[64][8];
-extern Bitboard ForwardBB[2][64];
-extern Bitboard PassedPawnMask[2][64];
-extern Bitboard AttackSpanMask[2][64];
-extern Bitboard PseudoAttacks[6][64];
+extern Bitboard SquareBB[SQUARE_NB];
+extern Bitboard FileBB[FILE_NB];
+extern Bitboard RankBB[RANK_NB];
+extern Bitboard AdjacentFilesBB[FILE_NB];
+extern Bitboard InFrontBB[COLOR_NB][RANK_NB];
+extern Bitboard StepAttacksBB[PIECE_NB][SQUARE_NB];
+extern Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
+extern Bitboard DistanceRingsBB[SQUARE_NB][8];
+extern Bitboard ForwardBB[COLOR_NB][SQUARE_NB];
+extern Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
+extern Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
+extern Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];

+extern int SquareDistance[SQUARE_NB][SQUARE_NB];
+
+const Bitboard DarkSquares = 0xAA55AA55AA55AA55ULL;

 /// Overloads of bitwise operators between a Bitboard and a Square for testing
 /// whether a given bit is set in a bitboard, and for setting and clearing bits.
@@ -87,13 +107,34 @@ inline Bitboard operator^(Bitboard b, Square s) {
  return b ^ SquareBB[s];
 }

-
-/// more_than_one() returns true if in 'b' there is more than one bit set
-
 inline bool more_than_one(Bitboard b) {
  return b & (b - 1);
 }

+inline int square_distance(Square s1, Square s2) {
+  return SquareDistance[s1][s2];
+}
+
+inline int file_distance(Square s1, Square s2) {
+  return abs(file_of(s1) - file_of(s2));
+}
+
+inline int rank_distance(Square s1, Square s2) {
+  return abs(rank_of(s1) - rank_of(s2));
+}
+
+
+/// shift_bb() moves bitboard one step along direction Delta. Mainly for pawns.
+
+template<Square Delta>
+inline Bitboard shift_bb(Bitboard b) {
+
+  return  Delta == DELTA_N  ?  b             << 8 : Delta == DELTA_S  ?  b             >> 8
+        : Delta == DELTA_NE ? (b & ~FileHBB) << 9 : Delta == DELTA_SE ? (b & ~FileHBB) >> 7
+        : Delta == DELTA_NW ? (b & ~FileABB) << 7 : Delta == DELTA_SW ? (b & ~FileABB) >> 9
+        : 0;
+}
+

 /// rank_bb() and file_bb() take a file or a square as input and return
 /// a bitboard representing all squares on the given file or rank.
@@ -115,7 +156,7 @@ inline Bitboard file_bb(Square s) {
 }


-/// adjacent_files_bb takes a file as input and returns a bitboard representing
+/// adjacent_files_bb() takes a file as input and returns a bitboard representing
 /// all squares on the adjacent files.

 inline Bitboard adjacent_files_bb(File f) {
@@ -123,30 +164,17 @@ inline Bitboard adjacent_files_bb(File f) {
 }


-/// this_and_adjacent_files_bb takes a file as input and returns a bitboard
-/// representing all squares on the given and adjacent files.
-
-inline Bitboard this_and_adjacent_files_bb(File f) {
-  return ThisAndAdjacentFilesBB[f];
-}
-
-
-/// in_front_bb() takes a color and a rank or square as input, and returns a
-/// bitboard representing all the squares on all ranks in front of the rank
-/// (or square), from the given color's point of view.  For instance,
-/// in_front_bb(WHITE, RANK_5) will give all squares on ranks 6, 7 and 8, while
-/// in_front_bb(BLACK, SQ_D3) will give all squares on ranks 1 and 2.
+/// in_front_bb() takes a color and a rank as input, and returns a bitboard
+/// representing all the squares on all ranks in front of the rank, from the
+/// given color's point of view. For instance, in_front_bb(BLACK, RANK_3) will
+/// give all squares on ranks 1 and 2.

 inline Bitboard in_front_bb(Color c, Rank r) {
  return InFrontBB[c][r];
 }

-inline Bitboard in_front_bb(Color c, Square s) {
-  return InFrontBB[c][rank_of(s)];
-}

-
-/// between_bb returns a bitboard representing all squares between two squares.
+/// between_bb() returns a bitboard representing all squares between two squares.
 /// For instance, between_bb(SQ_C4, SQ_F7) returns a bitboard with the bits for
 /// square d5 and e6 set.  If s1 and s2 are not on the same line, file or diagonal,
 /// 0 is returned.
@@ -156,7 +184,7 @@ inline Bitboard between_bb(Square s1, Square s2) {
 }


-/// forward_bb takes a color and a square as input, and returns a bitboard
+/// forward_bb() 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. Definition of the table is:
 /// ForwardBB[c][s] = in_front_bb(c, s) & file_bb(s)
@@ -166,27 +194,35 @@ inline Bitboard forward_bb(Color c, Square s) {
 }


-/// passed_pawn_mask takes a color and a square as input, and returns a
+/// pawn_attack_span() takes a color and a square as input, and returns a bitboard
+/// representing all squares that can be attacked by a pawn of the given color
+/// when it moves along its file starting from the given square. Definition is:
+/// PawnAttackSpan[c][s] = in_front_bb(c, s) & adjacent_files_bb(s);
+
+inline Bitboard pawn_attack_span(Color c, Square s) {
+  return PawnAttackSpan[c][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
 /// the given square is a passed pawn. Definition of the table is:
-/// PassedPawnMask[c][s] = in_front_bb(c, s) & this_and_adjacent_files_bb(s)
+/// PassedPawnMask[c][s] = pawn_attack_span(c, s) | forward_bb(c, s)

 inline Bitboard passed_pawn_mask(Color c, Square s) {
  return PassedPawnMask[c][s];
 }


-/// attack_span_mask takes a color and a square as input, and returns a bitboard
-/// representing all squares that can be attacked by a pawn of the given color
-/// when it moves along its file starting from the given square. Definition is:
-/// AttackSpanMask[c][s] = in_front_bb(c, s) & adjacent_files_bb(s);
+/// squares_of_color() returns a bitboard representing all squares with the same
+/// color of the given square.

-inline Bitboard attack_span_mask(Color c, Square s) {
-  return AttackSpanMask[c][s];
+inline Bitboard squares_of_color(Square s) {
+  return DarkSquares & s ? DarkSquares : ~DarkSquares;
 }


-/// squares_aligned returns true if the squares s1, s2 and s3 are aligned
+/// squares_aligned() returns true if the squares s1, s2 and s3 are aligned
 /// either on a straight or on a diagonal line.

 inline bool squares_aligned(Square s1, Square s2, Square s3) {
@@ -195,15 +231,6 @@ inline bool squares_aligned(Square s1, Square s2, Square s3) {
 }


-/// same_color_squares() returns a bitboard representing all squares with
-/// the same color of the given square.
-
-inline Bitboard same_color_squares(Square s) {
-  return Bitboard(0xAA55AA55AA55AA55ULL) & s ?  0xAA55AA55AA55AA55ULL
-                                             : ~0xAA55AA55AA55AA55ULL;
-}
-
-
 /// Functions for computing sliding attack bitboards. Function attacks_bb() takes
 /// a square and a bitboard of occupied squares as input, and returns a bitboard
 /// representing all squares attacked by Pt (bishop or rook) on the given square.
@@ -231,7 +258,7 @@ inline Bitboard attacks_bb(Square s, Bitboard occ) {
 /// lsb()/msb() finds the least/most significant bit in a nonzero bitboard.
 /// pop_lsb() finds and clears the least significant bit in a nonzero bitboard.

-#if defined(USE_BSFQ)
+#ifdef USE_BSFQ

 #  if defined(_MSC_VER) && !defined(__INTEL_COMPILER)

@@ -247,6 +274,21 @@ FORCE_INLINE Square msb(Bitboard b) {
  return (Square) index;
 }

+#  elif defined(__arm__)
+
+FORCE_INLINE int lsb32(uint32_t v) {
+  __asm__("rbit %0, %1" : "=r"(v) : "r"(v));
+  return __builtin_clz(v);
+}
+
+FORCE_INLINE Square msb(Bitboard b) {
+  return (Square) (63 - __builtin_clzll(b));
+}
+
+FORCE_INLINE Square lsb(Bitboard b) {
+  return (Square) (uint32_t(b) ? lsb32(uint32_t(b)) : 32 + lsb32(uint32_t(b >> 32)));
+}
+
 #  else

 FORCE_INLINE Square lsb(Bitboard b) { // Assembly code by Heinz van Saanen
@@ -265,11 +307,11 @@ FORCE_INLINE Square msb(Bitboard b) {

 FORCE_INLINE Square pop_lsb(Bitboard* b) {
  const Square s = lsb(*b);
-  *b &= ~(1ULL << s);
+  *b &= *b - 1;
  return s;
 }

-#else // if !defined(USE_BSFQ)
+#else // if defined(USE_BSFQ)

 extern Square msb(Bitboard b);
 extern Square lsb(Bitboard b);
@@ -277,4 +319,4 @@ extern Square pop_lsb(Bitboard* b);

 #endif

-#endif // !defined(BITBOARD_H_INCLUDED)
+#endif // #ifndef BITBOARD_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -18,7 +18,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(BITCOUNT_H_INCLUDED)
+#ifndef BITCOUNT_H_INCLUDED
 #define BITCOUNT_H_INCLUDED

 #include <cassert>
@@ -33,8 +33,8 @@ enum BitCountType {
 };

 /// Determine at compile time the best popcount<> specialization according if
-/// platform is 32 or 64 bits, to the maximum number of nonzero bits to count or
-/// use hardware popcnt instruction when available.
+/// platform is 32 or 64 bits, to the maximum number of nonzero bits to count
+/// and if hardware popcnt instruction is available.
 const BitCountType Full  = HasPopCnt ? CNT_HW_POPCNT : Is64Bit ? CNT_64 : CNT_32;
 const BitCountType Max15 = HasPopCnt ? CNT_HW_POPCNT : Is64Bit ? CNT_64_MAX15 : CNT_32_MAX15;

@@ -44,50 +44,44 @@ template<BitCountType> inline int popcount(Bitboard);

 template<>
 inline int popcount<CNT_64>(Bitboard b) {
-  b -= ((b>>1) & 0x5555555555555555ULL);
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b = ((b>>4) + b) & 0x0F0F0F0F0F0F0F0FULL;
-  b *= 0x0101010101010101ULL;
-  return int(b >> 56);
+  b -=  (b >> 1) & 0x5555555555555555ULL;
+  b  = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  b  = ((b >> 4) + b) & 0x0F0F0F0F0F0F0F0FULL;
+  return (b * 0x0101010101010101ULL) >> 56;
 }

 template<>
 inline int popcount<CNT_64_MAX15>(Bitboard b) {
-  b -= (b>>1) & 0x5555555555555555ULL;
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b *= 0x1111111111111111ULL;
-  return int(b >> 60);
+  b -=  (b >> 1) & 0x5555555555555555ULL;
+  b  = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  return (b * 0x1111111111111111ULL) >> 60;
 }

 template<>
 inline int popcount<CNT_32>(Bitboard b) {
  unsigned w = unsigned(b >> 32), v = unsigned(b);
-  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);
+  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 + (w >> 4) + w) & 0x0F0F0F0F;
+  return (v * 0x01010101) >> 24;
 }

 template<>
 inline int popcount<CNT_32_MAX15>(Bitboard b) {
  unsigned w = unsigned(b >> 32), v = unsigned(b);
-  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);
+  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);
+  return ((v + w) * 0x11111111) >> 28;
 }

 template<>
 inline int popcount<CNT_HW_POPCNT>(Bitboard b) {

-#if !defined(USE_POPCNT)
+#ifndef USE_POPCNT

  assert(false);
  return b != 0; // Avoid 'b not used' warning
@@ -102,11 +96,10 @@ inline int popcount<CNT_HW_POPCNT>(Bitboard b) {

 #else

-  unsigned long ret;
-  __asm__("popcnt %1, %0" : "=r" (ret) : "r" (b));
-  return ret;
+  __asm__("popcnt %1, %0" : "=r" (b) : "r" (b));
+  return b;

 #endif
 }

-#endif // !defined(BITCOUNT_H_INCLUDED)
+#endif // #ifndef BITCOUNT_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -35,8 +35,26 @@ using namespace std;

 namespace {

+  // A Polyglot book is a series of "entries" of 16 bytes. All integers are
+  // stored in big-endian format, with highest byte first (regardless of size).
+  // The entries are ordered according to the key in ascending order.
+  struct Entry {
+    uint64_t key;
+    uint16_t move;
+    uint16_t count;
+    uint32_t learn;
+  };
+
  // Random numbers from PolyGlot, used to compute book hash keys
-  const Key PolyGlotRandoms[781] = {
+  const union {
+    Key PolyGlotRandoms[781];
+    struct {
+      Key psq[12][64];  // [piece][square]
+      Key castle[4];    // [castle right]
+      Key enpassant[8]; // [file]
+      Key turn;
+    } Zobrist;
+  } PG = {{
    0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL,
    0x9C15F73E62A76AE2ULL, 0x75834465489C0C89ULL, 0x3290AC3A203001BFULL,
    0x0FBBAD1F61042279ULL, 0xE83A908FF2FB60CAULL, 0x0D7E765D58755C10ULL,
@@ -298,60 +316,49 @@ namespace {
    0x003A93D8B2806962ULL, 0x1C99DED33CB890A1ULL, 0xCF3145DE0ADD4289ULL,
    0xD0E4427A5514FB72ULL, 0x77C621CC9FB3A483ULL, 0x67A34DAC4356550BULL,
    0xF8D626AAAF278509ULL
-  };
+  }};

-  // Offsets to the PolyGlotRandoms[] array of zobrist keys
-  const Key* ZobPiece     = PolyGlotRandoms;
-  const Key* ZobCastle    = ZobPiece     + 12 * 64; // Pieces * squares
-  const Key* ZobEnPassant = ZobCastle    + 4;       // Castle flags
-  const Key* ZobTurn      = ZobEnPassant + 8;       // Number of files
+  // polyglot_key() returns the PolyGlot hash key of the given position
+  Key polyglot_key(const Position& pos) {

-  // book_key() returns the PolyGlot hash key of the given position
-  uint64_t book_key(const Position& pos) {
-
-    uint64_t key = 0;
+    Key key = 0;
    Bitboard b = pos.pieces();

    while (b)
    {
-        // In PolyGlotRandoms[] pieces are stored in the following sequence:
-        // BP = 0, WP = 1, BN = 2, WN = 3, ... BK = 10, WK = 11
        Square s = pop_lsb(&b);
        Piece p = pos.piece_on(s);
-        int pieceOfs = 2 * (type_of(p) - 1) + (color_of(p) == WHITE);
-        key ^= ZobPiece[64 * pieceOfs + s];
+
+        // PolyGlot pieces are: BP = 0, WP = 1, BN = 2, ... BK = 10, WK = 11
+        key ^= PG.Zobrist.psq[2 * (type_of(p) - 1) + (color_of(p) == WHITE)][s];
    }

    b = pos.can_castle(ALL_CASTLES);

    while (b)
-        key ^= ZobCastle[pop_lsb(&b)];
+        key ^= PG.Zobrist.castle[pop_lsb(&b)];

    if (pos.ep_square() != SQ_NONE)
-        key ^= ZobEnPassant[file_of(pos.ep_square())];
+        key ^= PG.Zobrist.enpassant[file_of(pos.ep_square())];

    if (pos.side_to_move() == WHITE)
-        key ^= ZobTurn[0];
+        key ^= PG.Zobrist.turn;

    return key;
  }

 } // namespace

-Book::Book() {
+PolyglotBook::PolyglotBook() : rkiss(Time::now() % 10000) {}

-  for (int i = Time::now() % 10000; i > 0; i--)
-      RKiss.rand<unsigned>(); // Make random number generation less deterministic
-}
-
-Book::~Book() { if (is_open()) close(); }
+PolyglotBook::~PolyglotBook() { if (is_open()) close(); }


-/// Book::operator>>() reads sizeof(T) chars from the file's binary byte stream
-/// and converts them in a number of type T. A Polyglot book stores numbers in
+/// operator>>() reads sizeof(T) chars from the file's binary byte stream and
+/// converts them in a number of type T. A Polyglot book stores numbers in
 /// big-endian format.

-template<typename T> Book& Book::operator>>(T& n) {
+template<typename T> PolyglotBook& PolyglotBook::operator>>(T& n) {

  n = 0;
  for (size_t i = 0; i < sizeof(T); i++)
@@ -360,15 +367,15 @@ template<typename T> Book& Book::operator>>(T& n) {
  return *this;
 }

-template<> Book& Book::operator>>(BookEntry& e) {
+template<> PolyglotBook& PolyglotBook::operator>>(Entry& e) {
  return *this >> e.key >> e.move >> e.count >> e.learn;
 }


-/// Book::open() tries to open a book file with the given name after closing
-/// any exsisting one.
+/// open() tries to open a book file with the given name after closing any
+/// exsisting one.

-bool Book::open(const char* fName) {
+bool PolyglotBook::open(const char* fName) {

  if (is_open()) // Cannot close an already closed file
      close();
@@ -381,22 +388,22 @@ bool Book::open(const char* fName) {
 }


-/// Book::probe() tries to find a book move for the given position. If no move
-/// is found returns MOVE_NONE. If pickBest is true returns always the highest
+/// probe() tries to find a book move for the given position. If no move is
+/// found returns MOVE_NONE. If pickBest is true returns always the highest
 /// rated move, otherwise randomly chooses one, based on the move score.

-Move Book::probe(const Position& pos, const string& fName, bool pickBest) {
+Move PolyglotBook::probe(const Position& pos, const string& fName, bool pickBest) {

  if (fileName != fName && !open(fName.c_str()))
      return MOVE_NONE;

-  BookEntry e;
+  Entry e;
  uint16_t best = 0;
  unsigned sum = 0;
  Move move = MOVE_NONE;
-  uint64_t key = book_key(pos);
+  Key key = polyglot_key(pos);

-  seekg(find_first(key) * sizeof(BookEntry), ios_base::beg);
+  seekg(find_first(key) * sizeof(Entry), ios_base::beg);

  while (*this >> e, e.key == key && good())
  {
@@ -406,7 +413,7 @@ Move Book::probe(const Position& pos, const string& fName, bool pickBest) {
      // Choose book move according to its score. If a move has a very
      // high score it has higher probability to be choosen than a move
      // with lower score. Note that first entry is always chosen.
-      if (   (sum && RKiss.rand<unsigned>() % sum < e.count)
+      if (   (sum && rkiss.rand<unsigned>() % sum < e.count)
          || (pickBest && e.count == best))
          move = Move(e.move);
  }
@@ -429,24 +436,24 @@ Move Book::probe(const Position& pos, const string& fName, bool pickBest) {
      move = make<PROMOTION>(from_sq(move), to_sq(move), PieceType(pt + 1));

  // Add 'special move' flags and verify it is legal
-  for (MoveList<LEGAL> ml(pos); !ml.end(); ++ml)
-      if (move == (ml.move() & 0x3FFF))
-          return ml.move();
+  for (MoveList<LEGAL> it(pos); *it; ++it)
+      if (move == (*it ^ type_of(*it)))
+          return *it;

  return MOVE_NONE;
 }


-/// Book::find_first() takes a book key as input, and does a binary search
-/// through the book file for the given key. Returns the index of the leftmost
-/// book entry with the same key as the input.
+/// find_first() takes a book key as input, and does a binary search through
+/// the book file for the given key. Returns the index of the leftmost book
+/// entry with the same key as the input.

-size_t Book::find_first(uint64_t key) {
+size_t PolyglotBook::find_first(Key key) {

  seekg(0, ios::end); // Move pointer to end, so tellg() gets file's size

-  size_t low = 0, mid, high = (size_t)tellg() / sizeof(BookEntry) - 1;
-  BookEntry e;
+  size_t low = 0, mid, high = (size_t)tellg() / sizeof(Entry) - 1;
+  Entry e;

  assert(low <= high);

@@ -456,7 +463,7 @@ size_t Book::find_first(uint64_t key) {

      assert(mid >= low && mid < high);

-      seekg(mid * sizeof(BookEntry), ios_base::beg);
+      seekg(mid * sizeof(Entry), ios_base::beg);
      *this >> e;

      if (key <= e.key)
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(BOOK_H_INCLUDED)
+#ifndef BOOK_H_INCLUDED
 #define BOOK_H_INCLUDED

 #include <fstream>
@@ -26,32 +26,20 @@
 #include "position.h"
 #include "rkiss.h"

-
-/// A Polyglot book is a series of "entries" of 16 bytes. All integers are
-/// stored highest byte first (regardless of size). The entries are ordered
-/// according to key. Lowest key first.
-struct BookEntry {
-  uint64_t key;
-  uint16_t move;
-  uint16_t count;
-  uint32_t learn;
-};
-
-
-class Book : private std::ifstream {
+class PolyglotBook : private std::ifstream {
 public:
-  Book();
-  ~Book();
+  PolyglotBook();
+ ~PolyglotBook();
  Move probe(const Position& pos, const std::string& fName, bool pickBest);

 private:
-  template<typename T> Book& operator>>(T& n);
+  template<typename T> PolyglotBook& operator>>(T& n);

  bool open(const char* fName);
-  size_t find_first(uint64_t key);
+  size_t find_first(Key key);

-  RKISS RKiss;
+  RKISS rkiss;
  std::string fileName;
 };

-#endif // !defined(BOOK_H_INCLUDED)
+#endif // #ifndef BOOK_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -31,7 +31,7 @@ namespace {

  // Table used to drive the defending king towards the edge of the board
  // in KX vs K and KQ vs KR endgames.
-  const int MateTable[64] = {
+  const int MateTable[SQUARE_NB] = {
    100, 90, 80, 70, 70, 80, 90, 100,
     90, 70, 60, 50, 50, 60, 70,  90,
     80, 60, 40, 30, 30, 40, 60,  80,
@@ -44,7 +44,7 @@ namespace {

  // Table used to drive the defending king towards a corner square of the
  // right color in KBN vs K endgames.
-  const int KBNKMateTable[64] = {
+  const int KBNKMateTable[SQUARE_NB] = {
    200, 190, 180, 170, 160, 150, 140, 130,
    190, 180, 170, 160, 150, 140, 130, 140,
    180, 170, 155, 140, 140, 125, 140, 150,
@@ -89,16 +89,21 @@ namespace {

 Endgames::Endgames() {

+  add<KK>("KK");
  add<KPK>("KPK");
+  add<KBK>("KBK");
+  add<KNK>("KNK");
  add<KNNK>("KNNK");
  add<KBNK>("KBNK");
  add<KRKP>("KRKP");
  add<KRKB>("KRKB");
  add<KRKN>("KRKN");
+  add<KQKP>("KQKP");
  add<KQKR>("KQKR");
  add<KBBKN>("KBBKN");

  add<KNPK>("KNPK");
+  add<KNPKB>("KNPKB");
  add<KRPKR>("KRPKR");
  add<KBPKB>("KBPKB");
  add<KBPKN>("KBPKN");
@@ -128,28 +133,25 @@ template<>
 Value Endgame<KXK>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
-  assert(pos.piece_count(weakerSide, PAWN) == VALUE_ZERO);
+  assert(!pos.count<PAWN>(weakerSide));
+  assert(!pos.checkers()); // Eval is never called when in check

  // Stalemate detection with lone king
-  if (    pos.side_to_move() == weakerSide
-      && !pos.in_check()
-      && !MoveList<LEGAL>(pos).size()) {
-    return VALUE_DRAW;
-  }
+  if (pos.side_to_move() == weakerSide && !MoveList<LEGAL>(pos).size())
+      return VALUE_DRAW;

  Square winnerKSq = pos.king_square(strongerSide);
  Square loserKSq = pos.king_square(weakerSide);

  Value result =   pos.non_pawn_material(strongerSide)
-                 + pos.piece_count(strongerSide, PAWN) * PawnValueEg
+                 + pos.count<PAWN>(strongerSide) * PawnValueEg
                 + MateTable[loserKSq]
                 + DistanceBonus[square_distance(winnerKSq, loserKSq)];

-  if (   pos.piece_count(strongerSide, QUEEN)
-      || pos.piece_count(strongerSide, ROOK)
-      || pos.bishop_pair(strongerSide)) {
-    result += VALUE_KNOWN_WIN;
-  }
+  if (   pos.count<QUEEN>(strongerSide)
+      || pos.count<ROOK>(strongerSide)
+      || pos.bishop_pair(strongerSide))
+      result += VALUE_KNOWN_WIN;

  return strongerSide == pos.side_to_move() ? result : -result;
 }
@@ -160,21 +162,21 @@ Value Endgame<KXK>::operator()(const Position& pos) const {
 template<>
 Value Endgame<KBNK>::operator()(const Position& pos) const {

-  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
-  assert(pos.piece_count(weakerSide, PAWN) == VALUE_ZERO);
  assert(pos.non_pawn_material(strongerSide) == KnightValueMg + BishopValueMg);
-  assert(pos.piece_count(strongerSide, BISHOP) == 1);
-  assert(pos.piece_count(strongerSide, KNIGHT) == 1);
-  assert(pos.piece_count(strongerSide, PAWN) == 0);
+  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
+  assert(pos.count<BISHOP>(strongerSide) == 1);
+  assert(pos.count<KNIGHT>(strongerSide) == 1);
+  assert(pos.count<  PAWN>(strongerSide) == 0);
+  assert(pos.count<  PAWN>(weakerSide  ) == 0);

  Square winnerKSq = pos.king_square(strongerSide);
  Square loserKSq = pos.king_square(weakerSide);
-  Square bishopSquare = pos.piece_list(strongerSide, BISHOP)[0];
+  Square bishopSq = pos.list<BISHOP>(strongerSide)[0];

  // kbnk_mate_table() tries to drive toward corners A1 or H8,
  // if we have a bishop that cannot reach the above squares we
  // mirror the kings so to drive enemy toward corners A8 or H1.
-  if (opposite_colors(bishopSquare, SQ_A1))
+  if (opposite_colors(bishopSq, SQ_A1))
  {
      winnerKSq = mirror(winnerKSq);
      loserKSq = mirror(loserKSq);
@@ -194,25 +196,25 @@ Value Endgame<KPK>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
-  assert(pos.piece_count(strongerSide, PAWN) == 1);
-  assert(pos.piece_count(weakerSide, PAWN) == 0);
+  assert(pos.count<PAWN>(strongerSide) == 1);
+  assert(pos.count<PAWN>(weakerSide  ) == 0);

  Square wksq, bksq, wpsq;
-  Color stm;
+  Color us;

  if (strongerSide == WHITE)
  {
      wksq = pos.king_square(WHITE);
      bksq = pos.king_square(BLACK);
-      wpsq = pos.piece_list(WHITE, PAWN)[0];
-      stm = pos.side_to_move();
+      wpsq = pos.list<PAWN>(WHITE)[0];
+      us   = pos.side_to_move();
  }
  else
  {
      wksq = ~pos.king_square(BLACK);
      bksq = ~pos.king_square(WHITE);
-      wpsq = ~pos.piece_list(BLACK, PAWN)[0];
-      stm  = ~pos.side_to_move();
+      wpsq = ~pos.list<PAWN>(BLACK)[0];
+      us   = ~pos.side_to_move();
  }

  if (file_of(wpsq) >= FILE_E)
@@ -222,7 +224,7 @@ Value Endgame<KPK>::operator()(const Position& pos) const {
      wpsq = mirror(wpsq);
  }

-  if (!Bitbases::probe_kpk(wksq, wpsq, bksq, stm))
+  if (!Bitbases::probe_kpk(wksq, wpsq, bksq, us))
      return VALUE_DRAW;

  Value result = VALUE_KNOWN_WIN + PawnValueEg + Value(rank_of(wpsq));
@@ -239,17 +241,17 @@ template<>
 Value Endgame<KRKP>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == RookValueMg);
-  assert(pos.piece_count(strongerSide, PAWN) == 0);
  assert(pos.non_pawn_material(weakerSide) == 0);
-  assert(pos.piece_count(weakerSide, PAWN) == 1);
+  assert(pos.count<PAWN>(strongerSide) == 0);
+  assert(pos.count<PAWN>(weakerSide  ) == 1);

  Square wksq, wrsq, bksq, bpsq;
  int tempo = (pos.side_to_move() == strongerSide);

  wksq = pos.king_square(strongerSide);
-  wrsq = pos.piece_list(strongerSide, ROOK)[0];
  bksq = pos.king_square(weakerSide);
-  bpsq = pos.piece_list(weakerSide, PAWN)[0];
+  wrsq = pos.list<ROOK>(strongerSide)[0];
+  bpsq = pos.list<PAWN>(weakerSide)[0];

  if (strongerSide == BLACK)
  {
@@ -296,10 +298,10 @@ template<>
 Value Endgame<KRKB>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == RookValueMg);
-  assert(pos.piece_count(strongerSide, PAWN) == 0);
-  assert(pos.non_pawn_material(weakerSide) == BishopValueMg);
-  assert(pos.piece_count(weakerSide, PAWN) == 0);
-  assert(pos.piece_count(weakerSide, BISHOP) == 1);
+  assert(pos.non_pawn_material(weakerSide  ) == BishopValueMg);
+  assert(pos.count<BISHOP>(weakerSide  ) == 1);
+  assert(pos.count<  PAWN>(weakerSide  ) == 0);
+  assert(pos.count<  PAWN>(strongerSide) == 0);

  Value result = Value(MateTable[pos.king_square(weakerSide)]);
  return strongerSide == pos.side_to_move() ? result : -result;
@@ -312,20 +314,51 @@ template<>
 Value Endgame<KRKN>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == RookValueMg);
-  assert(pos.piece_count(strongerSide, PAWN) == 0);
-  assert(pos.non_pawn_material(weakerSide) == KnightValueMg);
-  assert(pos.piece_count(weakerSide, PAWN) == 0);
-  assert(pos.piece_count(weakerSide, KNIGHT) == 1);
+  assert(pos.non_pawn_material(weakerSide  ) == KnightValueMg);
+  assert(pos.count<KNIGHT>(weakerSide  ) == 1);
+  assert(pos.count<  PAWN>(weakerSide  ) == 0);
+  assert(pos.count<  PAWN>(strongerSide) == 0);

  const int penalty[8] = { 0, 10, 14, 20, 30, 42, 58, 80 };

  Square bksq = pos.king_square(weakerSide);
-  Square bnsq = pos.piece_list(weakerSide, KNIGHT)[0];
+  Square bnsq = pos.list<KNIGHT>(weakerSide)[0];
  Value result = Value(MateTable[bksq] + penalty[square_distance(bksq, bnsq)]);
  return strongerSide == pos.side_to_move() ? result : -result;
 }


+/// KQ vs KP.  In general, a win for the stronger side, however, there are a few
+/// important exceptions.  Pawn on 7th rank, A,C,F or H file, with king next can
+/// be a draw, so we scale down to distance between kings only.
+template<>
+Value Endgame<KQKP>::operator()(const Position& pos) const {
+
+  assert(pos.non_pawn_material(strongerSide) == QueenValueMg);
+  assert(pos.non_pawn_material(weakerSide  ) == VALUE_ZERO);
+  assert(pos.count<PAWN>(strongerSide) == 0);
+  assert(pos.count<PAWN>(weakerSide  ) == 1);
+
+  Square winnerKSq = pos.king_square(strongerSide);
+  Square loserKSq = pos.king_square(weakerSide);
+  Square pawnSq = pos.list<PAWN>(weakerSide)[0];
+
+  Value result =  QueenValueEg
+                - PawnValueEg
+                + DistanceBonus[square_distance(winnerKSq, loserKSq)];
+
+  if (   square_distance(loserKSq, pawnSq) == 1
+      && relative_rank(weakerSide, pawnSq) == RANK_7)
+  {
+      File f = file_of(pawnSq);
+
+      if (f == FILE_A || f == FILE_C || f == FILE_F || f == FILE_H)
+          result = Value(DistanceBonus[square_distance(winnerKSq, loserKSq)]);
+  }
+  return strongerSide == pos.side_to_move() ? result : -result;
+}
+
+
 /// KQ vs KR.  This is almost identical to KX vs K:  We give the attacking
 /// king a bonus for having the kings close together, and for forcing the
 /// defending king towards the edge.  If we also take care to avoid null move
@@ -335,9 +368,9 @@ template<>
 Value Endgame<KQKR>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == QueenValueMg);
-  assert(pos.piece_count(strongerSide, PAWN) == 0);
-  assert(pos.non_pawn_material(weakerSide) == RookValueMg);
-  assert(pos.piece_count(weakerSide, PAWN) == 0);
+  assert(pos.non_pawn_material(weakerSide  ) == RookValueMg);
+  assert(pos.count<PAWN>(strongerSide) == 0);
+  assert(pos.count<PAWN>(weakerSide  ) == 0);

  Square winnerKSq = pos.king_square(strongerSide);
  Square loserKSq = pos.king_square(weakerSide);
@@ -353,16 +386,16 @@ Value Endgame<KQKR>::operator()(const Position& pos) const {
 template<>
 Value Endgame<KBBKN>::operator()(const Position& pos) const {

-  assert(pos.piece_count(strongerSide, BISHOP) == 2);
-  assert(pos.non_pawn_material(strongerSide) == 2*BishopValueMg);
-  assert(pos.piece_count(weakerSide, KNIGHT) == 1);
-  assert(pos.non_pawn_material(weakerSide) == KnightValueMg);
+  assert(pos.non_pawn_material(strongerSide) == 2 * BishopValueMg);
+  assert(pos.non_pawn_material(weakerSide  ) == KnightValueMg);
+  assert(pos.count<BISHOP>(strongerSide) == 2);
+  assert(pos.count<KNIGHT>(weakerSide  ) == 1);
  assert(!pos.pieces(PAWN));

  Value result = BishopValueEg;
  Square wksq = pos.king_square(strongerSide);
  Square bksq = pos.king_square(weakerSide);
-  Square nsq = pos.piece_list(weakerSide, KNIGHT)[0];
+  Square nsq = pos.list<KNIGHT>(weakerSide)[0];

  // Bonus for attacking king close to defending king
  result += Value(DistanceBonus[square_distance(wksq, bksq)]);
@@ -377,17 +410,13 @@ Value Endgame<KBBKN>::operator()(const Position& pos) const {
 }


-/// K and two minors vs K and one or two minors or K and two knights against
-/// king alone are always draw.
-template<>
-Value Endgame<KmmKm>::operator()(const Position&) const {
-  return VALUE_DRAW;
-}
+/// Some cases of trivial draws
+template<> Value Endgame<KK>::operator()(const Position&) const { return VALUE_DRAW; }
+template<> Value Endgame<KBK>::operator()(const Position&) const { return VALUE_DRAW; }
+template<> Value Endgame<KNK>::operator()(const Position&) const { return VALUE_DRAW; }
+template<> Value Endgame<KNNK>::operator()(const Position&) const { return VALUE_DRAW; }
+template<> Value Endgame<KmmKm>::operator()(const Position&) const { return VALUE_DRAW; }

-template<>
-Value Endgame<KNNK>::operator()(const Position&) const {
-  return VALUE_DRAW;
-}

 /// K, bishop and one or more pawns vs K. It checks for draws with rook pawns and
 /// a bishop of the wrong color. If such a draw is detected, SCALE_FACTOR_DRAW
@@ -397,20 +426,20 @@ template<>
 ScaleFactor Endgame<KBPsK>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == BishopValueMg);
-  assert(pos.piece_count(strongerSide, BISHOP) == 1);
-  assert(pos.piece_count(strongerSide, PAWN) >= 1);
+  assert(pos.count<BISHOP>(strongerSide) == 1);
+  assert(pos.count<  PAWN>(strongerSide) >= 1);

  // No assertions about the material of weakerSide, because we want draws to
  // be detected even when the weaker side has some pawns.

  Bitboard pawns = pos.pieces(strongerSide, PAWN);
-  File pawnFile = file_of(pos.piece_list(strongerSide, PAWN)[0]);
+  File pawnFile = file_of(pos.list<PAWN>(strongerSide)[0]);

  // All pawns are on a single rook file ?
  if (    (pawnFile == FILE_A || pawnFile == FILE_H)
      && !(pawns & ~file_bb(pawnFile)))
  {
-      Square bishopSq = pos.piece_list(strongerSide, BISHOP)[0];
+      Square bishopSq = pos.list<BISHOP>(strongerSide)[0];
      Square queeningSq = relative_square(strongerSide, pawnFile | RANK_8);
      Square kingSq = pos.king_square(weakerSide);

@@ -439,6 +468,29 @@ ScaleFactor Endgame<KBPsK>::operator()(const Position& pos) const {
              return SCALE_FACTOR_DRAW;
      }
  }
+
+  // All pawns on same B or G file? Then potential draw
+  if (    (pawnFile == FILE_B || pawnFile == FILE_G)
+      && !(pos.pieces(PAWN) & ~file_bb(pawnFile))
+      && pos.non_pawn_material(weakerSide) == 0
+      && pos.count<PAWN>(weakerSide) >= 1)
+  {
+      // Get weaker pawn closest to opponent's queening square
+      Bitboard wkPawns = pos.pieces(weakerSide, PAWN);
+      Square weakerPawnSq = strongerSide == WHITE ? msb(wkPawns) : lsb(wkPawns);
+
+      Square strongerKingSq = pos.king_square(strongerSide);
+      Square weakerKingSq = pos.king_square(weakerSide);
+      Square bishopSq = pos.list<BISHOP>(strongerSide)[0];
+
+      // Draw if weaker pawn is on rank 7, bishop can't attack the pawn, and
+      // weaker king can stop opposing opponent's king from penetrating.
+      if (   relative_rank(strongerSide, weakerPawnSq) == RANK_7
+          && opposite_colors(bishopSq, weakerPawnSq)
+          && square_distance(weakerPawnSq, weakerKingSq) <= square_distance(weakerPawnSq, strongerKingSq))
+          return SCALE_FACTOR_DRAW;
+  }
+
  return SCALE_FACTOR_NONE;
 }

@@ -449,19 +501,19 @@ template<>
 ScaleFactor Endgame<KQKRPs>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == QueenValueMg);
-  assert(pos.piece_count(strongerSide, QUEEN) == 1);
-  assert(pos.piece_count(strongerSide, PAWN) == 0);
-  assert(pos.piece_count(weakerSide, ROOK) == 1);
-  assert(pos.piece_count(weakerSide, PAWN) >= 1);
+  assert(pos.count<QUEEN>(strongerSide) == 1);
+  assert(pos.count< PAWN>(strongerSide) == 0);
+  assert(pos.count< ROOK>(weakerSide  ) == 1);
+  assert(pos.count< PAWN>(weakerSide  ) >= 1);

  Square kingSq = pos.king_square(weakerSide);
-  if (   relative_rank(weakerSide, kingSq) <= RANK_2
-      && relative_rank(weakerSide, pos.king_square(strongerSide)) >= RANK_4
+  if (    relative_rank(weakerSide, kingSq) <= RANK_2
+      &&  relative_rank(weakerSide, pos.king_square(strongerSide)) >= RANK_4
      && (pos.pieces(weakerSide, ROOK) & rank_bb(relative_rank(weakerSide, RANK_3)))
      && (pos.pieces(weakerSide, PAWN) & rank_bb(relative_rank(weakerSide, RANK_2)))
      && (pos.attacks_from<KING>(kingSq) & pos.pieces(weakerSide, PAWN)))
  {
-      Square rsq = pos.piece_list(weakerSide, ROOK)[0];
+      Square rsq = pos.list<ROOK>(weakerSide)[0];
      if (pos.attacks_from<PAWN>(rsq, strongerSide) & pos.pieces(weakerSide, PAWN))
          return SCALE_FACTOR_DRAW;
  }
@@ -479,15 +531,15 @@ template<>
 ScaleFactor Endgame<KRPKR>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == RookValueMg);
-  assert(pos.piece_count(strongerSide, PAWN) == 1);
-  assert(pos.non_pawn_material(weakerSide) == RookValueMg);
-  assert(pos.piece_count(weakerSide, PAWN) == 0);
+  assert(pos.non_pawn_material(weakerSide)   == RookValueMg);
+  assert(pos.count<PAWN>(strongerSide) == 1);
+  assert(pos.count<PAWN>(weakerSide  ) == 0);

  Square wksq = pos.king_square(strongerSide);
-  Square wrsq = pos.piece_list(strongerSide, ROOK)[0];
-  Square wpsq = pos.piece_list(strongerSide, PAWN)[0];
  Square bksq = pos.king_square(weakerSide);
-  Square brsq = pos.piece_list(weakerSide, ROOK)[0];
+  Square wrsq = pos.list<ROOK>(strongerSide)[0];
+  Square wpsq = pos.list<PAWN>(strongerSide)[0];
+  Square brsq = pos.list<ROOK>(weakerSide)[0];

  // Orient the board in such a way that the stronger side is white, and the
  // pawn is on the left half of the board.
@@ -597,12 +649,12 @@ template<>
 ScaleFactor Endgame<KRPPKRP>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == RookValueMg);
-  assert(pos.piece_count(strongerSide, PAWN) == 2);
-  assert(pos.non_pawn_material(weakerSide) == RookValueMg);
-  assert(pos.piece_count(weakerSide, PAWN) == 1);
+  assert(pos.non_pawn_material(weakerSide)   == RookValueMg);
+  assert(pos.count<PAWN>(strongerSide) == 2);
+  assert(pos.count<PAWN>(weakerSide  ) == 1);

-  Square wpsq1 = pos.piece_list(strongerSide, PAWN)[0];
-  Square wpsq2 = pos.piece_list(strongerSide, PAWN)[1];
+  Square wpsq1 = pos.list<PAWN>(strongerSide)[0];
+  Square wpsq2 = pos.list<PAWN>(strongerSide)[1];
  Square bksq = pos.king_square(weakerSide);

  // Does the stronger side have a passed pawn?
@@ -635,9 +687,9 @@ template<>
 ScaleFactor Endgame<KPsK>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
-  assert(pos.piece_count(strongerSide, PAWN) >= 2);
-  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
-  assert(pos.piece_count(weakerSide, PAWN) == 0);
+  assert(pos.non_pawn_material(weakerSide)   == VALUE_ZERO);
+  assert(pos.count<PAWN>(strongerSide) >= 2);
+  assert(pos.count<PAWN>(weakerSide  ) == 0);

  Square ksq = pos.king_square(weakerSide);
  Bitboard pawns = pos.pieces(strongerSide, PAWN);
@@ -648,7 +700,7 @@ ScaleFactor Endgame<KPsK>::operator()(const Position& pos) const {
      // Does the defending king block the pawns?
      if (   square_distance(ksq, relative_square(strongerSide, SQ_A8)) <= 1
          || (    file_of(ksq) == FILE_A
-              && !in_front_bb(strongerSide, ksq) & pawns))
+              && !(in_front_bb(strongerSide, rank_of(ksq)) & pawns)))
          return SCALE_FACTOR_DRAW;
  }
  // Are all pawns on the 'h' file?
@@ -657,7 +709,7 @@ ScaleFactor Endgame<KPsK>::operator()(const Position& pos) const {
    // Does the defending king block the pawns?
    if (   square_distance(ksq, relative_square(strongerSide, SQ_H8)) <= 1
        || (    file_of(ksq) == FILE_H
-            && !in_front_bb(strongerSide, ksq) & pawns))
+            && !(in_front_bb(strongerSide, rank_of(ksq)) & pawns)))
        return SCALE_FACTOR_DRAW;
  }
  return SCALE_FACTOR_NONE;
@@ -672,15 +724,15 @@ template<>
 ScaleFactor Endgame<KBPKB>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == BishopValueMg);
-  assert(pos.piece_count(strongerSide, BISHOP) == 1);
-  assert(pos.piece_count(strongerSide, PAWN) == 1);
-  assert(pos.non_pawn_material(weakerSide) == BishopValueMg);
-  assert(pos.piece_count(weakerSide, BISHOP) == 1);
-  assert(pos.piece_count(weakerSide, PAWN) == 0);
+  assert(pos.non_pawn_material(weakerSide  ) == BishopValueMg);
+  assert(pos.count<BISHOP>(strongerSide) == 1);
+  assert(pos.count<BISHOP>(weakerSide  ) == 1);
+  assert(pos.count<  PAWN>(strongerSide) == 1);
+  assert(pos.count<  PAWN>(weakerSide  ) == 0);

-  Square pawnSq = pos.piece_list(strongerSide, PAWN)[0];
-  Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP)[0];
-  Square weakerBishopSq = pos.piece_list(weakerSide, BISHOP)[0];
+  Square pawnSq = pos.list<PAWN>(strongerSide)[0];
+  Square strongerBishopSq = pos.list<BISHOP>(strongerSide)[0];
+  Square weakerBishopSq = pos.list<BISHOP>(weakerSide)[0];
  Square weakerKingSq = pos.king_square(weakerSide);

  // Case 1: Defending king blocks the pawn, and cannot be driven away
@@ -727,21 +779,21 @@ template<>
 ScaleFactor Endgame<KBPPKB>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == BishopValueMg);
-  assert(pos.piece_count(strongerSide, BISHOP) == 1);
-  assert(pos.piece_count(strongerSide, PAWN) == 2);
-  assert(pos.non_pawn_material(weakerSide) == BishopValueMg);
-  assert(pos.piece_count(weakerSide, BISHOP) == 1);
-  assert(pos.piece_count(weakerSide, PAWN) == 0);
+  assert(pos.non_pawn_material(weakerSide  ) == BishopValueMg);
+  assert(pos.count<BISHOP>(strongerSide) == 1);
+  assert(pos.count<BISHOP>(weakerSide  ) == 1);
+  assert(pos.count<  PAWN>(strongerSide) == 2);
+  assert(pos.count<  PAWN>(weakerSide  ) == 0);

-  Square wbsq = pos.piece_list(strongerSide, BISHOP)[0];
-  Square bbsq = pos.piece_list(weakerSide, BISHOP)[0];
+  Square wbsq = pos.list<BISHOP>(strongerSide)[0];
+  Square bbsq = pos.list<BISHOP>(weakerSide)[0];

  if (!opposite_colors(wbsq, bbsq))
      return SCALE_FACTOR_NONE;

  Square ksq = pos.king_square(weakerSide);
-  Square psq1 = pos.piece_list(strongerSide, PAWN)[0];
-  Square psq2 = pos.piece_list(strongerSide, PAWN)[1];
+  Square psq1 = pos.list<PAWN>(strongerSide)[0];
+  Square psq2 = pos.list<PAWN>(strongerSide)[1];
  Rank r1 = rank_of(psq1);
  Rank r2 = rank_of(psq2);
  Square blockSq1, blockSq2;
@@ -802,14 +854,14 @@ template<>
 ScaleFactor Endgame<KBPKN>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == BishopValueMg);
-  assert(pos.piece_count(strongerSide, BISHOP) == 1);
-  assert(pos.piece_count(strongerSide, PAWN) == 1);
-  assert(pos.non_pawn_material(weakerSide) == KnightValueMg);
-  assert(pos.piece_count(weakerSide, KNIGHT) == 1);
-  assert(pos.piece_count(weakerSide, PAWN) == 0);
+  assert(pos.non_pawn_material(weakerSide  ) == KnightValueMg);
+  assert(pos.count<BISHOP>(strongerSide) == 1);
+  assert(pos.count<KNIGHT>(weakerSide  ) == 1);
+  assert(pos.count<  PAWN>(strongerSide) == 1);
+  assert(pos.count<  PAWN>(weakerSide  ) == 0);

-  Square pawnSq = pos.piece_list(strongerSide, PAWN)[0];
-  Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP)[0];
+  Square pawnSq = pos.list<PAWN>(strongerSide)[0];
+  Square strongerBishopSq = pos.list<BISHOP>(strongerSide)[0];
  Square weakerKingSq = pos.king_square(weakerSide);

  if (   file_of(weakerKingSq) == file_of(pawnSq)
@@ -829,12 +881,12 @@ template<>
 ScaleFactor Endgame<KNPK>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == KnightValueMg);
-  assert(pos.piece_count(strongerSide, KNIGHT) == 1);
-  assert(pos.piece_count(strongerSide, PAWN) == 1);
-  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
-  assert(pos.piece_count(weakerSide, PAWN) == 0);
+  assert(pos.non_pawn_material(weakerSide  ) == VALUE_ZERO);
+  assert(pos.count<KNIGHT>(strongerSide) == 1);
+  assert(pos.count<  PAWN>(strongerSide) == 1);
+  assert(pos.count<  PAWN>(weakerSide  ) == 0);

-  Square pawnSq = pos.piece_list(strongerSide, PAWN)[0];
+  Square pawnSq = pos.list<PAWN>(strongerSide)[0];
  Square weakerKingSq = pos.king_square(weakerSide);

  if (   pawnSq == relative_square(strongerSide, SQ_A7)
@@ -849,6 +901,24 @@ ScaleFactor Endgame<KNPK>::operator()(const Position& pos) const {
 }


+/// K, knight and a pawn vs K and bishop. If knight can block bishop from taking
+/// pawn, it's a win. Otherwise, drawn.
+template<>
+ScaleFactor Endgame<KNPKB>::operator()(const Position& pos) const {
+
+  Square pawnSq = pos.list<PAWN>(strongerSide)[0];
+  Square bishopSq = pos.list<BISHOP>(weakerSide)[0];
+  Square weakerKingSq = pos.king_square(weakerSide);
+
+  // King needs to get close to promoting pawn to prevent knight from blocking.
+  // Rules for this are very tricky, so just approximate.
+  if (forward_bb(strongerSide, pawnSq) & pos.attacks_from<BISHOP>(bishopSq))
+      return ScaleFactor(square_distance(weakerKingSq, pawnSq));
+
+  return SCALE_FACTOR_NONE;
+}
+
+
 /// K and a pawn vs K and a pawn. This is done by removing the weakest side's
 /// pawn and probing the KP vs K bitbase: If the weakest side has a draw without
 /// the pawn, she probably has at least a draw with the pawn as well. The exception
@@ -858,21 +928,21 @@ template<>
 ScaleFactor Endgame<KPKP>::operator()(const Position& pos) const {

  assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
-  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
-  assert(pos.piece_count(WHITE, PAWN) == 1);
-  assert(pos.piece_count(BLACK, PAWN) == 1);
+  assert(pos.non_pawn_material(weakerSide  ) == VALUE_ZERO);
+  assert(pos.count<PAWN>(WHITE) == 1);
+  assert(pos.count<PAWN>(BLACK) == 1);

  Square wksq = pos.king_square(strongerSide);
  Square bksq = pos.king_square(weakerSide);
-  Square wpsq = pos.piece_list(strongerSide, PAWN)[0];
-  Color stm = pos.side_to_move();
+  Square wpsq = pos.list<PAWN>(strongerSide)[0];
+  Color us = pos.side_to_move();

  if (strongerSide == BLACK)
  {
      wksq = ~wksq;
      bksq = ~bksq;
      wpsq = ~wpsq;
-      stm  = ~stm;
+      us   = ~us;
  }

  if (file_of(wpsq) >= FILE_E)
@@ -890,5 +960,5 @@ ScaleFactor Endgame<KPKP>::operator()(const Position& pos) const {

  // Probe the KPK bitbase with the weakest side's pawn removed. If it's a draw,
  // it's probably at least a draw even with the pawn.
-  return Bitbases::probe_kpk(wksq, wpsq, bksq, stm) ? SCALE_FACTOR_NONE : SCALE_FACTOR_DRAW;
+  return Bitbases::probe_kpk(wksq, wpsq, bksq, us) ? SCALE_FACTOR_NONE : SCALE_FACTOR_DRAW;
 }
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(ENDGAME_H_INCLUDED)
+#ifndef ENDGAME_H_INCLUDED
 #define ENDGAME_H_INCLUDED

 #include <map>
@@ -33,15 +33,19 @@ enum EndgameType {

  // Evaluation functions

+  KK,    // K vs K
+  KBK,   // KB vs K
+  KNK,   // KN vs K
+  KNNK,  // KNN vs K
  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
+  KQKP,  // KQ vs KP
  KQKR,  // KQ vs KR
  KBBKN, // KBB vs KN
-  KNNK,  // KNN vs K
  KmmKm, // K and two minors vs K and one or two minors


@@ -57,6 +61,7 @@ enum EndgameType {
  KBPPKB,  // KBPP vs KB
  KBPKN,   // KBP vs KN
  KNPK,    // KNP vs K
+  KNPKB,   // KNP vs KB
  KPKP     // KP vs KP
 };

@@ -111,10 +116,10 @@ class Endgames {

 public:
  Endgames();
-  ~Endgames();
+ ~Endgames();

  template<typename T> T probe(Key key, T& eg)
  { return eg = map(eg).count(key) ? map(eg)[key] : NULL; }
 };

-#endif // !defined(ENDGAME_H_INCLUDED)
+#endif // #ifndef ENDGAME_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(EVALUATE_H_INCLUDED)
+#ifndef EVALUATE_H_INCLUDED
 #define EVALUATE_H_INCLUDED

 #include "types.h"
@@ -26,12 +26,10 @@ class Position;

 namespace Eval {

-extern Color RootColor;
-
 extern void init();
 extern Value evaluate(const Position& pos, Value& margin);
 extern std::string trace(const Position& pos);

 }

-#endif // !defined(EVALUATE_H_INCLUDED)
+#endif // #ifndef EVALUATE_H_INCLUDED
@@ -1,72 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  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.
-
-  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/>.
-*/
-
-#if !defined(HISTORY_H_INCLUDED)
-#define HISTORY_H_INCLUDED
-
-#include <algorithm>
-#include <cstring>
-
-#include "types.h"
-
-/// The History class stores statistics about how often different moves
-/// have been successful or unsuccessful during the current search. These
-/// statistics are used for reduction and move ordering decisions. History
-/// entries are stored according only to moving piece and destination square,
-/// in particular two moves with different origin but same destination and
-/// same piece will be considered identical.
-
-class History {
-
-public:
-  void clear();
-  Value value(Piece p, Square to) const;
-  void add(Piece p, Square to, Value bonus);
-  Value gain(Piece p, Square to) const;
-  void update_gain(Piece p, Square to, Value g);
-
-  static const Value MaxValue = Value(2000);
-
-private:
-  Value history[16][64];  // [piece][to_square]
-  Value maxGains[16][64]; // [piece][to_square]
-};
-
-inline void History::clear() {
-  memset(history,  0, 16 * 64 * sizeof(Value));
-  memset(maxGains, 0, 16 * 64 * sizeof(Value));
-}
-
-inline Value History::value(Piece p, Square to) const {
-  return history[p][to];
-}
-
-inline void History::add(Piece p, Square to, Value bonus) {
-  if (abs(history[p][to] + bonus) < MaxValue) history[p][to] += bonus;
-}
-
-inline Value History::gain(Piece p, Square to) const {
-  return maxGains[p][to];
-}
-
-inline void History::update_gain(Piece p, Square to, Value g) {
-  maxGains[p][to] = std::max(g, maxGains[p][to] - 1);
-}
-
-#endif // !defined(HISTORY_H_INCLUDED)
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -34,7 +34,7 @@ int main(int argc, char* argv[]) {

  UCI::init(Options);
  Bitboards::init();
-  Zobrist::init();
+  Position::init();
  Bitbases::init_kpk();
  Search::init();
  Eval::init();
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#include <algorithm>
+#include <algorithm>  // For std::min
 #include <cassert>
 #include <cstring>

@@ -35,18 +35,32 @@ namespace {
  const int NoPawnsSF[4] = { 6, 12, 32 };

  // Polynomial material balance parameters
-  const Value RedundantQueenPenalty = Value(320);
-  const Value RedundantRookPenalty  = Value(554);
+  const Value RedundantQueen = Value(320);
+  const Value RedundantRook  = Value(554);

-  const int LinearCoefficients[6] = { 1617, -162, -1172, -190, 105, 26 };
+  //                                  pair  pawn knight bishop rook queen
+  const int LinearCoefficients[6] = { 1617, -162, -1172, -190,  105,  26 };

-  const int QuadraticCoefficientsSameColor[][8] = {
-  { 7, 7, 7, 7, 7, 7 }, { 39, 2, 7, 7, 7, 7 }, { 35, 271, -4, 7, 7, 7 },
-  { 7, 25, 4, 7, 7, 7 }, { -27, -2, 46, 100, 56, 7 }, { 58, 29, 83, 148, -3, -25 } };
+  const int QuadraticCoefficientsSameColor[][PIECE_TYPE_NB] = {
+    // pair pawn knight bishop rook queen
+    {   7                               }, // Bishop pair
+    {  39,    2                         }, // Pawn
+    {  35,  271,  -4                    }, // Knight
+    {   7,  105,   4,    7              }, // Bishop
+    { -27,   -2,  46,   100,   56       }, // Rook
+    {  58,   29,  83,   148,   -3,  -25 }  // Queen
+  };

-  const int QuadraticCoefficientsOppositeColor[][8] = {
-  { 41, 41, 41, 41, 41, 41 }, { 37, 41, 41, 41, 41, 41 }, { 10, 62, 41, 41, 41, 41 },
-  { 57, 64, 39, 41, 41, 41 }, { 50, 40, 23, -22, 41, 41 }, { 106, 101, 3, 151, 171, 41 } };
+  const int QuadraticCoefficientsOppositeColor[][PIECE_TYPE_NB] = {
+    //           THEIR PIECES
+    // pair pawn knight bishop rook queen
+    {  41                               }, // Bishop pair
+    {  37,   41                         }, // Pawn
+    {  10,   62,  41                    }, // Knight      OUR PIECES
+    {  57,   64,  39,    41             }, // Bishop
+    {  50,   40,  23,   -22,   41       }, // Rook
+    { 106,  101,   3,   151,  171,   41 }  // Queen
+  };

  // Endgame evaluation and scaling functions accessed direcly and not through
  // the function maps because correspond to more then one material hash key.
@@ -61,38 +75,74 @@ namespace {
  // Helper templates used to detect a given material distribution
  template<Color Us> bool is_KXK(const Position& pos) {
    const Color Them = (Us == WHITE ? BLACK : WHITE);
-    return   pos.non_pawn_material(Them) == VALUE_ZERO
-          && pos.piece_count(Them, PAWN) == 0
-          && pos.non_pawn_material(Us)   >= RookValueMg;
+    return  !pos.count<PAWN>(Them)
+          && pos.non_pawn_material(Them) == VALUE_ZERO
+          && pos.non_pawn_material(Us) >= RookValueMg;
  }

  template<Color Us> bool is_KBPsKs(const Position& pos) {
-    return   pos.non_pawn_material(Us)   == BishopValueMg
-          && pos.piece_count(Us, BISHOP) == 1
-          && pos.piece_count(Us, PAWN)   >= 1;
+    return   pos.non_pawn_material(Us) == BishopValueMg
+          && pos.count<BISHOP>(Us) == 1
+          && pos.count<PAWN  >(Us) >= 1;
  }

  template<Color Us> bool is_KQKRPs(const Position& pos) {
    const Color Them = (Us == WHITE ? BLACK : WHITE);
-    return   pos.piece_count(Us, PAWN)    == 0
-          && pos.non_pawn_material(Us)    == QueenValueMg
-          && pos.piece_count(Us, QUEEN)   == 1
-          && pos.piece_count(Them, ROOK)  == 1
-          && pos.piece_count(Them, PAWN)  >= 1;
+    return  !pos.count<PAWN>(Us)
+          && pos.non_pawn_material(Us) == QueenValueMg
+          && pos.count<QUEEN>(Us)  == 1
+          && pos.count<ROOK>(Them) == 1
+          && pos.count<PAWN>(Them) >= 1;
+  }
+
+  /// imbalance() calculates imbalance comparing piece count of each
+  /// piece type for both colors.
+
+  template<Color Us>
+  int imbalance(const int pieceCount[][PIECE_TYPE_NB]) {
+
+    const Color Them = (Us == WHITE ? BLACK : WHITE);
+
+    int pt1, pt2, pc, v;
+    int value = 0;
+
+    // Redundancy of major pieces, formula based on Kaufman's paper
+    // "The Evaluation of Material Imbalances in Chess"
+    if (pieceCount[Us][ROOK] > 0)
+        value -=  RedundantRook * (pieceCount[Us][ROOK] - 1)
+                + RedundantQueen * pieceCount[Us][QUEEN];
+
+    // Second-degree polynomial material imbalance by Tord Romstad
+    for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
+    {
+        pc = pieceCount[Us][pt1];
+        if (!pc)
+            continue;
+
+        v = LinearCoefficients[pt1];
+
+        for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
+            v +=  QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
+                + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
+
+        value += pc * v;
+    }
+    return value;
  }

 } // namespace

+namespace Material {

-/// MaterialTable::probe() takes a position object as input, looks up a MaterialEntry
+/// Material::probe() takes a position object as input, looks up a MaterialEntry
 /// object, and returns a pointer to it. If the material configuration is not
 /// already present in the table, it is computed and stored there, so we don't
 /// have to recompute everything when the same material configuration occurs again.

-MaterialEntry* MaterialTable::probe(const Position& pos) {
+Entry* probe(const Position& pos, Table& entries, Endgames& endgames) {

  Key key = pos.material_key();
-  MaterialEntry* e = entries[key];
+  Entry* e = entries[key];

  // If e->key matches the position's material hash key, it means that we
  // have analysed this material configuration before, and we can simply
@@ -100,10 +150,10 @@ MaterialEntry* MaterialTable::probe(const Position& pos) {
  if (e->key == key)
      return e;

-  memset(e, 0, sizeof(MaterialEntry));
+  std::memset(e, 0, sizeof(Entry));
  e->key = key;
  e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
-  e->gamePhase = MaterialTable::game_phase(pos);
+  e->gamePhase = game_phase(pos);

  // Let's look if we have a specialized evaluation function for this
  // particular material configuration. First we look for a fixed
@@ -130,8 +180,8 @@ MaterialEntry* MaterialTable::probe(const Position& pos) {
      assert((pos.pieces(WHITE, KNIGHT) | pos.pieces(WHITE, BISHOP)));
      assert((pos.pieces(BLACK, KNIGHT) | pos.pieces(BLACK, BISHOP)));

-      if (   pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2
-          && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2)
+      if (   pos.count<BISHOP>(WHITE) + pos.count<KNIGHT>(WHITE) <= 2
+          && pos.count<BISHOP>(BLACK) + pos.count<KNIGHT>(BLACK) <= 2)
      {
          e->evaluationFunction = &EvaluateKmmKm[pos.side_to_move()];
          return e;
@@ -171,17 +221,17 @@ MaterialEntry* MaterialTable::probe(const Position& pos) {

  if (npm_w + npm_b == VALUE_ZERO)
  {
-      if (pos.piece_count(BLACK, PAWN) == 0)
+      if (!pos.count<PAWN>(BLACK))
      {
-          assert(pos.piece_count(WHITE, PAWN) >= 2);
+          assert(pos.count<PAWN>(WHITE) >= 2);
          e->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
      }
-      else if (pos.piece_count(WHITE, PAWN) == 0)
+      else if (!pos.count<PAWN>(WHITE))
      {
-          assert(pos.piece_count(BLACK, PAWN) >= 2);
+          assert(pos.count<PAWN>(BLACK) >= 2);
          e->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
      }
-      else if (pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1)
+      else if (pos.count<PAWN>(WHITE) == 1 && pos.count<PAWN>(BLACK) == 1)
      {
          // This is a special case because we set scaling functions
          // for both colors instead of only one.
@@ -191,82 +241,46 @@ MaterialEntry* MaterialTable::probe(const Position& pos) {
  }

  // No pawns makes it difficult to win, even with a material advantage
-  if (pos.piece_count(WHITE, PAWN) == 0 && npm_w - npm_b <= BishopValueMg)
+  if (!pos.count<PAWN>(WHITE) && npm_w - npm_b <= BishopValueMg)
  {
      e->factor[WHITE] = (uint8_t)
-      (npm_w == npm_b || npm_w < RookValueMg ? 0 : NoPawnsSF[std::min(pos.piece_count(WHITE, BISHOP), 2)]);
+      (npm_w == npm_b || npm_w < RookValueMg ? 0 : NoPawnsSF[std::min(pos.count<BISHOP>(WHITE), 2)]);
  }

-  if (pos.piece_count(BLACK, PAWN) == 0 && npm_b - npm_w <= BishopValueMg)
+  if (!pos.count<PAWN>(BLACK) && npm_b - npm_w <= BishopValueMg)
  {
      e->factor[BLACK] = (uint8_t)
-      (npm_w == npm_b || npm_b < RookValueMg ? 0 : NoPawnsSF[std::min(pos.piece_count(BLACK, BISHOP), 2)]);
+      (npm_w == npm_b || npm_b < RookValueMg ? 0 : NoPawnsSF[std::min(pos.count<BISHOP>(BLACK), 2)]);
  }

  // Compute the space weight
  if (npm_w + npm_b >= 2 * QueenValueMg + 4 * RookValueMg + 2 * KnightValueMg)
  {
-      int minorPieceCount =  pos.piece_count(WHITE, KNIGHT) + pos.piece_count(WHITE, BISHOP)
-                           + pos.piece_count(BLACK, KNIGHT) + pos.piece_count(BLACK, BISHOP);
+      int minorPieceCount =  pos.count<KNIGHT>(WHITE) + pos.count<BISHOP>(WHITE)
+                           + pos.count<KNIGHT>(BLACK) + pos.count<BISHOP>(BLACK);

-      e->spaceWeight = minorPieceCount * minorPieceCount;
+      e->spaceWeight = make_score(minorPieceCount * minorPieceCount, 0);
  }

  // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder
  // for the bishop pair "extended piece", this allow us to be more flexible
  // in defining bishop pair bonuses.
-  const int pieceCount[2][8] = {
-  { pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(WHITE, PAWN), pos.piece_count(WHITE, KNIGHT),
-    pos.piece_count(WHITE, BISHOP)    , pos.piece_count(WHITE, ROOK), pos.piece_count(WHITE, QUEEN) },
-  { pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT),
-    pos.piece_count(BLACK, BISHOP)    , pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } };
+  const int pieceCount[COLOR_NB][PIECE_TYPE_NB] = {
+  { pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE),
+    pos.count<BISHOP>(WHITE)    , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) },
+  { pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK),
+    pos.count<BISHOP>(BLACK)    , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } };

  e->value = (int16_t)((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16);
  return e;
 }


-/// MaterialTable::imbalance() calculates imbalance comparing piece count of each
-/// piece type for both colors.
-
-template<Color Us>
-int MaterialTable::imbalance(const int pieceCount[][8]) {
-
-  const Color Them = (Us == WHITE ? BLACK : WHITE);
-
-  int pt1, pt2, pc, v;
-  int value = 0;
-
-  // Redundancy of major pieces, formula based on Kaufman's paper
-  // "The Evaluation of Material Imbalances in Chess"
-  if (pieceCount[Us][ROOK] > 0)
-      value -=  RedundantRookPenalty * (pieceCount[Us][ROOK] - 1)
-              + RedundantQueenPenalty * pieceCount[Us][QUEEN];
-
-  // Second-degree polynomial material imbalance by Tord Romstad
-  for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
-  {
-      pc = pieceCount[Us][pt1];
-      if (!pc)
-          continue;
-
-      v = LinearCoefficients[pt1];
-
-      for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
-          v +=  QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
-              + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
-
-      value += pc * v;
-  }
-  return value;
-}
-
-
-/// MaterialTable::game_phase() calculates the phase given the current
+/// Material::game_phase() calculates the phase given the current
 /// position. Because the phase is strictly a function of the material, it
 /// is stored in MaterialEntry.

-Phase MaterialTable::game_phase(const Position& pos) {
+Phase game_phase(const Position& pos) {

  Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);

@@ -274,3 +288,5 @@ Phase MaterialTable::game_phase(const Position& pos) {
        : npm <= EndgameLimit ? PHASE_ENDGAME
        : Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
 }
+
+} // namespace Material
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(MATERIAL_H_INCLUDED)
+#ifndef MATERIAL_H_INCLUDED
 #define MATERIAL_H_INCLUDED

 #include "endgame.h"
@@ -25,96 +25,53 @@
 #include "position.h"
 #include "types.h"

-const int MaterialTableSize = 8192;
+namespace Material {

-/// Game phase
-enum Phase {
-  PHASE_ENDGAME = 0,
-  PHASE_MIDGAME = 128
-};
-
-
-/// MaterialEntry is a class which contains various information about a
-/// 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.
+/// Material::Entry contains various information about a 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".
 ///
 /// The scale factors are used to scale the evaluation score up or down.
 /// For instance, in KRB vs KR endgames, the score is scaled down by a factor
 /// of 4, which will result in scores of absolute value less than one pawn.

-class MaterialEntry {
+struct Entry {

-  friend struct MaterialTable;
-
-public:
-  Score material_value() const;
+  Score material_value() const { return make_score(value, value); }
+  Score space_weight() const { return spaceWeight; }
+  Phase game_phase() const { return gamePhase; }
+  bool specialized_eval_exists() const { return evaluationFunction != NULL; }
+  Value evaluate(const Position& p) const { return (*evaluationFunction)(p); }
  ScaleFactor scale_factor(const Position& pos, Color c) const;
-  int space_weight() const;
-  Phase game_phase() const;
-  bool specialized_eval_exists() const;
-  Value evaluate(const Position& pos) const;

-private:
  Key key;
  int16_t value;
-  uint8_t factor[2];
+  uint8_t factor[COLOR_NB];
  EndgameBase<Value>* evaluationFunction;
-  EndgameBase<ScaleFactor>* scalingFunction[2];
-  int spaceWeight;
+  EndgameBase<ScaleFactor>* scalingFunction[COLOR_NB];
+  Score spaceWeight;
  Phase gamePhase;
 };

+typedef HashTable<Entry, 8192> Table;

-/// The MaterialTable class represents a material hash table. The most important
-/// method is probe(), which returns a pointer to a MaterialEntry object.
+Entry* probe(const Position& pos, Table& entries, Endgames& endgames);
+Phase game_phase(const Position& pos);

-struct MaterialTable {
-
-  MaterialEntry* probe(const Position& pos);
-  static Phase game_phase(const Position& pos);
-  template<Color Us> static int imbalance(const int pieceCount[][8]);
-
-  HashTable<MaterialEntry, MaterialTableSize> entries;
-  Endgames endgames;
-};
-
-
-/// MaterialEntry::scale_factor takes a position and a color as input, and
+/// Material::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
 /// 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 MaterialEntry::scale_factor(const Position& pos, Color c) const {
+inline ScaleFactor Entry::scale_factor(const Position& pos, Color c) const {

-  if (!scalingFunction[c])
-      return ScaleFactor(factor[c]);
-
-  ScaleFactor sf = (*scalingFunction[c])(pos);
-  return sf == SCALE_FACTOR_NONE ? ScaleFactor(factor[c]) : sf;
+  return !scalingFunction[c] || (*scalingFunction[c])(pos) == SCALE_FACTOR_NONE
+        ? ScaleFactor(factor[c]) : (*scalingFunction[c])(pos);
 }

-inline Value MaterialEntry::evaluate(const Position& pos) const {
-  return (*evaluationFunction)(pos);
 }

-inline Score MaterialEntry::material_value() const {
-  return make_score(value, value);
-}
-
-inline int MaterialEntry::space_weight() const {
-  return spaceWeight;
-}
-
-inline Phase MaterialEntry::game_phase() const {
-  return gamePhase;
-}
-
-inline bool MaterialEntry::specialized_eval_exists() const {
-  return evaluationFunction != NULL;
-}
-
-#endif // !defined(MATERIAL_H_INCLUDED)
+#endif // #ifndef MATERIAL_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -24,57 +24,41 @@
 #include "misc.h"
 #include "thread.h"

-#if defined(__hpux)
-#    include <sys/pstat.h>
-#endif
-
 using namespace std;

-/// Version number. If Version is left empty, then Tag plus current
-/// date (in the format YYMMDD) is used as a version number.
-
-static const string Version = "2.3";
-static const string Tag = "";
+/// Version number. If Version is left empty, then compile date, in the
+/// format DD-MM-YY, is shown in engine_info.
+static const string Version = "4";


-/// engine_info() 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 Version is empty.
+/// engine_info() returns the full name of the current Stockfish version. This
+/// will be either "Stockfish <Tag> DD-MM-YY" (where DD-MM-YY is the date when
+/// the program was compiled) or "Stockfish <Version>", depending on whether
+/// Version is empty.

 const string engine_info(bool to_uci) {

  const string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
-  const string cpu64(Is64Bit ? " 64bit" : "");
-  const string popcnt(HasPopCnt ? " SSE4.2" : "");
-
  string month, day, year;
  stringstream s, date(__DATE__); // From compiler, format is "Sep 21 2008"

-  s << "Stockfish " << Version;
+  s << "Stockfish " << Version << setfill('0');

  if (Version.empty())
  {
      date >> month >> day >> year;
-
-      s << Tag << setfill('0') << " " << year.substr(2)
-        << setw(2) << (1 + months.find(month) / 4) << setw(2) << day;
+      s << setw(2) << day << setw(2) << (1 + months.find(month) / 4) << year.substr(2);
  }

-  s << cpu64 << popcnt << (to_uci ? "\nid author ": " by ")
+  s << (Is64Bit ? " 64" : "")
+    << (HasPopCnt ? " SSE4.2" : "")
+    << (to_uci ? "\nid author ": " by ")
    << "Tord Romstad, Marco Costalba and Joona Kiiski";

  return s.str();
 }


-/// Convert system time to milliseconds. That's all we need.
-
-Time::point Time::now() {
-  sys_time_t t; system_time(&t); return time_to_msec(t);
-}
-
-
 /// Debug functions used mainly to collect run-time statistics

 static uint64_t hits[2], means[2];
@@ -174,37 +158,12 @@ std::ostream& operator<<(std::ostream& os, SyncCout sc) {
 void start_logger(bool b) { Logger::start(b); }


-/// cpu_count() tries to detect the number of CPU cores
-
-int cpu_count() {
-
-#if defined(_WIN32) || defined(_WIN64)
-  SYSTEM_INFO s;
-  GetSystemInfo(&s);
-  return s.dwNumberOfProcessors;
-#else
-
-#  if defined(_SC_NPROCESSORS_ONLN)
-  return sysconf(_SC_NPROCESSORS_ONLN);
-#  elif defined(__hpux)
-  struct pst_dynamic psd;
-  if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) == -1)
-      return 1;
-  return psd.psd_proc_cnt;
-#  else
-  return 1;
-#  endif
-
-#endif
-}
-
-
 /// timed_wait() waits for msec milliseconds. It is mainly an helper to wrap
 /// conversion from milliseconds to struct timespec, as used by pthreads.

 void timed_wait(WaitCondition& sleepCond, Lock& sleepLock, int msec) {

-#if defined(_WIN32) || defined(_WIN64)
+#ifdef _WIN32
  int tm = msec;
 #else
  timespec ts, *tm = &ts;
@@ -221,24 +180,25 @@ void timed_wait(WaitCondition& sleepCond, Lock& sleepLock, int msec) {
 /// prefetch() preloads the given address in L1/L2 cache. This is a non
 /// blocking function and do not stalls the CPU waiting for data to be
 /// loaded from memory, that can be quite slow.
-#if defined(NO_PREFETCH)
+#ifdef NO_PREFETCH

 void prefetch(char*) {}

 #else

-#   include <xmmintrin.h>
-
 void prefetch(char* addr) {

-#  if defined(__INTEL_COMPILER) || defined(__ICL)
+#  if defined(__INTEL_COMPILER)
   // This hack prevents prefetches to be optimized away by
   // Intel compiler. Both MSVC and gcc seems not affected.
   __asm__ ("");
 #  endif

-  _mm_prefetch(addr, _MM_HINT_T2);
-  _mm_prefetch(addr+64, _MM_HINT_T2); // 64 bytes ahead
+#  if defined(__INTEL_COMPILER) || defined(_MSC_VER)
+  _mm_prefetch(addr, _MM_HINT_T0);
+#  else
+  __builtin_prefetch(addr);
+#  endif
 }

 #endif
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(MISC_H_INCLUDED)
+#ifndef MISC_H_INCLUDED
 #define MISC_H_INCLUDED

 #include <fstream>
@@ -27,7 +27,6 @@
 #include "types.h"

 extern const std::string engine_info(bool to_uci = false);
-extern int cpu_count();
 extern void timed_wait(WaitCondition&, Lock&, int);
 extern void prefetch(char* addr);
 extern void start_logger(bool b);
@@ -46,7 +45,7 @@ struct Log : public std::ofstream {

 namespace Time {
  typedef int64_t point;
-  point now();
+  inline point now() { return system_time_to_msec(); }
 }


@@ -66,4 +65,4 @@ std::ostream& operator<<(std::ostream&, SyncCout);
 #define sync_cout std::cout << io_lock
 #define sync_endl std::endl << io_unlock

-#endif // !defined(MISC_H_INCLUDED)
+#endif // #ifndef MISC_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -24,15 +24,15 @@

 /// Simple macro to wrap a very common while loop, no facny, no flexibility,
 /// hardcoded names 'mlist' and 'from'.
-#define SERIALIZE(b) while (b) (*mlist++).move = make_move(from, pop_lsb(&b))
+#define SERIALIZE(b) while (b) (mlist++)->move = make_move(from, pop_lsb(&b))

 /// Version used for pawns, where the 'from' square is given as a delta from the 'to' square
 #define SERIALIZE_PAWNS(b, d) while (b) { Square to = pop_lsb(&b); \
-                                         (*mlist++).move = make_move(to - (d), to); }
+                                         (mlist++)->move = make_move(to - (d), to); }
 namespace {

-  template<CastlingSide Side, bool Checks>
-  MoveStack* generate_castle(const Position& pos, MoveStack* mlist, Color us) {
+  template<CastlingSide Side, bool Checks, bool Chess960>
+  ExtMove* generate_castle(const Position& pos, ExtMove* mlist, Color us) {

    if (pos.castle_impeded(us, Side) || !pos.can_castle(make_castle_right(us, Side)))
        return mlist;
@@ -44,20 +44,22 @@ namespace {
    Square kto = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
    Bitboard enemies = pos.pieces(~us);

-    assert(!pos.in_check());
+    assert(!pos.checkers());

-    for (Square s = kto; s != kfrom; s += (Square)(Side == KING_SIDE ? -1 : 1))
+    const int K = Chess960 ? kto > kfrom ? -1 : 1
+                           : Side == KING_SIDE ? -1 : 1;
+
+    for (Square s = kto; s != kfrom; s += (Square)K)
        if (pos.attackers_to(s) & enemies)
            return mlist;

    // Because we generate only legal castling moves we need to verify that
    // when moving the castling rook we do not discover some hidden checker.
    // For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.
-    if (    pos.is_chess960()
-        && (pos.attackers_to(kto, pos.pieces() ^ rfrom) & enemies))
-            return mlist;
+    if (Chess960 && (pos.attackers_to(kto, pos.pieces() ^ rfrom) & enemies))
+        return mlist;

-    (*mlist++).move = make<CASTLE>(kfrom, rfrom);
+    (mlist++)->move = make<CASTLE>(kfrom, rfrom);

    if (Checks && !pos.move_gives_check((mlist - 1)->move, CheckInfo(pos)))
        mlist--;
@@ -66,42 +68,30 @@ namespace {
  }


-  template<Square Delta>
-  inline Bitboard move_pawns(Bitboard p) {
-
-    return  Delta == DELTA_N  ?  p << 8
-          : Delta == DELTA_S  ?  p >> 8
-          : Delta == DELTA_NE ? (p & ~FileHBB) << 9
-          : Delta == DELTA_SE ? (p & ~FileHBB) >> 7
-          : Delta == DELTA_NW ? (p & ~FileABB) << 7
-          : Delta == DELTA_SW ? (p & ~FileABB) >> 9 : 0;
-  }
-
-
  template<GenType Type, Square Delta>
-  inline MoveStack* generate_promotions(MoveStack* mlist, Bitboard pawnsOn7,
-                                        Bitboard target, const CheckInfo* ci) {
+  inline ExtMove* generate_promotions(ExtMove* mlist, Bitboard pawnsOn7,
+                                      Bitboard target, const CheckInfo* ci) {

-    Bitboard b = move_pawns<Delta>(pawnsOn7) & target;
+    Bitboard b = shift_bb<Delta>(pawnsOn7) & target;

    while (b)
    {
        Square to = pop_lsb(&b);

        if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
-            (*mlist++).move = make<PROMOTION>(to - Delta, to, QUEEN);
+            (mlist++)->move = make<PROMOTION>(to - Delta, to, QUEEN);

        if (Type == QUIETS || Type == EVASIONS || Type == NON_EVASIONS)
        {
-            (*mlist++).move = make<PROMOTION>(to - Delta, to, ROOK);
-            (*mlist++).move = make<PROMOTION>(to - Delta, to, BISHOP);
-            (*mlist++).move = make<PROMOTION>(to - Delta, to, KNIGHT);
+            (mlist++)->move = make<PROMOTION>(to - Delta, to, ROOK);
+            (mlist++)->move = make<PROMOTION>(to - Delta, to, BISHOP);
+            (mlist++)->move = make<PROMOTION>(to - Delta, to, KNIGHT);
        }

        // Knight-promotion is the only one that can give a direct check not
        // already included in the queen-promotion.
        if (Type == QUIET_CHECKS && (StepAttacksBB[W_KNIGHT][to] & ci->ksq))
-            (*mlist++).move = make<PROMOTION>(to - Delta, to, KNIGHT);
+            (mlist++)->move = make<PROMOTION>(to - Delta, to, KNIGHT);
        else
            (void)ci; // Silence a warning under MSVC
    }
@@ -111,8 +101,8 @@ namespace {


  template<Color Us, GenType Type>
-  MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist,
-                                 Bitboard target, const CheckInfo* ci) {
+  ExtMove* generate_pawn_moves(const Position& pos, ExtMove* mlist,
+                               Bitboard target, const CheckInfo* ci) {

    // Compute our parametrized parameters at compile time, named according to
    // the point of view of white side.
@@ -120,9 +110,9 @@ namespace {
    const Bitboard TRank8BB = (Us == WHITE ? Rank8BB  : Rank1BB);
    const Bitboard TRank7BB = (Us == WHITE ? Rank7BB  : Rank2BB);
    const Bitboard TRank3BB = (Us == WHITE ? Rank3BB  : Rank6BB);
-    const Square   UP       = (Us == WHITE ? DELTA_N  : DELTA_S);
-    const Square   RIGHT    = (Us == WHITE ? DELTA_NE : DELTA_SW);
-    const Square   LEFT     = (Us == WHITE ? DELTA_NW : DELTA_SE);
+    const Square   Up       = (Us == WHITE ? DELTA_N  : DELTA_S);
+    const Square   Right    = (Us == WHITE ? DELTA_NE : DELTA_SW);
+    const Square   Left     = (Us == WHITE ? DELTA_NW : DELTA_SE);

    Bitboard b1, b2, dc1, dc2, emptySquares;

@@ -137,8 +127,8 @@ namespace {
    {
        emptySquares = (Type == QUIETS || Type == QUIET_CHECKS ? target : ~pos.pieces());

-        b1 = move_pawns<UP>(pawnsNotOn7)   & emptySquares;
-        b2 = move_pawns<UP>(b1 & TRank3BB) & emptySquares;
+        b1 = shift_bb<Up>(pawnsNotOn7)   & emptySquares;
+        b2 = shift_bb<Up>(b1 & TRank3BB) & emptySquares;

        if (Type == EVASIONS) // Consider only blocking squares
        {
@@ -157,16 +147,16 @@ namespace {
            // promotion has been already generated among captures.
            if (pawnsNotOn7 & ci->dcCandidates)
            {
-                dc1 = move_pawns<UP>(pawnsNotOn7 & ci->dcCandidates) & emptySquares & ~file_bb(ci->ksq);
-                dc2 = move_pawns<UP>(dc1 & TRank3BB) & emptySquares;
+                dc1 = shift_bb<Up>(pawnsNotOn7 & ci->dcCandidates) & emptySquares & ~file_bb(ci->ksq);
+                dc2 = shift_bb<Up>(dc1 & TRank3BB) & emptySquares;

                b1 |= dc1;
                b2 |= dc2;
            }
        }

-        SERIALIZE_PAWNS(b1, UP);
-        SERIALIZE_PAWNS(b2, UP + UP);
+        SERIALIZE_PAWNS(b1, Up);
+        SERIALIZE_PAWNS(b2, Up + Up);
    }

    // Promotions and underpromotions
@@ -178,19 +168,19 @@ namespace {
        if (Type == EVASIONS)
            emptySquares &= target;

-        mlist = generate_promotions<Type, RIGHT>(mlist, pawnsOn7, enemies, ci);
-        mlist = generate_promotions<Type, LEFT>(mlist, pawnsOn7, enemies, ci);
-        mlist = generate_promotions<Type, UP>(mlist, pawnsOn7, emptySquares, ci);
+        mlist = generate_promotions<Type, Right>(mlist, pawnsOn7, enemies, ci);
+        mlist = generate_promotions<Type, Left >(mlist, pawnsOn7, enemies, ci);
+        mlist = generate_promotions<Type, Up>(mlist, pawnsOn7, emptySquares, ci);
    }

    // Standard and en-passant captures
    if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
    {
-        b1 = move_pawns<RIGHT>(pawnsNotOn7) & enemies;
-        b2 = move_pawns<LEFT >(pawnsNotOn7) & enemies;
+        b1 = shift_bb<Right>(pawnsNotOn7) & enemies;
+        b2 = shift_bb<Left >(pawnsNotOn7) & enemies;

-        SERIALIZE_PAWNS(b1, RIGHT);
-        SERIALIZE_PAWNS(b2, LEFT);
+        SERIALIZE_PAWNS(b1, Right);
+        SERIALIZE_PAWNS(b2, Left);

        if (pos.ep_square() != SQ_NONE)
        {
@@ -199,7 +189,7 @@ namespace {
            // An en passant capture can be an evasion only if the checking piece
            // is the double pushed pawn and so is in the target. Otherwise this
            // is a discovery check and we are forced to do otherwise.
-            if (Type == EVASIONS && !(target & (pos.ep_square() - UP)))
+            if (Type == EVASIONS && !(target & (pos.ep_square() - Up)))
                return mlist;

            b1 = pawnsNotOn7 & pos.attacks_from<PAWN>(pos.ep_square(), Them);
@@ -207,7 +197,7 @@ namespace {
            assert(b1);

            while (b1)
-                (*mlist++).move = make<ENPASSANT>(pop_lsb(&b1), pos.ep_square());
+                (mlist++)->move = make<ENPASSANT>(pop_lsb(&b1), pos.ep_square());
        }
    }

@@ -216,12 +206,12 @@ namespace {


  template<PieceType Pt, bool Checks> FORCE_INLINE
-  MoveStack* generate_moves(const Position& pos, MoveStack* mlist, Color us,
-                            Bitboard target, const CheckInfo* ci) {
+  ExtMove* generate_moves(const Position& pos, ExtMove* mlist, Color us,
+                          Bitboard target, const CheckInfo* ci) {

    assert(Pt != KING && Pt != PAWN);

-    const Square* pl = pos.piece_list(us, Pt);
+    const Square* pl = pos.list<Pt>(us);

    for (Square from = *pl; from != SQ_NONE; from = *++pl)
    {
@@ -231,7 +221,7 @@ namespace {
                && !(PseudoAttacks[Pt][from] & target & ci->checkSq[Pt]))
                continue;

-            if (ci->dcCandidates && (ci->dcCandidates & from))
+            if (unlikely(ci->dcCandidates) && (ci->dcCandidates & from))
                continue;
        }

@@ -247,34 +237,37 @@ namespace {
  }


-  FORCE_INLINE MoveStack* generate_king_moves(const Position& pos, MoveStack* mlist,
-                                              Color us, Bitboard target) {
-    Square from = pos.king_square(us);
-    Bitboard b = pos.attacks_from<KING>(from) & target;
-    SERIALIZE(b);
-    return mlist;
-  }
+  template<Color Us, GenType Type> FORCE_INLINE
+  ExtMove* generate_all(const Position& pos, ExtMove* mlist, Bitboard target,
+                        const CheckInfo* ci = NULL) {

+    const bool Checks = Type == QUIET_CHECKS;

-  template<GenType Type> FORCE_INLINE
-  MoveStack* generate_all_moves(const Position& pos, MoveStack* mlist, Color us,
-                                Bitboard target, const CheckInfo* ci = NULL) {
-
-    mlist = (us == WHITE ? generate_pawn_moves<WHITE, Type>(pos, mlist, target, ci)
-                         : generate_pawn_moves<BLACK, Type>(pos, mlist, target, ci));
-
-    mlist = generate_moves<KNIGHT, Type == QUIET_CHECKS>(pos, mlist, us, target, ci);
-    mlist = generate_moves<BISHOP, Type == QUIET_CHECKS>(pos, mlist, us, target, ci);
-    mlist = generate_moves<ROOK,   Type == QUIET_CHECKS>(pos, mlist, us, target, ci);
-    mlist = generate_moves<QUEEN,  Type == QUIET_CHECKS>(pos, mlist, us, target, ci);
+    mlist = generate_pawn_moves<Us, Type>(pos, mlist, target, ci);
+    mlist = generate_moves<KNIGHT, Checks>(pos, mlist, Us, target, ci);
+    mlist = generate_moves<BISHOP, Checks>(pos, mlist, Us, target, ci);
+    mlist = generate_moves<  ROOK, Checks>(pos, mlist, Us, target, ci);
+    mlist = generate_moves< QUEEN, Checks>(pos, mlist, Us, target, ci);

    if (Type != QUIET_CHECKS && Type != EVASIONS)
-        mlist = generate_king_moves(pos, mlist, us, target);
-
-    if (Type != CAPTURES && Type != EVASIONS && pos.can_castle(us))
    {
-        mlist = generate_castle<KING_SIDE,  Type == QUIET_CHECKS>(pos, mlist, us);
-        mlist = generate_castle<QUEEN_SIDE, Type == QUIET_CHECKS>(pos, mlist, us);
+        Square from = pos.king_square(Us);
+        Bitboard b = pos.attacks_from<KING>(from) & target;
+        SERIALIZE(b);
+    }
+
+    if (Type != CAPTURES && Type != EVASIONS && pos.can_castle(Us))
+    {
+        if (pos.is_chess960())
+        {
+            mlist = generate_castle< KING_SIDE, Checks, true>(pos, mlist, Us);
+            mlist = generate_castle<QUEEN_SIDE, Checks, true>(pos, mlist, Us);
+        }
+        else
+        {
+            mlist = generate_castle< KING_SIDE, Checks, false>(pos, mlist, Us);
+            mlist = generate_castle<QUEEN_SIDE, Checks, false>(pos, mlist, Us);
+        }
    }

    return mlist;
@@ -294,38 +287,33 @@ namespace {
 /// non-captures. Returns a pointer to the end of the move list.

 template<GenType Type>
-MoveStack* generate(const Position& pos, MoveStack* mlist) {
+ExtMove* generate(const Position& pos, ExtMove* mlist) {

  assert(Type == CAPTURES || Type == QUIETS || Type == NON_EVASIONS);
-  assert(!pos.in_check());
+  assert(!pos.checkers());

  Color us = pos.side_to_move();
-  Bitboard target;

-  if (Type == CAPTURES)
-      target = pos.pieces(~us);
+  Bitboard target = Type == CAPTURES     ?  pos.pieces(~us)
+                  : Type == QUIETS       ? ~pos.pieces()
+                  : Type == NON_EVASIONS ? ~pos.pieces(us) : 0;

-  else if (Type == QUIETS)
-      target = ~pos.pieces();
-
-  else if (Type == NON_EVASIONS)
-      target = ~pos.pieces(us);
-
-  return generate_all_moves<Type>(pos, mlist, us, target);
+  return us == WHITE ? generate_all<WHITE, Type>(pos, mlist, target)
+                     : generate_all<BLACK, Type>(pos, mlist, target);
 }

 // Explicit template instantiations
-template MoveStack* generate<CAPTURES>(const Position&, MoveStack*);
-template MoveStack* generate<QUIETS>(const Position&, MoveStack*);
-template MoveStack* generate<NON_EVASIONS>(const Position&, MoveStack*);
+template ExtMove* generate<CAPTURES>(const Position&, ExtMove*);
+template ExtMove* generate<QUIETS>(const Position&, ExtMove*);
+template ExtMove* generate<NON_EVASIONS>(const Position&, ExtMove*);


 /// generate<QUIET_CHECKS> generates all pseudo-legal non-captures and knight
 /// underpromotions that give check. Returns a pointer to the end of the move list.
 template<>
-MoveStack* generate<QUIET_CHECKS>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<QUIET_CHECKS>(const Position& pos, ExtMove* mlist) {

-  assert(!pos.in_check());
+  assert(!pos.checkers());

  Color us = pos.side_to_move();
  CheckInfo ci(pos);
@@ -347,21 +335,21 @@ MoveStack* generate<QUIET_CHECKS>(const Position& pos, MoveStack* mlist) {
     SERIALIZE(b);
  }

-  return generate_all_moves<QUIET_CHECKS>(pos, mlist, us, ~pos.pieces(), &ci);
+  return us == WHITE ? generate_all<WHITE, QUIET_CHECKS>(pos, mlist, ~pos.pieces(), &ci)
+                     : generate_all<BLACK, QUIET_CHECKS>(pos, mlist, ~pos.pieces(), &ci);
 }


 /// generate<EVASIONS> generates all pseudo-legal check evasions when the side
 /// to move is in check. Returns a pointer to the end of the move list.
 template<>
-MoveStack* generate<EVASIONS>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<EVASIONS>(const Position& pos, ExtMove* mlist) {

-  assert(pos.in_check());
+  assert(pos.checkers());

-  Square from, checksq;
  int checkersCnt = 0;
  Color us = pos.side_to_move();
-  Square ksq = pos.king_square(us);
+  Square ksq = pos.king_square(us), from = ksq /* For SERIALIZE */, checksq;
  Bitboard sliderAttacks = 0;
  Bitboard b = pos.checkers();

@@ -400,29 +388,29 @@ MoveStack* generate<EVASIONS>(const Position& pos, MoveStack* mlist) {

  // Generate evasions for king, capture and non capture moves
  b = pos.attacks_from<KING>(ksq) & ~pos.pieces(us) & ~sliderAttacks;
-  from = ksq;
  SERIALIZE(b);

  if (checkersCnt > 1)
      return mlist; // Double check, only a king move can save the day

  // Generate blocking evasions or captures of the checking piece
-  Bitboard target = between_bb(checksq, ksq) | pos.checkers();
+  Bitboard target = between_bb(checksq, ksq) | checksq;

-  return generate_all_moves<EVASIONS>(pos, mlist, us, target);
+  return us == WHITE ? generate_all<WHITE, EVASIONS>(pos, mlist, target)
+                     : generate_all<BLACK, EVASIONS>(pos, mlist, target);
 }


 /// generate<LEGAL> generates all the legal moves in the given position

 template<>
-MoveStack* generate<LEGAL>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<LEGAL>(const Position& pos, ExtMove* mlist) {

-  MoveStack *end, *cur = mlist;
+  ExtMove *end, *cur = mlist;
  Bitboard pinned = pos.pinned_pieces();
  Square ksq = pos.king_square(pos.side_to_move());

-  end = pos.in_check() ? generate<EVASIONS>(pos, mlist)
+  end = pos.checkers() ? generate<EVASIONS>(pos, mlist)
                       : generate<NON_EVASIONS>(pos, mlist);
  while (cur != end)
      if (   (pinned || from_sq(cur->move) == ksq || type_of(cur->move) == ENPASSANT)
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(MOVEGEN_H_INCLUDED)
+#ifndef MOVEGEN_H_INCLUDED
 #define MOVEGEN_H_INCLUDED

 #include "types.h"
@@ -34,22 +34,25 @@ enum GenType {
 class Position;

 template<GenType>
-MoveStack* generate(const Position& pos, MoveStack* mlist);
+ExtMove* generate(const Position& pos, ExtMove* mlist);

 /// The MoveList struct is a simple wrapper around generate(), sometimes comes
 /// handy to use this class instead of the low level generate() function.
 template<GenType T>
 struct MoveList {

-  explicit MoveList(const Position& pos) : cur(mlist), last(generate<T>(pos, mlist)) {}
+  explicit MoveList(const Position& pos) : cur(mlist), last(generate<T>(pos, mlist)) { last->move = MOVE_NONE; }
  void operator++() { cur++; }
-  bool end() const { return cur == last; }
-  Move move() const { return cur->move; }
+  Move operator*() const { return cur->move; }
  size_t size() const { return last - mlist; }
+  bool contains(Move m) const {
+    for (const ExtMove* it(mlist); it != last; ++it) if (it->move == m) return true;
+    return false;
+  }

 private:
-  MoveStack mlist[MAX_MOVES];
-  MoveStack *cur, *last;
+  ExtMove mlist[MAX_MOVES];
+  ExtMove *cur, *last;
 };

-#endif // !defined(MOVEGEN_H_INCLUDED)
+#endif // #ifndef MOVEGEN_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -18,16 +18,14 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#include <algorithm>
 #include <cassert>

-#include "movegen.h"
 #include "movepick.h"
 #include "thread.h"

 namespace {

-  enum Sequencer {
+  enum Stages {
    MAIN_SEARCH, CAPTURES_S1, KILLERS_S1, QUIETS_1_S1, QUIETS_2_S1, BAD_CAPTURES_S1,
    EVASION,     EVASIONS_S2,
    QSEARCH_0,   CAPTURES_S3, QUIET_CHECKS_S3,
@@ -37,14 +35,28 @@ namespace {
    STOP
  };

+  // Our insertion sort, guaranteed to be stable, as is needed
+  void insertion_sort(ExtMove* begin, ExtMove* end)
+  {
+    ExtMove tmp, *p, *q;
+
+    for (p = begin + 1; p < end; ++p)
+    {
+        tmp = *p;
+        for (q = p; q != begin && *(q-1) < tmp; --q)
+            *q = *(q-1);
+        *q = tmp;
+    }
+  }
+
  // Unary predicate used by std::partition to split positive scores from remaining
  // ones so to sort separately the two sets, and with the second sort delayed.
-  inline bool has_positive_score(const MoveStack& ms) { return ms.score > 0; }
+  inline bool has_positive_score(const ExtMove& ms) { return ms.score > 0; }

  // Picks and moves to the front the best move in the range [begin, end),
  // it is faster than sorting all the moves in advance when moves are few, as
  // normally are the possible captures.
-  inline MoveStack* pick_best(MoveStack* begin, MoveStack* end)
+  inline ExtMove* pick_best(ExtMove* begin, ExtMove* end)
  {
      std::swap(*begin, *std::max_element(begin, end));
      return begin;
@@ -58,53 +70,40 @@ namespace {
 /// search captures, promotions and some checks) and about how important good
 /// move ordering is at the current node.

-MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
-                       Search::Stack* s, Value beta) : pos(p), H(h), depth(d) {
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& h,
+                       Move* cm, Search::Stack* s) : pos(p), history(h), depth(d) {

  assert(d > DEPTH_ZERO);

-  captureThreshold = 0;
  cur = end = moves;
  endBadCaptures = moves + MAX_MOVES - 1;
+  countermoves = cm;
  ss = s;

-  if (p.in_check())
-      phase = EVASION;
+  if (p.checkers())
+      stage = EVASION;

  else
-  {
-      phase = MAIN_SEARCH;
-
-      killers[0].move = ss->killers[0];
-      killers[1].move = ss->killers[1];
-
-      // Consider sligtly negative captures as good if at low depth and far from beta
-      if (ss && ss->eval < beta - PawnValueMg && d < 3 * ONE_PLY)
-          captureThreshold = -PawnValueMg;
-
-      // Consider negative captures as good if still enough to reach beta
-      else if (ss && ss->eval > beta)
-          captureThreshold = beta - ss->eval;
-  }
+      stage = MAIN_SEARCH;

  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);
  end += (ttMove != MOVE_NONE);
 }

-MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
-                       Square sq) : pos(p), H(h), cur(moves), end(moves) {
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& h,
+                       Square sq) : pos(p), history(h), cur(moves), end(moves) {

  assert(d <= DEPTH_ZERO);

-  if (p.in_check())
-      phase = EVASION;
+  if (p.checkers())
+      stage = EVASION;

  else if (d > DEPTH_QS_NO_CHECKS)
-      phase = QSEARCH_0;
+      stage = QSEARCH_0;

  else if (d > DEPTH_QS_RECAPTURES)
  {
-      phase = QSEARCH_1;
+      stage = QSEARCH_1;

      // Skip TT move if is not a capture or a promotion, this avoids qsearch
      // tree explosion due to a possible perpetual check or similar rare cases
@@ -114,7 +113,7 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
  }
  else
  {
-      phase = RECAPTURE;
+      stage = RECAPTURE;
      recaptureSquare = sq;
      ttm = MOVE_NONE;
  }
@@ -123,15 +122,15 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
  end += (ttMove != MOVE_NONE);
 }

-MovePicker::MovePicker(const Position& p, Move ttm, const History& h, PieceType pt)
-                       : pos(p), H(h), cur(moves), end(moves) {
+MovePicker::MovePicker(const Position& p, Move ttm, const HistoryStats& h, PieceType pt)
+                       : pos(p), history(h), cur(moves), end(moves) {

-  assert(!pos.in_check());
+  assert(!pos.checkers());

-  phase = PROBCUT;
+  stage = PROBCUT;

  // In ProbCut we generate only captures better than parent's captured piece
-  captureThreshold = PieceValue[Mg][pt];
+  captureThreshold = PieceValue[MG][pt];
  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);

  if (ttMove && (!pos.is_capture(ttMove) ||  pos.see(ttMove) <= captureThreshold))
@@ -141,12 +140,10 @@ MovePicker::MovePicker(const Position& p, Move ttm, const History& h, PieceType
 }


-/// MovePicker::score_captures(), MovePicker::score_noncaptures() and
-/// MovePicker::score_evasions() assign a numerical move ordering score
-/// to each move in a move list.  The moves with highest scores will be
-/// picked first by next_move().
-
-void MovePicker::score_captures() {
+/// score() assign a numerical move ordering score to each move in a move list.
+/// The moves with highest scores will be picked first.
+template<>
+void MovePicker::score<CAPTURES>() {
  // Winning and equal captures in the main search are ordered by MVV/LVA.
  // Suprisingly, this appears to perform slightly better than SEE based
  // move ordering. The reason is probably that in a position with a winning
@@ -162,83 +159,99 @@ void MovePicker::score_captures() {
  // some SEE calls in case we get a cutoff (idea from Pablo Vazquez).
  Move m;

-  for (MoveStack* it = moves; it != end; ++it)
+  for (ExtMove* it = moves; it != end; ++it)
  {
      m = it->move;
-      it->score =  PieceValue[Mg][pos.piece_on(to_sq(m))]
+      it->score =  PieceValue[MG][pos.piece_on(to_sq(m))]
                 - type_of(pos.piece_moved(m));

      if (type_of(m) == PROMOTION)
-          it->score += PieceValue[Mg][promotion_type(m)];
+          it->score += PieceValue[MG][promotion_type(m)] - PieceValue[MG][PAWN];
+
+      else if (type_of(m) == ENPASSANT)
+          it->score += PieceValue[MG][PAWN];
  }
 }

-void MovePicker::score_noncaptures() {
+template<>
+void MovePicker::score<QUIETS>() {

  Move m;

-  for (MoveStack* it = moves; it != end; ++it)
+  for (ExtMove* it = moves; it != end; ++it)
  {
      m = it->move;
-      it->score = H.value(pos.piece_moved(m), to_sq(m));
+      it->score = history[pos.piece_moved(m)][to_sq(m)];
  }
 }

-void MovePicker::score_evasions() {
+template<>
+void MovePicker::score<EVASIONS>() {
  // Try good captures ordered by MVV/LVA, then non-captures if destination square
  // is not under attack, ordered by history value, then bad-captures and quiet
  // moves with a negative SEE. This last group is ordered by the SEE score.
  Move m;
  int seeScore;

-  if (end < moves + 2)
-      return;
-
-  for (MoveStack* it = moves; it != end; ++it)
+  for (ExtMove* it = moves; it != end; ++it)
  {
      m = it->move;
      if ((seeScore = pos.see_sign(m)) < 0)
-          it->score = seeScore - History::MaxValue; // Be sure we are at the bottom
+          it->score = seeScore - HistoryStats::Max; // At the bottom
+
      else if (pos.is_capture(m))
-          it->score =  PieceValue[Mg][pos.piece_on(to_sq(m))]
-                     - type_of(pos.piece_moved(m)) + History::MaxValue;
+          it->score =  PieceValue[MG][pos.piece_on(to_sq(m))]
+                     - type_of(pos.piece_moved(m)) + HistoryStats::Max;
      else
-          it->score = H.value(pos.piece_moved(m), to_sq(m));
+          it->score = history[pos.piece_moved(m)][to_sq(m)];
  }
 }


-/// MovePicker::generate_next() generates, scores and sorts the next bunch of moves,
-/// when there are no more moves to try for the current phase.
+/// generate_next() generates, scores and sorts the next bunch of moves, when
+/// there are no more moves to try for the current phase.

 void MovePicker::generate_next() {

  cur = moves;

-  switch (++phase) {
+  switch (++stage) {

  case CAPTURES_S1: case CAPTURES_S3: case CAPTURES_S4: case CAPTURES_S5: case CAPTURES_S6:
      end = generate<CAPTURES>(pos, moves);
-      score_captures();
+      score<CAPTURES>();
      return;

  case KILLERS_S1:
      cur = killers;
      end = cur + 2;
+
+      killers[0].move = ss->killers[0];
+      killers[1].move = ss->killers[1];
+      killers[2].move = killers[3].move = MOVE_NONE;
+
+      // Be sure countermoves are different from killers
+      for (int i = 0; i < 2; i++)
+          if (countermoves[i] != cur->move && countermoves[i] != (cur+1)->move)
+              (end++)->move = countermoves[i];
+
+      if (countermoves[1] && countermoves[1] == countermoves[0]) // Due to SMP races
+          killers[3].move = MOVE_NONE;
+
      return;

  case QUIETS_1_S1:
      endQuiets = end = generate<QUIETS>(pos, moves);
-      score_noncaptures();
+      score<QUIETS>();
      end = std::partition(cur, end, has_positive_score);
-      sort<MoveStack>(cur, end);
+      insertion_sort(cur, end);
      return;

  case QUIETS_2_S1:
      cur = end;
      end = endQuiets;
      if (depth >= 3 * ONE_PLY)
-          sort<MoveStack>(cur, end);
+          insertion_sort(cur, end);
      return;

  case BAD_CAPTURES_S1:
@@ -249,7 +262,8 @@ void MovePicker::generate_next() {

  case EVASIONS_S2:
      end = generate<EVASIONS>(pos, moves);
-      score_evasions();
+      if (end > moves + 1)
+          score<EVASIONS>();
      return;

  case QUIET_CHECKS_S3:
@@ -257,7 +271,7 @@ void MovePicker::generate_next() {
      return;

  case EVASION: case QSEARCH_0: case QSEARCH_1: case PROBCUT: case RECAPTURE:
-      phase = STOP;
+      stage = STOP;
  case STOP:
      end = cur + 1; // Avoid another next_phase() call
      return;
@@ -268,11 +282,10 @@ void MovePicker::generate_next() {
 }


-/// MovePicker::next_move() is the most important method of the MovePicker class.
-/// It returns a new pseudo legal move every time it is called, until there
-/// are no more moves left. It picks the move with the biggest score from a list
-/// of generated moves taking care not to return the tt move if has already been
-/// searched previously.
+/// next_move() is the most important method of the MovePicker class. It returns
+/// a new pseudo legal move every time is called, until there are no more moves
+/// left. It picks the move with the biggest score from a list of generated moves
+/// taking care not returning the ttMove if has already been searched previously.
 template<>
 Move MovePicker::next_move<false>() {

@@ -283,7 +296,7 @@ Move MovePicker::next_move<false>() {
      while (cur == end)
          generate_next();

-      switch (phase) {
+      switch (stage) {

      case MAIN_SEARCH: case EVASION: case QSEARCH_0: case QSEARCH_1: case PROBCUT:
          cur++;
@@ -293,9 +306,7 @@ Move MovePicker::next_move<false>() {
          move = pick_best(cur++, end)->move;
          if (move != ttMove)
          {
-              assert(captureThreshold <= 0); // Otherwise we cannot use see_sign()
-
-              if (pos.see_sign(move) >= captureThreshold)
+              if (pos.see_sign(move) >= 0)
                  return move;

              // Losing capture, move it to the tail of the array
@@ -316,7 +327,9 @@ Move MovePicker::next_move<false>() {
          move = (cur++)->move;
          if (   move != ttMove
              && move != killers[0].move
-              && move != killers[1].move)
+              && move != killers[1].move
+              && move != killers[2].move
+              && move != killers[3].move)
              return move;
          break;

@@ -359,6 +372,6 @@ Move MovePicker::next_move<false>() {

 /// Version of next_move() to use at split point nodes where the move is grabbed
 /// from the split point's shared MovePicker object. This function is not thread
-/// safe so should be lock protected by the caller.
+/// safe so must be lock protected by the caller.
 template<>
-Move MovePicker::next_move<true>() { return ss->sp->mp->next_move<false>(); }
+Move MovePicker::next_move<true>() { return ss->splitPoint->movePicker->next_move<false>(); }
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,15 +17,61 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined MOVEPICK_H_INCLUDED
+#ifndef MOVEPICK_H_INCLUDED
 #define MOVEPICK_H_INCLUDED

-#include "history.h"
+#include <algorithm> // For std::max
+#include <cstring>   // For std::memset
+
+#include "movegen.h"
 #include "position.h"
 #include "search.h"
 #include "types.h"


+/// The Stats struct stores moves statistics. According to the template parameter
+/// the class can store History, Gains and Countermoves. History records how often
+/// different moves have been successful or unsuccessful during the current search
+/// and is used for reduction and move ordering decisions. Gains records the move's
+/// best evaluation gain from one ply to the next and is used for pruning decisions.
+/// Countermoves store the move that refute a previous one. Entries are stored
+/// according only to moving piece and destination square, hence two moves with
+/// different origin but same destination and piece will be considered identical.
+template<bool Gain, typename T>
+struct Stats {
+
+  static const Value Max = Value(2000);
+
+  const T* operator[](Piece p) const { return table[p]; }
+  void clear() { std::memset(table, 0, sizeof(table)); }
+
+  void update(Piece p, Square to, Move m) {
+
+    if (m == table[p][to].first)
+        return;
+
+    table[p][to].second = table[p][to].first;
+    table[p][to].first = m;
+  }
+
+  void update(Piece p, Square to, Value v) {
+
+    if (Gain)
+        table[p][to] = std::max(v, table[p][to] - 1);
+
+    else if (abs(table[p][to] + v) < Max)
+        table[p][to] +=  v;
+  }
+
+private:
+  T table[PIECE_NB][SQUARE_NB];
+};
+
+typedef Stats< true, Value> GainsStats;
+typedef Stats<false, Value> HistoryStats;
+typedef Stats<false, std::pair<Move, Move> > CountermovesStats;
+
+
 /// MovePicker class is used to pick one pseudo legal move at a time from the
 /// current position. The most important method is next_move(), which returns a
 /// new pseudo legal move each time it is called, until there are no moves left,
@@ -38,27 +84,27 @@ class MovePicker {
  MovePicker& operator=(const MovePicker&); // Silence a warning under MSVC

 public:
-  MovePicker(const Position&, Move, Depth, const History&, Search::Stack*, Value);
-  MovePicker(const Position&, Move, Depth, const History&, Square);
-  MovePicker(const Position&, Move, const History&, PieceType);
+  MovePicker(const Position&, Move, Depth, const HistoryStats&, Square);
+  MovePicker(const Position&, Move, const HistoryStats&, PieceType);
+  MovePicker(const Position&, Move, Depth, const HistoryStats&, Move*, Search::Stack*);
+
  template<bool SpNode> Move next_move();

 private:
-  void score_captures();
-  void score_noncaptures();
-  void score_evasions();
+  template<GenType> void score();
  void generate_next();

  const Position& pos;
-  const History& H;
+  const HistoryStats& history;
  Search::Stack* ss;
+  Move* countermoves;
  Depth depth;
  Move ttMove;
-  MoveStack killers[2];
+  ExtMove killers[4];
  Square recaptureSquare;
-  int captureThreshold, phase;
-  MoveStack *cur, *end, *endQuiets, *endBadCaptures;
-  MoveStack moves[MAX_MOVES];
+  int captureThreshold, stage;
+  ExtMove *cur, *end, *endQuiets, *endBadCaptures;
+  ExtMove moves[MAX_MOVES];
 };

-#endif // !defined(MOVEPICK_H_INCLUDED)
+#endif // #ifndef MOVEPICK_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -20,7 +20,7 @@
 #include <cassert>
 #include <iomanip>
 #include <sstream>
-#include <string>
+#include <stack>

 #include "movegen.h"
 #include "notation.h"
@@ -28,7 +28,7 @@

 using namespace std;

-static const char* PieceToChar = " PNBRQK  pnbrqk";
+static const char* PieceToChar[COLOR_NB] = { " PNBRQK", " pnbrqk" };


 /// score_to_uci() converts a value to a string suitable for use with the UCI
@@ -75,7 +75,7 @@ const string move_to_uci(Move m, bool chess960) {
  string move = square_to_string(from) + square_to_string(to);

  if (type_of(m) == PROMOTION)
-      move += PieceToChar[make_piece(BLACK, promotion_type(m))]; // Lower case
+      move += PieceToChar[BLACK][promotion_type(m)]; // Lower case

  return move;
 }
@@ -89,9 +89,9 @@ Move move_from_uci(const Position& pos, string& str) {
  if (str.length() == 5) // Junior could send promotion piece in uppercase
      str[4] = char(tolower(str[4]));

-  for (MoveList<LEGAL> ml(pos); !ml.end(); ++ml)
-      if (str == move_to_uci(ml.move(), pos.is_chess960()))
-          return ml.move();
+  for (MoveList<LEGAL> it(pos); *it; ++it)
+      if (str == move_to_uci(*it, pos.is_chess960()))
+          return *it;

  return MOVE_NONE;
 }
@@ -108,10 +108,9 @@ const string move_to_san(Position& pos, Move m) {
  if (m == MOVE_NULL)
      return "(null)";

-  assert(pos.move_is_legal(m));
+  assert(MoveList<LEGAL>(pos).contains(m));

-  Bitboard attackers;
-  bool ambiguousMove, ambiguousFile, ambiguousRank;
+  Bitboard others, b;
  string san;
  Color us = pos.side_to_move();
  Square from = from_sq(m);
@@ -125,33 +124,25 @@ const string move_to_san(Position& pos, Move m) {
  {
      if (pt != PAWN)
      {
-          san = PieceToChar[pt]; // Upper case
+          san = PieceToChar[WHITE][pt]; // Upper case

-          // Disambiguation if we have more then one piece with destination 'to'
-          // note that for pawns is not needed because starting file is explicit.
-          ambiguousMove = ambiguousFile = ambiguousRank = false;
+          // Disambiguation if we have more then one piece of type 'pt' that can
+          // reach 'to' with a legal move.
+          others = b = (pos.attacks_from(pc, to) & pos.pieces(us, pt)) ^ from;

-          attackers = (pos.attacks_from(pc, to) & pos.pieces(us, pt)) ^ from;
-
-          while (attackers)
+          while (b)
          {
-              Square sq = pop_lsb(&attackers);
-
-              // Pinned pieces are not included in the possible sub-set
-              if (!pos.pl_move_is_legal(make_move(sq, to), pos.pinned_pieces()))
-                  continue;
-
-              ambiguousFile |= file_of(sq) == file_of(from);
-              ambiguousRank |= rank_of(sq) == rank_of(from);
-              ambiguousMove = true;
+              Move move = make_move(pop_lsb(&b), to);
+              if (!pos.pl_move_is_legal(move, pos.pinned_pieces()))
+                  others ^= from_sq(move);
          }

-          if (ambiguousMove)
+          if (others)
          {
-              if (!ambiguousFile)
+              if (!(others & file_bb(from)))
                  san += file_to_char(file_of(from));

-              else if (!ambiguousRank)
+              else if (!(others & rank_bb(from)))
                  san += rank_to_char(rank_of(from));

              else
@@ -167,7 +158,7 @@ const string move_to_san(Position& pos, Move m) {
      san += square_to_string(to);

      if (type_of(m) == PROMOTION)
-          san += string("=") + PieceToChar[promotion_type(m)];
+          san += string("=") + PieceToChar[WHITE][promotion_type(m)];
  }

  if (pos.move_gives_check(m, CheckInfo(pos)))
@@ -226,7 +217,7 @@ string pretty_pv(Position& pos, int depth, Value value, int64_t msecs, Move pv[]
  const int64_t K = 1000;
  const int64_t M = 1000000;

-  StateInfo state[MAX_PLY_PLUS_2], *st = state;
+  std::stack<StateInfo> st;
  Move* m = pv;
  string san, padding;
  size_t length;
@@ -261,7 +252,8 @@ string pretty_pv(Position& pos, int depth, Value value, int64_t msecs, Move pv[]
      s << san << ' ';
      length += san.length() + 1;

-      pos.do_move(*m++, *st++);
+      st.push(StateInfo());
+      pos.do_move(*m++, st.top());
  }

  while (m != pv)
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(NOTATION_H_INCLUDED)
+#ifndef NOTATION_H_INCLUDED
 #define NOTATION_H_INCLUDED

 #include <string>
@@ -32,4 +32,4 @@ const std::string move_to_uci(Move m, bool chess960);
 const std::string move_to_san(Position& pos, Move m);
 std::string pretty_pv(Position& pos, int depth, Value score, int64_t msecs, Move pv[]);

-#endif // !defined(NOTATION_H_INCLUDED)
+#endif // #ifndef NOTATION_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,6 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

+#include <algorithm>
 #include <cassert>

 #include "bitboard.h"
@@ -30,49 +31,48 @@ namespace {
  #define S(mg, eg) make_score(mg, eg)

  // Doubled pawn penalty by opposed flag and file
-  const Score DoubledPawnPenalty[2][8] = {
+  const Score Doubled[2][FILE_NB] = {
  { S(13, 43), S(20, 48), S(23, 48), S(23, 48),
    S(23, 48), S(23, 48), S(20, 48), S(13, 43) },
  { S(13, 43), S(20, 48), S(23, 48), S(23, 48),
    S(23, 48), S(23, 48), S(20, 48), S(13, 43) }};

  // Isolated pawn penalty by opposed flag and file
-  const Score IsolatedPawnPenalty[2][8] = {
+  const Score Isolated[2][FILE_NB] = {
  { S(37, 45), S(54, 52), S(60, 52), S(60, 52),
    S(60, 52), S(60, 52), S(54, 52), S(37, 45) },
  { S(25, 30), S(36, 35), S(40, 35), S(40, 35),
    S(40, 35), S(40, 35), S(36, 35), S(25, 30) }};

  // Backward pawn penalty by opposed flag and file
-  const Score BackwardPawnPenalty[2][8] = {
+  const Score Backward[2][FILE_NB] = {
  { S(30, 42), S(43, 46), S(49, 46), S(49, 46),
    S(49, 46), S(49, 46), S(43, 46), S(30, 42) },
  { S(20, 28), S(29, 31), S(33, 31), S(33, 31),
    S(33, 31), S(33, 31), S(29, 31), S(20, 28) }};

  // Pawn chain membership bonus by file
-  const Score ChainBonus[8] = {
+  const Score ChainMember[FILE_NB] = {
    S(11,-1), S(13,-1), S(13,-1), S(14,-1),
    S(14,-1), S(13,-1), S(13,-1), S(11,-1)
  };

  // Candidate passed pawn bonus by rank
-  const Score CandidateBonus[8] = {
+  const Score CandidatePassed[RANK_NB] = {
    S( 0, 0), S( 6, 13), S(6,13), S(14,29),
    S(34,68), S(83,166), S(0, 0), S( 0, 0)
  };

-  const Score PawnStructureWeight = S(233, 201);
+  // Weakness of our pawn shelter in front of the king indexed by [rank]
+  const Value ShelterWeakness[RANK_NB] =
+  { V(100), V(0), V(27), V(73), V(92), V(101), V(101) };

-  // Weakness of our pawn shelter in front of the king indexed by [king pawn][rank]
-  const Value ShelterWeakness[2][8] =
-  { { V(141), V(0), V(38), V(102), V(128), V(141), V(141) },
-    { V( 61), V(0), V(16), V( 44), V( 56), V( 61), V( 61) } };
-
-  // Danger of enemy pawns moving toward our king indexed by [pawn blocked][rank]
-  const Value StormDanger[2][8] =
-  { { V(26), V(0), V(128), V(51), V(26) },
-    { V(13), V(0), V( 64), V(25), V(13) } };
+  // Danger of enemy pawns moving toward our king indexed by
+  // [no friendly pawn | pawn unblocked | pawn blocked][rank of enemy pawn]
+  const Value StormDanger[3][RANK_NB] = {
+  { V( 0),  V(64), V(128), V(51), V(26) },
+  { V(26),  V(32), V( 96), V(38), V(20) },
+  { V( 0),  V( 0), V( 64), V(25), V(13) }};

  // Max bonus for king safety. Corresponds to start position with all the pawns
  // in front of the king and no enemy pawn on the horizont.
@@ -80,184 +80,176 @@ namespace {

  #undef S
  #undef V
-}

+  template<Color Us>
+  Score evaluate(const Position& pos, Pawns::Entry* e) {

-/// PawnTable::probe() takes a position object as input, computes a PawnEntry
-/// 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.
+    const Color  Them  = (Us == WHITE ? BLACK    : WHITE);
+    const Square Up    = (Us == WHITE ? DELTA_N  : DELTA_S);
+    const Square Right = (Us == WHITE ? DELTA_NE : DELTA_SW);
+    const Square Left  = (Us == WHITE ? DELTA_NW : DELTA_SE);

-PawnEntry* PawnTable::probe(const Position& pos) {
+    Bitboard b;
+    Square s;
+    File f;
+    Rank r;
+    bool passed, isolated, doubled, opposed, chain, backward, candidate;
+    Score value = SCORE_ZERO;
+    const Square* pl = pos.list<PAWN>(Us);
+
+    Bitboard ourPawns = pos.pieces(Us, PAWN);
+    Bitboard theirPawns = pos.pieces(Them, PAWN);
+
+    e->passedPawns[Us] = 0;
+    e->kingSquares[Us] = SQ_NONE;
+    e->semiopenFiles[Us] = 0xFF;
+    e->pawnAttacks[Us] = shift_bb<Right>(ourPawns) | shift_bb<Left>(ourPawns);
+    e->pawnsOnSquares[Us][BLACK] = popcount<Max15>(ourPawns & DarkSquares);
+    e->pawnsOnSquares[Us][WHITE] = pos.count<PAWN>(Us) - e->pawnsOnSquares[Us][BLACK];
+
+    // Loop through all pawns of the current color and score each pawn
+    while ((s = *pl++) != SQ_NONE)
+    {
+        assert(pos.piece_on(s) == make_piece(Us, PAWN));
+
+        f = file_of(s);
+        r = rank_of(s);
+
+        // This file cannot be semi-open
+        e->semiopenFiles[Us] &= ~(1 << f);
+
+        // Our rank plus previous one. Used for chain detection
+        b = rank_bb(r) | rank_bb(Us == WHITE ? r - Rank(1) : r + Rank(1));
+
+        // Flag the pawn as passed, isolated, doubled or member of a pawn
+        // chain (but not the backward one).
+        chain    =   ourPawns   & adjacent_files_bb(f) & b;
+        isolated = !(ourPawns   & adjacent_files_bb(f));
+        doubled  =   ourPawns   & forward_bb(Us, s);
+        opposed  =   theirPawns & forward_bb(Us, s);
+        passed   = !(theirPawns & passed_pawn_mask(Us, s));
+
+        // Test for backward pawn
+        backward = false;
+
+        // If the pawn is passed, isolated, or member of a pawn chain it cannot
+        // be backward. If there are friendly pawns behind on adjacent files
+        // or if can capture an enemy pawn it cannot be backward either.
+        if (   !(passed | isolated | chain)
+            && !(ourPawns & pawn_attack_span(Them, s))
+            && !(pos.attacks_from<PAWN>(s, Us) & theirPawns))
+        {
+            // We now know that there are no friendly pawns beside or behind this
+            // pawn on adjacent files. We now check whether the pawn is
+            // backward by looking in the forward direction on the adjacent
+            // files, and seeing whether we meet a friendly or an enemy pawn first.
+            b = pos.attacks_from<PAWN>(s, Us);
+
+            // Note that we are sure to find something because pawn is not passed
+            // nor isolated, so loop is potentially infinite, but it isn't.
+            while (!(b & (ourPawns | theirPawns)))
+                b = shift_bb<Up>(b);
+
+            // The friendly pawn needs to be at least two ranks closer than the
+            // enemy pawn in order to help the potentially backward pawn advance.
+            backward = (b | shift_bb<Up>(b)) & theirPawns;
+        }
+
+        assert(opposed | passed | (pawn_attack_span(Us, s) & theirPawns));
+
+        // A not passed pawn is a candidate to become passed if it is free to
+        // advance and if the number of friendly pawns beside or behind this
+        // pawn on adjacent files is higher or equal than the number of
+        // enemy pawns in the forward direction on the adjacent files.
+        candidate =   !(opposed | passed | backward | isolated)
+                   && (b = pawn_attack_span(Them, s + pawn_push(Us)) & ourPawns) != 0
+                   &&  popcount<Max15>(b) >= popcount<Max15>(pawn_attack_span(Us, s) & theirPawns);
+
+        // Passed pawns will be properly scored in evaluation because we need
+        // full attack info to evaluate passed pawns. Only the frontmost passed
+        // pawn on each file is considered a true passed pawn.
+        if (passed && !doubled)
+            e->passedPawns[Us] |= s;
+
+        // Score this pawn
+        if (isolated)
+            value -= Isolated[opposed][f];
+
+        if (doubled)
+            value -= Doubled[opposed][f];
+
+        if (backward)
+            value -= Backward[opposed][f];
+
+        if (chain)
+            value += ChainMember[f];
+
+        if (candidate)
+            value += CandidatePassed[relative_rank(Us, s)];
+    }
+
+    return value;
+  }
+
+} // namespace
+
+namespace Pawns {
+
+/// probe() takes a position object as input, computes a Entry 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.
+
+Entry* probe(const Position& pos, Table& entries) {

  Key key = pos.pawn_key();
-  PawnEntry* e = entries[key];
+  Entry* e = entries[key];

-  // If e->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 (e->key == key)
      return e;

  e->key = key;
-  e->passedPawns[WHITE] = e->passedPawns[BLACK] = 0;
-  e->kingSquares[WHITE] = e->kingSquares[BLACK] = SQ_NONE;
-  e->halfOpenFiles[WHITE] = e->halfOpenFiles[BLACK] = 0xFF;
-
-  Bitboard wPawns = pos.pieces(WHITE, PAWN);
-  Bitboard bPawns = pos.pieces(BLACK, PAWN);
-  e->pawnAttacks[WHITE] = ((wPawns & ~FileHBB) << 9) | ((wPawns & ~FileABB) << 7);
-  e->pawnAttacks[BLACK] = ((bPawns & ~FileHBB) >> 7) | ((bPawns & ~FileABB) >> 9);
-
-  e->value =  evaluate_pawns<WHITE>(pos, wPawns, bPawns, e)
-            - evaluate_pawns<BLACK>(pos, bPawns, wPawns, e);
-
-  e->value = apply_weight(e->value, PawnStructureWeight);
-
+  e->value = evaluate<WHITE>(pos, e) - evaluate<BLACK>(pos, e);
  return e;
 }


-/// PawnTable::evaluate_pawns() evaluates each pawn of the given color
-
-template<Color Us>
-Score PawnTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
-                                Bitboard theirPawns, PawnEntry* e) {
-
-  const Color Them = (Us == WHITE ? BLACK : WHITE);
-
-  Bitboard b;
-  Square s;
-  File f;
-  Rank r;
-  bool passed, isolated, doubled, opposed, chain, backward, candidate;
-  Score value = SCORE_ZERO;
-  const Square* pl = pos.piece_list(Us, PAWN);
-
-  // Loop through all pawns of the current color and score each pawn
-  while ((s = *pl++) != SQ_NONE)
-  {
-      assert(pos.piece_on(s) == make_piece(Us, PAWN));
-
-      f = file_of(s);
-      r = rank_of(s);
-
-      // This file cannot be half open
-      e->halfOpenFiles[Us] &= ~(1 << f);
-
-      // Our rank plus previous one. Used for chain detection
-      b = rank_bb(r) | rank_bb(Us == WHITE ? r - Rank(1) : r + Rank(1));
-
-      // Flag the pawn as passed, isolated, doubled or member of a pawn
-      // chain (but not the backward one).
-      chain    =   ourPawns   & adjacent_files_bb(f) & b;
-      isolated = !(ourPawns   & adjacent_files_bb(f));
-      doubled  =   ourPawns   & forward_bb(Us, s);
-      opposed  =   theirPawns & forward_bb(Us, s);
-      passed   = !(theirPawns & passed_pawn_mask(Us, s));
-
-      // Test for backward pawn
-      backward = false;
-
-      // If the pawn is passed, isolated, or member of a pawn chain it cannot
-      // be backward. If there are friendly pawns behind on adjacent files
-      // or if can capture an enemy pawn it cannot be backward either.
-      if (   !(passed | isolated | chain)
-          && !(ourPawns & attack_span_mask(Them, s))
-          && !(pos.attacks_from<PAWN>(s, Us) & theirPawns))
-      {
-          // We now know that there are no friendly pawns beside or behind this
-          // pawn on adjacent files. We now check whether the pawn is
-          // backward by looking in the forward direction on the adjacent
-          // files, and seeing whether we meet a friendly or an enemy pawn first.
-          b = pos.attacks_from<PAWN>(s, Us);
-
-          // Note that we are sure to find something because pawn is not passed
-          // nor isolated, so loop is potentially infinite, but it isn't.
-          while (!(b & (ourPawns | theirPawns)))
-              Us == WHITE ? b <<= 8 : b >>= 8;
-
-          // The friendly pawn needs to be at least two ranks closer than the
-          // enemy pawn in order to help the potentially backward pawn advance.
-          backward = (b | (Us == WHITE ? b << 8 : b >> 8)) & theirPawns;
-      }
-
-      assert(opposed | passed | (attack_span_mask(Us, s) & theirPawns));
-
-      // A not passed pawn is a candidate to become passed if it is free to
-      // advance and if the number of friendly pawns beside or behind this
-      // pawn on adjacent files is higher or equal than the number of
-      // enemy pawns in the forward direction on the adjacent files.
-      candidate =   !(opposed | passed | backward | isolated)
-                 && (b = attack_span_mask(Them, s + pawn_push(Us)) & ourPawns) != 0
-                 &&  popcount<Max15>(b) >= popcount<Max15>(attack_span_mask(Us, s) & theirPawns);
-
-      // Passed pawns will be properly scored in evaluation because we need
-      // full attack info to evaluate passed pawns. Only the frontmost passed
-      // pawn on each file is considered a true passed pawn.
-      if (passed && !doubled)
-          e->passedPawns[Us] |= s;
-
-      // Score this pawn
-      if (isolated)
-          value -= IsolatedPawnPenalty[opposed][f];
-
-      if (doubled)
-          value -= DoubledPawnPenalty[opposed][f];
-
-      if (backward)
-          value -= BackwardPawnPenalty[opposed][f];
-
-      if (chain)
-          value += ChainBonus[f];
-
-      if (candidate)
-          value += CandidateBonus[relative_rank(Us, s)];
-  }
-
-  return value;
-}
-
-
-/// PawnEntry::shelter_storm() calculates shelter and storm penalties for the file
+/// Entry::shelter_storm() calculates shelter and storm penalties for the file
 /// the king is on, as well as the two adjacent files.

 template<Color Us>
-Value PawnEntry::shelter_storm(const Position& pos, Square ksq) {
+Value Entry::shelter_storm(const Position& pos, Square ksq) {

  const Color Them = (Us == WHITE ? BLACK : WHITE);

  Value safety = MaxSafetyBonus;
-  Bitboard b = pos.pieces(PAWN) & (in_front_bb(Us, ksq) | rank_bb(ksq));
-  Bitboard ourPawns = b & pos.pieces(Us) & ~rank_bb(ksq);
+  Bitboard b = pos.pieces(PAWN) & (in_front_bb(Us, rank_of(ksq)) | rank_bb(ksq));
+  Bitboard ourPawns = b & pos.pieces(Us);
  Bitboard theirPawns = b & pos.pieces(Them);
  Rank rkUs, rkThem;
  File kf = file_of(ksq);

-  kf = (kf == FILE_A) ? kf++ : (kf == FILE_H) ? kf-- : kf;
+  kf = (kf == FILE_A) ? FILE_B : (kf == FILE_H) ? FILE_G : kf;

  for (int f = kf - 1; f <= kf + 1; f++)
  {
-      // Shelter penalty is higher for the pawn in front of the king
      b = ourPawns & FileBB[f];
-      rkUs = b ? rank_of(Us == WHITE ? lsb(b) : ~msb(b)) : RANK_1;
-      safety -= ShelterWeakness[f != kf][rkUs];
+      rkUs = b ? relative_rank(Us, Us == WHITE ? lsb(b) : msb(b)) : RANK_1;
+      safety -= ShelterWeakness[rkUs];

-      // Storm danger is smaller if enemy pawn is blocked
      b  = theirPawns & FileBB[f];
-      rkThem = b ? rank_of(Us == WHITE ? lsb(b) : ~msb(b)) : RANK_1;
-      safety -= StormDanger[rkThem == rkUs + 1][rkThem];
+      rkThem = b ? relative_rank(Us, Us == WHITE ? lsb(b) : msb(b)) : RANK_1;
+      safety -= StormDanger[rkUs == RANK_1 ? 0 : rkThem == rkUs + 1 ? 2 : 1][rkThem];
  }

  return safety;
 }


-/// PawnEntry::update_safety() calculates and caches a bonus for king safety. It is
+/// Entry::update_safety() calculates and caches a bonus for king safety. It is
 /// called only when king square changes, about 20% of total king_safety() calls.

 template<Color Us>
-Score PawnEntry::update_safety(const Position& pos, Square ksq) {
+Score Entry::update_safety(const Position& pos, Square ksq) {

  kingSquares[Us] = ksq;
  castleRights[Us] = pos.can_castle(Us);
@@ -283,5 +275,7 @@ Score PawnEntry::update_safety(const Position& pos, Square ksq) {
 }

 // Explicit template instantiation
-template Score PawnEntry::update_safety<WHITE>(const Position& pos, Square ksq);
-template Score PawnEntry::update_safety<BLACK>(const Position& pos, Square ksq);
+template Score Entry::update_safety<WHITE>(const Position& pos, Square ksq);
+template Score Entry::update_safety<BLACK>(const Position& pos, Square ksq);
+
+} // namespace Pawns
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,38 +17,40 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(PAWNS_H_INCLUDED)
+#ifndef PAWNS_H_INCLUDED
 #define PAWNS_H_INCLUDED

 #include "misc.h"
 #include "position.h"
 #include "types.h"

-const int PawnTableSize = 16384;
+namespace Pawns {

-/// PawnEntry 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 probe method in a PawnTable object)
-/// returns a pointer to a PawnEntry object.
+/// Pawns::Entry contains various information about a pawn structure. Currently,
+/// it only includes a middle game and 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 probe function)
+/// returns a pointer to an Entry object.

-class PawnEntry {
+struct Entry {

-  friend struct PawnTable;
+  Score pawns_value() const { return value; }
+  Bitboard pawn_attacks(Color c) const { return pawnAttacks[c]; }
+  Bitboard passed_pawns(Color c) const { return passedPawns[c]; }
+  int pawns_on_same_color_squares(Color c, Square s) const { return pawnsOnSquares[c][!!(DarkSquares & s)]; }
+  int semiopen(Color c, File f) const { return semiopenFiles[c] & (1 << int(f)); }
+  int semiopen_on_side(Color c, File f, bool left) const {

-public:
-  Score pawns_value() const;
-  Bitboard pawn_attacks(Color c) const;
-  Bitboard passed_pawns(Color c) 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;
+    return semiopenFiles[c] & (left ? ((1 << int(f)) - 1) : ~((1 << int(f+1)) - 1));
+  }

  template<Color Us>
-  Score king_safety(const Position& pos, Square ksq);
+  Score king_safety(const Position& pos, Square ksq)  {
+
+    return kingSquares[Us] == ksq && castleRights[Us] == pos.can_castle(Us)
+         ? kingSafety[Us] : update_safety<Us>(pos, ksq);
+  }

-private:
  template<Color Us>
  Score update_safety(const Position& pos, Square ksq);

@@ -56,60 +58,21 @@ private:
  Value shelter_storm(const Position& pos, Square ksq);

  Key key;
-  Bitboard passedPawns[2];
-  Bitboard pawnAttacks[2];
-  Square kingSquares[2];
-  int minKPdistance[2];
-  int castleRights[2];
+  Bitboard passedPawns[COLOR_NB];
+  Bitboard pawnAttacks[COLOR_NB];
+  Square kingSquares[COLOR_NB];
+  int minKPdistance[COLOR_NB];
+  int castleRights[COLOR_NB];
  Score value;
-  int halfOpenFiles[2];
-  Score kingSafety[2];
+  int semiopenFiles[COLOR_NB];
+  Score kingSafety[COLOR_NB];
+  int pawnsOnSquares[COLOR_NB][COLOR_NB];
 };

+typedef HashTable<Entry, 16384> Table;

-/// The PawnTable class represents a pawn hash table. The most important
-/// method is probe, which returns a pointer to a PawnEntry object.
+Entry* probe(const Position& pos, Table& entries);

-struct PawnTable {
-
-  PawnEntry* probe(const Position& pos);
-
-  template<Color Us>
-  static Score evaluate_pawns(const Position& pos, Bitboard ourPawns,
-                              Bitboard theirPawns, PawnEntry* e);
-
-  HashTable<PawnEntry, PawnTableSize> entries;
-};
-
-
-inline Score PawnEntry::pawns_value() const {
-  return value;
 }

-inline Bitboard PawnEntry::pawn_attacks(Color c) const {
-  return pawnAttacks[c];
-}
-
-inline Bitboard PawnEntry::passed_pawns(Color c) const {
-  return passedPawns[c];
-}
-
-inline int PawnEntry::file_is_half_open(Color c, File f) const {
-  return halfOpenFiles[c] & (1 << int(f));
-}
-
-inline int PawnEntry::has_open_file_to_left(Color c, File f) const {
-  return halfOpenFiles[c] & ((1 << int(f)) - 1);
-}
-
-inline int PawnEntry::has_open_file_to_right(Color c, File f) const {
-  return halfOpenFiles[c] & ~((1 << int(f+1)) - 1);
-}
-
-template<Color Us>
-inline Score PawnEntry::king_safety(const Position& pos, Square ksq) {
-  return kingSquares[Us] == ksq && castleRights[Us] == pos.can_castle(Us)
-       ? kingSafety[Us] : update_safety<Us>(pos, ksq);
-}
-
-#endif // !defined(PAWNS_H_INCLUDED)
+#endif // #ifndef PAWNS_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,10 +17,10 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(PLATFORM_H_INCLUDED)
+#ifndef PLATFORM_H_INCLUDED
 #define PLATFORM_H_INCLUDED

-#if defined(_MSC_VER)
+#ifdef _MSC_VER

 // Disable some silly and noisy warning from MSVC compiler
 #pragma warning(disable: 4127) // Conditional expression is constant
@@ -42,13 +42,15 @@ typedef unsigned __int64 uint64_t;
 #  include <inttypes.h>
 #endif

-#if !defined(_WIN32) && !defined(_WIN64) // Linux - Unix
+#ifndef _WIN32 // Linux - Unix

 #  include <sys/time.h>
-typedef timeval sys_time_t;

-inline void system_time(sys_time_t* t) { gettimeofday(t, NULL); }
-inline int64_t time_to_msec(const sys_time_t& t) { return t.tv_sec * 1000LL + t.tv_usec / 1000; }
+inline int64_t system_time_to_msec() {
+  timeval t;
+  gettimeofday(&t, NULL);
+  return t.tv_sec * 1000LL + t.tv_usec / 1000;
+}

 #  include <pthread.h>
 typedef pthread_mutex_t Lock;
@@ -65,18 +67,20 @@ typedef void*(*pt_start_fn)(void*);
 #  define cond_signal(x) pthread_cond_signal(&(x))
 #  define cond_wait(x,y) pthread_cond_wait(&(x),&(y))
 #  define cond_timedwait(x,y,z) pthread_cond_timedwait(&(x),&(y),z)
-#  define thread_create(x,f,t) !pthread_create(&(x),NULL,(pt_start_fn)f,t)
+#  define thread_create(x,f,t) pthread_create(&(x),NULL,(pt_start_fn)f,t)
 #  define thread_join(x) pthread_join(x, NULL)

 #else // Windows and MinGW

 #  include <sys/timeb.h>
-typedef _timeb sys_time_t;

-inline void system_time(sys_time_t* t) { _ftime(t); }
-inline int64_t time_to_msec(const sys_time_t& t) { return t.time * 1000LL + t.millitm; }
+inline int64_t system_time_to_msec() {
+  _timeb t;
+  _ftime(&t);
+  return t.time * 1000LL + t.millitm;
+}

-#if !defined(NOMINMAX)
+#ifndef NOMINMAX
 #  define NOMINMAX // disable macros min() and max()
 #endif

@@ -92,6 +96,9 @@ typedef CRITICAL_SECTION Lock;
 typedef HANDLE WaitCondition;
 typedef HANDLE NativeHandle;

+// On Windows 95 and 98 parameter lpThreadId my not be null
+inline DWORD* dwWin9xKludge() { static DWORD dw; return &dw; }
+
 #  define lock_init(x) InitializeCriticalSection(&(x))
 #  define lock_grab(x) EnterCriticalSection(&(x))
 #  define lock_release(x) LeaveCriticalSection(&(x))
@@ -101,9 +108,9 @@ typedef HANDLE NativeHandle;
 #  define cond_signal(x) SetEvent(x)
 #  define cond_wait(x,y) { lock_release(y); WaitForSingleObject(x, INFINITE); lock_grab(y); }
 #  define cond_timedwait(x,y,z) { lock_release(y); WaitForSingleObject(x,z); lock_grab(y); }
-#  define thread_create(x,f,t) (x = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)f,t,0,NULL), x != NULL)
+#  define thread_create(x,f,t) (x = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)f,t,0,dwWin9xKludge()))
 #  define thread_join(x) { WaitForSingleObject(x, INFINITE); CloseHandle(x); }

 #endif

-#endif // !defined(PLATFORM_H_INCLUDED)
+#endif // #ifndef PLATFORM_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,10 +17,11 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(POSITION_H_INCLUDED)
+#ifndef POSITION_H_INCLUDED
 #define POSITION_H_INCLUDED

 #include <cassert>
+#include <cstddef>

 #include "bitboard.h"
 #include "types.h"
@@ -29,7 +30,7 @@
 /// The checkInfo struct is initialized at c'tor time and keeps info used
 /// to detect if a move gives check.
 class Position;
-class Thread;
+struct Thread;

 struct CheckInfo {

@@ -37,21 +38,21 @@ struct CheckInfo {

  Bitboard dcCandidates;
  Bitboard pinned;
-  Bitboard checkSq[8];
+  Bitboard checkSq[PIECE_TYPE_NB];
  Square ksq;
 };


 /// 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
+/// is made on the board (by calling Position::do_move), a StateInfo object
 /// must be passed as a parameter.

 struct StateInfo {
  Key pawnKey, materialKey;
-  Value npMaterial[2];
+  Value npMaterial[COLOR_NB];
  int castleRights, rule50, pliesFromNull;
-  Score psqScore;
+  Score psq;
  Square epSquare;

  Key key;
@@ -60,13 +61,10 @@ struct StateInfo {
  StateInfo* previous;
 };

-struct ReducedStateInfo {
-  Key pawnKey, materialKey;
-  Value npMaterial[2];
-  int castleRights, rule50, pliesFromNull;
-  Score psqScore;
-  Square epSquare;
-};
+
+/// When making a move the current StateInfo up to 'key' excluded is copied to
+/// the new one. Here we calculate the quad words (64bits) needed to be copied.
+const size_t StateCopySize64 = offsetof(StateInfo, key) / sizeof(uint64_t) + 1;


 /// The position data structure. A position consists of the following data:
@@ -95,13 +93,14 @@ class Position {
 public:
  Position() {}
  Position(const Position& p, Thread* t) { *this = p; thisThread = t; }
-  Position(const std::string& f, bool c960, Thread* t) { from_fen(f, c960, t); }
+  Position(const std::string& f, bool c960, Thread* t) { set(f, c960, t); }
  Position& operator=(const Position&);
+  static void init();

  // Text input/output
-  void from_fen(const std::string& fen, bool isChess960, Thread* th);
-  const std::string to_fen() const;
-  void print(Move m = MOVE_NONE) const;
+  void set(const std::string& fen, bool isChess960, Thread* th);
+  const std::string fen() const;
+  const std::string pretty(Move m = MOVE_NONE) const;

  // Position representation
  Bitboard pieces() const;
@@ -114,8 +113,8 @@ public:
  Square king_square(Color c) const;
  Square ep_square() const;
  bool is_empty(Square s) const;
-  const Square* piece_list(Color c, PieceType pt) const;
-  int piece_count(Color c, PieceType pt) const;
+  template<PieceType Pt> int count(Color c) const;
+  template<PieceType Pt> const Square* list(Color c) const;

  // Castling
  int can_castle(CastleRight f) const;
@@ -124,7 +123,6 @@ public:
  Square castle_rook_square(Color c, CastlingSide s) const;

  // Checking
-  bool in_check() const;
  Bitboard checkers() const;
  Bitboard discovered_check_candidates() const;
  Bitboard pinned_pieces() const;
@@ -139,8 +137,6 @@ public:

  // Properties of moves
  bool move_gives_check(Move m, const CheckInfo& ci) const;
-  bool move_attacks_square(Move m, Square s) const;
-  bool move_is_legal(const Move m) const;
  bool pl_move_is_legal(Move m, Bitboard pinned) const;
  bool is_pseudo_legal(const Move m) const;
  bool is_capture(Move m) const;
@@ -159,10 +155,11 @@ public:
  void do_move(Move m, StateInfo& st);
  void do_move(Move m, StateInfo& st, const CheckInfo& ci, bool moveIsCheck);
  void undo_move(Move m);
-  template<bool Do> void do_null_move(StateInfo& st);
+  void do_null_move(StateInfo& st);
+  void undo_null_move();

  // Static exchange evaluation
-  int see(Move m) const;
+  int see(Move m, int asymmThreshold = 0) const;
  int see_sign(Move m) const;

  // Accessing hash keys
@@ -173,17 +170,16 @@ public:

  // Incremental piece-square evaluation
  Score psq_score() const;
-  Score psq_delta(Piece p, Square from, Square to) const;
  Value non_pawn_material(Color c) const;

  // Other properties of the position
  Color side_to_move() const;
-  int startpos_ply_counter() const;
+  int game_ply() const;
  bool is_chess960() const;
  Thread* this_thread() const;
  int64_t nodes_searched() const;
  void set_nodes_searched(int64_t n);
-  template<bool SkipRepetition> bool is_draw() const;
+  bool is_draw() const;

  // Position consistency check, for debugging
  bool pos_is_ok(int* failedStep = NULL) const;
@@ -192,12 +188,14 @@ public:
 private:
  // Initialization helpers (used while setting up a position)
  void clear();
-  void put_piece(Piece p, Square s);
  void set_castle_right(Color c, Square rfrom);

-  // Helper template functions
-  template<bool Do> void do_castle_move(Move m);
-  template<bool FindPinned> Bitboard hidden_checkers() const;
+  // Helper functions
+  void do_castle(Square kfrom, Square kto, Square rfrom, Square rto);
+  Bitboard hidden_checkers(Square ksq, Color c) const;
+  void put_piece(Square s, Color c, PieceType pt);
+  void remove_piece(Square s, Color c, PieceType pt);
+  void move_piece(Square from, Square to, Color c, PieceType pt);

  // Computing hash keys from scratch (for initialization and debugging)
  Key compute_key() const;
@@ -209,20 +207,20 @@ private:
  Value compute_non_pawn_material(Color c) const;

  // Board and pieces
-  Piece board[64];             // [square]
-  Bitboard byTypeBB[8];        // [pieceType]
-  Bitboard byColorBB[2];       // [color]
-  int pieceCount[2][8];        // [color][pieceType]
-  Square pieceList[2][8][16];  // [color][pieceType][index]
-  int index[64];               // [square]
+  Piece board[SQUARE_NB];
+  Bitboard byTypeBB[PIECE_TYPE_NB];
+  Bitboard byColorBB[COLOR_NB];
+  int pieceCount[COLOR_NB][PIECE_TYPE_NB];
+  Square pieceList[COLOR_NB][PIECE_TYPE_NB][16];
+  int index[SQUARE_NB];

  // Other info
-  int castleRightsMask[64];      // [square]
-  Square castleRookSquare[2][2]; // [color][side]
-  Bitboard castlePath[2][2];     // [color][side]
+  int castleRightsMask[SQUARE_NB];
+  Square castleRookSquare[COLOR_NB][CASTLING_SIDE_NB];
+  Bitboard castlePath[COLOR_NB][CASTLING_SIDE_NB];
  StateInfo startState;
  int64_t nodes;
-  int startPosPly;
+  int gamePly;
  Color sideToMove;
  Thread* thisThread;
  StateInfo* st;
@@ -277,12 +275,12 @@ inline Bitboard Position::pieces(Color c, PieceType pt1, PieceType pt2) const {
  return byColorBB[c] & (byTypeBB[pt1] | byTypeBB[pt2]);
 }

-inline int Position::piece_count(Color c, PieceType pt) const {
-  return pieceCount[c][pt];
+template<PieceType Pt> inline int Position::count(Color c) const {
+  return pieceCount[c][Pt];
 }

-inline const Square* Position::piece_list(Color c, PieceType pt) const {
-  return pieceList[c][pt];
+template<PieceType Pt> inline const Square* Position::list(Color c) const {
+  return pieceList[c][Pt];
 }

 inline Square Position::ep_square() const {
@@ -334,16 +332,12 @@ inline Bitboard Position::checkers() const {
  return st->checkersBB;
 }

-inline bool Position::in_check() const {
-  return st->checkersBB != 0;
-}
-
 inline Bitboard Position::discovered_check_candidates() const {
-  return hidden_checkers<false>();
+  return hidden_checkers(king_square(~sideToMove), sideToMove);
 }

 inline Bitboard Position::pinned_pieces() const {
-  return hidden_checkers<true>();
+  return hidden_checkers(king_square(sideToMove), ~sideToMove);
 }

 inline bool Position::pawn_is_passed(Color c, Square s) const {
@@ -354,10 +348,6 @@ inline Key Position::key() const {
  return st->key;
 }

-inline Key Position::exclusion_key() const {
-  return st->key ^ Zobrist::exclusion;
-}
-
 inline Key Position::pawn_key() const {
  return st->pawnKey;
 }
@@ -366,12 +356,8 @@ inline Key Position::material_key() const {
  return st->materialKey;
 }

-inline Score Position::psq_delta(Piece p, Square from, Square to) const {
-  return pieceSquareTable[p][to] - pieceSquareTable[p][from];
-}
-
 inline Score Position::psq_score() const {
-  return st->psqScore;
+  return st->psq;
 }

 inline Value Position::non_pawn_material(Color c) const {
@@ -384,8 +370,8 @@ inline bool Position::is_passed_pawn_push(Move m) const {
        && pawn_is_passed(sideToMove, to_sq(m));
 }

-inline int Position::startpos_ply_counter() const {
-  return startPosPly + st->pliesFromNull; // HACK
+inline int Position::game_ply() const {
+  return gamePly;
 }

 inline bool Position::opposite_bishops() const {
@@ -430,4 +416,44 @@ inline Thread* Position::this_thread() const {
  return thisThread;
 }

-#endif // !defined(POSITION_H_INCLUDED)
+inline void Position::put_piece(Square s, Color c, PieceType pt) {
+
+  board[s] = make_piece(c, pt);
+  byTypeBB[ALL_PIECES] |= s;
+  byTypeBB[pt] |= s;
+  byColorBB[c] |= s;
+  index[s] = pieceCount[c][pt]++;
+  pieceList[c][pt][index[s]] = s;
+}
+
+inline void Position::move_piece(Square from, Square to, Color c, PieceType pt) {
+
+  // index[from] is not updated and becomes stale. This works as long
+  // as index[] is accessed just by known occupied squares.
+  Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
+  byTypeBB[ALL_PIECES] ^= from_to_bb;
+  byTypeBB[pt] ^= from_to_bb;
+  byColorBB[c] ^= from_to_bb;
+  board[from] = NO_PIECE;
+  board[to] = make_piece(c, pt);
+  index[to] = index[from];
+  pieceList[c][pt][index[to]] = to;
+}
+
+inline void Position::remove_piece(Square s, Color c, PieceType pt) {
+
+  // WARNING: This is not a reversible operation. If we remove a piece in
+  // do_move() and then replace it in undo_move() we will put it at the end of
+  // the list and not in its original place, it means index[] and pieceList[]
+  // are not guaranteed to be invariant to a do_move() + undo_move() sequence.
+  byTypeBB[ALL_PIECES] ^= s;
+  byTypeBB[pt] ^= s;
+  byColorBB[c] ^= s;
+  /* board[s] = NO_PIECE; */ // Not needed, will be overwritten by capturing
+  Square lastSquare = pieceList[c][pt][--pieceCount[c][pt]];
+  index[lastSquare] = index[s];
+  pieceList[c][pt][index[lastSquare]] = lastSquare;
+  pieceList[c][pt][pieceCount[c][pt]] = SQ_NONE;
+}
+
+#endif // #ifndef POSITION_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(PSQTAB_H_INCLUDED)
+#ifndef PSQTAB_H_INCLUDED
 #define PSQTAB_H_INCLUDED

 #include "types.h"
@@ -29,16 +29,16 @@
 /// a given square a (midgame, endgame) score pair is assigned. PSQT is defined
 /// for white side, for black side the tables are symmetric.

-static const Score PSQT[][64] = {
+static const Score PSQT[][SQUARE_NB] = {
  { },
  { // Pawn
   S(  0, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0,  0), S( 0, 0), S( 0, 0), S(  0, 0),
-   S(-28,-8), S(-6,-8), S( 4,-8), S(14,-8), S(14,-8), S( 4,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S( 9,-8), S(36,-8), S(36,-8), S( 9,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S(17,-8), S(58,-8), S(58,-8), S(17,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S(17,-8), S(36,-8), S(36,-8), S(17,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S( 9,-8), S(14,-8), S(14,-8), S( 9,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S( 4,-8), S(14,-8), S(14,-8), S( 4,-8), S(-6,-8), S(-28,-8),
+   S(-20,-8), S(-6,-8), S( 4,-8), S(14,-8), S(14,-8), S( 4,-8), S(-6,-8), S(-20,-8),
+   S(-20,-8), S(-6,-8), S( 9,-8), S(34,-8), S(34,-8), S( 9,-8), S(-6,-8), S(-20,-8),
+   S(-20,-8), S(-6,-8), S(17,-8), S(54,-8), S(54,-8), S(17,-8), S(-6,-8), S(-20,-8),
+   S(-20,-8), S(-6,-8), S(17,-8), S(34,-8), S(34,-8), S(17,-8), S(-6,-8), S(-20,-8),
+   S(-20,-8), S(-6,-8), S( 9,-8), S(14,-8), S(14,-8), S( 9,-8), S(-6,-8), S(-20,-8),
+   S(-20,-8), S(-6,-8), S( 4,-8), S(14,-8), S(14,-8), S( 4,-8), S(-6,-8), S(-20,-8),
   S(  0, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0,  0), S( 0, 0), S( 0, 0), S(  0, 0)
  },
  { // Knight
@@ -95,4 +95,4 @@ static const Score PSQT[][64] = {

 #undef S

-#endif // !defined(PSQTAB_H_INCLUDED)
+#endif // #ifndef PSQTAB_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -22,7 +22,7 @@
  (at your option) any later version.
 */

-#if !defined(RKISS_H_INCLUDED)
+#ifndef RKISS_H_INCLUDED
 #define RKISS_H_INCLUDED

 #include "types.h"
@@ -43,14 +43,12 @@

 class RKISS {

-  // Keep variables always together
-  struct S { uint64_t a, b, c, d; } s;
+  struct S { uint64_t a, b, c, d; } s; // Keep variables always together

  uint64_t rotate(uint64_t x, uint64_t k) const {
    return (x << k) | (x >> (64 - k));
  }

-  // Return 64 bit unsigned integer in between [0, 2^64 - 1]
  uint64_t rand64() {

    const uint64_t
@@ -61,18 +59,16 @@ class RKISS {
    return s.d = e + s.a;
  }

-  // Init seed and scramble a few rounds
-  void raninit() {
+public:
+  RKISS(int seed = 73) {

    s.a = 0xf1ea5eed;
    s.b = s.c = s.d = 0xd4e12c77;
-    for (int i = 0; i < 73; i++)
+    for (int i = 0; i < seed; i++) // Scramble a few rounds
        rand64();
  }

-public:
-  RKISS() { raninit(); }
  template<typename T> T rand() { return T(rand64()); }
 };

-#endif // !defined(RKISS_H_INCLUDED)
+#endif // #ifndef RKISS_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(SEARCH_H_INCLUDED)
+#ifndef SEARCH_H_INCLUDED
 #define SEARCH_H_INCLUDED

 #include <cstring>
@@ -38,15 +38,16 @@ namespace Search {
 /// has its own array of Stack objects, indexed by the current ply.

 struct Stack {
-  SplitPoint* sp;
+  SplitPoint* splitPoint;
  int ply;
  Move currentMove;
  Move excludedMove;
  Move killers[2];
  Depth reduction;
-  Value eval;
+  Value staticEval;
  Value evalMargin;
  int skipNullMove;
+  int futilityMoveCount;
 };


@@ -56,12 +57,11 @@ struct Stack {
 /// all non-pv moves.
 struct RootMove {

-  RootMove(){} // Needed by sort()
  RootMove(Move m) : score(-VALUE_INFINITE), prevScore(-VALUE_INFINITE) {
    pv.push_back(m); pv.push_back(MOVE_NONE);
  }

-  bool operator<(const RootMove& m) const { return score < m.score; }
+  bool operator<(const RootMove& m) const { return score > m.score; } // Ascending sort
  bool operator==(const Move& m) const { return pv[0] == m; }

  void extract_pv_from_tt(Position& pos);
@@ -79,10 +79,10 @@ struct RootMove {

 struct LimitsType {

-  LimitsType() { memset(this, 0, sizeof(LimitsType)); }
-  bool use_time_management() const { return !(movetime | depth | nodes | infinite); }
+  LimitsType() { std::memset(this, 0, sizeof(LimitsType)); }
+  bool use_time_management() const { return !(mate | movetime | depth | nodes | infinite); }

-  int time[2], inc[2], movestogo, depth, nodes, movetime, infinite, ponder;
+  int time[COLOR_NB], inc[COLOR_NB], movestogo, depth, nodes, movetime, mate, infinite, ponder;
 };


@@ -98,7 +98,8 @@ typedef std::auto_ptr<std::stack<StateInfo> > StateStackPtr;
 extern volatile SignalsType Signals;
 extern LimitsType Limits;
 extern std::vector<RootMove> RootMoves;
-extern Position RootPosition;
+extern Position RootPos;
+extern Color RootColor;
 extern Time::point SearchTime;
 extern StateStackPtr SetupStates;

@@ -108,4 +109,4 @@ extern void think();

 } // namespace Search

-#endif // !defined(SEARCH_H_INCLUDED)
+#endif // #ifndef SEARCH_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,8 +17,8 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

+#include <algorithm> // For std::count
 #include <cassert>
-#include <iostream>

 #include "movegen.h"
 #include "search.h"
@@ -29,101 +29,37 @@ using namespace Search;

 ThreadPool Threads; // Global object

-namespace { extern "C" {
+namespace {

 // start_routine() is the C function which is called when a new thread
- // is launched. It is a wrapper to member function pointed by start_fn.
+ // is launched. It is a wrapper to the virtual function idle_loop().

- long start_routine(Thread* th) { (th->*(th->start_fn))(); return 0; }
-
-} }
+ extern "C" { long start_routine(ThreadBase* th) { th->idle_loop(); return 0; } }


-// Thread c'tor starts a newly-created thread of execution that will call
-// the idle loop function pointed by start_fn going immediately to sleep.
+ // Helpers to launch a thread after creation and joining before delete. Must be
+ // outside Thread c'tor and d'tor because object shall be fully initialized
+ // when start_routine (and hence virtual idle_loop) is called and when joining.

-Thread::Thread(Fn fn) {
+ template<typename T> T* new_thread() {
+   T* th = new T();
+   thread_create(th->handle, start_routine, th); // Will go to sleep
+   return th;
+ }

-  is_searching = do_exit = false;
-  maxPly = splitPointsCnt = 0;
-  curSplitPoint = NULL;
-  start_fn = fn;
-  idx = Threads.size();
+ void delete_thread(ThreadBase* th) {
+   th->exit = true; // Search must be already finished
+   th->notify_one();
+   thread_join(th->handle); // Wait for thread termination
+   delete th;
+ }

-  do_sleep = (fn != &Thread::main_loop); // Avoid a race with start_searching()
-
-  if (!thread_create(handle, start_routine, this))
-  {
-      std::cerr << "Failed to create thread number " << idx << std::endl;
-      ::exit(EXIT_FAILURE);
-  }
 }


-// Thread d'tor waits for thread termination before to return.
+// ThreadBase::notify_one() wakes up the thread when there is some work to do

-Thread::~Thread() {
-
-  assert(do_sleep);
-
-  do_exit = true; // Search must be already finished
-  wake_up();
-  thread_join(handle); // Wait for thread termination
-}
-
-
-// Thread::timer_loop() is where the timer thread waits maxPly milliseconds and
-// then calls check_time(). If maxPly is 0 thread sleeps until is woken up.
-extern void check_time();
-
-void Thread::timer_loop() {
-
-  while (!do_exit)
-  {
-      mutex.lock();
-      sleepCondition.wait_for(mutex, maxPly ? maxPly : INT_MAX);
-      mutex.unlock();
-      check_time();
-  }
-}
-
-
-// Thread::main_loop() is where the main thread is parked waiting to be started
-// when there is a new search. Main thread will launch all the slave threads.
-
-void Thread::main_loop() {
-
-  while (true)
-  {
-      mutex.lock();
-
-      do_sleep = true; // Always return to sleep after a search
-      is_searching = false;
-
-      while (do_sleep && !do_exit)
-      {
-          Threads.sleepCondition.notify_one(); // Wake up UI thread if needed
-          sleepCondition.wait(mutex);
-      }
-
-      mutex.unlock();
-
-      if (do_exit)
-          return;
-
-      is_searching = true;
-
-      Search::think();
-
-      assert(is_searching);
-  }
-}
-
-
-// Thread::wake_up() wakes up the thread, normally at the beginning of the search
-// or, if "sleeping threads" is used at split time.
-
-void Thread::wake_up() {
+void ThreadBase::notify_one() {

  mutex.lock();
  sleepCondition.notify_one();
@@ -131,29 +67,89 @@ void Thread::wake_up() {
 }


-// Thread::wait_for_stop_or_ponderhit() is called when the maximum depth is
-// reached while the program is pondering. The point is to work around a wrinkle
-// in the UCI protocol: When pondering, the engine is not allowed to give a
-// "bestmove" before the GUI sends it a "stop" or "ponderhit" command. We simply
-// wait here until one of these commands (that raise StopRequest) is sent and
-// then return, after which the bestmove and pondermove will be printed.
+// ThreadBase::wait_for() set the thread to sleep until condition 'b' turns true

-void Thread::wait_for_stop_or_ponderhit() {
-
-  Signals.stopOnPonderhit = true;
+void ThreadBase::wait_for(volatile const bool& b) {

  mutex.lock();
-  while (!Signals.stop) sleepCondition.wait(mutex);;
+  while (!b) sleepCondition.wait(mutex);
  mutex.unlock();
 }


+// Thread c'tor just inits data but does not launch any thread of execution that
+// instead will be started only upon c'tor returns.
+
+Thread::Thread() /* : splitPoints() */ { // Value-initialization bug in MSVC
+
+  searching = false;
+  maxPly = splitPointsSize = 0;
+  activeSplitPoint = NULL;
+  activePosition = NULL;
+  idx = Threads.size();
+}
+
+
+// TimerThread::idle_loop() is where the timer thread waits msec milliseconds
+// and then calls check_time(). If msec is 0 thread sleeps until is woken up.
+extern void check_time();
+
+void TimerThread::idle_loop() {
+
+  while (!exit)
+  {
+      mutex.lock();
+
+      if (!exit)
+          sleepCondition.wait_for(mutex, msec ? msec : INT_MAX);
+
+      mutex.unlock();
+
+      if (msec)
+          check_time();
+  }
+}
+
+
+// MainThread::idle_loop() is where the main thread is parked waiting to be started
+// when there is a new search. Main thread will launch all the slave threads.
+
+void MainThread::idle_loop() {
+
+  while (true)
+  {
+      mutex.lock();
+
+      thinking = false;
+
+      while (!thinking && !exit)
+      {
+          Threads.sleepCondition.notify_one(); // Wake up UI thread if needed
+          sleepCondition.wait(mutex);
+      }
+
+      mutex.unlock();
+
+      if (exit)
+          return;
+
+      searching = true;
+
+      Search::think();
+
+      assert(searching);
+
+      searching = false;
+  }
+}
+
+
 // Thread::cutoff_occurred() checks whether a beta cutoff has occurred in the
 // current active split point, or in some ancestor of the split point.

 bool Thread::cutoff_occurred() const {

-  for (SplitPoint* sp = curSplitPoint; sp; sp = sp->parent)
+  for (SplitPoint* sp = activeSplitPoint; sp; sp = sp->parentSplitPoint)
      if (sp->cutoff)
          return true;

@@ -164,46 +160,47 @@ bool Thread::cutoff_occurred() const {
 // Thread::is_available_to() checks whether the thread is available to help the
 // thread 'master' at a split point. An obvious requirement is that thread must
 // be idle. With more than two threads, this is not sufficient: If the thread is
-// the master of some active split point, it is only available as a slave to the
-// slaves which are busy searching the split point at the top of slaves split
-// point stack (the "helpful master concept" in YBWC terminology).
+// the master of some split point, it is only available as a slave to the slaves
+// which are busy searching the split point at the top of slaves split point
+// stack (the "helpful master concept" in YBWC terminology).

-bool Thread::is_available_to(Thread* master) const {
+bool Thread::is_available_to(const Thread* master) const {

-  if (is_searching)
+  if (searching)
      return false;

  // Make a local copy to be sure doesn't become zero under our feet while
  // testing next condition and so leading to an out of bound access.
-  int spCnt = splitPointsCnt;
+  int size = splitPointsSize;

-  // No active split points means that the thread is available as a slave for any
+  // No split points means that the thread is available as a slave for any
  // other thread otherwise apply the "helpful master" concept if possible.
-  return !spCnt || (splitPoints[spCnt - 1].slavesMask & (1ULL << master->idx));
+  return !size || (splitPoints[size - 1].slavesMask & (1ULL << master->idx));
 }


-// init() is called at startup. Initializes lock and condition variable and
-// launches requested threads sending them immediately to sleep. We cannot use
+// init() is called at startup to create and launch requested threads, that will
+// go immediately to sleep due to 'sleepWhileIdle' set to true. We cannot use
 // a c'tor becuase Threads is a static object and we need a fully initialized
-// engine at this point due to allocation of endgames in Thread c'tor.
+// engine at this point due to allocation of Endgames in Thread c'tor.

 void ThreadPool::init() {

-  timer = new Thread(&Thread::timer_loop);
-  threads.push_back(new Thread(&Thread::main_loop));
+  sleepWhileIdle = true;
+  timer = new_thread<TimerThread>();
+  push_back(new_thread<MainThread>());
  read_uci_options();
 }


-// exit() cleanly terminates the threads before the program exits.
+// exit() cleanly terminates the threads before the program exits

 void ThreadPool::exit() {

-  for (size_t i = 0; i < threads.size(); i++)
-      delete threads[i];
+  delete_thread(timer); // As first because check_time() accesses threads data

-  delete timer;
+  for (iterator it = begin(); it != end(); ++it)
+      delete_thread(*it);
 }


@@ -216,221 +213,182 @@ void ThreadPool::read_uci_options() {

  maxThreadsPerSplitPoint = Options["Max Threads per Split Point"];
  minimumSplitDepth       = Options["Min Split Depth"] * ONE_PLY;
-  useSleepingThreads      = Options["Use Sleeping Threads"];
  size_t requested        = Options["Threads"];

  assert(requested > 0);

-  while (threads.size() < requested)
-      threads.push_back(new Thread(&Thread::idle_loop));
+  // Value 0 has a special meaning: We determine the optimal minimum split depth
+  // automatically. Anyhow the minimumSplitDepth should never be under 4 plies.
+  if (!minimumSplitDepth)
+      minimumSplitDepth = (requested < 8 ? 4 : 7) * ONE_PLY;
+  else
+      minimumSplitDepth = std::max(4 * ONE_PLY, minimumSplitDepth);

-  while (threads.size() > requested)
+  while (size() < requested)
+      push_back(new_thread<Thread>());
+
+  while (size() > requested)
  {
-      delete threads.back();
-      threads.pop_back();
+      delete_thread(back());
+      pop_back();
  }
 }


-// wake_up() is called before a new search to start the threads that are waiting
-// on the sleep condition and to reset maxPly. When useSleepingThreads is set
-// threads will be woken up at split time.
+// slave_available() tries to find an idle thread which is available as a slave
+// for the thread 'master'.

-void ThreadPool::wake_up() const {
+Thread* ThreadPool::available_slave(const Thread* master) const {

-  for (size_t i = 0; i < threads.size(); i++)
-  {
-      threads[i]->maxPly = 0;
-      threads[i]->do_sleep = false;
+  for (const_iterator it = begin(); it != end(); ++it)
+      if ((*it)->is_available_to(master))
+          return *it;

-      if (!useSleepingThreads)
-          threads[i]->wake_up();
-  }
-}
-
-
-// sleep() is called after the search finishes to ask all the threads but the
-// main one to go waiting on a sleep condition.
-
-void ThreadPool::sleep() const {
-
-  // Main thread will go to sleep by itself to avoid a race with start_searching()
-  for (size_t i = 1; i < threads.size(); i++)
-      threads[i]->do_sleep = true;
-}
-
-
-// available_slave_exists() tries to find an idle thread which is available as
-// a slave for the thread 'master'.
-
-bool ThreadPool::available_slave_exists(Thread* master) const {
-
-  for (size_t i = 0; i < threads.size(); i++)
-      if (threads[i]->is_available_to(master))
-          return true;
-
-  return false;
+  return NULL;
 }


 // split() does the actual work of distributing the work at a node between
 // several available threads. If it does not succeed in splitting the node
-// (because no idle threads are available, or because we have no unused split
-// point objects), the function immediately returns. If splitting is possible, a
-// SplitPoint object is initialized with all the data that must be copied to the
-// helper threads and then helper threads are told that they have been assigned
-// work. This will cause them to instantly leave their idle loops and call
-// search(). When all threads have returned from search() then split() returns.
+// (because no idle threads are available), the function immediately returns.
+// If splitting is possible, a SplitPoint object is initialized with all the
+// data that must be copied to the helper threads and then helper threads are
+// told that they have been assigned work. This will cause them to instantly
+// leave their idle loops and call search(). When all threads have returned from
+// search() then split() returns.

 template <bool Fake>
-Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta,
-                        Value bestValue, Move* bestMove, Depth depth,
-                        Move threatMove, int moveCount, MovePicker* mp, int nodeType) {
+void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Value* bestValue,
+                   Move* bestMove, Depth depth, Move threatMove, int moveCount,
+                   MovePicker* movePicker, int nodeType, bool cutNode) {

  assert(pos.pos_is_ok());
-  assert(bestValue > -VALUE_INFINITE);
-  assert(bestValue <= alpha);
-  assert(alpha < beta);
-  assert(beta <= VALUE_INFINITE);
-  assert(depth > DEPTH_ZERO);
-
-  Thread* master = pos.this_thread();
-
-  if (master->splitPointsCnt >= MAX_SPLITPOINTS_PER_THREAD)
-      return bestValue;
+  assert(*bestValue <= alpha && alpha < beta && beta <= VALUE_INFINITE);
+  assert(*bestValue > -VALUE_INFINITE);
+  assert(depth >= Threads.minimumSplitDepth);
+  assert(searching);
+  assert(splitPointsSize < MAX_SPLITPOINTS_PER_THREAD);

  // Pick the next available split point from the split point stack
-  SplitPoint& sp = master->splitPoints[master->splitPointsCnt];
+  SplitPoint& sp = splitPoints[splitPointsSize];

-  sp.parent = master->curSplitPoint;
-  sp.master = master;
-  sp.cutoff = false;
-  sp.slavesMask = 1ULL << master->idx;
+  sp.masterThread = this;
+  sp.parentSplitPoint = activeSplitPoint;
+  sp.slavesMask = 1ULL << idx;
  sp.depth = depth;
+  sp.bestValue = *bestValue;
  sp.bestMove = *bestMove;
  sp.threatMove = threatMove;
  sp.alpha = alpha;
  sp.beta = beta;
  sp.nodeType = nodeType;
-  sp.bestValue = bestValue;
-  sp.mp = mp;
+  sp.cutNode = cutNode;
+  sp.movePicker = movePicker;
  sp.moveCount = moveCount;
  sp.pos = &pos;
  sp.nodes = 0;
+  sp.cutoff = false;
  sp.ss = ss;

-  assert(master->is_searching);
-
-  master->curSplitPoint = &sp;
-  int slavesCnt = 0;
-
  // Try to allocate available threads and ask them to start searching setting
-  // is_searching flag. This must be done under lock protection to avoid concurrent
+  // 'searching' flag. This must be done under lock protection to avoid concurrent
  // allocation of the same slave by another master.
+  Threads.mutex.lock();
  sp.mutex.lock();
-  mutex.lock();

-  for (size_t i = 0; i < threads.size() && !Fake; ++i)
-      if (threads[i]->is_available_to(master))
-      {
-          sp.slavesMask |= 1ULL << i;
-          threads[i]->curSplitPoint = &sp;
-          threads[i]->is_searching = true; // Slave leaves idle_loop()
+  splitPointsSize++;
+  activeSplitPoint = &sp;
+  activePosition = NULL;

-          if (useSleepingThreads)
-              threads[i]->wake_up();
+  size_t slavesCnt = 1; // This thread is always included
+  Thread* slave;

-          if (++slavesCnt + 1 >= maxThreadsPerSplitPoint) // Master is always included
-              break;
-      }
-
-  master->splitPointsCnt++;
-
-  mutex.unlock();
-  sp.mutex.unlock();
+  while (    (slave = Threads.available_slave(this)) != NULL
+         && ++slavesCnt <= Threads.maxThreadsPerSplitPoint && !Fake)
+  {
+      sp.slavesMask |= 1ULL << slave->idx;
+      slave->activeSplitPoint = &sp;
+      slave->searching = true; // Slave leaves idle_loop()
+      slave->notify_one(); // Could be sleeping
+  }

  // Everything is set up. The master thread enters the idle loop, from which
-  // it will instantly launch a search, because its is_searching flag is set.
+  // it will instantly launch a search, because its 'searching' flag is set.
  // The thread will return from the idle loop when all slaves have finished
  // their work at this split point.
-  if (slavesCnt || Fake)
+  if (slavesCnt > 1 || Fake)
  {
-      master->idle_loop();
+      sp.mutex.unlock();
+      Threads.mutex.unlock();
+
+      Thread::idle_loop(); // Force a call to base class idle_loop()

      // In helpful master concept a master can help only a sub-tree of its split
      // point, and because here is all finished is not possible master is booked.
-      assert(!master->is_searching);
+      assert(!searching);
+      assert(!activePosition);
+
+      // We have returned from the idle loop, which means that all threads are
+      // finished. Note that setting 'searching' and decreasing splitPointsSize is
+      // done under lock protection to avoid a race with Thread::is_available_to().
+      Threads.mutex.lock();
+      sp.mutex.lock();
  }

-  // We have returned from the idle loop, which means that all threads are
-  // finished. Note that setting is_searching and decreasing splitPointsCnt is
-  // done under lock protection to avoid a race with Thread::is_available_to().
-  sp.mutex.lock(); // To protect sp.nodes
-  mutex.lock();
-
-  master->is_searching = true;
-  master->splitPointsCnt--;
-  master->curSplitPoint = sp.parent;
+  searching = true;
+  splitPointsSize--;
+  activeSplitPoint = sp.parentSplitPoint;
+  activePosition = &pos;
  pos.set_nodes_searched(pos.nodes_searched() + sp.nodes);
  *bestMove = sp.bestMove;
+  *bestValue = sp.bestValue;

-  mutex.unlock();
  sp.mutex.unlock();
-
-  return sp.bestValue;
+  Threads.mutex.unlock();
 }

 // Explicit template instantiations
-template Value ThreadPool::split<false>(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker*, int);
-template Value ThreadPool::split<true>(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker*, int);
+template void Thread::split<false>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int, bool);
+template void Thread::split< true>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int, bool);


-// set_timer() is used to set the timer to trigger after msec milliseconds.
-// If msec is 0 then timer is stopped.
+// wait_for_think_finished() waits for main thread to go to sleep then returns

-void ThreadPool::set_timer(int msec) {
+void ThreadPool::wait_for_think_finished() {

-  timer->mutex.lock();
-  timer->maxPly = msec;
-  timer->sleepCondition.notify_one(); // Wake up and restart the timer
-  timer->mutex.unlock();
-}
-
-
-// wait_for_search_finished() waits for main thread to go to sleep, this means
-// search is finished. Then returns.
-
-void ThreadPool::wait_for_search_finished() {
-
-  Thread* t = main_thread();
+  MainThread* t = main();
  t->mutex.lock();
-  t->sleepCondition.notify_one(); // In case is waiting for stop or ponderhit
-  while (!t->do_sleep) sleepCondition.wait(t->mutex);
+  while (t->thinking) sleepCondition.wait(t->mutex);
  t->mutex.unlock();
 }


-// start_searching() wakes up the main thread sleeping in  main_loop() so to start
-// a new search, then returns immediately.
+// start_thinking() wakes up the main thread sleeping in MainThread::idle_loop()
+// so to start a new search, then returns immediately.

-void ThreadPool::start_searching(const Position& pos, const LimitsType& limits,
-                                 const std::vector<Move>& searchMoves, StateStackPtr& states) {
-  wait_for_search_finished();
+void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits,
+                                const std::vector<Move>& searchMoves, StateStackPtr& states) {
+  wait_for_think_finished();

  SearchTime = Time::now(); // As early as possible

  Signals.stopOnPonderhit = Signals.firstRootMove = false;
  Signals.stop = Signals.failedLowAtRoot = false;

-  RootPosition = pos;
-  Limits = limits;
-  SetupStates = states; // Ownership transfer here
  RootMoves.clear();
+  RootPos = pos;
+  Limits = limits;
+  if (states.get()) // If we don't set a new position, preserve current state
+  {
+      SetupStates = states; // Ownership transfer here
+      assert(!states.get());
+  }

-  for (MoveList<LEGAL> ml(pos); !ml.end(); ++ml)
-      if (searchMoves.empty() || count(searchMoves.begin(), searchMoves.end(), ml.move()))
-          RootMoves.push_back(RootMove(ml.move()));
+  for (MoveList<LEGAL> it(pos); *it; ++it)
+      if (   searchMoves.empty()
+          || std::count(searchMoves.begin(), searchMoves.end(), *it))
+          RootMoves.push_back(RootMove(*it));

-  main_thread()->do_sleep = false;
-  main_thread()->wake_up();
+  main()->thinking = true;
+  main()->notify_one(); // Starts main thread
 }
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(THREAD_H_INCLUDED)
+#ifndef THREAD_H_INCLUDED
 #define THREAD_H_INCLUDED

 #include <vector>
@@ -28,7 +28,7 @@
 #include "position.h"
 #include "search.h"

-const int MAX_THREADS = 32;
+const int MAX_THREADS = 64; // Because SplitPoint::slavesMask is a uint64_t
 const int MAX_SPLITPOINTS_PER_THREAD = 8;

 struct Mutex {
@@ -56,22 +56,23 @@ private:
  WaitCondition c;
 };

-class Thread;
+struct Thread;

 struct SplitPoint {

  // Const data after split point has been setup
  const Position* pos;
  const Search::Stack* ss;
+  Thread* masterThread;
  Depth depth;
  Value beta;
  int nodeType;
-  Thread* master;
  Move threatMove;
+  bool cutNode;

  // Const pointers to shared data
-  MovePicker* mp;
-  SplitPoint* parent;
+  MovePicker* movePicker;
+  SplitPoint* parentSplitPoint;

  // Shared data
  Mutex mutex;
@@ -85,84 +86,93 @@ struct SplitPoint {
 };


+/// ThreadBase struct is the base of the hierarchy from where we derive all the
+/// specialized thread classes.
+
+struct ThreadBase {
+
+  ThreadBase() : exit(false) {}
+  virtual ~ThreadBase() {}
+  virtual void idle_loop() = 0;
+  void notify_one();
+  void wait_for(volatile const bool& b);
+
+  Mutex mutex;
+  ConditionVariable sleepCondition;
+  NativeHandle handle;
+  volatile bool exit;
+};
+
+
 /// Thread struct keeps together all the thread related stuff like locks, state
 /// and especially split points. We also use per-thread pawn and material hash
 /// tables so that once we get a pointer to an entry its life time is unlimited
 /// and we don't have to care about someone changing the entry under our feet.

-class Thread {
+struct Thread : public ThreadBase {

-  typedef void (Thread::* Fn) (); // Pointer to member function
-
-public:
-  Thread(Fn fn);
- ~Thread();
-
-  void wake_up();
+  Thread();
+  virtual void idle_loop();
  bool cutoff_occurred() const;
-  bool is_available_to(Thread* master) const;
-  void idle_loop();
-  void main_loop();
-  void timer_loop();
-  void wait_for_stop_or_ponderhit();
+  bool is_available_to(const Thread* master) const;
+
+  template <bool Fake>
+  void split(Position& pos, const Search::Stack* ss, Value alpha, Value beta, Value* bestValue, Move* bestMove,
+             Depth depth, Move threatMove, int moveCount, MovePicker* movePicker, int nodeType, bool cutNode);

  SplitPoint splitPoints[MAX_SPLITPOINTS_PER_THREAD];
-  MaterialTable materialTable;
-  PawnTable pawnTable;
+  Material::Table materialTable;
+  Endgames endgames;
+  Pawns::Table pawnsTable;
+  Position* activePosition;
  size_t idx;
  int maxPly;
-  Mutex mutex;
-  ConditionVariable sleepCondition;
-  NativeHandle handle;
-  Fn start_fn;
-  SplitPoint* volatile curSplitPoint;
-  volatile int splitPointsCnt;
-  volatile bool is_searching;
-  volatile bool do_sleep;
-  volatile bool do_exit;
+  SplitPoint* volatile activeSplitPoint;
+  volatile int splitPointsSize;
+  volatile bool searching;
 };


-/// ThreadPool class handles all the threads related stuff like init, starting,
+/// MainThread and TimerThread are derived classes used to characterize the two
+/// special threads: the main one and the recurring timer.
+
+struct MainThread : public Thread {
+  MainThread() : thinking(true) {} // Avoid a race with start_thinking()
+  virtual void idle_loop();
+  volatile bool thinking;
+};
+
+struct TimerThread : public ThreadBase {
+  TimerThread() : msec(0) {}
+  virtual void idle_loop();
+  int msec;
+};
+
+
+/// ThreadPool struct handles all the threads related stuff like init, starting,
 /// parking and, the most important, launching a slave thread at a split point.
 /// All the access to shared thread data is done through this class.

-class ThreadPool {
+struct ThreadPool : public std::vector<Thread*> {

-public:
  void init(); // No c'tor and d'tor, threads rely on globals that should
  void exit(); // be initialized and valid during the whole thread lifetime.

-  Thread& operator[](size_t id) { return *threads[id]; }
-  bool use_sleeping_threads() const { return useSleepingThreads; }
-  int min_split_depth() const { return minimumSplitDepth; }
-  size_t size() const { return threads.size(); }
-  Thread* main_thread() { return threads[0]; }
-
-  void wake_up() const;
-  void sleep() const;
+  MainThread* main() { return static_cast<MainThread*>((*this)[0]); }
  void read_uci_options();
-  bool available_slave_exists(Thread* master) const;
-  void set_timer(int msec);
-  void wait_for_search_finished();
-  void start_searching(const Position&, const Search::LimitsType&,
-                       const std::vector<Move>&, Search::StateStackPtr&);
+  Thread* available_slave(const Thread* master) const;
+  void wait_for_think_finished();
+  void start_thinking(const Position&, const Search::LimitsType&,
+                      const std::vector<Move>&, Search::StateStackPtr&);

-  template <bool Fake>
-  Value split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value bestValue, Move* bestMove,
-              Depth depth, Move threatMove, int moveCount, MovePicker* mp, int nodeType);
-private:
-  friend class Thread;
-
-  std::vector<Thread*> threads;
-  Thread* timer;
+  bool sleepWhileIdle;
+  Depth minimumSplitDepth;
+  size_t maxThreadsPerSplitPoint;
  Mutex mutex;
  ConditionVariable sleepCondition;
-  Depth minimumSplitDepth;
-  int maxThreadsPerSplitPoint;
-  bool useSleepingThreads;
+  TimerThread* timer;
 };

 extern ThreadPool Threads;

-#endif // !defined(THREAD_H_INCLUDED)
+#endif // #ifndef THREAD_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -29,7 +29,7 @@ namespace {
  /// Constants

  const int MoveHorizon  = 50;    // Plan time management at most this many moves ahead
-  const float MaxRatio   = 3.0f;  // When in trouble, we can step over reserved time with this ratio
+  const float MaxRatio   = 7.0f;  // When in trouble, we can step over reserved time with this ratio
  const float StealRatio = 0.33f; // However we must not steal time from remaining moves over this ratio


@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(TIMEMAN_H_INCLUDED)
+#ifndef TIMEMAN_H_INCLUDED
 #define TIMEMAN_H_INCLUDED

 /// The TimeManager class computes the optimal time to think depending on the
@@ -36,4 +36,4 @@ private:
  int unstablePVExtraTime;
 };

-#endif // !defined(TIMEMAN_H_INCLUDED)
+#endif // #ifndef TIMEMAN_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -25,42 +25,32 @@

 TranspositionTable TT; // Our global transposition table

-TranspositionTable::TranspositionTable() {
-
-  size = generation = 0;
-  entries = NULL;
-}
-
-TranspositionTable::~TranspositionTable() {
-
-  delete [] entries;
-}
-

 /// TranspositionTable::set_size() sets the size of the transposition table,
-/// measured in megabytes. Transposition table consists of a power of 2 number of
-/// TTCluster and each cluster consists of ClusterSize number of TTEntries. Each
-/// non-empty entry contains information of exactly one position.
+/// measured in megabytes. Transposition table consists of a power of 2 number
+/// of clusters and each cluster consists of ClusterSize number of TTEntry.

 void TranspositionTable::set_size(size_t mbSize) {

-  size_t newSize = 1ULL << msb((mbSize << 20) / sizeof(TTCluster));
+  assert(msb((mbSize << 20) / sizeof(TTEntry)) < 32);

-  if (newSize == size)
+  uint32_t size = ClusterSize << msb((mbSize << 20) / sizeof(TTEntry[ClusterSize]));
+
+  if (hashMask == size - ClusterSize)
      return;

-  size = newSize;
-  delete [] entries;
-  entries = new (std::nothrow) TTCluster[size];
+  hashMask = size - ClusterSize;
+  free(mem);
+  mem = calloc(size * sizeof(TTEntry) + CACHE_LINE_SIZE - 1, 1);

-  if (!entries)
+  if (!mem)
  {
      std::cerr << "Failed to allocate " << mbSize
                << "MB for transposition table." << std::endl;
      exit(EXIT_FAILURE);
  }

-  clear(); // Operator new is not guaranteed to initialize memory to zero
+  table = (TTEntry*)((uintptr_t(mem) + CACHE_LINE_SIZE - 1) & ~(CACHE_LINE_SIZE - 1));
 }


@@ -70,7 +60,24 @@ void TranspositionTable::set_size(size_t mbSize) {

 void TranspositionTable::clear() {

-  memset(entries, 0, size * sizeof(TTCluster));
+  std::memset(table, 0, (hashMask + ClusterSize) * sizeof(TTEntry));
+}
+
+
+/// TranspositionTable::probe() looks up the current position in the
+/// transposition table. Returns a pointer to the TTEntry or NULL if
+/// position is not found.
+
+const TTEntry* TranspositionTable::probe(const Key key) const {
+
+  const TTEntry* tte = first_entry(key);
+  uint32_t key32 = key >> 32;
+
+  for (unsigned i = 0; i < ClusterSize; i++, tte++)
+      if (tte->key() == key32)
+          return tte;
+
+  return NULL;
 }


@@ -82,60 +89,33 @@ void TranspositionTable::clear() {
 /// 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.

-void TranspositionTable::store(const Key posKey, Value v, Bound t, Depth d, Move m, Value statV, Value kingD) {
+void TranspositionTable::store(const Key key, Value v, Bound b, Depth d, Move m, Value statV, Value evalM) {

  int c1, c2, c3;
  TTEntry *tte, *replace;
-  uint32_t posKey32 = posKey >> 32; // Use the high 32 bits as key inside the cluster
+  uint32_t key32 = key >> 32; // Use the high 32 bits as key inside the cluster

-  tte = replace = first_entry(posKey);
+  tte = replace = first_entry(key);

-  for (int i = 0; i < ClusterSize; i++, tte++)
+  for (unsigned i = 0; i < ClusterSize; i++, tte++)
  {
-      if (!tte->key() || tte->key() == posKey32) // Empty or overwrite old
+      if (!tte->key() || tte->key() == key32) // Empty or overwrite old
      {
-          // Preserve any existing ttMove
-          if (m == MOVE_NONE)
-              m = tte->move();
+          if (!m)
+              m = tte->move(); // Preserve any existing ttMove

-          tte->save(posKey32, v, t, d, m, generation, statV, kingD);
-          return;
+          replace = tte;
+          break;
      }

      // Implement replace strategy
      c1 = (replace->generation() == generation ?  2 : 0);
-      c2 = (tte->generation() == generation || tte->type() == BOUND_EXACT ? -2 : 0);
+      c2 = (tte->generation() == generation || tte->bound() == BOUND_EXACT ? -2 : 0);
      c3 = (tte->depth() < replace->depth() ?  1 : 0);

      if (c1 + c2 + c3 > 0)
          replace = tte;
  }
-  replace->save(posKey32, v, t, d, m, generation, statV, kingD);
-}
-
-
-/// TranspositionTable::probe() looks up the current position in the
-/// transposition table. Returns a pointer to the TTEntry or NULL if
-/// position is not found.
-
-TTEntry* TranspositionTable::probe(const Key posKey) const {
-
-  uint32_t posKey32 = posKey >> 32;
-  TTEntry* tte = first_entry(posKey);
-
-  for (int i = 0; i < ClusterSize; i++, tte++)
-      if (tte->key() == posKey32)
-          return tte;
-
-  return NULL;
-}
-
-
-/// TranspositionTable::new_search() is called at the beginning of every new
-/// 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++;
+
+  replace->save(key32, v, b, d, m, generation, statV, evalM);
 }
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,99 +17,81 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(TT_H_INCLUDED)
+#ifndef TT_H_INCLUDED
 #define TT_H_INCLUDED

 #include "misc.h"
 #include "types.h"

-/// The TTEntry is the class of transposition table entries
+/// The TTEntry is the 128 bit transposition table entry, defined as below:
 ///
-/// A TTEntry needs 128 bits to be stored
-///
-/// bit  0-31: key
-/// bit 32-63: data
-/// bit 64-79: value
-/// bit 80-95: depth
-/// bit 96-111: static value
-/// bit 112-127: margin of static value
-///
-/// the 32 bits of the data field are so defined
-///
-/// bit  0-15: move
-/// bit 16-20: not used
-/// bit 21-22: value type
-/// bit 23-31: generation
+/// key: 32 bit
+/// move: 16 bit
+/// bound type: 8 bit
+/// generation: 8 bit
+/// value: 16 bit
+/// depth: 16 bit
+/// static value: 16 bit
+/// static margin: 16 bit

-class TTEntry {
+struct TTEntry {

-public:
-  void save(uint32_t k, Value v, Bound b, Depth d, Move m, int g, Value statV, Value statM) {
+  void save(uint32_t k, Value v, Bound b, Depth d, Move m, int g, Value ev, Value em) {

    key32        = (uint32_t)k;
    move16       = (uint16_t)m;
-    bound        = (uint8_t)b;
+    bound8       = (uint8_t)b;
    generation8  = (uint8_t)g;
    value16      = (int16_t)v;
    depth16      = (int16_t)d;
-    staticValue  = (int16_t)statV;
-    staticMargin = (int16_t)statM;
+    evalValue    = (int16_t)ev;
+    evalMargin   = (int16_t)em;
  }
-  void set_generation(int g) { generation8 = (uint8_t)g; }
+  void set_generation(uint8_t g) { generation8 = g; }

-  uint32_t key() const              { return key32; }
-  Depth depth() const               { return (Depth)depth16; }
-  Move move() const                 { return (Move)move16; }
-  Value value() const               { return (Value)value16; }
-  Bound type() const                { return (Bound)bound; }
-  int generation() const            { return (int)generation8; }
-  Value static_value() const        { return (Value)staticValue; }
-  Value static_value_margin() const { return (Value)staticMargin; }
+  uint32_t key() const      { return key32; }
+  Depth depth() const       { return (Depth)depth16; }
+  Move move() const         { return (Move)move16; }
+  Value value() const       { return (Value)value16; }
+  Bound bound() const       { return (Bound)bound8; }
+  int generation() const    { return (int)generation8; }
+  Value eval_value() const  { return (Value)evalValue; }
+  Value eval_margin() const { return (Value)evalMargin; }

 private:
  uint32_t key32;
  uint16_t move16;
-  uint8_t bound, generation8;
-  int16_t value16, depth16, staticValue, staticMargin;
+  uint8_t bound8, generation8;
+  int16_t value16, depth16, evalValue, evalMargin;
 };


-/// This is the number of TTEntry slots for each cluster
-const int ClusterSize = 4;
-
-
-/// TTCluster consists of ClusterSize number of TTEntries. Size of TTCluster
-/// must not be bigger than a cache line size. In case it is less, it should
-/// be padded to guarantee always aligned accesses.
-
-struct TTCluster {
-  TTEntry data[ClusterSize];
-};
-
-
-/// The transposition table class. This is basically just a huge array containing
-/// TTCluster objects, and a few methods for writing and reading entries.
+/// A TranspositionTable consists of a power of 2 number of clusters and each
+/// cluster consists of ClusterSize number of TTEntry. Each non-empty entry
+/// contains information of exactly one position. Size of a cluster shall not be
+/// bigger than a cache line size. In case it is less, it should be padded to
+/// guarantee always aligned accesses.

 class TranspositionTable {

-  TranspositionTable(const TranspositionTable&);
-  TranspositionTable& operator=(const TranspositionTable&);
+  static const unsigned ClusterSize = 4; // A cluster is 64 Bytes

 public:
-  TranspositionTable();
-  ~TranspositionTable();
+ ~TranspositionTable() { free(mem); }
+  void new_search() { generation++; }
+
+  const TTEntry* probe(const Key key) const;
+  TTEntry* first_entry(const Key key) const;
+  void refresh(const TTEntry* tte) const;
  void set_size(size_t mbSize);
  void clear();
-  void store(const Key posKey, Value v, Bound type, Depth d, Move m, Value statV, Value kingD);
-  TTEntry* probe(const Key posKey) const;
-  void new_search();
-  TTEntry* first_entry(const Key posKey) const;
-  void refresh(const TTEntry* tte) const;
+  void store(const Key key, Value v, Bound type, Depth d, Move m, Value statV, Value kingD);

 private:
-  size_t size;
-  TTCluster* entries;
-  uint8_t generation; // Size must be not bigger then TTEntry::generation8
+  uint32_t hashMask;
+  TTEntry* table;
+  void* mem;
+  uint8_t generation; // Size must be not bigger than TTEntry::generation8
 };

 extern TranspositionTable TT;
@@ -119,9 +101,9 @@ extern TranspositionTable TT;
 /// a cluster given a position. The lowest order bits of the key are used to
 /// get the index of the cluster.

-inline TTEntry* TranspositionTable::first_entry(const Key posKey) const {
+inline TTEntry* TranspositionTable::first_entry(const Key key) const {

-  return entries[((uint32_t)posKey) & (size - 1)].data;
+  return table + ((uint32_t)key & hashMask);
 }


@@ -133,4 +115,4 @@ inline void TranspositionTable::refresh(const TTEntry* tte) const {
  const_cast<TTEntry*>(tte)->set_generation(generation);
 }

-#endif // !defined(TT_H_INCLUDED)
+#endif // #ifndef TT_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(TYPES_H_INCLUDED)
+#ifndef TYPES_H_INCLUDED
 #define TYPES_H_INCLUDED

 /// For Linux and OSX configuration is done automatically using Makefile. To get
@@ -35,13 +35,16 @@
 ///               | only in 64-bit mode. For compiling requires hardware with
 ///               | popcnt support.

+#include <cassert>
 #include <cctype>
 #include <climits>
 #include <cstdlib>

 #include "platform.h"

-#if defined(_WIN64)
+#define unlikely(x) (x) // For code annotation purposes
+
+#if defined(_WIN64) && !defined(IS_64BIT)
 #  include <intrin.h> // MSVC popcnt and bsfq instrinsics
 #  define IS_64BIT
 #  define USE_BSFQ
@@ -51,13 +54,18 @@
 #  include <nmmintrin.h> // Intel header for _mm_popcnt_u64() intrinsic
 #endif

+#  if !defined(NO_PREFETCH) && (defined(__INTEL_COMPILER) || defined(_MSC_VER))
+#   include <xmmintrin.h> // Intel and Microsoft header for _mm_prefetch()
+#  endif
+
+#define CACHE_LINE_SIZE 64
 #if defined(_MSC_VER) || defined(__INTEL_COMPILER)
-#  define CACHE_LINE_ALIGNMENT __declspec(align(64))
+#  define CACHE_LINE_ALIGNMENT __declspec(align(CACHE_LINE_SIZE))
 #else
-#  define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(64)))
+#  define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(CACHE_LINE_SIZE)))
 #endif

-#if defined(_MSC_VER)
+#ifdef _MSC_VER
 #  define FORCE_INLINE  __forceinline
 #elif defined(__GNUC__)
 #  define FORCE_INLINE  inline __attribute__((always_inline))
@@ -65,13 +73,13 @@
 #  define FORCE_INLINE  inline
 #endif

-#if defined(USE_POPCNT)
+#ifdef USE_POPCNT
 const bool HasPopCnt = true;
 #else
 const bool HasPopCnt = false;
 #endif

-#if defined(IS_64BIT)
+#ifdef IS_64BIT
 const bool Is64Bit = true;
 #else
 const bool Is64Bit = false;
@@ -82,26 +90,7 @@ typedef uint64_t Bitboard;

 const int MAX_MOVES      = 192;
 const int MAX_PLY        = 100;
-const int MAX_PLY_PLUS_2 = MAX_PLY + 2;
-
-const Bitboard FileABB = 0x0101010101010101ULL;
-const Bitboard FileBBB = FileABB << 1;
-const Bitboard FileCBB = FileABB << 2;
-const Bitboard FileDBB = FileABB << 3;
-const Bitboard FileEBB = FileABB << 4;
-const Bitboard FileFBB = FileABB << 5;
-const Bitboard FileGBB = FileABB << 6;
-const Bitboard FileHBB = FileABB << 7;
-
-const Bitboard Rank1BB = 0xFF;
-const Bitboard Rank2BB = Rank1BB << (8 * 1);
-const Bitboard Rank3BB = Rank1BB << (8 * 2);
-const Bitboard Rank4BB = Rank1BB << (8 * 3);
-const Bitboard Rank5BB = Rank1BB << (8 * 4);
-const Bitboard Rank6BB = Rank1BB << (8 * 5);
-const Bitboard Rank7BB = Rank1BB << (8 * 6);
-const Bitboard Rank8BB = Rank1BB << (8 * 7);
-
+const int MAX_PLY_PLUS_6 = MAX_PLY + 6;

 /// A move needs 16 bits to be stored
 ///
@@ -115,29 +104,37 @@ const Bitboard Rank8BB = Rank1BB << (8 * 7);
 /// while MOVE_NONE and MOVE_NULL have the same origin and destination square.

 enum Move {
-  MOVE_NONE = 0,
+  MOVE_NONE,
  MOVE_NULL = 65
 };

 enum MoveType {
-  NORMAL    = 0,
+  NORMAL,
  PROMOTION = 1 << 14,
  ENPASSANT = 2 << 14,
  CASTLE    = 3 << 14
 };

 enum CastleRight {  // Defined as in PolyGlot book hash key
-  CASTLES_NONE = 0,
-  WHITE_OO     = 1,
-  WHITE_OOO    = 2,
-  BLACK_OO     = 4,
-  BLACK_OOO    = 8,
-  ALL_CASTLES  = 15
+  CASTLES_NONE,
+  WHITE_OO,
+  WHITE_OOO   = WHITE_OO << 1,
+  BLACK_OO    = WHITE_OO << 2,
+  BLACK_OOO   = WHITE_OO << 3,
+  ALL_CASTLES = WHITE_OO | WHITE_OOO | BLACK_OO | BLACK_OOO,
+  CASTLE_RIGHT_NB = 16
 };

 enum CastlingSide {
  KING_SIDE,
-  QUEEN_SIDE
+  QUEEN_SIDE,
+  CASTLING_SIDE_NB = 2
+};
+
+enum Phase {
+  PHASE_ENDGAME,
+  PHASE_MIDGAME = 128,
+  MG = 0, EG = 1, PHASE_NB = 2
 };

 enum ScaleFactor {
@@ -148,9 +145,9 @@ enum ScaleFactor {
 };

 enum Bound {
-  BOUND_NONE  = 0,
-  BOUND_UPPER = 1,
-  BOUND_LOWER = 2,
+  BOUND_NONE,
+  BOUND_UPPER,
+  BOUND_LOWER,
  BOUND_EXACT = BOUND_UPPER | BOUND_LOWER
 };

@@ -168,8 +165,6 @@ enum Value {
  VALUE_ENSURE_INTEGER_SIZE_P = INT_MAX,
  VALUE_ENSURE_INTEGER_SIZE_N = INT_MIN,

-  Mg = 0, Eg = 1,
-
  PawnValueMg   = 198,   PawnValueEg   = 258,
  KnightValueMg = 817,   KnightValueEg = 846,
  BishopValueMg = 836,   BishopValueEg = 857,
@@ -178,18 +173,20 @@ enum Value {
 };

 enum PieceType {
-  NO_PIECE_TYPE = 0, ALL_PIECES = 0,
-  PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
+  NO_PIECE_TYPE, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING,
+  ALL_PIECES = 0,
+  PIECE_TYPE_NB = 8
 };

 enum Piece {
-  NO_PIECE = 16, // color_of(NO_PIECE) == NO_COLOR
-  W_PAWN = 1, W_KNIGHT =  2, W_BISHOP =  3, W_ROOK =  4, W_QUEEN =  5, W_KING =  6,
-  B_PAWN = 9, B_KNIGHT = 10, B_BISHOP = 11, B_ROOK = 12, B_QUEEN = 13, B_KING = 14
+  NO_PIECE,
+  W_PAWN = 1, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING,
+  B_PAWN = 9, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING,
+  PIECE_NB = 16
 };

 enum Color {
-  WHITE, BLACK, NO_COLOR
+  WHITE, BLACK, NO_COLOR, COLOR_NB = 2
 };

 enum Depth {
@@ -199,7 +196,7 @@ enum Depth {
  DEPTH_ZERO          =  0 * ONE_PLY,
  DEPTH_QS_CHECKS     = -1 * ONE_PLY,
  DEPTH_QS_NO_CHECKS  = -2 * ONE_PLY,
-  DEPTH_QS_RECAPTURES = -5 * ONE_PLY,
+  DEPTH_QS_RECAPTURES = -7 * ONE_PLY,

  DEPTH_NONE = -127 * ONE_PLY
 };
@@ -215,6 +212,8 @@ enum Square {
  SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8,
  SQ_NONE,

+  SQUARE_NB = 64,
+
  DELTA_N =  8,
  DELTA_E =  1,
  DELTA_S = -8,
@@ -229,11 +228,11 @@ enum Square {
 };

 enum File {
-  FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H
+  FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, FILE_NB
 };

 enum Rank {
-  RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8
+  RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8, RANK_NB
 };


@@ -242,7 +241,7 @@ enum Rank {
 /// for midgame value. Compiler is free to choose the enum type as long as can
 /// keep its data, so ensure Score to be an integer type.
 enum Score {
-  SCORE_ZERO = 0,
+  SCORE_ZERO,
  SCORE_ENSURE_INTEGER_SIZE_P = INT_MAX,
  SCORE_ENSURE_INTEGER_SIZE_N = INT_MIN
 };
@@ -252,7 +251,7 @@ inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }
 /// Extracting the signed lower and upper 16 bits it not so trivial because
 /// according to the standard a simple cast to short is implementation defined
 /// and so is a right shift of a signed integer.
-inline Value mg_value(Score s) { return Value(((s + 32768) & ~0xffff) / 0x10000); }
+inline Value mg_value(Score s) { return Value(((s + 0x8000) & ~0xffff) / 0x10000); }

 /// On Intel 64 bit we have a small speed regression with the standard conforming
 /// version, so use a faster code in this case that, although not 100% standard
@@ -309,38 +308,17 @@ inline Score operator/(Score s, int i) {
  return make_score(mg_value(s) / i, eg_value(s) / i);
 }

-/// Weight score v by score w trying to prevent overflow
-inline Score apply_weight(Score v, Score w) {
-  return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
-                    (int(eg_value(v)) * eg_value(w)) / 0x100);
-}
-
 #undef ENABLE_OPERATORS_ON
 #undef ENABLE_SAFE_OPERATORS_ON

-namespace Zobrist {
+extern Value PieceValue[PHASE_NB][PIECE_NB];

-  extern Key psq[2][8][64]; // [color][pieceType][square / piece count]
-  extern Key enpassant[8];  // [file]
-  extern Key castle[16];    // [castleRight]
-  extern Key side;
-  extern Key exclusion;
-
-  void init();
-}
-
-CACHE_LINE_ALIGNMENT
-
-extern Score pieceSquareTable[16][64]; // [piece][square]
-extern Value PieceValue[2][18];        // [Mg / Eg][piece / pieceType]
-extern int SquareDistance[64][64];     // [square][square]
-
-struct MoveStack {
+struct ExtMove {
  Move move;
  int score;
 };

-inline bool operator<(const MoveStack& f, const MoveStack& s) {
+inline bool operator<(const ExtMove& f, const ExtMove& s) {
  return f.score < s.score;
 }

@@ -377,6 +355,7 @@ inline PieceType type_of(Piece p)  {
 }

 inline Color color_of(Piece p) {
+  assert(p != NO_PIECE);
  return Color(p >> 3);
 }

@@ -413,24 +392,12 @@ inline bool opposite_colors(Square s1, Square s2) {
  return ((s >> 3) ^ s) & 1;
 }

-inline int file_distance(Square s1, Square s2) {
-  return abs(file_of(s1) - file_of(s2));
-}
-
-inline int rank_distance(Square s1, Square s2) {
-  return abs(rank_of(s1) - rank_of(s2));
-}
-
-inline int square_distance(Square s1, Square s2) {
-  return SquareDistance[s1][s2];
-}
-
-inline char file_to_char(File f) {
-  return char(f - FILE_A + int('a'));
+inline char file_to_char(File f, bool tolower = true) {
+  return char(f - FILE_A + (tolower ? 'a' : 'A'));
 }

 inline char rank_to_char(Rank r) {
-  return char(r - RANK_1 + int('1'));
+  return char(r - RANK_1 + '1');
 }

 inline Square pawn_push(Color c) {
@@ -459,7 +426,7 @@ inline Move make_move(Square from, Square to) {

 template<MoveType T>
 inline Move make(Square from, Square to, PieceType pt = KNIGHT) {
-  return Move(to | (from << 6) | T | ((pt - KNIGHT) << 12)) ;
+  return Move(to | (from << 6) | T | ((pt - KNIGHT) << 12));
 }

 inline bool is_ok(Move m) {
@@ -473,21 +440,4 @@ inline const std::string square_to_string(Square s) {
  return ch;
 }

-/// Our insertion sort implementation, works with pointers and iterators and is
-/// guaranteed to be stable, as is needed.
-template<typename T, typename K>
-void sort(K first, K last)
-{
-  T tmp;
-  K p, q;
-
-  for (p = first + 1; p < last; p++)
-  {
-      tmp = *p;
-      for (q = p; q != first && *(q-1) < tmp; --q)
-          *q = *(q-1);
-      *q = tmp;
-  }
-}
-
-#endif // !defined(TYPES_H_INCLUDED)
+#endif // #ifndef TYPES_H_INCLUDED
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,6 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

+#include <iomanip>
 #include <iostream>
 #include <sstream>
 #include <string>
@@ -41,9 +42,9 @@ namespace {
  // position just before to start searching). Needed by repetition draw detection.
  Search::StateStackPtr SetupStates;

-  void set_option(istringstream& up);
-  void set_position(Position& pos, istringstream& up);
-  void go(Position& pos, istringstream& up);
+  void setoption(istringstream& up);
+  void position(Position& pos, istringstream& up);
+  void go(const Position& pos, istringstream& up);
 }


@@ -54,79 +55,33 @@ namespace {

 void UCI::loop(const string& args) {

-  Position pos(StartFEN, false, Threads.main_thread()); // The root position
-  string cmd, token;
+  Position pos(StartFEN, false, Threads.main()); // The root position
+  string token, cmd = args;

-  while (token != "quit")
-  {
-      if (!args.empty())
-          cmd = args;
-
-      else if (!getline(cin, cmd)) // Block here waiting for input
+  do {
+      if (args.empty() && !getline(cin, cmd)) // Block here waiting for input
          cmd = "quit";

      istringstream is(cmd);

      is >> skipws >> token;

-      if (token == "quit" || token == "stop")
+      if (token == "quit" || token == "stop" || token == "ponderhit")
      {
-          Search::Signals.stop = true;
-          Threads.wait_for_search_finished(); // Cannot quit while threads are running
-      }
-
-      else if (token == "ponderhit")
-      {
-          // The opponent has played the expected move. GUI sends "ponderhit" if
-          // we were told to ponder on the same move the opponent has played. We
-          // should continue searching but switching from pondering to normal search.
-          Search::Limits.ponder = false;
-
-          if (Search::Signals.stopOnPonderhit)
+          // GUI sends 'ponderhit' to tell us to ponder on the same move the
+          // opponent has played. In case Signals.stopOnPonderhit is set we are
+          // waiting for 'ponderhit' to stop the search (for instance because we
+          // already ran out of time), otherwise we should continue searching but
+          // switching from pondering to normal search.
+          if (token != "ponderhit" || Search::Signals.stopOnPonderhit)
          {
              Search::Signals.stop = true;
-              Threads.main_thread()->wake_up(); // Could be sleeping
+              Threads.main()->notify_one(); // Could be sleeping
          }
+          else
+              Search::Limits.ponder = false;
      }
-
-      else if (token == "go")
-          go(pos, is);
-
-      else if (token == "ucinewgame")
-      { /* Avoid returning "Unknown command" */ }
-
-      else if (token == "isready")
-          sync_cout << "readyok" << sync_endl;
-
-      else if (token == "position")
-          set_position(pos, is);
-
-      else if (token == "setoption")
-          set_option(is);
-
-      else if (token == "d")
-          pos.print();
-
-      else if (token == "flip")
-          pos.flip();
-
-      else if (token == "eval")
-          sync_cout << Eval::trace(pos) << sync_endl;
-
-      else if (token == "bench")
-          benchmark(pos, is);
-
-      else if (token == "key")
-          sync_cout << "key: " << hex     << pos.key()
-                    << "\nmaterial key: " << pos.material_key()
-                    << "\npawn key: "     << pos.pawn_key() << sync_endl;
-
-      else if (token == "uci")
-          sync_cout << "id name " << engine_info(true)
-                    << "\n"       << Options
-                    << "\nuciok"  << sync_endl;
-
-      else if (token == "perft" && (is >> token)) // Read depth
+      else if (token == "perft" && (is >> token)) // Read perft depth
      {
          stringstream ss;

@@ -135,27 +90,48 @@ void UCI::loop(const string& args) {

          benchmark(pos, ss);
      }
+      else if (token == "key")
+          sync_cout << hex << uppercase << setfill('0')
+                    << "position key: "   << setw(16) << pos.key()
+                    << "\nmaterial key: " << setw(16) << pos.material_key()
+                    << "\npawn key:     " << setw(16) << pos.pawn_key()
+                    << dec << sync_endl;

+      else if (token == "uci")
+          sync_cout << "id name " << engine_info(true)
+                    << "\n"       << Options
+                    << "\nuciok"  << sync_endl;
+
+      else if (token == "eval")
+      {
+          Search::RootColor = pos.side_to_move(); // Ensure it is set
+          sync_cout << Eval::trace(pos) << sync_endl;
+      }
+      else if (token == "ucinewgame") { /* Avoid returning "Unknown command" */ }
+      else if (token == "go")         go(pos, is);
+      else if (token == "position")   position(pos, is);
+      else if (token == "setoption")  setoption(is);
+      else if (token == "flip")       pos.flip();
+      else if (token == "bench")      benchmark(pos, is);
+      else if (token == "d")          sync_cout << pos.pretty() << sync_endl;
+      else if (token == "isready")    sync_cout << "readyok" << sync_endl;
      else
          sync_cout << "Unknown command: " << cmd << sync_endl;

-      if (!args.empty()) // Command line arguments have one-shot behaviour
-      {
-          Threads.wait_for_search_finished();
-          break;
-      }
-  }
+  } while (token != "quit" && args.empty()); // Args have one-shot behaviour
+
+  Threads.wait_for_think_finished(); // Cannot quit while search is running
 }


 namespace {

-  // set_position() is called when engine receives the "position" UCI command.
+  // position() is called when engine receives the "position" UCI command.
  // The function sets up the position described in the given fen string ("fen")
  // or the starting position ("startpos") and then makes the moves given in the
  // following move list ("moves").

-  void set_position(Position& pos, istringstream& is) {
+  void position(Position& pos, istringstream& is) {

    Move m;
    string token, fen;
@@ -173,7 +149,7 @@ namespace {
    else
        return;

-    pos.from_fen(fen, Options["UCI_Chess960"], Threads.main_thread());
+    pos.set(fen, Options["UCI_Chess960"], Threads.main());
    SetupStates = Search::StateStackPtr(new std::stack<StateInfo>());

    // Parse move list (if any)
@@ -185,10 +161,10 @@ namespace {
  }


-  // set_option() is called when engine receives the "setoption" UCI command. The
+  // setoption() is called when engine receives the "setoption" UCI command. The
  // function updates the UCI option ("name") to the given value ("value").

-  void set_option(istringstream& is) {
+  void setoption(istringstream& is) {

    string token, name, value;

@@ -210,10 +186,10 @@ namespace {


  // go() is called when engine receives the "go" UCI command. The function sets
-  // the thinking time and other parameters from the input string, and then starts
+  // the thinking time and other parameters from the input string, and starts
  // the search.

-  void go(Position& pos, istringstream& is) {
+  void go(const Position& pos, istringstream& is) {

    Search::LimitsType limits;
    vector<Move> searchMoves;
@@ -221,31 +197,23 @@ namespace {

    while (is >> token)
    {
-        if (token == "wtime")
-            is >> limits.time[WHITE];
-        else if (token == "btime")
-            is >> limits.time[BLACK];
-        else if (token == "winc")
-            is >> limits.inc[WHITE];
-        else if (token == "binc")
-            is >> limits.inc[BLACK];
-        else if (token == "movestogo")
-            is >> limits.movestogo;
-        else if (token == "depth")
-            is >> limits.depth;
-        else if (token == "nodes")
-            is >> limits.nodes;
-        else if (token == "movetime")
-            is >> limits.movetime;
-        else if (token == "infinite")
-            limits.infinite = true;
-        else if (token == "ponder")
-            limits.ponder = true;
-        else if (token == "searchmoves")
+        if (token == "searchmoves")
            while (is >> token)
                searchMoves.push_back(move_from_uci(pos, token));
+
+        else if (token == "wtime")     is >> limits.time[WHITE];
+        else if (token == "btime")     is >> limits.time[BLACK];
+        else if (token == "winc")      is >> limits.inc[WHITE];
+        else if (token == "binc")      is >> limits.inc[BLACK];
+        else if (token == "movestogo") is >> limits.movestogo;
+        else if (token == "depth")     is >> limits.depth;
+        else if (token == "nodes")     is >> limits.nodes;
+        else if (token == "movetime")  is >> limits.movetime;
+        else if (token == "mate")      is >> limits.mate;
+        else if (token == "infinite")  limits.infinite = true;
+        else if (token == "ponder")    limits.ponder = true;
    }

-    Threads.start_searching(pos, limits, searchMoves, SetupStates);
+    Threads.start_thinking(pos, limits, searchMoves, SetupStates);
  }
 }
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -51,31 +51,29 @@ bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const


 /// init() initializes the UCI options to their hard coded default values
-/// and initializes the default value of "Threads" and "Min Split Depth"
-/// parameters according to the number of CPU cores detected.

 void init(OptionsMap& o) {

-  int cpus = std::min(cpu_count(), MAX_THREADS);
-  int msd = cpus < 8 ? 4 : 7;
-
-  o["Use Debug Log"]               = Option(false, on_logger);
-  o["Use Search Log"]              = Option(false);
+  o["Write Debug Log"]             = Option(false, on_logger);
+  o["Write Search Log"]            = Option(false);
  o["Search Log Filename"]         = Option("SearchLog.txt");
  o["Book File"]                   = Option("book.bin");
  o["Best Book Move"]              = Option(false);
-  o["Mobility (Middle Game)"]      = Option(100, 0, 200, on_eval);
+  o["Contempt Factor"]             = Option(0, -50,  50);
+  o["Mobility (Midgame)"]          = Option(100, 0, 200, on_eval);
  o["Mobility (Endgame)"]          = Option(100, 0, 200, on_eval);
-  o["Passed Pawns (Middle Game)"]  = Option(100, 0, 200, on_eval);
+  o["Pawn Structure (Midgame)"]    = Option(100, 0, 200, on_eval);
+  o["Pawn Structure (Endgame)"]    = Option(100, 0, 200, on_eval);
+  o["Passed Pawns (Midgame)"]      = Option(100, 0, 200, on_eval);
  o["Passed Pawns (Endgame)"]      = Option(100, 0, 200, on_eval);
  o["Space"]                       = Option(100, 0, 200, on_eval);
  o["Aggressiveness"]              = Option(100, 0, 200, on_eval);
  o["Cowardice"]                   = Option(100, 0, 200, on_eval);
-  o["Min Split Depth"]             = Option(msd, 4, 7, on_threads);
-  o["Max Threads per Split Point"] = Option(5, 4, 8, on_threads);
-  o["Threads"]                     = Option(cpus, 1, MAX_THREADS, on_threads);
-  o["Use Sleeping Threads"]        = Option(false, on_threads);
-  o["Hash"]                        = Option(32, 4, 8192, on_hash_size);
+  o["Min Split Depth"]             = Option(0, 0, 12, on_threads);
+  o["Max Threads per Split Point"] = Option(5, 4,  8, on_threads);
+  o["Threads"]                     = Option(1, 1, MAX_THREADS, on_threads);
+  o["Idle Threads Sleep"]          = Option(false);
+  o["Hash"]                        = Option(32, 1, 8192, on_hash_size);
  o["Clear Hash"]                  = Option(on_clear_hash);
  o["Ponder"]                      = Option(true);
  o["OwnBook"]                     = Option(false);
@@ -1,7 +1,7 @@
 /*
  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2013 Marco Costalba, Joona Kiiski, Tord Romstad

  Stockfish is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-#if !defined(UCIOPTION_H_INCLUDED)
+#ifndef UCIOPTION_H_INCLUDED
 #define UCIOPTION_H_INCLUDED

 #include <map>
@@ -66,4 +66,4 @@ void loop(const std::string&);

 extern UCI::OptionsMap Options;

-#endif // !defined(UCIOPTION_H_INCLUDED)
+#endif // #ifndef UCIOPTION_H_INCLUDED