X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=4f5a3480ef00c68270d38647a14d3f68df511e85;hp=978041e8ff5bad79f9483ac5fabc551165f802be;hb=2b6bc70f7bf266602a3ca59abb606699bdf544c8;hpb=94dcac1feeb142a56ed2ebddb96ef672460f1d49

diff --git a/src/search.cpp b/src/search.cpp
index 978041e8..4f5a3480 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -172,10 +172,17 @@ namespace {
   const bool PruneDefendingMoves = false;
   const bool PruneBlockingMoves  = false;
 
+  // If the TT move is at least SingleReplyMargin better then the
+  // remaining ones we will extend it.
+  const Value SingleReplyMargin = Value(0x64);
+
   // Margins for futility pruning in the quiescence search, and at frontier
   // and near frontier nodes.
   const Value FutilityMarginQS = Value(0x80);
 
+  // Each move futility margin is decreased
+  const Value IncrementalFutilityMargin = Value(0x8);
+
   // 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
@@ -274,7 +281,7 @@ namespace {
   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 search(Position& pos, SearchStack ss[], Value beta, Depth depth, int ply, bool allowNullmove, int threadID, Move excludedMove = MOVE_NONE);
   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);
@@ -310,7 +317,7 @@ namespace {
              Value *alpha, Value *beta, Value *bestValue,
              const Value futilityValue, const Value approximateValue,
              Depth depth, int *moves,
-             MovePicker *mp, Bitboard dcCandidates, int master, bool pvNode);
+             MovePicker *mp, int master, bool pvNode);
   void wake_sleeping_threads();
 
 #if !defined(_MSC_VER)
