/// The Stats struct stores moves statistics. According to the template parameter
/// the class can store History and Countermoves. History records how often
/// different moves have been successful or unsuccessful during the current search
/// and is used for reduction and move ordering decisions.
/// Countermoves store the move that refute a previous one. Entries are stored
/// using only the moving piece and destination square, hence two moves with
/// different origin but same destination and piece will be considered identical.
template<typename T, bool CM = false>
struct Stats {

  static const Value Max = Value(1 << 28);

  const T* operator[](Piece pc) const { return table[pc]; }
  T* operator[](Piece pc) { return table[pc]; }
  void clear() { std::memset(table, 0, sizeof(table)); }
  void update(Piece pc, Square to, Move m) { table[pc][to] = m; }
  void update(Piece pc, Square to, Value v) {

    if (abs(int(v)) >= 324)
        return;

    table[pc][to] -= table[pc][to] * abs(int(v)) / (CM ? 936 : 324);
    table[pc][to] += int(v) * 32;
  }

private:
  T table[PIECE_NB][SQUARE_NB];
};

typedef Stats<Move> MoveStats;
typedef Stats<Value, false> HistoryStats;
typedef Stats<Value,  true> CounterMoveStats;
typedef Stats<CounterMoveStats> CounterMoveHistoryStats;

table[piece][to_square] → learned information about that move

typedef Stats<Move> MoveStats;

MoveStats countermoves;

// Opponent played Nf6
// We responded with d4 (good response)
countermoves.update(BLACK_KNIGHT, SQ_F6, MOVE_D2D4);

// Later, opponent plays Nf6 again:
Move response = countermoves[BLACK_KNIGHT][SQ_F6];
// response = d4
// Try this first! (likely good again)

typedef Stats<Value, false> HistoryStats;

HistoryStats history;

// Position A: Opponent played d5
// We try Ne4 → beta cutoff
history.update(WHITE_KNIGHT, SQ_E4, +64);

// Position B: Opponent played c5  
// We try Ne4 → beta cutoff again
history.update(WHITE_KNIGHT, SQ_E4, +36);

// Position C: Opponent played Nf6
// We try Ne4 → beta cutoff again
history.update(WHITE_KNIGHT, SQ_E4, +49);

// Result:
history[WHITE_KNIGHT][SQ_E4] = 5000+ (high score)

// Interpretation:
"Ne4 has been good in general, regardless of what opponent did. This will be the first move we try for next couple of searches even if we don't play it now."

typedef Stats<Value, true> CounterMoveStats;

typedef Stats<CounterMoveStats> CounterMoveHistoryStats;

// Underlying structure:
CounterMoveStats table[PIECE_NB][SQUARE_NB];
//                     ↓
//        Value table2[PIECE_NB][SQUARE_NB];

// Final structure:
Value table[piece1][square1][piece2][square2];

CounterMoveHistoryStats cmHistory;

// Opponent: Nf6 (BLACK_KNIGHT to f6)
// We: d4 (WHITE_PAWN to d4)
// Result: Good! (caused cutoff)

cmHistory[BLACK_KNIGHT][SQ_F6].update(WHITE_PAWN, SQ_D4, +64);

// Later:
// We want to evaluate what if Opponent plays Nf6 again
Value score = cmHistory[BLACK_KNIGHT][SQ_F6][WHITE_PAWN][SQ_D4];
// score = 2048 (d4 was good response to Nf6 before, let's try it first)

// HISTORY (context-free):
history[WHITE_KNIGHT][SQ_E4] = 5000
"Ne4 is often good"

// COUNTERMOVE HISTORY (context-aware):
cmh[BLACK_PAWN][SQ_D5][WHITE_KNIGHT][SQ_E4] = 3000
"Ne4 is often good WHEN opponent played d5"

cmh[BLACK_KNIGHT][SQ_F6][WHITE_KNIGHT][SQ_E4] = -500
"Ne4 is often BAD WHEN opponent played Nf6"

