X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=78b85485d1efcf24ac9b53e11eb383c797f8ed05;hp=5bb12a856ce19dcb3085727960cc7dc9f5ba1fc6;hb=18cd83a38042a3993678e88bc8163ceb1cbd62b4;hpb=22f9f0cabe6f8de8051470fae3917533a411067e

diff --git a/src/search.cpp b/src/search.cpp
index 5bb12a85..78b85485 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -23,6 +23,7 @@
 ////
 
 #include <cassert>
+#include <cstring>
 #include <fstream>
 #include <iostream>
 #include <sstream>
@@ -31,7 +32,9 @@
 #include "evaluate.h"
 #include "history.h"
 #include "misc.h"
+#include "movegen.h"
 #include "movepick.h"
+#include "lock.h"
 #include "san.h"
 #include "search.h"
 #include "thread.h"
@@ -47,57 +50,23 @@ namespace {
 
   /// Types
 
-  //The IterationInfoType is used to store search history
-  //iteration by iteration.
+  // IterationInfoType stores search results for each iteration
   //
-  //Because we use relatively small (dynamic) aspiration window,
-  //there happens many fail highs and fail lows in root. And
-  //because we don't do researches in those cases, "value" stored
-  //here is not necessarily exact. Instead in case of fail high/low
-  //we guess what the right value might be and store our guess
-  //as "speculated value" and then move on...
-
-  class IterationInfoType {
-    private:
-      Value _value;
-      Value _speculatedValue;
-      bool _failHigh;
-      bool _failLow;
-    public:
-      IterationInfoType() {
-        clear();
-      }
-
-      inline void clear() {
-        set(Value(0));
-      }
-
-      inline void set(Value v) {
-        set(v, v, false, false);
-      }
-
-      inline void set(Value v, Value specV, bool fHigh, bool fLow) {
-        _value = v;
-        _speculatedValue = specV;
-        _failHigh = fHigh;
-        _failLow = fLow;
-      }
+  // Because we use relatively small (dynamic) aspiration window,
+  // there happens many fail highs and fail lows in root. And
+  // because we don't do researches in those cases, "value" stored
+  // here is not necessarily exact. Instead in case of fail high/low
+  // we guess what the right value might be and store our guess
+  // as a "speculated value" and then move on. Speculated values are
+  // used just to calculate aspiration window width, so also if are
+  // not exact is not big a problem.
 
-      inline Value value() {
-        return _value;
-      }
-
-      inline Value speculated_value() {
-        return _speculatedValue;
-      }
+  struct IterationInfoType {
 
-      inline bool fail_high() {
-        return _failHigh;
-      }
+    IterationInfoType(Value v = Value(0), Value sv = Value(0))
+    : value(v), speculatedValue(sv) {}
 
-      inline bool fail_low() {
-        return _failLow;
-      }
+    Value value, speculatedValue;
   };
 
 
@@ -105,7 +74,8 @@ namespace {
   // Apart for the first one that has its score, following moves
   // normally have score -VALUE_INFINITE, so are ordered according
   // to the number of beta cutoffs occurred under their subtree during
-  // the last iteration.
+  // the last iteration. The counters are per thread variables to avoid
+  // concurrent accessing under SMP case.
 
   struct BetaCounterType {
 
@@ -113,8 +83,6 @@ namespace {
     void clear();
     void add(Color us, Depth d, int threadID);
     void read(Color us, int64_t& our, int64_t& their);
-
-    int64_t hits[THREAD_MAX][2];
   };
 
 
@@ -141,7 +109,7 @@ namespace {
   class RootMoveList {
 
   public:
-    RootMoveList(Position &pos, Move searchMoves[]);
+    RootMoveList(Position& pos, Move searchMoves[]);
     inline Move get_move(int moveNum) const;
     inline Value get_move_score(int moveNum) const;
     inline void set_move_score(int moveNum, Value score);
@@ -162,129 +130,124 @@ namespace {
   };
 
 
-  /// Constants and variables
-
-  // Minimum number of full depth (i.e. non-reduced) moves at PV and non-PV
-  // nodes:
-  int LMRPVMoves = 15;
-  int LMRNonPVMoves = 4;
+  /// Constants
 
-  // Depth limit for use of dynamic threat detection:
-  Depth ThreatDepth = 5*OnePly;
+  // Search depth at iteration 1
+  const Depth InitialDepth = OnePly /*+ OnePly/2*/;
 
-  // Depth limit for selective search:
-  Depth SelectiveDepth = 7*OnePly;
+  // Depth limit for selective search
+  const Depth SelectiveDepth = 7 * OnePly;
 
   // Use internal iterative deepening?
   const bool UseIIDAtPVNodes = true;
   const bool UseIIDAtNonPVNodes = false;
 
-  // Internal iterative deepening margin.  At Non-PV moves, when
-  // UseIIDAtNonPVNodes is true, we do an internal iterative deepening search
-  // when the static evaluation is at most IIDMargin below beta.
+  // Internal iterative deepening margin. At Non-PV moves, when
+  // UseIIDAtNonPVNodes is true, we do an internal iterative deepening
+  // search when the static evaluation is at most IIDMargin below beta.
   const Value IIDMargin = Value(0x100);
 
-  // Easy move margin.  An easy move candidate must be at least this much
+  // Easy move margin. An easy move candidate must be at least this much
   // better than the second best move.
   const Value EasyMoveMargin = Value(0x200);
 
-  // Problem margin.  If the score of the first move at iteration N+1 has
+  // Problem margin. If the score of the first move at iteration N+1 has
   // dropped by more than this since iteration N, the boolean variable
   // "Problem" is set to true, which will make the program spend some extra
   // time looking for a better move.
   const Value ProblemMargin = Value(0x28);
 
-  // No problem margin.  If the boolean "Problem" is true, and a new move
+  // No problem margin. If the boolean "Problem" is true, and a new move
   // is found at the root which is less than NoProblemMargin worse than the
   // best move from the previous iteration, Problem is set back to false.
   const Value NoProblemMargin = Value(0x14);
 
-  // Null move margin.  A null move search will not be done if the approximate
+  // Null move margin. A null move search will not be done if the approximate
   // evaluation of the position is more than NullMoveMargin below beta.
   const Value NullMoveMargin = Value(0x300);
 
-  // Pruning criterions.  See the code and comments in ok_to_prune() to
+  // Pruning criterions. See the code and comments in ok_to_prune() to
   // understand their precise meaning.
-  const bool PruneEscapeMoves = false;
+  const bool PruneEscapeMoves    = false;
   const bool PruneDefendingMoves = false;
-  const bool PruneBlockingMoves = false;
-
-  // Use futility pruning?
-  bool UseQSearchFutilityPruning = true;
-  bool UseFutilityPruning = true;
+  const bool PruneBlockingMoves  = false;
 
   // Margins for futility pruning in the quiescence search, and at frontier
-  // and near frontier nodes
-  Value FutilityMarginQS = Value(0x80);
-  Value FutilityMargins[6] = { Value(0x100), Value(0x200), Value(0x250),
-                               Value(0x2A0), Value(0x340), Value(0x3A0) };
+  // and near frontier nodes.
+  const Value FutilityMarginQS = Value(0x80);
 
+  // Remaining depth:                  1 ply         1.5 ply       2 ply         2.5 ply       3 ply         3.5 ply
+  const Value FutilityMargins[12] = { Value(0x100), Value(0x120), Value(0x200), Value(0x220), Value(0x250), Value(0x270),
+  //                                   4 ply         4.5 ply       5 ply         5.5 ply       6 ply         6.5 ply
+                                      Value(0x2A0), Value(0x2C0), Value(0x340), Value(0x360), Value(0x3A0), Value(0x3C0) };
   // Razoring
-  const bool RazorAtDepthOne = false;
-  Depth RazorDepth = 4*OnePly;
-  Value RazorMargin = Value(0x300);
+  const Depth RazorDepth = 4*OnePly;
 
-  // Last seconds noise filtering (LSN)
-  bool UseLSNFiltering = false;
-  bool looseOnTime = false;
-  int LSNTime = 4 * 1000; // In milliseconds
-  Value LSNValue = Value(0x200);
-
-  // Extensions.  Array index 0 is used at non-PV nodes, index 1 at PV nodes.
-  Depth CheckExtension[2] = {OnePly, OnePly};
-  Depth SingleReplyExtension[2] = {OnePly / 2, OnePly / 2};
-  Depth PawnPushTo7thExtension[2] = {OnePly / 2, OnePly / 2};
-  Depth PassedPawnExtension[2] = {Depth(0), Depth(0)};
-  Depth PawnEndgameExtension[2] = {OnePly, OnePly};
-  Depth MateThreatExtension[2] = {Depth(0), Depth(0)};
+  // Remaining depth:                 1 ply         1.5 ply       2 ply         2.5 ply       3 ply         3.5 ply
+  const Value RazorMargins[6]     = { Value(0x180), Value(0x300), Value(0x300), Value(0x3C0), Value(0x3C0), Value(0x3C0) };
 
-  // Search depth at iteration 1
-  const Depth InitialDepth = OnePly /*+ OnePly/2*/;
+  // Remaining depth:                 1 ply         1.5 ply       2 ply         2.5 ply       3 ply         3.5 ply
+  const Value RazorApprMargins[6] = { Value(0x520), Value(0x300), Value(0x300), Value(0x300), Value(0x300), Value(0x300) };
 
-  // Node counters
-  int NodesSincePoll;
-  int NodesBetweenPolls = 30000;
+
+  /// Variables initialized by UCI options
+
+  // Minimum number of full depth (i.e. non-reduced) moves at PV and non-PV nodes
+  int LMRPVMoves, LMRNonPVMoves; // heavy SMP read access for the latter
+
+  // Depth limit for use of dynamic threat detection
+  Depth ThreatDepth; // heavy SMP read access
+
+  // Last seconds noise filtering (LSN)
+  const bool UseLSNFiltering = true;
+  const int LSNTime = 4000; // In milliseconds
+  const Value LSNValue = value_from_centipawns(200);
+  bool loseOnTime = false;
+
+  // Extensions. Array index 0 is used at non-PV nodes, index 1 at PV nodes.
+  // There is heavy SMP read access on these arrays
+  Depth CheckExtension[2], SingleReplyExtension[2], PawnPushTo7thExtension[2];
+  Depth PassedPawnExtension[2], PawnEndgameExtension[2], MateThreatExtension[2];
 
   // Iteration counters
   int Iteration;
-  BetaCounterType BetaCounter;
+  BetaCounterType BetaCounter; // has per-thread internal data
 
-  // Scores and number of times the best move changed for each iteration:
+  // Scores and number of times the best move changed for each iteration
   IterationInfoType IterationInfo[PLY_MAX_PLUS_2];
   int BestMoveChangesByIteration[PLY_MAX_PLUS_2];
 
   // MultiPV mode
-  int MultiPV = 1;
+  int MultiPV;
 
   // Time managment variables
   int SearchStartTime;
   int MaxNodes, MaxDepth;
-  int MaxSearchTime, AbsoluteMaxSearchTime, ExtraSearchTime;
-  Move EasyMove;
+  int MaxSearchTime, AbsoluteMaxSearchTime, ExtraSearchTime, ExactMaxTime;
   int RootMoveNumber;
   bool InfiniteSearch;
   bool PonderSearch;
   bool StopOnPonderhit;
-  bool AbortSearch;
+  bool AbortSearch; // heavy SMP read access
   bool Quit;
   bool FailHigh;
   bool FailLow;
   bool Problem;
-  bool PonderingEnabled;
-  int ExactMaxTime;
 
   // Show current line?
-  bool ShowCurrentLine = false;
+  bool ShowCurrentLine;
 
   // Log file
-  bool UseLogFile = false;
+  bool UseLogFile;
   std::ofstream LogFile;
 
   // MP related variables
-  Depth MinimumSplitDepth = 4*OnePly;
-  int MaxThreadsPerSplitPoint = 4;
+  int ActiveThreads = 1;
+  Depth MinimumSplitDepth;
+  int MaxThreadsPerSplitPoint;
   Thread Threads[THREAD_MAX];
   Lock MPLock;
+  Lock IOLock;
   bool AllThreadsShouldExit = false;
   const int MaxActiveSplitPoints = 8;
   SplitPoint SplitPointStack[THREAD_MAX][MaxActiveSplitPoints];
@@ -297,50 +260,54 @@ namespace {
   HANDLE SitIdleEvent[THREAD_MAX];
 #endif
 
+  // Node counters, used only by thread[0] but try to keep in different
+  // cache lines (64 bytes each) from the heavy SMP read accessed variables.
+  int NodesSincePoll;
+  int NodesBetweenPolls = 30000;
+
+  // History table
+  History H;
+
 
   /// Functions
 
-  Value id_loop(const Position &pos, Move searchMoves[]);
-  Value root_search(Position &pos, SearchStack ss[], RootMoveList &rml,
-                    Value alpha, Value beta);
-  Value search_pv(Position &pos, SearchStack ss[], Value alpha, Value beta,
-                  Depth depth, int ply, int threadID);
-  Value search(Position &pos, SearchStack ss[], Value beta,
-               Depth depth, int ply, bool allowNullmove, int threadID);
-  Value qsearch(Position &pos, SearchStack ss[], Value alpha, Value beta,
-                Depth depth, int ply, int threadID);
-  void sp_search(SplitPoint *sp, int threadID);
-  void sp_search_pv(SplitPoint *sp, int threadID);
+  Value id_loop(const Position& pos, Move searchMoves[]);
+  Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value alpha, Value beta);
+  Value search_pv(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
+  Value search(Position& pos, SearchStack ss[], Value beta, Depth depth, int ply, bool allowNullmove, int threadID);
+  Value qsearch(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
+  void sp_search(SplitPoint* sp, int threadID);
+  void sp_search_pv(SplitPoint* sp, int threadID);
   void init_node(SearchStack ss[], int ply, int threadID);
   void update_pv(SearchStack ss[], int ply);
-  void sp_update_pv(SearchStack *pss, SearchStack ss[], int ply);
-  bool connected_moves(const Position &pos, Move m1, Move m2);
+  void sp_update_pv(SearchStack* pss, SearchStack ss[], int ply);
+  bool connected_moves(const Position& pos, Move m1, Move m2);
   bool value_is_mate(Value value);
   bool move_is_killer(Move m, const SearchStack& ss);
-  Depth extension(const Position &pos, Move m, bool pvNode, bool capture, bool check, bool singleReply, bool mateThreat, bool* dangerous);
-  bool ok_to_do_nullmove(const Position &pos);
-  bool ok_to_prune(const Position &pos, Move m, Move threat, Depth d);
+  Depth extension(const Position& pos, Move m, bool pvNode, bool capture, bool check, bool singleReply, bool mateThreat, bool* dangerous);
+  bool ok_to_do_nullmove(const Position& pos);
+  bool ok_to_prune(const Position& pos, Move m, Move threat, Depth d);
   bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply);
-  bool ok_to_history(const Position &pos, Move m);
+  bool ok_to_history(const Position& pos, Move m);
   void update_history(const Position& pos, Move m, Depth depth, Move movesSearched[], int moveCount);
   void update_killers(Move m, SearchStack& ss);
 
   bool fail_high_ply_1();
-  bool aspiration_fail_high_ply_1();
   int current_search_time();
   int nps();
   void poll();
   void ponderhit();
   void print_current_line(SearchStack ss[], int ply, int threadID);
   void wait_for_stop_or_ponderhit();
+  void init_ss_array(SearchStack ss[]);
 
-  void idle_loop(int threadID, SplitPoint *waitSp);
+  void idle_loop(int threadID, SplitPoint* waitSp);
   void init_split_point_stack();
   void destroy_split_point_stack();
   bool thread_should_stop(int threadID);
   bool thread_is_available(int slave, int master);
   bool idle_thread_exists(int master);
-  bool split(const Position &pos, SearchStack *ss, int ply,
+  bool split(const Position& pos, SearchStack* ss, int ply,
              Value *alpha, Value *beta, Value *bestValue, Depth depth, int *moves,
              MovePicker *mp, Bitboard dcCandidates, int master, bool pvNode);
   void wake_sleeping_threads();
@@ -354,53 +321,16 @@ namespace {
 }
 
 
-////
-//// Global variables
-////
-
-// The main transposition table
-TranspositionTable TT = TranspositionTable(TTDefaultSize);
-
-
-// Number of active threads:
-int ActiveThreads = 1;
-
-// Locks.  In principle, there is no need for IOLock to be a global variable,
-// but it could turn out to be useful for debugging.
-Lock IOLock;
-
-History H;  // Should be made local?
-
-// The empty search stack
-SearchStack EmptySearchStack;
-
-
-// SearchStack::init() initializes a search stack. Used at the beginning of a
-// new search from the root.
-void SearchStack::init(int ply) {
-
-  pv[ply] = pv[ply + 1] = MOVE_NONE;
-  currentMove = threatMove = MOVE_NONE;
-  reduction = Depth(0);
-}
-
-void SearchStack::initKillers() {
-
-  mateKiller = MOVE_NONE;
-  for (int i = 0; i < KILLER_MAX; i++)
-      killers[i] = MOVE_NONE;
-}
-
-
 ////
 //// Functions
 ////
 
 /// think() is the external interface to Stockfish's search, and is called when
-/// the program receives the UCI 'go' command.  It initializes various
-/// search-related global variables, and calls root_search()
+/// the program receives the UCI 'go' command. It initializes various
+/// search-related global variables, and calls root_search(). It returns false
+/// when a quit command is received during the search.
 
-void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
+bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
            int time[], int increment[], int movesToGo, int maxDepth,
            int maxNodes, int maxTime, Move searchMoves[]) {
 
@@ -409,27 +339,23 @@ void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
   {
       Move bookMove;
       if (get_option_value_string("Book File") != OpeningBook.file_name())
-      {
-          OpeningBook.close();
           OpeningBook.open("book.bin");
-      }
+
       bookMove = OpeningBook.get_move(pos);
       if (bookMove != MOVE_NONE)
       {
           std::cout << "bestmove " << bookMove << std::endl;
-          return;
+          return true;
       }
   }
 
   // Initialize global search variables
   Idle = false;
   SearchStartTime = get_system_time();
-  EasyMove = MOVE_NONE;
   for (int i = 0; i < THREAD_MAX; i++)
   {
       Threads[i].nodes = 0ULL;
       Threads[i].failHighPly1 = false;
-      Threads[i].aspirationFailHighPly1 = false;
   }
   NodesSincePoll = 0;
   InfiniteSearch = infinite;
@@ -445,9 +371,12 @@ void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
   // Read UCI option values
   TT.set_size(get_option_value_int("Hash"));
   if (button_was_pressed("Clear Hash"))
+  {
       TT.clear();
+      loseOnTime = false; // reset at the beginning of a new game
+  }
 
-  PonderingEnabled = get_option_value_bool("Ponder");
+  bool PonderingEnabled = get_option_value_bool("Ponder");
   MultiPV = get_option_value_int("MultiPV");
 
   CheckExtension[1] = Depth(get_option_value_int("Check Extension (PV nodes)"));
@@ -468,10 +397,9 @@ void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
   MateThreatExtension[1] = Depth(get_option_value_int("Mate Threat Extension (PV nodes)"));
   MateThreatExtension[0] = Depth(get_option_value_int("Mate Threat Extension (non-PV nodes)"));
 
-  LMRPVMoves     = get_option_value_int("Full Depth Moves (PV nodes)") + 1;
-  LMRNonPVMoves  = get_option_value_int("Full Depth Moves (non-PV nodes)") + 1;
-  ThreatDepth    = get_option_value_int("Threat Depth") * OnePly;
-  SelectiveDepth = get_option_value_int("Selective Plies") * OnePly;
+  LMRPVMoves    = get_option_value_int("Full Depth Moves (PV nodes)") + 1;
+  LMRNonPVMoves = get_option_value_int("Full Depth Moves (non-PV nodes)") + 1;
+  ThreatDepth   = get_option_value_int("Threat Depth") * OnePly;
 
   Chess960 = get_option_value_bool("UCI_Chess960");
   ShowCurrentLine = get_option_value_bool("UCI_ShowCurrLine");
@@ -479,26 +407,12 @@ void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
   if (UseLogFile)
       LogFile.open(get_option_value_string("Search Log Filename").c_str(), std::ios::out | std::ios::app);
 
-  UseQSearchFutilityPruning = get_option_value_bool("Futility Pruning (Quiescence Search)");
-  UseFutilityPruning = get_option_value_bool("Futility Pruning (Main Search)");
-
-  FutilityMarginQS = value_from_centipawns(get_option_value_int("Futility Margin (Quiescence Search)"));
-  int fmScale = get_option_value_int("Futility Margin Scale Factor (Main Search)");
-  for (int i = 0; i < 6; i++)
-      FutilityMargins[i] = (FutilityMargins[i] * fmScale) / 100;
-
-  RazorDepth = (get_option_value_int("Maximum Razoring Depth") + 1) * OnePly;
-  RazorMargin = value_from_centipawns(get_option_value_int("Razoring Margin"));
-
-  UseLSNFiltering = get_option_value_bool("LSN filtering");
-  LSNTime = get_option_value_int("LSN Time Margin (sec)") * 1000;
-  LSNValue = value_from_centipawns(get_option_value_int("LSN Value Margin"));
-
   MinimumSplitDepth = get_option_value_int("Minimum Split Depth") * OnePly;
   MaxThreadsPerSplitPoint = get_option_value_int("Maximum Number of Threads per Split Point");
 
   read_weights(pos.side_to_move());
 
+  // Set the number of active threads
   int newActiveThreads = get_option_value_int("Threads");
   if (newActiveThreads != ActiveThreads)
   {
@@ -506,13 +420,13 @@ void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
       init_eval(ActiveThreads);
   }
 
-  // Wake up sleeping threads:
+  // Wake up sleeping threads
   wake_sleeping_threads();
 
   for (int i = 1; i < ActiveThreads; i++)
       assert(thread_is_available(i, 0));
 
-  // Set thinking time:
+  // Set thinking time
   int myTime = time[side_to_move];
   int myIncrement = increment[side_to_move];
 
@@ -559,30 +473,30 @@ void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
   else
       NodesBetweenPolls = 30000;
 
-
-  // Write information to search log file:
+  // Write information to search log file
   if (UseLogFile)
       LogFile << "Searching: " << pos.to_fen() << std::endl
-              << "infinite: " << infinite
-              << " ponder: " << ponder
-              << " time: " << myTime
+              << "infinite: "  << infinite
+              << " ponder: "   << ponder
+              << " time: "     << myTime
               << " increment: " << myIncrement
               << " moves to go: " << movesToGo << std::endl;
 
 
-  // We're ready to start thinking.  Call the iterative deepening loop
-  // function:
-  if (!looseOnTime)
+  // We're ready to start thinking. Call the iterative deepening loop function
+  //
+  // FIXME we really need to cleanup all this LSN ugliness
+  if (!loseOnTime)
   {
       Value v = id_loop(pos, searchMoves);
-      looseOnTime = (   UseLSNFiltering
-                     && myTime < LSNTime
-                     && myIncrement == 0
-                     && v < -LSNValue);
+      loseOnTime = (   UseLSNFiltering
+                    && myTime < LSNTime
+                    && myIncrement == 0
+                    && v < -LSNValue);
   }
   else
   {
-      looseOnTime = false; // reset for next match
+      loseOnTime = false; // reset for next match
       while (SearchStartTime + myTime + 1000 > get_system_time())
           ; // wait here
       id_loop(pos, searchMoves); // to fail gracefully
@@ -591,14 +505,8 @@ void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
   if (UseLogFile)
       LogFile.close();
 
-  if (Quit)
-  {
-      OpeningBook.close();
-      stop_threads();
-      quit_eval();
-      exit(0);
-  }
   Idle = true;
+  return !Quit;
 }
 
 
@@ -617,7 +525,7 @@ void init_threads() {
   for (i = 0; i < THREAD_MAX; i++)
       Threads[i].activeSplitPoints = 0;
 
-  // Initialize global locks:
+  // Initialize global locks
   lock_init(&MPLock, NULL);
   lock_init(&IOLock, NULL);
 
@@ -650,13 +558,9 @@ void init_threads() {
       CreateThread(NULL, 0, init_thread, (LPVOID)(&i), 0, iID);
 #endif
 
-      // Wait until the thread has finished launching:
+      // Wait until the thread has finished launching
       while (!Threads[i].running);
   }
-
-  // Init also the empty search stack
-  EmptySearchStack.init(0);
-  EmptySearchStack.initKillers();
 }
 
 
@@ -690,6 +594,22 @@ int64_t nodes_searched() {
 }
 
 
+// SearchStack::init() initializes a search stack. Used at the beginning of a
+// new search from the root.
+void SearchStack::init(int ply) {
+
+  pv[ply] = pv[ply + 1] = MOVE_NONE;
+  currentMove = threatMove = MOVE_NONE;
+  reduction = Depth(0);
+}
+
+void SearchStack::initKillers() {
+
+  mateKiller = MOVE_NONE;
+  for (int i = 0; i < KILLER_MAX; i++)
+      killers[i] = MOVE_NONE;
+}
+
 namespace {
 
   // id_loop() is the main iterative deepening loop.  It calls root_search
@@ -697,7 +617,7 @@ namespace {
   // been consumed, the user stops the search, or the maximum search depth is
   // reached.
 
-  Value id_loop(const Position &pos, Move searchMoves[]) {
+  Value id_loop(const Position& pos, Move searchMoves[]) {
 
     Position p(pos);
     SearchStack ss[PLY_MAX_PLUS_2];
@@ -705,18 +625,23 @@ namespace {
     // searchMoves are verified, copied, scored and sorted
     RootMoveList rml(p, searchMoves);
 
+    // Print RootMoveList c'tor startup scoring to the standard output,
+    // so that we print information also for iteration 1.
+    std::cout << "info depth " << 1 << "\ninfo depth " << 1
+              << " score " << value_to_string(rml.get_move_score(0))
+              << " time " << current_search_time()
+              << " nodes " << nodes_searched()
+              << " nps " << nps()
+              << " pv " << rml.get_move(0) << "\n";
+
     // Initialize
     TT.new_search();
     H.clear();
-    for (int i = 0; i < 3; i++)
-    {
-        ss[i].init(i);
-        ss[i].initKillers();
-    }
-    IterationInfo[1].set(rml.get_move_score(0));
+    init_ss_array(ss);
+    IterationInfo[1] = IterationInfoType(rml.get_move_score(0), rml.get_move_score(0));
     Iteration = 1;
 
-    EasyMove = rml.scan_for_easy_move();
+    Move EasyMove = rml.scan_for_easy_move();
 
     // Iterative deepening loop
     while (Iteration < PLY_MAX)
@@ -730,59 +655,62 @@ namespace {
 
         std::cout << "info depth " << Iteration << std::endl;
 
-        //Calculate dynamic search window based on previous iterations.
-        Value alpha;
-        Value beta;
-
-        if (MultiPV == 1 && Iteration >= 6) {
-          Value prevDelta1 = IterationInfo[Iteration - 1].speculated_value() - IterationInfo[Iteration - 2].speculated_value();
-          Value prevDelta2 = IterationInfo[Iteration - 2].speculated_value() - IterationInfo[Iteration - 3].speculated_value();
+        // Calculate dynamic search window based on previous iterations
+        Value alpha, beta;
 
-          Value delta = Max((2 * Abs(prevDelta1) + Abs(prevDelta2)) , ProblemMargin);
+        if (MultiPV == 1 && Iteration >= 6 && abs(IterationInfo[Iteration - 1].value) < VALUE_KNOWN_WIN)
+        {
+            int prevDelta1 = IterationInfo[Iteration - 1].speculatedValue - IterationInfo[Iteration - 2].speculatedValue;
+            int prevDelta2 = IterationInfo[Iteration - 2].speculatedValue - IterationInfo[Iteration - 3].speculatedValue;
 
-          alpha = IterationInfo[Iteration - 1].value() - delta;
-          beta  = IterationInfo[Iteration - 1].value() + delta;
-          if (alpha < - VALUE_INFINITE) alpha = - VALUE_INFINITE;
-          if (beta  >   VALUE_INFINITE) beta = VALUE_INFINITE;
+            int delta = Max(2 * abs(prevDelta1) + abs(prevDelta2), ProblemMargin);
 
-        } else {
-          alpha = - VALUE_INFINITE;
-          beta  =   VALUE_INFINITE;
+            alpha = Max(IterationInfo[Iteration - 1].value - delta, -VALUE_INFINITE);
+            beta  = Min(IterationInfo[Iteration - 1].value + delta,  VALUE_INFINITE);
+        }
+        else
+        {
+            alpha = - VALUE_INFINITE;
+            beta  =   VALUE_INFINITE;
         }
 
         // Search to the current depth
         Value value = root_search(p, ss, rml, alpha, beta);
-        if (AbortSearch)
-          break; //Value cannot be trusted. Break out immediately!
 
         // Write PV to transposition table, in case the relevant entries have
-        // been overwritten during the search:
+        // been overwritten during the search.
         TT.insert_pv(p, ss[0].pv);
 
+        if (AbortSearch)
+            break; // Value cannot be trusted. Break out immediately!
+
         //Save info about search result
-        Value speculated_value = value;
+        Value speculatedValue;
         bool fHigh = false;
         bool fLow = false;
+        Value delta = value - IterationInfo[Iteration - 1].value;
 
-        Value prev_value = IterationInfo[Iteration - 1].value();
-        Value delta = value - prev_value;
-
-        if (value >= beta) {
-          fHigh = true;
-          speculated_value = prev_value + 2 * delta;
-          BestMoveChangesByIteration[Iteration] += 2; //This is used to tell time management to allocate more time
-        } else if (value <= alpha) {
-          fLow = true;
-          speculated_value = prev_value + 2 * delta;
-          BestMoveChangesByIteration[Iteration] += 3; //This is used to tell time management to allocate more time
-        } else {
-          //nothing
+        if (value >= beta)
+        {
+            assert(delta > 0);
+
+            fHigh = true;
+            speculatedValue = value + delta;
+            BestMoveChangesByIteration[Iteration] += 2; // Allocate more time
         }
+        else if (value <= alpha)
+        {
+            assert(value == alpha);
+            assert(delta < 0);
 
-        if (speculated_value < - VALUE_INFINITE) speculated_value = - VALUE_INFINITE;
-        if (speculated_value >   VALUE_INFINITE) speculated_value =   VALUE_INFINITE;
+            fLow = true;
+            speculatedValue = value + delta;
+            BestMoveChangesByIteration[Iteration] += 3; // Allocate more time
+        } else
+            speculatedValue = value;
 
-        IterationInfo[Iteration].set(value, speculated_value, fHigh, fLow);
+        speculatedValue = Min(Max(speculatedValue, -VALUE_INFINITE), VALUE_INFINITE);
+        IterationInfo[Iteration] = IterationInfoType(value, speculatedValue);
 
         // Erase the easy move if it differs from the new best move
         if (ss[0].pv[0] != EasyMove)
@@ -795,19 +723,21 @@ namespace {
             // Time to stop?
             bool stopSearch = false;
 
-            // Stop search early if there is only a single legal move:
+            // Stop search early if there is only a single legal move
             if (Iteration >= 6 && rml.move_count() == 1)
                 stopSearch = true;
 
             // Stop search early when the last two iterations returned a mate score
             if (  Iteration >= 6
-                && abs(IterationInfo[Iteration].value()) >= abs(VALUE_MATE) - 100
-                && abs(IterationInfo[Iteration-1].value()) >= abs(VALUE_MATE) - 100)
+                && abs(IterationInfo[Iteration].value) >= abs(VALUE_MATE) - 100
+                && abs(IterationInfo[Iteration-1].value) >= abs(VALUE_MATE) - 100)
                 stopSearch = true;
 
             // Stop search early if one move seems to be much better than the rest
             int64_t nodes = nodes_searched();
-            if (   Iteration >= 8 && !fLow && !fHigh
+            if (   Iteration >= 8
+                && !fLow
+                && !fHigh
                 && EasyMove == ss[0].pv[0]
                 && (  (   rml.get_move_cumulative_nodes(0) > (nodes * 85) / 100
                        && current_search_time() > MaxSearchTime / 16)
@@ -891,7 +821,7 @@ namespace {
   // scheme (perhaps we should try to use this at internal PV nodes, too?)
   // and prints some information to the standard output.
 
-  Value root_search(Position &pos, SearchStack ss[], RootMoveList &rml, Value alpha, Value beta) {
+  Value root_search(Position& pos, SearchStack ss[], RootMoveList &rml, Value alpha, Value beta) {
 
     Value oldAlpha = alpha;
     Value value;
@@ -900,12 +830,14 @@ namespace {
     // Loop through all the moves in the root move list
     for (int i = 0; i <  rml.move_count() && !AbortSearch; i++)
     {
-        if (alpha >= beta) {
-          rml.set_move_score(i, -VALUE_INFINITE);
-          //Leave node-counters and beta-counters as they are.
-          continue;
+        if (alpha >= beta)
+        {
+            // We failed high, invalidate and skip next moves, leave node-counters
+            // and beta-counters as they are and quickly return, we will try to do
+            // a research at the next iteration with a bigger aspiration window.
+            rml.set_move_score(i, -VALUE_INFINITE);
+            continue;
         }
-
         int64_t nodes;
         Move move;
         StateInfo st;
@@ -929,8 +861,9 @@ namespace {
                       << " currmovenumber " << i + 1 << std::endl;
 
         // Decide search depth for this move
+        bool moveIsCapture = pos.move_is_capture(move);
         bool dangerous;
-        ext = extension(pos, move, true, pos.move_is_capture(move), pos.move_is_check(move), false, false, &dangerous);
+        ext = extension(pos, move, true, moveIsCapture, pos.move_is_check(move), false, false, &dangerous);
         newDepth = (Iteration - 2) * OnePly + ext + InitialDepth;
 
         // Make the move, and search it
@@ -938,27 +871,46 @@ namespace {
 
         if (i < MultiPV)
         {
+            // Aspiration window is disabled in multi-pv case
+            if (MultiPV > 1)
+                alpha = -VALUE_INFINITE;
+
             value = -search_pv(pos, ss, -beta, -alpha, newDepth, 1, 0);
             // If the value has dropped a lot compared to the last iteration,
             // set the boolean variable Problem to true. This variable is used
             // for time managment: When Problem is true, we try to complete the
             // current iteration before playing a move.
-            Problem = (Iteration >= 2 && value <= IterationInfo[Iteration-1].value() - ProblemMargin);
+            Problem = (Iteration >= 2 && value <= IterationInfo[Iteration-1].value - ProblemMargin);
 
             if (Problem && StopOnPonderhit)
                 StopOnPonderhit = false;
         }
         else
         {
-            value = -search(pos, ss, -alpha, newDepth, 1, true, 0);
+            if (   newDepth >= 3*OnePly
+                && i >= MultiPV + LMRPVMoves
+                && !dangerous
+                && !moveIsCapture
+                && !move_is_promotion(move)
+                && !move_is_castle(move))
+            {
+                ss[0].reduction = OnePly;
+                value = -search(pos, ss, -alpha, newDepth-OnePly, 1, true, 0);
+            } else
+                value = alpha + 1; // Just to trigger next condition
+
             if (value > alpha)
             {
-                // Fail high! Set the boolean variable FailHigh to true, and
-                // re-search the move with a big window. The variable FailHigh is
-                // used for time managment: We try to avoid aborting the search
-                // prematurely during a fail high research.
-                FailHigh = true;
-                value = -search_pv(pos, ss, -beta, -alpha, newDepth, 1, 0);
+                value = -search(pos, ss, -alpha, newDepth, 1, true, 0);
+                if (value > alpha)
+                {
+                    // Fail high! Set the boolean variable FailHigh to true, and
+                    // re-search the move with a big window. The variable FailHigh is
+                    // used for time managment: We try to avoid aborting the search
+                    // prematurely during a fail high research.
+                    FailHigh = true;
+                    value = -search_pv(pos, ss, -beta, -alpha, newDepth, 1, 0);
+                }
             }
         }
 
@@ -968,7 +920,7 @@ namespace {
         // was aborted because the user interrupted the search or because we
         // ran out of time. In this case, the return value of the search cannot
         // be trusted, and we break out of the loop without updating the best
-        // move and/or PV:
+        // move and/or PV.
         if (AbortSearch)
             break;
 
@@ -987,11 +939,12 @@ namespace {
             rml.set_move_score(i, -VALUE_INFINITE);
         else
         {
-            // New best move!
+            // PV move or new best move!
 
             // Update PV
             rml.set_move_score(i, value);
             update_pv(ss, 0);
+            TT.extract_pv(pos, ss[0].pv, PLY_MAX);
             rml.set_move_pv(i, ss[0].pv);
 
             if (MultiPV == 1)
@@ -1002,9 +955,11 @@ namespace {
                 if (i > 0)
                     BestMoveChangesByIteration[Iteration]++;
 
-                // Print search information to the standard output:
+                // Print search information to the standard output
                 std::cout << "info depth " << Iteration
                           << " score " << value_to_string(value)
+                          << ((value >= beta)?
+                              " lowerbound" : ((value <= alpha)? " upperbound" : ""))
                           << " time " << current_search_time()
                           << " nodes " << nodes_searched()
                           << " nps " << nps()
@@ -1016,15 +971,18 @@ namespace {
                 std::cout << std::endl;
 
                 if (UseLogFile)
-                    LogFile << pretty_pv(pos, current_search_time(), Iteration, nodes_searched(), value, ss[0].pv)
+                    LogFile << pretty_pv(pos, current_search_time(), Iteration, nodes_searched(), value, 
+                                         ((value >= beta)? VALUE_TYPE_LOWER
+                                          : ((value <= alpha)? VALUE_TYPE_UPPER : VALUE_TYPE_EXACT)),
+                                         ss[0].pv)
                             << std::endl;
 
                 if (value > alpha)
-                  alpha = value;
+                    alpha = value;
 
                 // Reset the global variable Problem to false if the value isn't too
                 // far below the final value from the last iteration.
-                if (value > IterationInfo[Iteration - 1].value() - NoProblemMargin)
+                if (value > IterationInfo[Iteration - 1].value - NoProblemMargin)
                     Problem = false;
             }
             else // MultiPV > 1
@@ -1048,13 +1006,11 @@ namespace {
                 }
                 alpha = rml.get_move_score(Min(i, MultiPV-1));
             }
-        }
+        } // New best move case
 
-        if (alpha <= oldAlpha)
-          FailLow = true;
-        else
-          FailLow = false;
+        assert(alpha >= oldAlpha);
 
+        FailLow = (alpha == oldAlpha);
     }
     return alpha;
   }
@@ -1062,7 +1018,7 @@ namespace {
 
   // search_pv() is the main search function for PV nodes.
 
-  Value search_pv(Position &pos, SearchStack ss[], Value alpha, Value beta,
+  Value search_pv(Position& pos, SearchStack ss[], Value alpha, Value beta,
                   Depth depth, int ply, int threadID) {
 
     assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE);
@@ -1098,7 +1054,7 @@ namespace {
 
     // Transposition table lookup. At PV nodes, we don't use the TT for
     // pruning, but only for move ordering.
-    const TTEntry* tte = TT.retrieve(pos);
+    const TTEntry* tte = TT.retrieve(pos.get_key());
     Move ttMove = (tte ? tte->move() : MOVE_NONE);
 
     // Go with internal iterative deepening if we don't have a TT move
@@ -1110,16 +1066,16 @@ namespace {
 
     // Initialize a MovePicker object for the current position, and prepare
     // to search all moves
-    MovePicker mp = MovePicker(pos, true, ttMove, ss[ply], depth);
-
     Move move, movesSearched[256];
     int moveCount = 0;
     Value value, bestValue = -VALUE_INFINITE;
-    Bitboard dcCandidates = mp.discovered_check_candidates();
     Color us = pos.side_to_move();
     bool isCheck = pos.is_check();
     bool mateThreat = pos.has_mate_threat(opposite_color(us));
 
+    MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
+    Bitboard dcCandidates = mp.discovered_check_candidates();
+
     // Loop through all legal moves until no moves remain or a beta cutoff
     // occurs.
     while (   alpha < beta
@@ -1128,7 +1084,7 @@ namespace {
     {
       assert(move_is_ok(move));
 
-      bool singleReply = (isCheck && mp.number_of_moves() == 1);
+      bool singleReply = (isCheck && mp.number_of_evasions() == 1);
       bool moveIsCheck = pos.move_is_check(move, dcCandidates);
       bool moveIsCapture = pos.move_is_capture(move);
 
@@ -1149,11 +1105,11 @@ namespace {
       {
         // Try to reduce non-pv search depth by one ply if move seems not problematic,
         // if the move fails high will be re-searched at full depth.
-        if (    depth >= 2*OnePly
+        if (    depth >= 3*OnePly
             &&  moveCount >= LMRPVMoves
             && !dangerous
             && !moveIsCapture
-            && !move_promotion(move)
+            && !move_is_promotion(move)
             && !move_is_castle(move)
             && !move_is_killer(move, ss[ply]))
         {
@@ -1167,29 +1123,19 @@ namespace {
         {
             ss[ply].reduction = Depth(0);
             value = -search(pos, ss, -alpha, newDepth, ply+1, true, threadID);
-            if (value > alpha /*&& value < beta*/)
+            if (value > alpha && value < beta)
             {
                 // When the search fails high at ply 1 while searching the first
                 // move at the root, set the flag failHighPly1. This is used for
                 // time managment:  We don't want to stop the search early in
                 // such cases, because resolving the fail high at ply 1 could
                 // result in a big drop in score at the root.
-                if (ply == 1 && RootMoveNumber == 1) {
+                if (ply == 1 && RootMoveNumber == 1)
                     Threads[threadID].failHighPly1 = true;
-                    if (value >= beta) {
-                      Threads[threadID].aspirationFailHighPly1 = true;
-                    }
-                }
 
                 // A fail high occurred. Re-search at full window (pv search)
                 value = -search_pv(pos, ss, -beta, -alpha, newDepth, ply+1, threadID);
                 Threads[threadID].failHighPly1 = false;
-                //FIXME: Current implementation of Problem code is not completely thread-safe.
-                //If poll is called before pv is updated, we lose this move.
-                //(failHighPly1 also suffers from same kind of problems though. There is also a small
-                //fraction of time when failHighPly1 and Problem are _both_ false, though we
-                //are facing bad problems. If we are very unlucky search is terminated).
-                Threads[threadID].aspirationFailHighPly1 = false;
           }
         }
       }
@@ -1210,10 +1156,10 @@ namespace {
           }
           // If we are at ply 1, and we are searching the first root move at
           // ply 0, set the 'Problem' variable if the score has dropped a lot
-          // (from the computer's point of view) since the previous iteration:
+          // (from the computer's point of view) since the previous iteration.
           if (   ply == 1
               && Iteration >= 2
-              && -value <= IterationInfo[Iteration-1].value() - ProblemMargin)
+              && -value <= IterationInfo[Iteration-1].value - ProblemMargin)
               Problem = true;
       }
 
@@ -1231,7 +1177,7 @@ namespace {
     }
 
     // All legal moves have been searched.  A special case: If there were
-    // no legal moves, it must be mate or stalemate:
+    // no legal moves, it must be mate or stalemate.
     if (moveCount == 0)
         return (isCheck ? value_mated_in(ply) : VALUE_DRAW);
 
@@ -1241,7 +1187,7 @@ namespace {
         return bestValue;
 
     if (bestValue <= oldAlpha)
-        TT.store(pos, value_to_tt(bestValue, ply), depth, MOVE_NONE, VALUE_TYPE_UPPER);
+        TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_UPPER, depth, MOVE_NONE);
 
     else if (bestValue >= beta)
     {
@@ -1252,10 +1198,10 @@ namespace {
             update_history(pos, m, depth, movesSearched, moveCount);
             update_killers(m, ss[ply]);
         }
-        TT.store(pos, value_to_tt(bestValue, ply), depth, m, VALUE_TYPE_LOWER);
+        TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, m);
     }
     else
-        TT.store(pos, value_to_tt(bestValue, ply), depth, ss[ply].pv[ply], VALUE_TYPE_EXACT);
+        TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_EXACT, depth, ss[ply].pv[ply]);
 
     return bestValue;
   }
@@ -1263,7 +1209,7 @@ namespace {
 
   // search() is the search function for zero-width nodes.
 
-  Value search(Position &pos, SearchStack ss[], Value beta, Depth depth,
+  Value search(Position& pos, SearchStack ss[], Value beta, Depth depth,
                int ply, bool allowNullmove, int threadID) {
 
     assert(beta >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
@@ -1297,7 +1243,7 @@ namespace {
         return beta - 1;
 
     // Transposition table lookup
-    const TTEntry* tte = TT.retrieve(pos);
+    const TTEntry* tte = TT.retrieve(pos.get_key());
     Move ttMove = (tte ? tte->move() : MOVE_NONE);
 
     if (tte && ok_to_use_TT(tte, depth, beta, ply))
@@ -1328,11 +1274,7 @@ namespace {
 
         pos.undo_null_move();
 
-        if (value_is_mate(nullValue))
-        {
-            /* Do not return unproven mates */
-        }
-        else if (nullValue >= beta)
+        if (nullValue >= beta)
         {
             if (depth < 6 * OnePly)
                 return beta;
@@ -1360,17 +1302,15 @@ namespace {
     }
     // Null move search not allowed, try razoring
     else if (   !value_is_mate(beta)
-             && approximateEval < beta - RazorMargin
              && depth < RazorDepth
-             && (RazorAtDepthOne || depth > OnePly)
+             && approximateEval < beta - RazorApprMargins[int(depth) - 2]
+             && ss[ply - 1].currentMove != MOVE_NULL
              && ttMove == MOVE_NONE
              && !pos.has_pawn_on_7th(pos.side_to_move()))
     {
         Value v = qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
-        if (   (v < beta - RazorMargin - RazorMargin / 4)
-            || (depth <= 2*OnePly && v < beta - RazorMargin)
-            || (depth <=   OnePly && v < beta - RazorMargin / 2))
-            return v;
+        if (v < beta - RazorMargins[int(depth) - 2])
+          return v;
     }
 
     // Go with internal iterative deepening if we don't have a TT move
@@ -1382,18 +1322,21 @@ namespace {
     }
 
     // Initialize a MovePicker object for the current position, and prepare
-    // to search all moves:
-    MovePicker mp = MovePicker(pos, false, ttMove, ss[ply], depth);
+    // to search all moves.
+    MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
 
     Move move, movesSearched[256];
     int moveCount = 0;
     Value value, bestValue = -VALUE_INFINITE;
     Bitboard dcCandidates = mp.discovered_check_candidates();
     Value futilityValue = VALUE_NONE;
-    bool useFutilityPruning =   UseFutilityPruning
-                             && depth < SelectiveDepth
+    bool useFutilityPruning =   depth < SelectiveDepth
                              && !isCheck;
 
+    // Avoid calling evaluate() if we already have the score in TT
+    if (tte && (tte->type() & VALUE_TYPE_EVAL))
+        futilityValue = value_from_tt(tte->value(), ply) + FutilityMargins[int(depth) - 2];
+
     // Loop through all legal moves until no moves remain or a beta cutoff
     // occurs.
     while (   bestValue < beta
@@ -1402,7 +1345,7 @@ namespace {
     {
       assert(move_is_ok(move));
 
-      bool singleReply = (isCheck && mp.number_of_moves() == 1);
+      bool singleReply = (isCheck && mp.number_of_evasions() == 1);
       bool moveIsCheck = pos.move_is_check(move, dcCandidates);
       bool moveIsCapture = pos.move_is_capture(move);
 
@@ -1417,7 +1360,7 @@ namespace {
       if (    useFutilityPruning
           && !dangerous
           && !moveIsCapture
-          && !move_promotion(move))
+          && !move_is_promotion(move))
       {
           // History pruning. See ok_to_prune() definition
           if (   moveCount >= 2 + int(depth)
@@ -1425,12 +1368,11 @@ namespace {
               continue;
 
           // Value based pruning
-          if (depth < 7 * OnePly && approximateEval < beta)
+          if (approximateEval < beta)
           {
               if (futilityValue == VALUE_NONE)
                   futilityValue =  evaluate(pos, ei, threadID)
-                                 + FutilityMargins[int(depth)/2 - 1]
-                                 + 32 * (depth & 1);
+                                 + FutilityMargins[int(depth) - 2];
 
               if (futilityValue < beta)
               {
@@ -1447,11 +1389,11 @@ namespace {
 
       // Try to reduce non-pv search depth by one ply if move seems not problematic,
       // if the move fails high will be re-searched at full depth.
-      if (    depth >= 2*OnePly
+      if (    depth >= 3*OnePly
           &&  moveCount >= LMRNonPVMoves
           && !dangerous
           && !moveIsCapture
-          && !move_promotion(move)
+          && !move_is_promotion(move)
           && !move_is_castle(move)
           && !move_is_killer(move, ss[ply]))
       {
@@ -1505,7 +1447,7 @@ namespace {
         return bestValue;
 
     if (bestValue < beta)
-        TT.store(pos, value_to_tt(bestValue, ply), depth, MOVE_NONE, VALUE_TYPE_UPPER);
+        TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_UPPER, depth, MOVE_NONE);
     else
     {
         BetaCounter.add(pos.side_to_move(), depth, threadID);
@@ -1515,7 +1457,7 @@ namespace {
             update_history(pos, m, depth, movesSearched, moveCount);
             update_killers(m, ss[ply]);
         }
-        TT.store(pos, value_to_tt(bestValue, ply), depth, m, VALUE_TYPE_LOWER);
+        TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, m);
     }
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
@@ -1528,7 +1470,7 @@ namespace {
   // search function when the remaining depth is zero (or, to be more precise,
   // less than OnePly).
 
-  Value qsearch(Position &pos, SearchStack ss[], Value alpha, Value beta,
+  Value qsearch(Position& pos, SearchStack ss[], Value alpha, Value beta,
                 Depth depth, int ply, int threadID) {
 
     assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE);
@@ -1553,7 +1495,7 @@ namespace {
     bool pvNode = (beta - alpha != 1);
     if (!pvNode)
     {
-        tte = TT.retrieve(pos);
+        tte = TT.retrieve(pos.get_key());
         if (tte && ok_to_use_TT(tte, depth, beta, ply))
         {
             assert(tte->type() != VALUE_TYPE_EVAL);
@@ -1561,6 +1503,7 @@ namespace {
             return value_from_tt(tte->value(), ply);
         }
     }
+    Move ttMove = (tte ? tte->move() : MOVE_NONE);
 
     // Evaluate the position statically
     EvalInfo ei;
@@ -1571,10 +1514,9 @@ namespace {
     if (isCheck)
         staticValue = -VALUE_INFINITE;
 
-    else if (tte && tte->type() == VALUE_TYPE_EVAL)
+    else if (tte && (tte->type() & VALUE_TYPE_EVAL))
     {
         // Use the cached evaluation score if possible
-        assert(tte->value() == evaluate(pos, ei, threadID));
         assert(ei.futilityMargin == Value(0));
 
         staticValue = tte->value();
@@ -1593,7 +1535,7 @@ namespace {
     {
         // Store the score to avoid a future costly evaluation() call
         if (!isCheck && !tte && ei.futilityMargin == 0)
-            TT.store(pos, value_to_tt(bestValue, ply), Depth(-127*OnePly), MOVE_NONE, VALUE_TYPE_EVAL);
+            TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_EV_LO, Depth(-127*OnePly), MOVE_NONE);
 
         return bestValue;
     }
@@ -1604,7 +1546,7 @@ namespace {
     // Initialize a MovePicker object for the current position, and prepare
     // to search the moves.  Because the depth is <= 0 here, only captures,
     // queen promotions and checks (only if depth == 0) will be generated.
-    MovePicker mp = MovePicker(pos, pvNode, MOVE_NONE, EmptySearchStack, depth);
+    MovePicker mp = MovePicker(pos, ttMove, depth, H);
     Move move;
     int moveCount = 0;
     Bitboard dcCandidates = mp.discovered_check_candidates();
@@ -1622,11 +1564,10 @@ namespace {
       ss[ply].currentMove = move;
 
       // Futility pruning
-      if (    UseQSearchFutilityPruning
-          &&  enoughMaterial
+      if (   enoughMaterial
           && !isCheck
           && !pvNode
-          && !move_promotion(move)
+          && !move_is_promotion(move)
           && !pos.move_is_check(move, dcCandidates)
           && !pos.move_is_passed_pawn_push(move))
       {
@@ -1647,10 +1588,8 @@ namespace {
 
       // Don't search captures and checks with negative SEE values
       if (   !isCheck
-          && !move_promotion(move)
-          && (pos.midgame_value_of_piece_on(move_from(move)) >
-              pos.midgame_value_of_piece_on(move_to(move)))
-          &&  pos.see(move) < 0)
+          && !move_is_promotion(move)
+          &&  pos.see_sign(move) < 0)
           continue;
 
       // Make and search the move.
@@ -1674,29 +1613,31 @@ namespace {
     }
 
     // All legal moves have been searched.  A special case: If we're in check
-    // and no legal moves were found, it is checkmate:
+    // and no legal moves were found, it is checkmate.
     if (pos.is_check() && moveCount == 0) // Mate!
         return value_mated_in(ply);
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
 
     // Update transposition table
+    Move m = ss[ply].pv[ply];
     if (!pvNode)
     {
+        // If bestValue isn't changed it means it is still the static evaluation of
+        // the node, so keep this info to avoid a future costly evaluation() call.
+        ValueType type = (bestValue == staticValue && !ei.futilityMargin ? VALUE_TYPE_EV_UP : VALUE_TYPE_UPPER);
         Depth d = (depth == Depth(0) ? Depth(0) : Depth(-1));
+
         if (bestValue < beta)
-            TT.store(pos, value_to_tt(bestValue, ply), d, MOVE_NONE, VALUE_TYPE_UPPER);
+            TT.store(pos.get_key(), value_to_tt(bestValue, ply), type, d, MOVE_NONE);
         else
-            TT.store(pos, value_to_tt(bestValue, ply), d, MOVE_NONE, VALUE_TYPE_LOWER);
+            TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, d, m);
     }
 
     // Update killers only for good check moves
-    Move m = ss[ply].currentMove;
     if (alpha >= beta && ok_to_history(pos, m)) // Only non capture moves are considered
-    {
-        // Wrong to update history when depth is <= 0
         update_killers(m, ss[ply]);
-    }
+
     return bestValue;
   }
 
@@ -1709,18 +1650,17 @@ namespace {
   // also don't need to store anything to the hash table here:  This is taken
   // care of after we return from the split point.
 
-  void sp_search(SplitPoint *sp, int threadID) {
+  void sp_search(SplitPoint* sp, int threadID) {
 
     assert(threadID >= 0 && threadID < ActiveThreads);
     assert(ActiveThreads > 1);
 
     Position pos = Position(sp->pos);
-    SearchStack *ss = sp->sstack[threadID];
+    SearchStack* ss = sp->sstack[threadID];
     Value value;
     Move move;
     bool isCheck = pos.is_check();
-    bool useFutilityPruning =    UseFutilityPruning
-                              && sp->depth < SelectiveDepth
+    bool useFutilityPruning =     sp->depth < SelectiveDepth
                               && !isCheck;
 
     while (    sp->bestValue < sp->beta
@@ -1747,7 +1687,7 @@ namespace {
       if (    useFutilityPruning
           && !dangerous
           && !moveIsCapture
-          && !move_promotion(move)
+          && !move_is_promotion(move)
           &&  moveCount >= 2 + int(sp->depth)
           &&  ok_to_prune(pos, move, ss[sp->ply].threatMove, sp->depth))
         continue;
@@ -1761,7 +1701,7 @@ namespace {
       if (   !dangerous
           &&  moveCount >= LMRNonPVMoves
           && !moveIsCapture
-          && !move_promotion(move)
+          && !move_is_promotion(move)
           && !move_is_castle(move)
           && !move_is_killer(move, ss[sp->ply]))
       {
@@ -1804,7 +1744,7 @@ namespace {
     lock_grab(&(sp->lock));
 
     // If this is the master thread and we have been asked to stop because of
-    // a beta cutoff higher up in the tree, stop all slave threads:
+    // a beta cutoff higher up in the tree, stop all slave threads.
     if (sp->master == threadID && thread_should_stop(threadID))
         for (int i = 0; i < ActiveThreads; i++)
             if (sp->slaves[i])
@@ -1822,16 +1762,16 @@ namespace {
   // the normal search_pv() function, but simpler.  Because we have already
   // probed the hash table and searched the first move before splitting, we
   // don't have to repeat all this work in sp_search_pv().  We also don't
-  // need to store anything to the hash table here:  This is taken care of
+  // need to store anything to the hash table here: This is taken care of
   // after we return from the split point.
 
-  void sp_search_pv(SplitPoint *sp, int threadID) {
+  void sp_search_pv(SplitPoint* sp, int threadID) {
 
     assert(threadID >= 0 && threadID < ActiveThreads);
     assert(ActiveThreads > 1);
 
     Position pos = Position(sp->pos);
-    SearchStack *ss = sp->sstack[threadID];
+    SearchStack* ss = sp->sstack[threadID];
     Value value;
     Move move;
 
@@ -1864,7 +1804,7 @@ namespace {
       if (   !dangerous
           &&  moveCount >= LMRPVMoves
           && !moveIsCapture
-          && !move_promotion(move)
+          && !move_is_promotion(move)
           && !move_is_castle(move)
           && !move_is_killer(move, ss[sp->ply]))
       {
@@ -1879,23 +1819,18 @@ namespace {
           ss[sp->ply].reduction = Depth(0);
           value = -search(pos, ss, -sp->alpha, newDepth, sp->ply+1, true, threadID);
 
-          if (value > sp->alpha /*&& value < sp->beta*/)
+          if (value > sp->alpha && value < sp->beta)
           {
               // When the search fails high at ply 1 while searching the first
               // move at the root, set the flag failHighPly1.  This is used for
-              // time managment:  We don't want to stop the search early in
+              // time managment: We don't want to stop the search early in
               // such cases, because resolving the fail high at ply 1 could
               // result in a big drop in score at the root.
-              if (sp->ply == 1 && RootMoveNumber == 1) {
+              if (sp->ply == 1 && RootMoveNumber == 1)
                   Threads[threadID].failHighPly1 = true;
-                  if (value >= sp->beta) {
-                    Threads[threadID].aspirationFailHighPly1 = true;
-                  }
-              }
 
               value = -search_pv(pos, ss, -sp->beta, -sp->alpha, newDepth, sp->ply+1, threadID);
               Threads[threadID].failHighPly1 = false;
-              Threads[threadID].aspirationFailHighPly1 = false;
         }
       }
       pos.undo_move(move);
@@ -1917,10 +1852,10 @@ namespace {
               if (value == value_mate_in(sp->ply + 1))
                   ss[sp->ply].mateKiller = move;
 
-              if(value >= sp->beta)
+              if (value >= sp->beta)
               {
-                  for(int i = 0; i < ActiveThreads; i++)
-                      if(i != threadID && (i == sp->master || sp->slaves[i]))
+                  for (int i = 0; i < ActiveThreads; i++)
+                      if (i != threadID && (i == sp->master || sp->slaves[i]))
                           Threads[i].stop = true;
 
                   sp->finished = true;
@@ -1931,7 +1866,7 @@ namespace {
         // (from the computer's point of view) since the previous iteration.
         if (   sp->ply == 1
             && Iteration >= 2
-            && -value <= IterationInfo[Iteration-1].value() - ProblemMargin)
+            && -value <= IterationInfo[Iteration-1].value - ProblemMargin)
             Problem = true;
       }
       lock_release(&(sp->lock));
@@ -1959,13 +1894,13 @@ namespace {
   void BetaCounterType::clear() {
 
     for (int i = 0; i < THREAD_MAX; i++)
-        hits[i][WHITE] = hits[i][BLACK] = 0ULL;
+        Threads[i].betaCutOffs[WHITE] = Threads[i].betaCutOffs[BLACK] = 0ULL;
   }
 
   void BetaCounterType::add(Color us, Depth d, int threadID) {
 
     // Weighted count based on depth
-    hits[threadID][us] += int(d);
+    Threads[threadID].betaCutOffs[us] += unsigned(d);
   }
 
   void BetaCounterType::read(Color us, int64_t& our, int64_t& their) {
@@ -1973,8 +1908,8 @@ namespace {
     our = their = 0UL;
     for (int i = 0; i < THREAD_MAX; i++)
     {
-        our += hits[i][us];
-        their += hits[i][opposite_color(us)];
+        our += Threads[i].betaCutOffs[us];
+        their += Threads[i].betaCutOffs[opposite_color(us)];
     }
   }
 
@@ -1984,7 +1919,7 @@ namespace {
   // Constructor
 
   RootMove::RootMove() {
-    nodes = cumulativeNodes = 0ULL;
+    nodes = cumulativeNodes = ourBeta = theirBeta = 0ULL;
   }
 
   // RootMove::operator<() is the comparison function used when
@@ -2010,32 +1945,31 @@ namespace {
     bool includeAllMoves = (searchMoves[0] == MOVE_NONE);
 
     // Generate all legal moves
-    int lm_count = generate_legal_moves(pos, mlist);
+    MoveStack* last = generate_moves(pos, mlist);
 
     // Add each move to the moves[] array
-    for (int i = 0; i < lm_count; i++)
+    for (MoveStack* cur = mlist; cur != last; cur++)
     {
         bool includeMove = includeAllMoves;
 
         for (int k = 0; !includeMove && searchMoves[k] != MOVE_NONE; k++)
-            includeMove = (searchMoves[k] == mlist[i].move);
+            includeMove = (searchMoves[k] == cur->move);
 
-        if (includeMove)
-        {
-            // Find a quick score for the move
-            StateInfo st;
-            SearchStack ss[PLY_MAX_PLUS_2];
-
-            moves[count].move = mlist[i].move;
-            moves[count].nodes = 0ULL;
-            pos.do_move(moves[count].move, st);
-            moves[count].score = -qsearch(pos, ss, -VALUE_INFINITE, VALUE_INFINITE,
-                                          Depth(0), 1, 0);
-            pos.undo_move(moves[count].move);
-            moves[count].pv[0] = moves[i].move;
-            moves[count].pv[1] = MOVE_NONE; // FIXME
-            count++;
-        }
+        if (!includeMove)
+            continue;
+
+        // Find a quick score for the move
+        StateInfo st;
+        SearchStack ss[PLY_MAX_PLUS_2];
+        init_ss_array(ss);
+
+        moves[count].move = cur->move;
+        pos.do_move(moves[count].move, st);
+        moves[count].score = -qsearch(pos, ss, -VALUE_INFINITE, VALUE_INFINITE, Depth(0), 1, 0);
+        pos.undo_move(moves[count].move);
+        moves[count].pv[0] = moves[count].move;
+        moves[count].pv[1] = MOVE_NONE; // FIXME
+        count++;
     }
     sort();
   }
@@ -2140,24 +2074,26 @@ namespace {
   // for user input and checks whether it is time to stop the search.
 
   void init_node(SearchStack ss[], int ply, int threadID) {
+
     assert(ply >= 0 && ply < PLY_MAX);
     assert(threadID >= 0 && threadID < ActiveThreads);
 
     Threads[threadID].nodes++;
 
-    if(threadID == 0) {
-      NodesSincePoll++;
-      if(NodesSincePoll >= NodesBetweenPolls) {
-        poll();
-        NodesSincePoll = 0;
-      }
+    if (threadID == 0)
+    {
+        NodesSincePoll++;
+        if (NodesSincePoll >= NodesBetweenPolls)
+        {
+            poll();
+            NodesSincePoll = 0;
+        }
     }
-
     ss[ply].init(ply);
     ss[ply+2].initKillers();
 
-    if(Threads[threadID].printCurrentLine)
-      print_current_line(ss, ply, threadID);
+    if (Threads[threadID].printCurrentLine)
+        print_current_line(ss, ply, threadID);
   }
 
 
@@ -2180,7 +2116,7 @@ namespace {
   // difference between the two functions is that sp_update_pv also updates
   // the PV at the parent node.
 
-  void sp_update_pv(SearchStack *pss, SearchStack ss[], int ply) {
+  void sp_update_pv(SearchStack* pss, SearchStack ss[], int ply) {
     assert(ply >= 0 && ply < PLY_MAX);
 
     ss[ply].pv[ply] = pss[ply].pv[ply] = ss[ply].currentMove;
@@ -2197,62 +2133,65 @@ namespace {
   // assumed to be the move that was made to reach the current position, while
   // the second move is assumed to be a move from the current position.
 
-  bool connected_moves(const Position &pos, Move m1, Move m2) {
+  bool connected_moves(const Position& pos, Move m1, Move m2) {
+
     Square f1, t1, f2, t2;
+    Piece p;
 
     assert(move_is_ok(m1));
     assert(move_is_ok(m2));
 
-    if(m2 == MOVE_NONE)
-      return false;
+    if (m2 == MOVE_NONE)
+        return false;
 
-    // Case 1: The moving piece is the same in both moves.
+    // Case 1: The moving piece is the same in both moves
     f2 = move_from(m2);
     t1 = move_to(m1);
-    if(f2 == t1)
-      return true;
+    if (f2 == t1)
+        return true;
 
-    // Case 2: The destination square for m2 was vacated by m1.
+    // Case 2: The destination square for m2 was vacated by m1
     t2 = move_to(m2);
     f1 = move_from(m1);
-    if(t2 == f1)
-      return true;
+    if (t2 == f1)
+        return true;
 
-    // Case 3: Moving through the vacated square:
-    if(piece_is_slider(pos.piece_on(f2)) &&
-       bit_is_set(squares_between(f2, t2), f1))
+    // Case 3: Moving through the vacated square
+    if (   piece_is_slider(pos.piece_on(f2))
+        && bit_is_set(squares_between(f2, t2), f1))
       return true;
 
-    // Case 4: The destination square for m2 is attacked by the moving piece
-    // in m1:
-    if(pos.piece_attacks_square(pos.piece_on(t1), t1, t2))
-      return true;
+    // Case 4: The destination square for m2 is attacked by the moving piece in m1
+    p = pos.piece_on(t1);
+    if (bit_is_set(pos.attacks_from(p, t1), t2))
+        return true;
 
-    // Case 5: Discovered check, checking piece is the piece moved in m1:
-    if(piece_is_slider(pos.piece_on(t1)) &&
-       bit_is_set(squares_between(t1, pos.king_square(pos.side_to_move())),
-                  f2) &&
-       !bit_is_set(squares_between(t2, pos.king_square(pos.side_to_move())),
-                   t2)) {
-      Bitboard occ = pos.occupied_squares();
-      Color us = pos.side_to_move();
-      Square ksq = pos.king_square(us);
-      clear_bit(&occ, f2);
-      if(pos.type_of_piece_on(t1) == BISHOP) {
-        if(bit_is_set(bishop_attacks_bb(ksq, occ), t1))
-          return true;
-      }
-      else if(pos.type_of_piece_on(t1) == ROOK) {
-        if(bit_is_set(rook_attacks_bb(ksq, occ), t1))
-          return true;
-      }
-      else {
-        assert(pos.type_of_piece_on(t1) == QUEEN);
-        if(bit_is_set(queen_attacks_bb(ksq, occ), t1))
-          return true;
-      }
+    // Case 5: Discovered check, checking piece is the piece moved in m1
+    if (   piece_is_slider(p)
+        && bit_is_set(squares_between(t1, pos.king_square(pos.side_to_move())), f2)
+        && !bit_is_set(squares_between(t1, pos.king_square(pos.side_to_move())), t2))
+    {
+        Bitboard occ = pos.occupied_squares();
+        Color us = pos.side_to_move();
+        Square ksq = pos.king_square(us);
+        clear_bit(&occ, f2);
+        if (type_of_piece(p) == BISHOP)
+        {
+            if (bit_is_set(bishop_attacks_bb(ksq, occ), t1))
+                return true;
+        }
+        else if (type_of_piece(p) == ROOK)
+        {
+            if (bit_is_set(rook_attacks_bb(ksq, occ), t1))
+                return true;
+        }
+        else
+        {
+            assert(type_of_piece(p) == QUEEN);
+            if (bit_is_set(queen_attacks_bb(ksq, occ), t1))
+                return true;
+        }
     }
-
     return false;
   }
 
@@ -2296,25 +2235,29 @@ namespace {
     assert(m != MOVE_NONE);
 
     Depth result = Depth(0);
-    *dangerous = check || singleReply || mateThreat;
+    *dangerous = check | singleReply | mateThreat;
 
-    if (check)
-        result += CheckExtension[pvNode];
+    if (*dangerous)
+    {
+        if (check)
+            result += CheckExtension[pvNode];
 
-    if (singleReply)
-        result += SingleReplyExtension[pvNode];
+        if (singleReply)
+            result += SingleReplyExtension[pvNode];
 
-    if (mateThreat)
-        result += MateThreatExtension[pvNode];
+        if (mateThreat)
+            result += MateThreatExtension[pvNode];
+    }
 
     if (pos.type_of_piece_on(move_from(m)) == PAWN)
     {
-        if (pos.move_is_pawn_push_to_7th(m))
+        Color c = pos.side_to_move();
+        if (relative_rank(c, move_to(m)) == RANK_7)
         {
             result += PawnPushTo7thExtension[pvNode];
             *dangerous = true;
         }
-        if (pos.move_is_passed_pawn_push(m))
+        if (pos.pawn_is_passed(c, move_to(m)))
         {
             result += PassedPawnExtension[pvNode];
             *dangerous = true;
@@ -2325,7 +2268,7 @@ namespace {
         && pos.type_of_piece_on(move_to(m)) != PAWN
         && (  pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
             - pos.midgame_value_of_piece_on(move_to(m)) == Value(0))
-        && !move_promotion(m)
+        && !move_is_promotion(m)
         && !move_is_ep(m))
     {
         result += PawnEndgameExtension[pvNode];
@@ -2335,7 +2278,7 @@ namespace {
     if (   pvNode
         && capture
         && pos.type_of_piece_on(move_to(m)) != PAWN
-        && pos.see(m) >= 0)
+        && pos.see_sign(m) >= 0)
     {
         result += OnePly/2;
         *dangerous = true;
@@ -2353,10 +2296,9 @@ namespace {
   // probably a good idea to avoid null moves in at least some more
   // complicated endgames, e.g. KQ vs KR.  FIXME
 
-  bool ok_to_do_nullmove(const Position &pos) {
-    if(pos.non_pawn_material(pos.side_to_move()) == Value(0))
-      return false;
-    return true;
+  bool ok_to_do_nullmove(const Position& pos) {
+
+    return pos.non_pawn_material(pos.side_to_move()) != Value(0);
   }
 
 
@@ -2364,23 +2306,24 @@ namespace {
   // non-tactical moves late in the move list close to the leaves are
   // candidates for pruning.
 
-  bool ok_to_prune(const Position &pos, Move m, Move threat, Depth d) {
-    Square mfrom, mto, tfrom, tto;
+  bool ok_to_prune(const Position& pos, Move m, Move threat, Depth d) {
 
     assert(move_is_ok(m));
     assert(threat == MOVE_NONE || move_is_ok(threat));
-    assert(!move_promotion(m));
+    assert(!move_is_promotion(m));
     assert(!pos.move_is_check(m));
     assert(!pos.move_is_capture(m));
     assert(!pos.move_is_passed_pawn_push(m));
     assert(d >= OnePly);
 
+    Square mfrom, mto, tfrom, tto;
+
     mfrom = move_from(m);
     mto = move_to(m);
     tfrom = move_from(threat);
     tto = move_to(threat);
 
-    // Case 1: Castling moves are never pruned.
+    // Case 1: Castling moves are never pruned
     if (move_is_castle(m))
         return false;
 
@@ -2396,10 +2339,10 @@ namespace {
         && (   pos.midgame_value_of_piece_on(tfrom) >= pos.midgame_value_of_piece_on(tto)
             || pos.type_of_piece_on(tfrom) == KING)
         && pos.move_attacks_square(m, tto))
-      return false;
+        return false;
 
-    // Case 4: Don't prune moves with good history.
-    if (!H.ok_to_prune(pos.piece_on(move_from(m)), m, d))
+    // Case 4: Don't prune moves with good history
+    if (!H.ok_to_prune(pos.piece_on(mfrom), mto, d))
         return false;
 
     // Case 5: If the moving piece in the threatened move is a slider, don't
@@ -2408,8 +2351,8 @@ namespace {
         && threat != MOVE_NONE
         && piece_is_slider(pos.piece_on(tfrom))
         && bit_is_set(squares_between(tfrom, tto), mto)
-        && pos.see(m) >= 0)
-            return false;
+        && pos.see_sign(m) >= 0)
+        return false;
 
     return true;
   }
@@ -2436,7 +2379,7 @@ namespace {
 
   bool ok_to_history(const Position& pos, Move m) {
 
-    return !pos.move_is_capture(m) && !move_promotion(m);
+    return !pos.move_is_capture(m) && !move_is_promotion(m);
   }
 
 
@@ -2446,13 +2389,13 @@ namespace {
   void update_history(const Position& pos, Move m, Depth depth,
                       Move movesSearched[], int moveCount) {
 
-    H.success(pos.piece_on(move_from(m)), m, depth);
+    H.success(pos.piece_on(move_from(m)), move_to(m), depth);
 
     for (int i = 0; i < moveCount - 1; i++)
     {
         assert(m != movesSearched[i]);
         if (ok_to_history(pos, movesSearched[i]))
-            H.failure(pos.piece_on(move_from(movesSearched[i])), movesSearched[i]);
+            H.failure(pos.piece_on(move_from(movesSearched[i])), move_to(movesSearched[i]));
     }
   }
 
@@ -2471,21 +2414,17 @@ namespace {
     ss.killers[0] = m;
   }
 
+
   // fail_high_ply_1() checks if some thread is currently resolving a fail
   // high at ply 1 at the node below the first root node.  This information
   // is used for time managment.
 
   bool fail_high_ply_1() {
-    for(int i = 0; i < ActiveThreads; i++)
-      if(Threads[i].failHighPly1)
-        return true;
-    return false;
-  }
 
-  bool aspiration_fail_high_ply_1() {
     for(int i = 0; i < ActiveThreads; i++)
-      if(Threads[i].aspirationFailHighPly1)
-        return true;
+        if (Threads[i].failHighPly1)
+            return true;
+
     return false;
   }
 
@@ -2528,13 +2467,14 @@ namespace {
             AbortSearch = true;
             PonderSearch = false;
             Quit = true;
+            return;
         }
-        else if(command == "stop")
+        else if (command == "stop")
         {
             AbortSearch = true;
             PonderSearch = false;
         }
-        else if(command == "ponderhit")
+        else if (command == "ponderhit")
             ponderhit();
     }
     // Print search information
@@ -2567,8 +2507,8 @@ namespace {
         return;
 
     bool overTime =     t > AbsoluteMaxSearchTime
-                     || (RootMoveNumber == 1 && t > MaxSearchTime + ExtraSearchTime && !FailLow && !aspiration_fail_high_ply_1())
-                     || (  !FailHigh && !FailLow && !fail_high_ply_1() && !aspiration_fail_high_ply_1() && !Problem
+                     || (RootMoveNumber == 1 && t > MaxSearchTime + ExtraSearchTime && !FailLow) //FIXME: We are not checking any problem flags, BUG?
+                     || (  !FailHigh && !FailLow && !fail_high_ply_1() && !Problem
                          && t > 6*(MaxSearchTime + ExtraSearchTime));
 
     if (   (Iteration >= 3 && (!InfiniteSearch && overTime))
@@ -2583,9 +2523,10 @@ namespace {
   // it correctly predicted the opponent's move.
 
   void ponderhit() {
+
     int t = current_search_time();
     PonderSearch = false;
-    if(Iteration >= 3 &&
+    if (Iteration >= 3 &&
        (!InfiniteSearch && (StopOnPonderhit ||
                             t > AbsoluteMaxSearchTime ||
                             (RootMoveNumber == 1 &&
@@ -2600,20 +2541,35 @@ namespace {
   // thread.  Called when the UCI option UCI_ShowCurrLine is 'true'.
 
   void print_current_line(SearchStack ss[], int ply, int threadID) {
+
     assert(ply >= 0 && ply < PLY_MAX);
     assert(threadID >= 0 && threadID < ActiveThreads);
 
-    if(!Threads[threadID].idle) {
-      lock_grab(&IOLock);
-      std::cout << "info currline " << (threadID + 1);
-      for(int p = 0; p < ply; p++)
-        std::cout << " " << ss[p].currentMove;
-      std::cout << std::endl;
-      lock_release(&IOLock);
+    if (!Threads[threadID].idle)
+    {
+        lock_grab(&IOLock);
+        std::cout << "info currline " << (threadID + 1);
+        for (int p = 0; p < ply; p++)
+            std::cout << " " << ss[p].currentMove;
+
+        std::cout << std::endl;
+        lock_release(&IOLock);
     }
     Threads[threadID].printCurrentLine = false;
-    if(threadID + 1 < ActiveThreads)
-      Threads[threadID + 1].printCurrentLine = true;
+    if (threadID + 1 < ActiveThreads)
+        Threads[threadID + 1].printCurrentLine = true;
+  }
+
+
+  // init_ss_array() does a fast reset of the first entries of a SearchStack array
+
+  void init_ss_array(SearchStack ss[]) {
+
+    for (int i = 0; i < 3; i++)
+    {
+        ss[i].init(i);
+        ss[i].initKillers();
+    }
   }
 
 
@@ -2625,20 +2581,21 @@ namespace {
   // after which the bestmove and pondermove will be printed (in id_loop()).
 
   void wait_for_stop_or_ponderhit() {
+
     std::string command;
 
-    while(true) {
-      if(!std::getline(std::cin, command))
-        command = "quit";
-
-      if(command == "quit") {
-        OpeningBook.close();
-        stop_threads();
-        quit_eval();
-        exit(0);
-      }
-      else if(command == "ponderhit" || command == "stop")
-        break;
+    while (true)
+    {
+        if (!std::getline(std::cin, command))
+            command = "quit";
+
+        if (command == "quit")
+        {
+            Quit = true;
+            break;
+        }
+        else if (command == "ponderhit" || command == "stop")
+            break;
     }
   }
 
@@ -2647,7 +2604,7 @@ namespace {
   // The parameter "waitSp", if non-NULL, is a pointer to an active SplitPoint
   // object for which the current thread is the master.
 
-  void idle_loop(int threadID, SplitPoint *waitSp) {
+  void idle_loop(int threadID, SplitPoint* waitSp) {
     assert(threadID >= 0 && threadID < THREAD_MAX);
 
     Threads[threadID].running = true;
@@ -2669,7 +2626,7 @@ namespace {
 #endif
       }
 
-      // If this thread has been assigned work, launch a search:
+      // If this thread has been assigned work, launch a search
       if(Threads[threadID].workIsWaiting) {
         Threads[threadID].workIsWaiting = false;
         if(Threads[threadID].splitPoint->pvNode)
@@ -2680,7 +2637,7 @@ namespace {
       }
 
       // If this thread is the master of a split point and all threads have
-      // finished their work at this split point, return from the idle loop:
+      // finished their work at this split point, return from the idle loop.
       if(waitSp != NULL && waitSp->cpus == 0)
         return;
     }
@@ -2719,7 +2676,7 @@ namespace {
   bool thread_should_stop(int threadID) {
     assert(threadID >= 0 && threadID < ActiveThreads);
 
-    SplitPoint *sp;
+    SplitPoint* sp;
 
     if(Threads[threadID].stop)
       return true;
@@ -2792,9 +2749,9 @@ namespace {
   // threads have returned from sp_search_pv (or, equivalently, when
   // splitPoint->cpus becomes 0), split() returns true.
 
-  bool split(const Position &p, SearchStack *sstck, int ply,
-             Value *alpha, Value *beta, Value *bestValue, Depth depth, int *moves,
-             MovePicker *mp, Bitboard dcCandidates, int master, bool pvNode) {
+  bool split(const Position& p, SearchStack* sstck, int ply,
+             Value* alpha, Value* beta, Value* bestValue, Depth depth, int* moves,
+             MovePicker* mp, Bitboard dcCandidates, int master, bool pvNode) {
 
     assert(p.is_ok());
     assert(sstck != NULL);
@@ -2806,24 +2763,24 @@ namespace {
     assert(master >= 0 && master < ActiveThreads);
     assert(ActiveThreads > 1);
 
-    SplitPoint *splitPoint;
+    SplitPoint* splitPoint;
     int i;
 
     lock_grab(&MPLock);
 
     // If no other thread is available to help us, or if we have too many
-    // active split points, don't split:
+    // active split points, don't split.
     if(!idle_thread_exists(master) ||
        Threads[master].activeSplitPoints >= MaxActiveSplitPoints) {
       lock_release(&MPLock);
       return false;
     }
 
-    // Pick the next available split point object from the split point stack:
+    // Pick the next available split point object from the split point stack
     splitPoint = SplitPointStack[master] + Threads[master].activeSplitPoints;
     Threads[master].activeSplitPoints++;
 
-    // Initialize the split point object:
+    // Initialize the split point object
     splitPoint->parent = Threads[master].splitPoint;
     splitPoint->finished = false;
     splitPoint->ply = ply;
@@ -2842,11 +2799,11 @@ namespace {
     for(i = 0; i < ActiveThreads; i++)
       splitPoint->slaves[i] = 0;
 
-    // Copy the current position and the search stack to the master thread:
+    // Copy the current position and the search stack to the master thread
     memcpy(splitPoint->sstack[master], sstck, (ply+1)*sizeof(SearchStack));
     Threads[master].splitPoint = splitPoint;
 
-    // Make copies of the current position and search stack for each thread:
+    // Make copies of the current position and search stack for each thread
     for(i = 0; i < ActiveThreads && splitPoint->cpus < MaxThreadsPerSplitPoint;
         i++)
       if(thread_is_available(i, master)) {
@@ -2876,7 +2833,7 @@ namespace {
     idle_loop(master, splitPoint);
 
     // We have returned from the idle loop, which means that all threads are
-    // finished.  Update alpha, beta and bestvalue, and return:
+    // finished. Update alpha, beta and bestvalue, and return.
     lock_grab(&MPLock);
     if(pvNode) *alpha = splitPoint->alpha;
     *beta = splitPoint->beta;