@@ -333,25 +340,25 @@ namespace {
 int perft(Position& pos, Depth depth)
 {
     Move move;
-    MovePicker mp = MovePicker(pos, MOVE_NONE, depth, H);
-    Bitboard dcCandidates = pos.discovered_check_candidates(pos.side_to_move());
     int sum = 0;
+    MovePicker mp = MovePicker(pos, MOVE_NONE, depth, H);
 
     // If we are at the last ply we don't need to do and undo
     // the moves, just to count them.
     if (depth <= OnePly) // Replace with '<' to test also qsearch
     {
-        while ((move = mp.get_next_move()) != MOVE_NONE) sum++;
+        while (mp.get_next_move()) sum++;
         return sum;
     }
 
     // Loop through all legal moves
+    CheckInfo ci(pos);
     while ((move = mp.get_next_move()) != MOVE_NONE)
     {
-      StateInfo st;
-      pos.do_move(move, st, dcCandidates);
-      sum += perft(pos, depth - OnePly);
-      pos.undo_move(move);
+        StateInfo st;
+        pos.do_move(move, st, ci, pos.move_is_check(move, ci));
+        sum += perft(pos, depth - OnePly);
+        pos.undo_move(move);
     }
     return sum;
 }
@@ -862,7 +869,7 @@ namespace {
 
     Value oldAlpha = alpha;
     Value value;
-    Bitboard dcCandidates = pos.discovered_check_candidates(pos.side_to_move());
+    CheckInfo ci(pos);
 
     // Loop through all the moves in the root move list
     for (int i = 0; i <  rml.move_count() && !AbortSearch; i++)
@@ -898,13 +905,14 @@ namespace {
                       << " currmovenumber " << i + 1 << std::endl;
 
         // Decide search depth for this move
+        bool moveIsCheck = pos.move_is_check(move);
         bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
         bool dangerous;
-        ext = extension(pos, move, true, captureOrPromotion, pos.move_is_check(move), false, false, &dangerous);
+        ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
         newDepth = (Iteration - 2) * OnePly + ext + InitialDepth;
 
         // Make the move, and search it
-        pos.do_move(move, st, dcCandidates);
+        pos.do_move(move, st, ci, moveIsCheck);
 
         if (i < MultiPV)
         {
@@ -1062,6 +1070,17 @@ namespace {
     assert(ply >= 0 && ply < PLY_MAX);
     assert(threadID >= 0 && threadID < ActiveThreads);
 
+    Move movesSearched[256];
+    EvalInfo ei;
+    StateInfo st;
+    const TTEntry* tte;
+    Move ttMove, move;
+    Depth ext, newDepth;
+    Value oldAlpha, value;
+    bool isCheck, mateThreat, singleReply, moveIsCheck, captureOrPromotion, dangerous;
+    int moveCount = 0;
+    Value bestValue = -VALUE_INFINITE;
+
     if (depth < OnePly)
         return qsearch(pos, ss, alpha, beta, Depth(0), ply, threadID);
 
@@ -1076,13 +1095,11 @@ namespace {
     if (pos.is_draw())
         return VALUE_DRAW;
 
-    EvalInfo ei;
-
     if (ply >= PLY_MAX - 1)
         return pos.is_check() ? quick_evaluate(pos) : evaluate(pos, ei, threadID);
 
     // Mate distance pruning
-    Value oldAlpha = alpha;
+    oldAlpha = alpha;
     alpha = Max(value_mated_in(ply), alpha);
     beta = Min(value_mate_in(ply+1), beta);
     if (alpha >= beta)
@@ -1090,8 +1107,8 @@ 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.get_key());
-    Move ttMove = (tte ? tte->move() : MOVE_NONE);
+    tte = TT.retrieve(pos.get_key());
+    ttMove = (tte ? tte->move() : MOVE_NONE);
 
     // Go with internal iterative deepening if we don't have a TT move
     if (UseIIDAtPVNodes && ttMove == MOVE_NONE && depth >= 5*OnePly)
@@ -1102,15 +1119,10 @@ namespace {
 
     // Initialize a MovePicker object for the current position, and prepare
     // to search all moves
-    Move move, movesSearched[256];
-    int moveCount = 0;
-    Value value, bestValue = -VALUE_INFINITE;
-    Color us = pos.side_to_move();
-    bool isCheck = pos.is_check();
-    bool mateThreat = pos.has_mate_threat(opposite_color(us));
-
+    isCheck = pos.is_check();
+    mateThreat = pos.has_mate_threat(opposite_color(pos.side_to_move()));
+    CheckInfo ci(pos);
     MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
-    Bitboard dcCandidates = pos.discovered_check_candidates(us);
 
     // Loop through all legal moves until no moves remain or a beta cutoff
     // occurs.
@@ -1120,20 +1132,44 @@ namespace {
     {
       assert(move_is_ok(move));
 
-      bool singleReply = (isCheck && mp.number_of_evasions() == 1);
-      bool moveIsCheck = pos.move_is_check(move, dcCandidates);
-      bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
-
-      movesSearched[moveCount++] = ss[ply].currentMove = move;
+      singleReply = (isCheck && mp.number_of_evasions() == 1);
+      moveIsCheck = pos.move_is_check(move, ci);
+      captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
       // Decide the new search depth
-      bool dangerous;
-      Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, singleReply, mateThreat, &dangerous);
-      Depth newDepth = depth - OnePly + ext;
+      ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, singleReply, mateThreat, &dangerous);
+
+      // We want to extend the TT move if it is much better then remaining ones.
+      // To verify this we do a reduced search on all the other moves but the ttMove,
+      // if result is lower then TT value minus a margin then we assume ttMove is the
+      // only one playable. It is a kind of relaxed single reply extension.
+      if (   depth >= 4 * OnePly
+          && move == ttMove
+          && ext < OnePly
+          && is_lower_bound(tte->type())
+          && tte->depth() >= depth - 3 * OnePly)
+      {
+          Value ttValue = value_from_tt(tte->value(), ply);
+
+          if (abs(ttValue) < VALUE_KNOWN_WIN)
+          {
+              Depth d = Max(Min(depth / 2,  depth - 4 * OnePly), OnePly);
+              Value excValue = search(pos, ss, ttValue - SingleReplyMargin, d, ply, false, threadID, ttMove);
+
+              // If search result is well below the foreseen score of the ttMove then we
+              // assume ttMove is the only one realistically playable and we extend it.
+              if (excValue < ttValue - SingleReplyMargin)
+                  ext = OnePly;
+          }
+      }
+
+      newDepth = depth - OnePly + ext;
+
+      // Update current move
+      movesSearched[moveCount++] = ss[ply].currentMove = move;
 
       // Make and search the move
-      StateInfo st;
-      pos.do_move(move, st, dcCandidates);
+      pos.do_move(move, st, ci, moveIsCheck);
 
       if (moveCount == 1) // The first move in list is the PV
           value = -search_pv(pos, ss, -beta, -alpha, newDepth, ply+1, threadID);
@@ -1206,8 +1242,8 @@ namespace {
           && idle_thread_exists(threadID)
           && !AbortSearch
           && !thread_should_stop(threadID)
-          && split(pos, ss, ply, &alpha, &beta, &bestValue, VALUE_NONE, VALUE_NONE, depth,
-                   &moveCount, &mp, dcCandidates, threadID, true))
+          && split(pos, ss, ply, &alpha, &beta, &bestValue, VALUE_NONE, VALUE_NONE,
+                   depth, &moveCount, &mp, threadID, true))
           break;
     }
 
@@ -1227,13 +1263,13 @@ namespace {
     else if (bestValue >= beta)
     {
         BetaCounter.add(pos.side_to_move(), depth, threadID);
-        Move m = ss[ply].pv[ply];
-        if (!pos.move_is_capture_or_promotion(m))
+        move = ss[ply].pv[ply];
+        if (!pos.move_is_capture_or_promotion(move))
         {
-            update_history(pos, m, depth, movesSearched, moveCount);
-            update_killers(m, ss[ply]);
+            update_history(pos, move, depth, movesSearched, moveCount);
+            update_killers(move, ss[ply]);
         }
-        TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, m);
+        TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, move);
     }
     else
         TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_EXACT, depth, ss[ply].pv[ply]);
@@ -1245,12 +1281,24 @@ namespace {
   // search() is the search function for zero-width nodes.
 
   Value search(Position& pos, SearchStack ss[], Value beta, Depth depth,
-               int ply, bool allowNullmove, int threadID) {
+               int ply, bool allowNullmove, int threadID, Move excludedMove) {
 
     assert(beta >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
     assert(ply >= 0 && ply < PLY_MAX);
     assert(threadID >= 0 && threadID < ActiveThreads);
 
+    Move movesSearched[256];
+    EvalInfo ei;
+    StateInfo st;
+    const TTEntry* tte;
+    Move ttMove, move;
+    Depth ext, newDepth;
+    Value approximateEval, nullValue, value, futilityValue, futilityValueScaled;
+    bool isCheck, useFutilityPruning, singleReply, moveIsCheck, captureOrPromotion, dangerous;
+    bool mateThreat = false;
+    int moveCount = 0;
+    Value bestValue = -VALUE_INFINITE;
+
     if (depth < OnePly)
         return qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
 
@@ -1265,8 +1313,6 @@ namespace {
     if (pos.is_draw())
         return VALUE_DRAW;
 
-    EvalInfo ei;
-
     if (ply >= PLY_MAX - 1)
         return pos.is_check() ? quick_evaluate(pos) : evaluate(pos, ei, threadID);
 
@@ -1277,9 +1323,13 @@ namespace {
     if (value_mate_in(ply + 1) < beta)
         return beta - 1;
 
+    // We don't want the score of a partial search to overwrite a previous full search
+    // TT value, so we use a different position key in case of an excluded move exsists.
+    Key posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key();
+
     // Transposition table lookup
-    const TTEntry* tte = TT.retrieve(pos.get_key());
-    Move ttMove = (tte ? tte->move() : MOVE_NONE);
+    tte = TT.retrieve(posKey);
+    ttMove = (tte ? tte->move() : MOVE_NONE);
 
     if (tte && ok_to_use_TT(tte, depth, beta, ply))
     {
@@ -1287,9 +1337,8 @@ namespace {
         return value_from_tt(tte->value(), ply);
     }
 
-    Value approximateEval = quick_evaluate(pos);
-    bool mateThreat = false;
-    bool isCheck = pos.is_check();
+    approximateEval = quick_evaluate(pos);
+    isCheck = pos.is_check();
 
     // Null move search
     if (    allowNullmove
@@ -1301,11 +1350,16 @@ namespace {
     {
         ss[ply].currentMove = MOVE_NULL;
 
-        StateInfo st;
         pos.do_null_move(st);
-        int R = (depth >= 5 * OnePly ? 4 : 3); // Null move dynamic reduction
 
-        Value nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID);
+        // Null move dynamic reduction based on depth
+        int R = (depth >= 5 * OnePly ? 4 : 3);
+
+        // Null move dynamic reduction based on value
+        if (approximateEval - beta > PawnValueMidgame)
+            R++;
+
+        nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID);
 
         pos.undo_null_move();
 
@@ -1343,8 +1397,9 @@ namespace {
              && 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 - RazorMargins[int(depth) - 2])
+        Value rbeta = beta - RazorMargins[int(depth) - 2];
+        Value v = qsearch(pos, ss, rbeta-1, rbeta, Depth(0), ply, threadID);
+        if (v < rbeta)
           return v;
     }
 
@@ -1359,46 +1414,72 @@ namespace {
     // Initialize a MovePicker object for the current position, and prepare
     // 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;
-    Color us = pos.side_to_move();
-    Bitboard dcCandidates = pos.discovered_check_candidates(us);
-    Value futilityValue = VALUE_NONE;
-    bool useFutilityPruning =   depth < SelectiveDepth
-                             && !isCheck;
+    CheckInfo ci(pos);
+    futilityValue = VALUE_NONE;
+    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.
+    // Move count pruning limit
+    const int MCLimit = 3 + (1 << (3*int(depth)/8));
+
+    // Loop through all legal moves until no moves remain or a beta cutoff occurs
     while (   bestValue < beta
            && (move = mp.get_next_move()) != MOVE_NONE
            && !thread_should_stop(threadID))
     {
       assert(move_is_ok(move));
 
-      bool singleReply = (isCheck && mp.number_of_evasions() == 1);
-      bool moveIsCheck = pos.move_is_check(move, dcCandidates);
-      bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
+      if (move == excludedMove)
+          continue;
 
-      movesSearched[moveCount++] = ss[ply].currentMove = move;
+      singleReply = (isCheck && mp.number_of_evasions() == 1);
+      moveIsCheck = pos.move_is_check(move, ci);
+      captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
       // Decide the new search depth
-      bool dangerous;
-      Depth ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, singleReply, mateThreat, &dangerous);
-      Depth newDepth = depth - OnePly + ext;
+      ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, singleReply, mateThreat, &dangerous);
+
+      // We want to extend the TT move if it is much better then remaining ones.
+      // To verify this we do a reduced search on all the other moves but the ttMove,
+      // if result is lower then TT value minus a margin then we assume ttMove is the
+      // only one playable. It is a kind of relaxed single reply extension.
+      if (   depth >= 4 * OnePly
+          && !excludedMove // do not allow recursive single-reply search
+          && move == ttMove
+          && ext < OnePly
+          && is_lower_bound(tte->type())
+          && tte->depth() >= depth - 3 * OnePly)
+      {
+          Value ttValue = value_from_tt(tte->value(), ply);
+
+          if (abs(ttValue) < VALUE_KNOWN_WIN)
+          {
+              Depth d = Max(Min(depth / 2,  depth - 4 * OnePly), OnePly);
+              Value excValue = search(pos, ss, ttValue - SingleReplyMargin, d, ply, false, threadID, ttMove);
+
+              // If search result is well below the foreseen score of the ttMove then we
+              // assume ttMove is the only one realistically playable and we extend it.
+              if (excValue < ttValue - SingleReplyMargin)
+                  ext = (depth >= 8 * OnePly) ? OnePly : ext + OnePly / 2;
+          }
+      }
+
+      newDepth = depth - OnePly + ext;
+
+      // Update current move
+      movesSearched[moveCount++] = ss[ply].currentMove = move;
 
       // Futility pruning
       if (    useFutilityPruning
           && !dangerous
-          && !captureOrPromotion)
+          && !captureOrPromotion
+          &&  move != ttMove)
       {
           // History pruning. See ok_to_prune() definition
-          if (   moveCount >= 2 + int(depth)
+          if (   moveCount >= MCLimit
               && ok_to_prune(pos, move, ss[ply].threatMove, depth)
               && bestValue > value_mated_in(PLY_MAX))
               continue;
@@ -1408,20 +1489,21 @@ namespace {
           {
               if (futilityValue == VALUE_NONE)
                   futilityValue =  evaluate(pos, ei, threadID)
-                                 + FutilityMargins[int(depth) - 2];
+                                 + 64*(2+bitScanReverse32(int(depth) * int(depth)));
 
-              if (futilityValue < beta)
+              futilityValueScaled = futilityValue - moveCount * IncrementalFutilityMargin;
+
+              if (futilityValueScaled < beta)
               {
-                  if (futilityValue > bestValue)
-                      bestValue = futilityValue;
+                  if (futilityValueScaled > bestValue)
+                      bestValue = futilityValueScaled;
                   continue;
               }
           }
       }
 
       // Make and search the move
-      StateInfo st;
-      pos.do_move(move, st, dcCandidates);
+      pos.do_move(move, st, ci, moveIsCheck);
 
       // 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.
@@ -1466,15 +1548,15 @@ namespace {
           && idle_thread_exists(threadID)
           && !AbortSearch
           && !thread_should_stop(threadID)
-          && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, approximateEval, depth, &moveCount,
-                   &mp, dcCandidates, threadID, false))
+          && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, approximateEval,
+                   depth, &moveCount, &mp, threadID, false))
         break;
     }
 
     // All legal moves have been searched.  A special case: If there were
     // no legal moves, it must be mate or stalemate.
     if (moveCount == 0)
-        return (pos.is_check() ? value_mated_in(ply) : VALUE_DRAW);
+        return excludedMove ? beta - 1 : (pos.is_check() ? value_mated_in(ply) : VALUE_DRAW);
 
     // If the search is not aborted, update the transposition table,
     // history counters, and killer moves.
@@ -1482,17 +1564,17 @@ namespace {
         return bestValue;
 
     if (bestValue < beta)
-        TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_UPPER, depth, MOVE_NONE);
+        TT.store(posKey, value_to_tt(bestValue, ply), VALUE_TYPE_UPPER, depth, MOVE_NONE);
     else
     {
         BetaCounter.add(pos.side_to_move(), depth, threadID);
-        Move m = ss[ply].pv[ply];
-        if (!pos.move_is_capture_or_promotion(m))
+        move = ss[ply].pv[ply];
+        if (!pos.move_is_capture_or_promotion(move))
         {
-            update_history(pos, m, depth, movesSearched, moveCount);
-            update_killers(m, ss[ply]);
+            update_history(pos, move, depth, movesSearched, moveCount);
+            update_killers(move, ss[ply]);
         }
-        TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, m);
+        TT.store(posKey, value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, move);
     }
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
@@ -1514,6 +1596,15 @@ namespace {
     assert(ply >= 0 && ply < PLY_MAX);
     assert(threadID >= 0 && threadID < ActiveThreads);
 
+    EvalInfo ei;
+    StateInfo st;
+    Move ttMove, move;
+    Value staticValue, bestValue, value, futilityValue;
+    bool isCheck, enoughMaterial, moveIsCheck;
+    const TTEntry* tte = NULL;
+    int moveCount = 0;
+    bool pvNode = (beta - alpha != 1);
+
     // Initialize, and make an early exit in case of an aborted search,
     // an instant draw, maximum ply reached, etc.
     init_node(ss, ply, threadID);
@@ -1526,8 +1617,6 @@ namespace {
         return VALUE_DRAW;
 
     // Transposition table lookup, only when not in PV
-    TTEntry* tte = NULL;
-    bool pvNode = (beta - alpha != 1);
     if (!pvNode)
     {
         tte = TT.retrieve(pos.get_key());
@@ -1538,12 +1627,10 @@ namespace {
             return value_from_tt(tte->value(), ply);
         }
     }
-    Move ttMove = (tte ? tte->move() : MOVE_NONE);
+    ttMove = (tte ? tte->move() : MOVE_NONE);
 
     // Evaluate the position statically
-    EvalInfo ei;
-    Value staticValue;
-    bool isCheck = pos.is_check();
+    isCheck = pos.is_check();
     ei.futilityMargin = Value(0); // Manually initialize futilityMargin
 
     if (isCheck)
@@ -1564,7 +1651,7 @@ namespace {
 
     // Initialize "stand pat score", and return it immediately if it is
     // at least beta.
-    Value bestValue = staticValue;
+    bestValue = staticValue;
 
     if (bestValue >= beta)
     {
@@ -1582,11 +1669,8 @@ namespace {
     // 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, ttMove, depth, H);
-    Move move;
-    int moveCount = 0;
-    Color us = pos.side_to_move();
-    Bitboard dcCandidates = pos.discovered_check_candidates(us);
-    bool enoughMaterial = pos.non_pawn_material(us) > RookValueMidgame;
+    CheckInfo ci(pos);
+    enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
 
     // Loop through the moves until no moves remain or a beta cutoff
     // occurs.
@@ -1598,20 +1682,23 @@ namespace {
       moveCount++;
       ss[ply].currentMove = move;
 
+      moveIsCheck = pos.move_is_check(move, ci);
+
       // Futility pruning
       if (   enoughMaterial
           && !isCheck
           && !pvNode
+          && !moveIsCheck
+          &&  move != ttMove
           && !move_is_promotion(move)
-          && !pos.move_is_check(move, dcCandidates)
           && !pos.move_is_passed_pawn_push(move))
       {
-          Value futilityValue = staticValue
-                              + Max(pos.midgame_value_of_piece_on(move_to(move)),
-                                    pos.endgame_value_of_piece_on(move_to(move)))
-                              + (move_is_ep(move) ? PawnValueEndgame : Value(0))
-                              + FutilityMarginQS
-                              + ei.futilityMargin;
+          futilityValue =  staticValue
+                         + Max(pos.midgame_value_of_piece_on(move_to(move)),
+                               pos.endgame_value_of_piece_on(move_to(move)))
+                         + (move_is_ep(move) ? PawnValueEndgame : Value(0))
+                         + FutilityMarginQS
+                         + ei.futilityMargin;
 
           if (futilityValue < alpha)
           {
@@ -1628,10 +1715,9 @@ namespace {
           &&  pos.see_sign(move) < 0)
           continue;
 
-      // Make and search the move.
-      StateInfo st;
-      pos.do_move(move, st, dcCandidates);
-      Value value = -qsearch(pos, ss, -beta, -alpha, depth-OnePly, ply+1, threadID);
+      // Make and search the move
+      pos.do_move(move, st, ci, moveIsCheck);
+      value = -qsearch(pos, ss, -beta, -alpha, depth-OnePly, ply+1, threadID);
       pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
@@ -1656,7 +1742,7 @@ namespace {
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
 
     // Update transposition table
-    Move m = ss[ply].pv[ply];
+    move = ss[ply].pv[ply];
     if (!pvNode)
     {
         // If bestValue isn't changed it means it is still the static evaluation of
@@ -1667,12 +1753,12 @@ namespace {
         if (bestValue < beta)
             TT.store(pos.get_key(), value_to_tt(bestValue, ply), type, d, MOVE_NONE);
         else
-            TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, d, m);
+            TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, d, move);
     }
 
     // Update killers only for good check moves
-    if (alpha >= beta && !pos.move_is_capture_or_promotion(m))
-        update_killers(m, ss[ply]);
+    if (alpha >= beta && !pos.move_is_capture_or_promotion(move))
+        update_killers(move, ss[ply]);
 
     return bestValue;
   }
@@ -1692,6 +1778,7 @@ namespace {
     assert(ActiveThreads > 1);
 
     Position pos = Position(sp->pos);
+    CheckInfo ci(pos);
     SearchStack* ss = sp->sstack[threadID];
     Value value;
     Move move;
@@ -1705,7 +1792,7 @@ namespace {
     {
       assert(move_is_ok(move));
 
-      bool moveIsCheck = pos.move_is_check(move, sp->dcCandidates);
+      bool moveIsCheck = pos.move_is_check(move, ci);
       bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
       lock_grab(&(sp->lock));
@@ -1756,7 +1843,7 @@ namespace {
 
       // Make and search the move.
       StateInfo st;
-      pos.do_move(move, st, sp->dcCandidates);
+      pos.do_move(move, st, ci, moveIsCheck);
 
       // 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.
@@ -1835,6 +1922,7 @@ namespace {
     assert(ActiveThreads > 1);
 
     Position pos = Position(sp->pos);
+    CheckInfo ci(pos);
     SearchStack* ss = sp->sstack[threadID];
     Value value;
     Move move;
@@ -1843,7 +1931,7 @@ namespace {
            && !thread_should_stop(threadID)
            && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
     {
-      bool moveIsCheck = pos.move_is_check(move, sp->dcCandidates);
+      bool moveIsCheck = pos.move_is_check(move, ci);
       bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
       assert(move_is_ok(move));
@@ -1861,7 +1949,7 @@ namespace {
 
       // Make and search the move.
       StateInfo st;
-      pos.do_move(move, st, sp->dcCandidates);
+      pos.do_move(move, st, ci, moveIsCheck);
 
       // 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.
@@ -2805,7 +2893,7 @@ namespace {
   bool split(const Position& p, SearchStack* sstck, int ply,
              Value* alpha, Value* beta, Value* bestValue, const Value futilityValue,
              const Value approximateEval, Depth depth, int* moves,
-             MovePicker* mp, Bitboard dcCandidates, int master, bool pvNode) {
+             MovePicker* mp, int master, bool pvNode) {
 
     assert(p.is_ok());
     assert(sstck != NULL);
@@ -2842,7 +2930,6 @@ namespace {
     splitPoint->alpha = pvNode? *alpha : (*beta - 1);
     splitPoint->beta = *beta;
     splitPoint->pvNode = pvNode;
-    splitPoint->dcCandidates = dcCandidates;
     splitPoint->bestValue = *bestValue;
     splitPoint->futilityValue = futilityValue;
     splitPoint->approximateEval = approximateEval;