// Opponent just played Nf6

// Calculate move score for Ne4:
int score_Ne4 = 0;

// Add general history
score_Ne4 += history[WHITE_KNIGHT][SQ_E4];          // +5000

// Add context-specific history
score_Ne4 += cmh[BLACK_KNIGHT][SQ_F6]               // -500
                [WHITE_KNIGHT][SQ_E4];

// Total: 5000 - 500 = 4500

// Calculate for Nd4:
int score_Nd4 = 0;
score_Nd4 += history[WHITE_KNIGHT][SQ_D4];          // +1000
score_Nd4 += cmh[BLACK_KNIGHT][SQ_F6]               // +2000
                [WHITE_KNIGHT][SQ_D4];
// Total: 1000 + 2000 = 3000

// Result: Try Ne4 first (4500 > 3000)

void update(Piece pc, Square to, Value v) {
    if (abs(int(v)) >= 324)
        return;

    table[pc][to] -= table[pc][to] * abs(int(v)) / (CM ? 936 : 324);
    table[pc][to] += int(v) * 32;
}

1. Try TT move (best for this exact position)
2. Try countermove (good pattern across positions)
3. Try other moves ordered by history

// Move ordering priority:
1. TT move         ← Specific to this exact position (best!)
2. Countermove     ← General pattern (good guess)
3. History         ← Statistical frequency
4. Other moves

Value table[COLOR_NB][SQUARE_NB][SQUARE_NB];
//          ↑         ↑           ↑
//        Color     From        To
//        (2)       (64)        (64)

table[piece][to_square]

// Example:
history[WHITE_KNIGHT][e4]
// "Knight moves to e4" (from anywhere)

table[color][from_square][to_square]

// Example:
fromTo[WHITE][f3][e4]
// "Move from f3 to e4" (any piece!)

FromToStats fromToHistory;

// Move: Nf3-e5 (knight from f3 to e5)
fromToHistory.update(WHITE, make_move(f3, e5), +64);

// Stored at:
table[WHITE][f3][e5] = 2048

// Later, any move f3→e5 gets this score:
// - Nf3-e5 (knight) ✓
// - Bf3-e5 (bishop, if possible) ✓  
// - Even pawn f3-e5 (if legal) ✓

// But NOT:
// - Nd2-e5 (different from-square) ✗

Position: Knight can go to e5 from two squares

// From f3:
history[WHITE_KNIGHT][e5] = 5000    // "Ne5 is good"
fromTo[WHITE][f3][e5] = 8000        // "f3→e5 path is especially good!"

// From d2:
history[WHITE_KNIGHT][e5] = 5000    // "Ne5 is good" (same!)
fromTo[WHITE][d2][e5] = 1000        // "d2→e5 path is less good"

// Result: Prefer Nf3-e5 over Nd2-e5

MovePicker mp(pos, ttMove, depth, ss);

Move m;
while ((m = mp.next_move()) != MOVE_NONE) {
    // Try move in best-first order
    score = -search(pos.do_move(m), ...);
    if (score >= beta)
        break;  // Cutoff! (hopefully on first move)
}

MovePicker(const Position&, Move, Value);
MovePicker(const Position&, Move, Depth, Square);
MovePicker(const Position&, Move, Depth, Search::Stack*);

MovePicker(const Position& p, Move ttm, Value threshold);

MovePicker mp(pos, ttMove, -100);
// Only generate captures that don't lose >1 pawn

MovePicker::MovePicker(const Position& p, Move ttm, Value th)
           : pos(p), threshold(th) {

  assert(!pos.checkers());

  stage = PROBCUT;

  // In ProbCut we generate captures with SEE higher than the given threshold
  ttMove =   ttm
          && pos.pseudo_legal(ttm)
          && pos.capture(ttm)
          && pos.see_ge(ttm, threshold + 1)? ttm : MOVE_NONE;

  stage += (ttMove == MOVE_NONE);
}

assert(!pos.checkers());

stage = PROBCUT;

enum Stage {
    MAIN_TT = 0,
    // ...
    PROBCUT,           // Only high-SEE captures
    PROBCUT_CAPTURES,  // Generate and return them
    // ...
};

ttMove =   ttm
        && pos.pseudo_legal(ttm)
        && pos.capture(ttm)
        && pos.see_ge(ttm, threshold + 1) ? ttm : MOVE_NONE;

MovePicker(const Position& p, Move ttm, Depth d, Square sq);

// Opponent just captured on e4
MovePicker mp(pos, ttMove, depth, SQ_E4);
// Prioritize recaptures on e4

MovePicker::MovePicker(const Position& p, Move ttm, Depth d, Square s)
           : pos(p) {

  assert(d <= DEPTH_ZERO);

  if (pos.checkers())
      stage = EVASION;

  else if (d > DEPTH_QS_NO_CHECKS)
      stage = QSEARCH_WITH_CHECKS;

  else if (d > DEPTH_QS_RECAPTURES)
      stage = QSEARCH_NO_CHECKS;

  else
  {
      stage = QSEARCH_RECAPTURES;
      recaptureSquare = s;
      return;
  }

  ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE;
  stage += (ttMove == MOVE_NONE);
}

// Depth constants (negative values):
DEPTH_ZERO = 0
DEPTH_QS_CHECKS = 0        // Try checks in quiescence
DEPTH_QS_NO_CHECKS = -1    // No checks, just captures
DEPTH_QS_RECAPTURES = -5   // Only recaptures on specific square

// Typical quiescence depths:
d = 0    → Can try checks
d = -1   → Only captures, no checks
d = -2   → Only captures, no checks
d = -5   → Only recaptures on one square
d = -7   → Only recaptures on one square

assert(d <= DEPTH_ZERO);

if (mode == QS_CHECKS) ...
else if (mode == QS_CAPTURES) ...
else if (mode == QS_RECAPTURES) ...

depth--

MovePicker::MovePicker(const Position& p, Move ttm, Depth d, Search::Stack* s)
    : pos(p), ss(s), depth(d)

assert(d > DEPTH_ZERO);

Square prevSq = to_sq((ss-1)->currentMove);

// ss points to current ply
// ss-1 points to PARENT ply

countermove = pos.this_thread()->counterMoves[pos.piece_on(prevSq)][prevSq];

// Get the thread searching this position
// Each thread has its own move statistics
Thread* thread = pos.this_thread();

// What piece is on the square opponent just moved to?
Piece theirPiece = pos.piece_on(prevSq);

// Example:
// Opponent played Nd4
// prevSq = d4
// piece_on(d4) = BLACK_KNIGHT

// Look up our recorded response to this move
Move cm = counterMoves[BLACK_KNIGHT][d4];

// This is the move we previously found to be good
// when opponent played their knight to d4

stage = pos.checkers() ? EVASION : MAIN_SEARCH;

if (pos.checkers())
    stage = EVASION;

// Must get out of check!
// Generate only evasion moves

else
    stage = MAIN_SEARCH;

// Normal position
// Generate all moves in priority order:
// TT → Captures → Killers → Countermove → Quiets → Bad Captures

ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE;

stage += (ttMove == MOVE_NONE);

// With valid TT move:
stage = MAIN_SEARCH (e.g., 0)
stage += 0
// = MAIN_SEARCH (try TT move first)

// Without TT move:
stage = MAIN_SEARCH (0)
stage += 1
// = MAIN_SEARCH + 1 (skip to captures)

private:
    const Position& pos;              // Current position
    const Search::Stack* ss;          // Search stack (killers, history)
    Move countermove;                 // Countermove to try
    Depth depth;                      // Search depth
    Move ttMove;                      // TT move (highest priority)
    Square recaptureSquare;           // For recapture prioritization
    Value threshold;                  // SEE threshold for captures
    int stage;                        // Current generation stage
    
    ExtMove *cur;                     // Current move pointer
    ExtMove *endMoves;                // End of generated moves
    ExtMove *endBadCaptures;          // Separator for bad captures
    ExtMove moves[MAX_MOVES];         // Move buffer (218 max)

const Position& pos;

const Search::Stack* ss;

search(depth=5) → ss[0]
 search(depth=4) → ss[1]
  search(depth=3) → ss[2]
   search(depth=2) → ss[3]

Move countermove;

// In constructor:
if (ss && ss->ply > 0) {
    Move lastMove = (ss-1)->currentMove;  // Opponent's last move
    countermove = counterMoves[lastMove];  // Our recorded response
}

Depth depth;

Move MovePicker::next_move() {
    // At depth < 3, skip quiet moves (ProbCut)
    if (depth < 3 * ONE_PLY && stage == QUIET_MOVES)
        stage = BAD_CAPTURES;  // Skip to bad captures
    
    // History bonus: depth²
    int bonus = depth * depth;
    history.update(move, bonus);
}

search(move, depth=10) → expensive

search(move, depth=4)
if score >= beta + margin:
    prune branch

Move ttMove;

// In search:
TTEntry* tte = TT.probe(pos.key());
Move ttMove = tte ? tte->move() : MOVE_NONE;

MovePicker mp(pos, ttMove, depth, ss);

// First call to next_move():
Move m1 = mp.next_move();
// Returns ttMove immediately if legal

// When generating captures:
for (Move m : all_captures) {
    if (m == ttMove)
        continue;  // Skip, already tried
    // ... add to list
}

Square recaptureSquare;

MovePicker::MovePicker(const Position& p, Move ttm, Depth d, Square sq)
    : pos(p), ttMove(ttm), depth(d), recaptureSquare(sq)
{
    // sq = square where opponent just captured
}

// In search, after opponent captures:
if (is_capture(move)) {
    Square capSq = to_sq(move);
    // Search recaptures deeply
    MovePicker mp(pos, ttMove, depth, capSq);
}

Value threshold;

// Quiescence constructor:
MovePicker::MovePicker(const Position& p, Move ttm, Value th)
    : pos(p), ttMove(ttm), threshold(th)

// In next_move():
Move capture = next_capture();
if (pos.see_ge(capture, threshold))
    return capture;  // Good capture
else
    continue;  // Skip bad capture

int stage;

enum Stage {
    MAIN_SEARCH,           // Entry point
    GOOD_CAPTURES,         // Return winning captures
    KILLERS,               // Try killer moves
    GOOD_QUIETS,           // Try quiet moves with good history
    BAD_CAPTURES,          // Return losing captures
    EVASION,               // In check (special)
    PROBCUT,               // High SEE captures only
    QSEARCH,               // Quiescence (captures only)
    // ... more
};

  // Our insertion sort, which is guaranteed to be stable, as it should be
  void insertion_sort(ExtMove* begin, ExtMove* end)
  {
    ExtMove tmp, *p, *q;

    for (p = begin + 1; p < end; ++p)
    {
        tmp = *p;
        for (q = p; q != begin && *(q-1) < tmp; --q)
            *q = *(q-1);
        *q = tmp;
    }
  }

Before sort:  [MoveA, MoveB]
After sort :  [MoveA, MoveB]   (not swapped)

[MoveB, MoveA]

  case QUIET_INIT:
      cur = endBadCaptures;
      endMoves = generate<QUIETS>(pos, cur);
      score<QUIETS>();
      if (depth < 3 * ONE_PLY)
      {
          ExtMove* goodQuiet = std::partition(cur, endMoves, [](const ExtMove& m)
                                             { return m.value > VALUE_ZERO; });
          insertion_sort(cur, goodQuiet);
      } else
          insertion_sort(cur, endMoves);
      ++stage;

cur = endBadCaptures;
endMoves = generate<QUIETS>(pos, cur);
score<QUIETS>();

[Killer1, Killer2, Countermove, history moves, trash moves...]

if (depth < 3 * ONE_PLY)
{
    ExtMove* goodQuiet = std::partition(cur, endMoves,
        [](const ExtMove& m){ return m.value > VALUE_ZERO; });

    insertion_sort(cur, goodQuiet);
}

  // pick_best() finds the best move in the range (begin, end) and moves it to
  // the front. It's faster than sorting all the moves in advance when there
  // are few moves, e.g., the possible captures.
  Move pick_best(ExtMove* begin, ExtMove* end)
  {
      std::swap(*begin, *std::max_element(begin, end));
      return *begin;
  }

// In next_move():
while (cur < endMoves) {
    pick_best(cur, endMoves);  // Find best of remaining
    return (cur++)->move;      // Return it, advance pointer
}

// Each call: O(n), O(n-1), O(n-2)...
// Total: O(n²) worst case
// But usually cutoff happens early → much faster!

/// score() assigns a numerical value to each move in a move list. The moves with
/// highest values will be picked first.
template<>
void MovePicker::score<CAPTURES>() {
  // Winning and equal captures in the main search are ordered by MVV, preferring
  // captures near our home rank. Surprisingly, this appears to perform slightly
  // better than SEE-based move ordering: exchanging big pieces before capturing
  // a hanging piece probably helps to reduce the subtree size.
  // In the main search we want to push captures with negative SEE values to the
  // badCaptures[] array, but instead of doing it now we delay until the move
  // has been picked up, saving some SEE calls in case we get a cutoff.
  for (auto& m : *this)
      m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
               - Value(200 * relative_rank(pos.side_to_move(), to_sq(m)));
}

PieceValue[MG][pos.piece_on(to_sq(m))]

- Value(200 * relative_rank(pos.side_to_move(), to_sq(m)))

// relative_rank returns rank from OUR perspective:
// Rank 1 = our home rank (lowest, best)
// Rank 8 = opponent's home rank (highest, penalized)

// For White:
relative_rank(WHITE, a1) = 1  (home rank)
relative_rank(WHITE, a4) = 4  (middle)
relative_rank(WHITE, a8) = 8  (opponent's rank)

// For Black (reversed!):
relative_rank(BLACK, a8) = 1  (home rank)
relative_rank(BLACK, a4) = 5  (middle)
relative_rank(BLACK, a1) = 8  (opponent's rank)

// Done LATER in next_move():
case GOOD_CAPTURES:
    while (cur < endMoves) {
        pick_best(cur, endMoves);
        
        // SEE check happens HERE (when move is actually picked)
        if (!pos.see_ge(*cur, Value(-55 * cur->value / 1024)))
            *endBadCaptures++ = *cur++;  // Move to bad captures
        else
            return (cur++)->move;  // Return good capture
    }

template<>
void MovePicker::score<QUIETS>() {

  const HistoryStats& history = pos.this_thread()->history;
  const FromToStats& fromTo = pos.this_thread()->fromTo;

  const CounterMoveStats* cm = (ss-1)->counterMoves;
  const CounterMoveStats* fm = (ss-2)->counterMoves;
  const CounterMoveStats* f2 = (ss-4)->counterMoves;

  Color c = pos.side_to_move();

  for (auto& m : *this)
      m.value =      history[pos.moved_piece(m)][to_sq(m)]
               + (cm ? (*cm)[pos.moved_piece(m)][to_sq(m)] : VALUE_ZERO)
               + (fm ? (*fm)[pos.moved_piece(m)][to_sq(m)] : VALUE_ZERO)
               + (f2 ? (*f2)[pos.moved_piece(m)][to_sq(m)] : VALUE_ZERO)
               + fromTo.get(c, m);
}

this  → pointer to current MovePicker object
*this → the MovePicker object itself

ExtMove* begin() { return cur; }
ExtMove* end()   { return endMoves; }

for (auto& m : *this)

for (ExtMove* it = this->begin(); it != this->end(); ++it) {
    auto& m = *it;
}

m.value =
    history score
  + countermove score (1 ply ago)
  + countermove score (2 ply ago)
  + countermove score (4 ply ago)
  + from-to heuristic

template<>
void MovePicker::score<EVASIONS>() {
    const HistoryStats& history = pos.this_thread()->history;
    const FromToStats& fromTo = pos.this_thread()->fromTo;
    Color c = pos.side_to_move();
    
    for (auto& m : *this)
        if (pos.capture(m))
            m.value = PieceValue[MG][pos.piece_on(to_sq(m))]
                    - Value(type_of(pos.moved_piece(m))) + HistoryStats::Max;
        else
            m.value = history[pos.moved_piece(m)][to_sq(m)]
                    + fromTo.get(c, m);
}

if (pos.capture(m))
    m.value = PieceValue[MG][pos.piece_on(to_sq(m))]  // Victim value
            - Value(type_of(pos.moved_piece(m)))        // Attacker type penalty
            + HistoryStats::Max;                        // Large bonus!

PieceValue[MG][pos.piece_on(to_sq(m))]
// Capture queen (+900) > capture rook (+500) > capture pawn (+100)

- Value(type_of(pos.moved_piece(m)))

// type_of returns piece type as integer:
PAWN   = 1
KNIGHT = 2
BISHOP = 3
ROOK   = 4
QUEEN  = 5
KING   = 6

// Small penalty for using expensive piece to capture
// Pawn captures preferred over queen captures
// (but victim value dominates)

+ HistoryStats::Max  // = 1 << 28 (very large number!)

// Captures score: 0 to ~900 + HistoryStats::Max
// Non-captures score: history + fromTo (can be negative!)

// Adding HistoryStats::Max ensures:
// ALL captures score higher than ALL non-captures!

// Without bonus:
Capture pawn:   100 (small)
Good quiet:     5000 (from history)
→ Quiet tried before capture! WRONG!

// With bonus:
Capture pawn:   100 + 268M = 268M+ (huge!)
Good quiet:     5000 (small)
→ All captures tried before quiets ✓

else
    m.value = history[pos.moved_piece(m)][to_sq(m)]
            + fromTo.get(c, m);

case MAIN_SEARCH:
    ++stage;
    return ttMove;

case CAPTURES_INIT:
    endBadCaptures = cur = moves;
    endMoves = generate<CAPTURES>(pos, cur);
    score<CAPTURES>();
    ++stage;
    // Fall through to GOOD_CAPTURES

endBadCaptures = moves  // Start of bad captures section
cur = moves             // Current pointer
endMoves = ...          // End of captures

// Memory layout:
[moves ... endBadCaptures ... endMoves)

case GOOD_CAPTURES:
    while (cur < endMoves) {
        move = pick_best(cur++, endMoves);
        if (move != ttMove) {
            if (pos.see_ge(move, VALUE_ZERO))
                return move;  // Good capture!
            
            // Losing capture, save for later
            *endBadCaptures++ = move;
        }
    }
    // Falls through to killers

case KILLERS:  // This actually handles first killer
    ++stage;
    move = ss->killers[0];
    if (   move != MOVE_NONE
        && move != ttMove
        && pos.pseudo_legal(move)
        && !pos.capture(move))
        return move;
    // Falls through to second killer

// Second killer (no case label, falls through from above)
++stage;
move = ss->killers[1];
if (   move != MOVE_NONE
    && move != ttMove
    && pos.pseudo_legal(move)
    && !pos.capture(move))
    return move;
// Falls through to countermove

case COUNTERMOVE:
    ++stage;
    move = countermove;
    if (   move != MOVE_NONE
        && move != ttMove
        && move != ss->killers[0]
        && move != ss->killers[1]
        && pos.pseudo_legal(move)
        && !pos.capture(move))
        return move;
    // Falls through to quiet init

case QUIET_INIT:
    cur = endBadCaptures;  // Start after bad captures
    endMoves = generate<QUIETS>(pos, cur);
    score<QUIETS>();  // 5-component scoring
    
    if (depth < 3 * ONE_PLY) {
        // Shallow: only sort good quiets
        ExtMove* goodQuiet = std::partition(cur, endMoves, 
            [](const ExtMove& m) { return m.value > VALUE_ZERO; });
        insertion_sort(cur, goodQuiet);
    } else {
        // Deep: sort all quiets
        insertion_sort(cur, endMoves);
    }
    ++stage;
    // Falls through to QUIET

case QUIET:
    while (cur < endMoves) {
        move = *cur++;
        if (  move != ttMove
           && move != ss->killers[0]
           && move != ss->killers[1]
           && move != countermove)
            return move;
    }
    ++stage;
    cur = moves;  // Reset to start
    // Falls through to BAD_CAPTURES

case BAD_CAPTURES:
    if (cur < endBadCaptures)
        return *cur++;
    break;  // END of main search path

case EVASION:
    ++stage;
    return ttMove;

case EVASIONS_INIT:
    cur = moves;
    endMoves = generate<EVASIONS>(pos, cur);
    score<EVASIONS>();  // MVV-LVA + Max or history
    ++stage;
    // Falls through to ALL_EVASIONS

case ALL_EVASIONS:
    while (cur < endMoves) {
        move = pick_best(cur++, endMoves);
        if (move != ttMove)
            return move;
    }
    break;  // END of evasion path

case PROBCUT:
    ++stage;
    return ttMove;

case PROBCUT_INIT:
    cur = moves;
    endMoves = generate<CAPTURES>(pos, cur);
    score<CAPTURES>();
    ++stage;
    // Falls through to PROBCUT_CAPTURES

case PROBCUT_CAPTURES:
    while (cur < endMoves) {
        move = pick_best(cur++, endMoves);
        if (  move != ttMove
           && pos.see_ge(move, threshold + 1))
            return move;
    }
    break;  // END of probcut path

case QSEARCH_WITH_CHECKS:
case QSEARCH_NO_CHECKS:
    ++stage;
    return ttMove;

case QCAPTURES_1_INIT:
case QCAPTURES_2_INIT:
    cur = moves;
    endMoves = generate<CAPTURES>(pos, cur);
    score<CAPTURES>();
    ++stage;
    // Falls through

case QCAPTURES_1:
case QCAPTURES_2:
    while (cur < endMoves) {
        move = pick_best(cur++, endMoves);
        if (move != ttMove)
            return move;
    }
    
    if (stage == QCAPTURES_2)
        break;  // QSEARCH_NO_CHECKS ends here
    
    // QSEARCH_WITH_CHECKS continues:
    cur = moves;
    endMoves = generate<QUIET_CHECKS>(pos, cur);
    ++stage;
    // Falls through to QCHECKS

case QCHECKS:
    while (cur < endMoves) {
        move = cur++->move;  // No pick_best (already sorted)
        if (move != ttMove)
            return move;
    }
    break;  // END of qsearch with checks

case QSEARCH_RECAPTURES:
    cur = moves;
    endMoves = generate<CAPTURES>(pos, cur);
    score<CAPTURES>();
    ++stage;
    // Falls through to QRECAPTURES

case QRECAPTURES:
    while (cur < endMoves) {
        move = pick_best(cur++, endMoves);
        if (to_sq(move) == recaptureSquare)
            return move;
    }
    break;  // END of recaptures only