path: root/src/searchsup.c

/**

Copyright (c) Scott Gasch

Module Name:

    searchsup.c

Abstract:

    Search support routines.  See also search.c, root.c, and split.c.

Author:

    Scott Gasch ([email protected]) 06 Oct 2005

Revision History:

**/

#include "chess.h"

extern SCORE g_iRootScore[2];
extern ULONG g_uHardExtendLimit;
extern ULONG g_uIterateDepth;

void
UpdatePV(SEARCHER_THREAD_CONTEXT *ctx, MOVE mv)
/**

Routine description:

    Update the principle variation at this depth.

Parameters:

    SEARCHER_THREAD_CONTEXT *ctx,
    MOVE mv

Return value:

    void

**/
{
    PLY_INFO *this = &(ctx->sPlyInfo[ctx->uPly]);
    PLY_INFO *next = (this + 1);
    ULONG u = ctx->uPly;

    ASSERT(u < MAX_PLY_PER_SEARCH);
    this->PV[u] = mv;
    u++;

    // HASHMOVE/RECOGNMOVE/DRAWMOVE/MATEMOVE/EGTBMOVE are sentinels, not real
    // moves -- WalkPV (util.c) treats any of them as a hard PV
    // truncation point and asserts the slot right after one is
    // always a zero terminator. Copying the child ply's PV tail
    // forward below would instead leave whatever move happens to
    // already be sitting in that reused sPlyInfo slot (sPlyInfo[] is
    // shared across every node that ever occupies this ply, never
    // zeroed between unrelated nodes) -- if some earlier, unrelated
    // node at this same ply also once wrote the same sentinel there
    // and nothing since overwrote it, that stale leftover reproduces
    // the sentinel value a second time in a row and trips the assert
    // (util.c:1093, found via debug_smoke_test.sh under MP). Hard-
    // terminate immediately instead of inheriting the child's tail.
    if ((mv.uMove == HASHMOVE.uMove) ||
        (mv.uMove == RECOGNMOVE.uMove) ||
        (mv.uMove == DRAWMOVE.uMove) ||
        (mv.uMove == MATEMOVE.uMove) ||
        (mv.uMove == EGTBMOVE.uMove))
    {
        if (u < MAX_PLY_PER_SEARCH)
        {
            this->PV[u].uMove = 0;
        }
        return;
    }

    while(u < MAX_PLY_PER_SEARCH)
    {
        this->PV[u] = next->PV[u];
        if (0 == this->PV[u].uMove)
        {
            break;
        }
        u++;
    }
}


FLAG
CheckInputAndTimers(IN SEARCHER_THREAD_CONTEXT *ctx)
/**

Routine description:

    This code is called from search when the total number of nodes
    searched is a multiple of g_MoveTimer.uNodeCheckMask.  Its job is
    to check for user input waiting on the input queue and to check to
    see if we are over a time limit.

Parameters:

    void

Return value:

    static FLAG : TRUE if the search should terminate and unroll,
                  FALSE if the search can continue

**/
{
    double dTimeStamp;

    //
    // See if there's user input to process.
    //
    if ((ctx->uThreadNumber == 0) && (NumberOfPendingInputEvents() != 0))
    {
        ParseUserInput(TRUE);

        //
        // If the user input can be handled in the middle of the
        // search then it will have been.  If it cannot be handled
        // without stopping the search then ParseUserInput will flip
        // this bit in the MoveTimer to tell us (any any other
        // searcher threads) to stop and unroll.
        //
        if (WE_SHOULD_STOP_SEARCHING)
        {
            return(TRUE);
        }
    }

    //
    // Also check time limits now.
    //
    if (-1 != g_MoveTimer.dSoftTimeLimit)
    {
        dTimeStamp = SystemTimeStamp();
        if ((g_MoveTimer.bvFlags & TIMER_CURRENT_OBVIOUS) ||
            (g_MoveTimer.bvFlags & TIMER_CURRENT_WONT_UNBLOCK))
        {
            Trace("OBVIOUS MOVE / WON'T UNBLOCK --> stop searching now\n");
            g_MoveTimer.bvFlags |= TIMER_STOPPING;
            return(TRUE);
        }

        if (dTimeStamp > g_MoveTimer.dSoftTimeLimit)
        {
            //
            // If we have exceeded the soft time limit, move now unless...
            //
            if ((!(g_MoveTimer.bvFlags & TIMER_JUST_OUT_OF_BOOK)) &&
                (!(g_MoveTimer.bvFlags & TIMER_ROOT_POSITION_CRITICAL)) &&
                (!(g_MoveTimer.bvFlags & TIMER_RESOLVING_ROOT_FL)) &&
                (!(g_MoveTimer.bvFlags & TIMER_RESOLVING_ROOT_FH)) &&
                (!(g_MoveTimer.bvFlags & TIMER_MANY_ROOT_FLS)) &&
                (g_MoveTimer.bvFlags & TIMER_SEARCHING_FIRST_MOVE))
            {
                Trace("SOFT TIMER (%3.1f sec) --> "
                      "stop searching now\n",
                      dTimeStamp - g_MoveTimer.dStartTime);
                g_MoveTimer.bvFlags |= TIMER_STOPPING;
                return(TRUE);
            }
        }

        //
        // If we have exceeded the hard limit, we have to move no matter
        // what.
        //
        if (dTimeStamp > g_MoveTimer.dHardTimeLimit)
        {
            Trace("HARD TIMER (%3.1f sec) --> "
                  "stop searching now\n",
                  dTimeStamp - g_MoveTimer.dStartTime);
            g_MoveTimer.bvFlags |= TIMER_STOPPING;
            return(TRUE);
        }
    }

    //
    // Also check raw node count limit here.
    //
    if (g_Options.u64MaxNodeCount != 0ULL &&
        ctx->sCounters.tree.u64TotalNodeCount > g_Options.u64MaxNodeCount)
    {
        Trace("NODE COUNT LIMIT (limit %llu, searched %llu) "
              "--> stop searching now\n", g_Options.u64MaxNodeCount,
              ctx->sCounters.tree.u64TotalNodeCount);
        g_MoveTimer.bvFlags |= TIMER_STOPPING;
        return(TRUE);
    }
    return(FALSE);
}


FLAG
ThreadUnderTerminatingSplit(IN SEARCHER_THREAD_CONTEXT *ctx)
{
    ULONG u;

    //
    // A thread can be nested in more than one split at once (a helper
    // thread can itself call StartParallelSearch while inside
    // HelpSearch for an outer split), so pSplitInfo[] is a stack, not
    // a single slot -- slot 0 is the outermost split this thread is
    // part of, later slots are progressively more nested ones. Any of
    // them terminating means this thread's current work is moot, so
    // all populated slots must be checked, not just the first one
    // found.
    //
    for (u = 0; u < NUM_SPLIT_PTRS_IN_CONTEXT; u++)
    {
        if ((ctx->pSplitInfo[u] != NULL) &&
            (ctx->pSplitInfo[u]->fTerminate == TRUE))
        {
            return(TRUE);
        }
    }
    return(FALSE);
}


// 2026-10-02: moved here from search.c, along with the rest of the
// joint-table-driven graduated-LMR machinery below -- this used to be
// split across two files purely to minimize the original diff against
// HEAD's LMR (GetLMRReduction decided only the baseline -ONE_PLY,
// search.c's move loop did all the bucket/joint-table post-processing
// on top). That split made it easy to reduce FAR less than intended:
// the baseline decision and the "how much more" decision were made
// from two different, inconsistently-strict dynamic signals. Now one
// function makes the whole call.
//
// EstimateHangingMaterialCp/HangCpBucket/GapCpBucket/MoveNumBucket/
// DepthBucket are no longer file-static -- search.c's own joint-table
// COLLECTION instrumentation (the measurement block gated on
// fPruneReduceEligible alone, independent of whether uDepth>TWO_PLY or
// any reduction is actually applied -- this is what's still generating
// the next round of g_uJointFHThousandths data, a live, in-progress
// collection run as of this writing) still needs them, so they're
// declared in chess.h and shared rather than duplicated.
SCORE
EstimateHangingMaterialCp(IN SEARCHER_THREAD_CONTEXT *ctx,
                          IN MOVE mv,
                          IN ULONG uMoveNum,
                          IN BITBOARD bbMinorAttacksSnapshot[2],
                          IN BITBOARD bbRookAttacksSnapshot[2])
/**

Routine description:

    Does this quiet (or losing-capture) move look like it hangs
    material? Used as one axis ("dumb") of the joint fail-high
    prediction table. "Strictly cheaper" only (an equal-value trade is
    routinely fine, not a blunder) and generalized over every piece
    type instead of hand-picking specific attacker/victim pairs.

Return value:

    SCORE : estimated cp loss (>= 0), or 0 if nothing looks hung -- EXCEPT
        for a capture/promotion scored under MOVE_SCORING_IID_RESCORED
        (ctx->sPlyInfo[ctx->uPly - 1].eMoveScoringScheme), where the
        result can be negative. fPruneReduceEligible only ever admits a
        capture/promotion here when generate.c's own SEE sign flagged it
        as a LOSING one, so ordinarily ComputeMoveScore's decoded value
        is guaranteed negative and this just flips its sign into a
        positive loss. But IID rescoring (searchsup.c's
        RescoreMovesViaSearch, unconditionally live -- see chess.h's
        unconditional `#define DO_IID`) overwrites iValue with a real,
        searched eval-axis score for every move at that ply, which can
        legitimately disagree with the cheap SEE-sign classification
        that got mv into this eligible population in the first place --
        a capture that LOOKS like a material-losing trade can still be
        the actual best move in the position (a real tactic SEE can't
        see), in which case the honest searched score is positive, not
        negative, and this function will return a NEGATIVE number here.
        2026-10-04: deliberately trust the searched score over the SEE
        sign in that case rather than clamping it away -- IID's shallow
        search genuinely knows more than a static material exchange
        does, and a caller folding this value directly into a margin
        calculation WANTS "this move turned out to actually be good" to
        look like the opposite of "hung", not like "hung = 0" (this
        historically mattered for EFP's margin check, search.c, now
        removed -- the reasoning is preserved here in case a future
        direct-margin consumer reappears). Callers that need a
        true cp-loss-or-zero reading instead (the "dumb" axis feeding
        the joint FH table) must go through HangCpBucket, which clamps
        exactly this case to bucket 0 rather than asserting it away.

**/
{
    POSITION *pos = &ctx->sPosition; // already reflects the position
                                     // AFTER mv (MakeMove already ran)
    ULONG uOpponent = pos->uToMove;  // side to move now == opponent of
                                     // whoever just moved
    BITBOARD bbTo;
    SCORE iMoveScore;

    ASSERT(ctx->uPly >= 1);

    if (IS_CAPTURE_OR_PROMOTION(mv))
    {
#ifdef DEBUG
        if (mv.pPromoted) {
            ASSERT(pos->rgSquare[mv.cTo].pPiece == mv.pPromoted);
        }
        else
        {
            ASSERT(pos->rgSquare[mv.cTo].pPiece == mv.pMoved);
        }
#endif
        // No ASSERT(iMoveScore < 0) here -- see this function's own
        // return-value comment above. It was true under every
        // generate.c tier-encoded scoring scheme (the only ones in
        // play when this ASSERT was written), but IID rescoring can
        // legitimately make it false.
        iMoveScore = ComputeMoveScore(ctx, mv, uMoveNum);
        return -iMoveScore;
    }
#ifdef DEBUG
    else
    {
        ASSERT(pos->rgSquare[mv.cTo].pPiece == mv.pMoved);
    }
#endif

    // A king can't "hang material" in the sense this function measures
    // -- it's never capturable, so PIECE_VALUE(KING) (== INFINITY_SCORE)
    // has no business feeding into a cp-loss estimate at all.
    if (IS_KING(mv.pMoved))
    {
        return 0;
    }

    // Any non-pawn moved onto a square an enemy pawn attacks --
    // always unconditionally bad, a pawn is the cheapest possible
    // attacker there is.
    if ((!IS_PAWN(mv.pMoved)) &&
        (0 != (g_PawnAttackOriginBB[uOpponent][mv.cTo] & pos->bbPawns[uOpponent])))
    {
        return (SCORE)(PIECE_VALUE(mv.pMoved) - VALUE_PAWN);
    }

    // Enemy KING adjacency, checked fresh (real board state, no
    // scratch-bitboard involved either way). A king can only capture
    // on a square its own side doesn't leave it in check on, so king
    // "attacking" our destination square means nothing by itself --
    // only flag this when OUR side has zero defenders of the square.
    // Pawns excluded, same reasoning as the pawn-attack check above.
    bbTo = COOR_TO_BB(mv.cTo);
    if ((!IS_PAWN(mv.pMoved)) &&
        (0 != (g_KingAttacksBB[mv.cTo] & COOR_TO_BB(KingPosition(pos, uOpponent)))))
    {
        ULONG uMover = FLIP(uOpponent);
        BITBOARD bbOurDefenders =
            _WhoAttacksSquareBB(pos, mv.cTo, uMover, pos->bbOccupied) |
            (g_PawnAttackOriginBB[uMover][mv.cTo] & pos->bbPawns[uMover]);

        if (0 == bbOurDefenders)
        {
            return (SCORE)PIECE_VALUE(mv.pMoved);
        }
        // Defended -- the king alone isn't a threat here. Fall through
        // to the minor/rook checks below.
    }

    // Anything worth more than a minor, moved onto a square an enemy
    // minor attacks. Snapshotted locally by the caller -- NOT read
    // from pos->bbMinorAttacks directly, which gets clobbered by every
    // recursive Eval() call made while searching an earlier sibling
    // move and is never restored by UnmakeMove.
    if ((PIECE_VALUE(mv.pMoved) > VALUE_KNIGHT) &&
        (0 != (bbMinorAttacksSnapshot[uOpponent] & bbTo)))
    {
        return (SCORE)(PIECE_VALUE(mv.pMoved) - VALUE_KNIGHT);
    }

    // Anything worth more than a rook, moved onto a square an enemy
    // rook attacks. Same snapshot reasoning as the minor check above.
    if ((PIECE_VALUE(mv.pMoved) > VALUE_ROOK) &&
        (0 != (bbRookAttacksSnapshot[uOpponent] & bbTo)))
    {
        return (SCORE)(PIECE_VALUE(mv.pMoved) - VALUE_ROOK);
    }

    // 2026-10-10: mv itself looks perfectly clean, but this node already
    // had one of the mover's OWN pieces flagged trapped by
    // _EvalTrappedPieces at node entry (ctx->cTrapped[uPly], uPly being
    // the PARENT ply here -- MakeMove already advanced ctx->uPly to the
    // child, so the parent's own slot is uPly-1; see RecordTrappedPiece's
    // ASSERT that the recorded piece's color always equals the mover's,
    // never the opponent's). Half credit, not full: mv doesn't move that
    // piece, so it isn't the thing hanging it, but it's also not doing
    // anything about it either, and a position with a trapped piece
    // sitting there is a real, if lesser, source of risk than this
    // move's own clean bill of health suggests. Only reached for a quiet
    // move (every capture/promotion already returned above) and only
    // overrides the "nothing hung" verdict -- never stacks with an
    // already-nonzero estimate from this same move.
    COOR cOwnTrapped = ctx->cTrapped[ctx->uPly - 1];
    if (IS_ON_BOARD(cOwnTrapped) && (mv.cFrom != cOwnTrapped))
    {
        PIECE pTrapped = ctx->pTrapped[ctx->uPly - 1];
#ifdef DEBUG
        ASSERT(GET_COLOR(pTrapped) == FLIP(uOpponent));
#endif
        return (SCORE)(PIECE_VALUE(pTrapped) / 2);
    }
    return 0;
}

// See chess.h's HANG_CP_BUCKETS comment for the bucket shape.
//
// 2026-10-04: was ASSERT(iHangCp >= 0), on the belief that
// EstimateHangingMaterialCp (its only real producer) could never
// return a negative value. That ASSERT is wrong, not just stale -- see
// EstimateHangingMaterialCp's own return-value comment: IID rescoring
// can legitimately make it negative (a capture SEE-sign flagged as
// losing, but which a real shallow search found is actually the best
// move in the position). A negative input just means "even more
// definitely not hung" than 0 already does, so it belongs in the same
// bucket 0 -- clamp rather than assert.
ULONG
HangCpBucket(SCORE iHangCp)
{
    ULONG u;

    if (iHangCp <= 0)
    {
        return 0;
    }
    u = 1 + (((ULONG)iHangCp - 1) / HANG_CP_BUCKET_WIDTH);
    return MINU(u, HANG_CP_BUCKETS - 1);
}

// See chess.h's GAP_CP_BUCKETS comment for the bucket shape. Unlike
// HangCpBucket, the input can legitimately be negative or zero (this
// node's own eval already meets or beats alpha) -- that whole
// non-positive range collapses into bucket 0, same as HANG's "not
// dumb".
ULONG
GapCpBucket(SCORE iGapCp)
{
    ULONG u;

    if (iGapCp <= 0)
    {
        return 0;
    }
    u = 1 + (((ULONG)iGapCp - 1) / GAP_CP_BUCKET_WIDTH);
    return MINU(u, GAP_CP_BUCKETS - 1);
}

// See chess.h's IMPROVE_BUCKETS comment for the bucket shape. Unlike
// HangCpBucket/GapCpBucket, there is no single "safe/below-threshold"
// catchall here -- iImprovement is genuinely signed and two-sided (a
// node legitimately being worse than two plies ago is an expected,
// common outcome, not a degenerate corner case), so this buckets both
// tails symmetrically around a center "didn't really move" bucket
// instead of collapsing one whole sign onto bucket 0.
ULONG
ImproveBucket(SCORE iImprovement)
{
    // Center bucket (index 5 of 11): "didn't really move" either way.
    if ((iImprovement > -IMPROVE_CP_CENTER_WIDTH) &&
        (iImprovement < IMPROVE_CP_CENTER_WIDTH))
    {
        return 5;
    }
    if (iImprovement > 0)
    {
        // 6..10: getting better, 100cp-wide bins, 10 is the 500cp+
        // overflow.
        ULONG u = 6 + (((ULONG)iImprovement - IMPROVE_CP_CENTER_WIDTH) /
                       IMPROVE_BUCKET_WIDTH);
        return MINU(u, IMPROVE_BUCKETS - 1);
    }
    // 0..4: getting worse, 100cp-wide bins, 0 is the 500cp+ overflow
    // (most negative == smallest index, mirroring 6..10's direction).
    {
        ULONG uMag = (ULONG)(-iImprovement) - IMPROVE_CP_CENTER_WIDTH;
        ULONG u = 4 - (uMag / IMPROVE_BUCKET_WIDTH);

        if (uMag / IMPROVE_BUCKET_WIDTH >= 5)
        {
            return 0;
        }
        return u;
    }
}

// See chess.h's GAP_BETA_BUCKETS comment. Unlike ImproveBucket, this
// is called only where the caller has already gated iEval > iBeta
// (the static-NM/beta-table's own eligibility), so iGapBeta is always
// >= 0 here -- no symmetric/center bucket needed, just plain
// 100cp-wide bins from 0, wide enough (2000cp) to find where FH%
// actually saturates.
ULONG
GapBetaBucket(SCORE iGapBeta)
{
    ULONG u = (ULONG)iGapBeta / GAP_BETA_BUCKET_WIDTH;
    return MINU(u, GAP_BETA_BUCKETS - 1);
}


// See chess.h's MOVE_NUM_BUCKETS comment. uMoveNum is 1-based (the
// caller passes uLegalMoves, right after MakeMove succeeded) -- index
// 0 is never produced.
ULONG
MoveNumBucket(ULONG uMoveNum)
{
    ASSERT(uMoveNum >= 1);
    return MINU(uMoveNum, MOVE_NUM_BUCKETS - 1);
}

// See chess.h's SEARCH_DEPTH_BUCKETS comment. uCandDepth is uDepth /
// ONE_PLY, whole plies, legitimately 0 or above.
ULONG
DepthBucket(ULONG uCandDepth)
{
    return MINU(uCandDepth, SEARCH_DEPTH_BUCKETS - 1);
}

// Maps this project's raw, marginal-resolution bucket indices (exactly
// what DepthBucket/MoveNumBucket produce, and what the 2026-09-28
// collection run counted against) down to the coarser, cache-shaped
// indices g_uJointFHThousandths was actually baked at. dumb and gap
// pass through unchanged (shipped shape kept them at full marginal
// resolution -- see the plan doc's table). Must stay in exact lockstep
// with bake_joint.py's ship_depth()/ship_late() -- these are the same
// mapping, just re-derived in C for the live lookup path. File-private
// -- only the prediction lookup just below needs the shipped shape;
// search.c's own collection instrumentation counts at full raw
// resolution and never calls these.
static ULONG
_ShipDepthBucket(ULONG uRawDepthBucket)
{
    if (uRawDepthBucket <= 9) return uRawDepthBucket;
    if (uRawDepthBucket <= 13) return 10;
    return 11;
}

static ULONG
_ShipLateBucket(ULONG uRawLateBucket)
{
    // Raw indices 0 and 1 are never produced: uMoveNum is 1-based (so 0
    // is out), and the collection/live eligibility gate itself
    // (fPruneReduceEligible, search.c, requires uLegalMoves > 1) means
    // the raw value handed to MoveNumBucket is never less than 2
    // either. Shift the real range (2..) down by two so the shipped
    // array wastes no slot -- confirmed against the 2026-09-30
    // collection run, which showed ship_late bucket 0 permanently empty
    // under the old (-1) shift.
    if ((uRawLateBucket >= 2) && (uRawLateBucket <= 13)) return uRawLateBucket - 2;
    if (uRawLateBucket <= 21) return 12;
    if (uRawLateBucket <= 31) return 13;
    return 14;
}

#define JOINT_TABLE_SENTINEL (0xFFFF)

// Looks up this move's predicted FH% (thousandths of a percent) from
// the baked joint table, given the four RAW bucket indices (as
// HangCpBucket/GapCpBucket/MoveNumBucket/DepthBucket produce them).
// Returns JOINT_TABLE_SENTINEL both for a genuine below-sample-floor
// cell AND for dumb bucket 1 (1-100cp "hung") -- traced to ~97%
// SEE-scored losing captures/underpromotions misfiled into the
// quiet-move axis (2026-09-28 plan doc), not a real "this move looks
// safe" signal. Treating it as "no data" rather than trusting its
// literal (low) value means it can never justify extra reduction, nor
// withhold it -- it just falls back to whatever the other checks say.
USHORT
_JointTablePredictedFHThousandths(IN ULONG uRawDepthBucket,
                                   IN ULONG uRawDumbBucket,
                                   IN ULONG uRawGapBucket,
                                   IN ULONG uRawLateBucket,
                                   IN ULONG uRawImproveBucket)
{
    if (1 == uRawDumbBucket)
    {
        return JOINT_TABLE_SENTINEL;
    }
    return g_uJointFHThousandths[_ShipDepthBucket(uRawDepthBucket)]
                                [uRawDumbBucket]
                                [uRawGapBucket]
                                [_ShipLateBucket(uRawLateBucket)]
                                [uRawImproveBucket];
}

// Looks up this node's predicted FH% (thousandths of a percent, i.e.
// 100000 == 100.0%) from g_uBetaFHThousandths, given the raw depth
// bucket (shipped via _ShipDepthBucket same as the alpha lookup
// above) and the gap/own-improve/enemy-improve buckets. Caller is
// responsible for eligibility (iEval > iBeta, etc.) -- this function
// does no gating of its own and returns JOINT_TABLE_SENTINEL (0xFFFF)
// for any below-floor cell regardless.
//
// g_uBetaFHThousandths itself stores the GAP TO 100% (thousandths of
// a percentage point), not FH% directly -- a USHORT can't hold
// FH%*1000 up to 100000, so the direct encoding would saturate every
// cell above FH%=65.534% into one bucket, right where this table is
// actually read. Storing the complement instead keeps full
// resolution across the near-100% range that matters. This function
// re-inverts back to a true FH%*1000 before returning, so callers get
// ordinary "bigger == more confident" semantics.
ULONG
_BetaTablePredictedFHThousandths(IN ULONG uRawDepthBucket,
                                  IN ULONG uGapBetaBucket,
                                  IN ULONG uOwnImproveBucket,
                                  IN ULONG uEnemyImproveBucket)
{
    USHORT uRawGap = g_uBetaFHThousandths[_ShipDepthBucket(uRawDepthBucket)]
                                         [uGapBetaBucket]
                                         [uOwnImproveBucket]
                                         [uEnemyImproveBucket];
    if (JOINT_TABLE_SENTINEL == uRawGap)
    {
        return JOINT_TABLE_SENTINEL;
    }
    return (ULONG)(100000 - uRawGap);
}

// 2026-10-02: reverted from the DELIBERATE EXTREME EXPERIMENT values
// (9000/8300/1000) back to the original p75/p25/p5-derived calibration
// (72/5/1) -- that experiment was measured while the dynamic gate
// below still had the old fake-100%-decaying-to-10% behavior, itself
// loose and slow to release. Now that the dynamic gate is honest,
// stacking the most aggressive static multiplier on top of it risks
// double-counting the same conservatism twice. Re-measure node
// savings/solve rate with both changes together before drawing any
// conclusion about either one in isolation.
// 2026-10-02: tried loosening to 150/20/5 (cap 4) in the hope that
// Crafty's much larger LMR magnitudes at comparable remaining depth
// (5-10 plies: see lmr_testing discussion) would translate here too.
// Measured sd10 ringers node count instead went UP (23.0M -> 27.7M,
// WORSE than even HEAD's 26.9M) with the tier-1 bucket specifically
// showing a re-search rate (4.13%) HIGHER than tier 0's (2.73%) --
// exactly the "distribution-shift failure" this file's own research-
// rate-calibration comment warns about (low-predicted-FH tiers should
// show a RISING research rate with tier, never an inversion at tier
// 1). Reverted to the original p75/p25/p5-derived 72/5/1/cap-3 --
// MAGNITUDE loosening hits a re-search-tax wall fast; the admission
// widening above (LMR_STATIC_ADMIT_PCT_THOUSANDTHS) is the lever that
// actually worked without this failure mode, because it answers "do
// we reduce at all" (base -1 ply, cheap even when wrong) rather than
// "how much" (large cuts, expensive when wrong).
#define JOINT_EXTRA_TIER1_PCT_THOUSANDTHS (72)   // ~p75 of the live
                                              // tries-weighted
                                              // distribution: +1 ply
#define JOINT_EXTRA_TIER2_PCT_THOUSANDTHS (5)    // ~p25: +2 plies
#define JOINT_EXTRA_TIER3_PCT_THOUSANDTHS (1)    // ~p5: below this (the
                                              // rare, best-predicted
                                              // traffic), +3 plies --
                                              // the max cut
// 2026-10-02: increasing MAGNITUDE again, but narrower than the
// 150/20/5 attempt above -- that one widened TIER1's ADMISSION
// boundary (which moves qualify at all) and broke (tier-1 research
// rate inverted above tier-0's). This time: leave all three admission
// boundaries (72/5/1) untouched, only raise the PAYOUT for tiers 2/3
// -- the stricter, already-proven-safe buckets (their research rate
// was LOWER than tier 0's even before this change, i.e. headroom, not
// a crack). Tier 1 keeps its original +1 payout unchanged since it's
// the bucket closest to the population that just proved fragile.
#define JOINT_EXTRA_MAX_PLIES (5)

// 2026-10-02: ADMISSION is a separate question from MAGNITUDE.
// JOINT_EXTRA_TIER1_PCT_THOUSANDTHS above was previously doing double duty
// as both "is the base -ONE_PLY even allowed" AND "does this move
// additionally earn +1 extra ply" -- a threshold calibrated for the
// latter (the top ~25% of traffic) is far too strict a gate for the
// former. The overnight self-play evidence (old dodgy thresholds,
// effectively a no-op admission gate at this layer) shipped even-or-
// better strength at 0.9-1.0 ply deeper than HEAD -- direct evidence
// that broad admission, not a narrow "only the provably safest moves"
// gate, is the right call here. Set this wide open: the static table
// only vetoes the base reduction when it has a real opinion AND that
// opinion is actively bad (worse than the whole-population baseline
// rate), never merely "not in the top tier."
// 2026-10-02: max-admission (1000, a no-op gate) measured a real,
// consistent sn5M solve-count loss on all three curated suites vs.
// HEAD (ringers -2, confident_quick -2, hard_quick -1) despite being
// deeper/lower-EBF than the 500 setting below -- unlike sd10 (where a
// solve dip from less search is expected and uninteresting), a dip at
// FIXED NODE BUDGET means the extra depth bought by over-wide
// admission isn't paying for itself yet. 500 was flat-to-noise on all
// three at sn5M while still gaining +0.1/+0.4/+0.5 ply over HEAD --
// this is the safer base to build further levers (e.g. LMP) on top of.
// 2026-10-03: LEFT AT 500 across the Wilson-upper-bound re-bake of
// g_uJointFHThousandths (see data.c's header). The re-bake raised
// 19,649 of 21,780 cells, which cut the admitting-CELL count at 500
// from 21,047 to 15,415 -- so it was briefly raised to 1000 to
// compensate. That was wrong: cell counts are not traffic-weighted.
// Measured against the real eligible population (87.8M tries from the
// 2026-10-03 sd10 collection), admit<500 on the NEW table admits
// 92.57% of LMR traffic versus 92.88% measured on the old one, while
// 1000 admits 95.62% -- i.e. 500 is the value that holds LMR behavior
// constant, and the raised cells turn out to be overwhelmingly
// low-traffic ones. Lesson: size any threshold change against
// tries-weighted traffic, never against cell counts.
#define LMR_STATIC_ADMIT_PCT_THOUSANDTHS (500)  // 0.500%
#ifdef DEPTH_ONLY_EXTRA_REDUCTION
// See GNUmakefile's DEPTH_ONLY_EXTRA_REDUCTION comment -- the trigger
// threshold below (6 plies) already guarantees the full R=3 extra plus
// the base -1 ply (4 total cut) leaves at least this much remaining, so
// this floor is smaller than the axis-gated version's -- it's a pure
// safety net here, not doing the real gating work (the depth trigger
// is).
#define JOINT_EXTRA_MIN_REMAINING_DEPTH (TWO_PLY)
#define DEPTH_ONLY_TRIGGER_DEPTH (6 * ONE_PLY)
#else
// 2026-09-29: ONE_PLY -- the most aggressive floor. NEUTRALIZE_NULL_
// BAILOUT (GNUmakefile) showed the earlier FOUR_PLY floor's
// justification (a measured silent-miss rate) was overwhelmingly
// (80-99.8%) a measurement artifact of shadow-verification
// methodology, not genuine reduction danger -- the true false-negative
// rate at FOUR_PLY, once properly measured, was already near zero.
#define JOINT_EXTRA_MIN_REMAINING_DEPTH (ONE_PLY)
#endif

// 2026-10-02: g_iLMRQuietReduction (dynamic.c/InitLMRTable) is a
// Crafty/Ethereal-shaped flat log(depth)*log(moves) table, built at
// startup, that NOTHING has ever read -- a prior session built the
// simple mechanism and then went and built the joint-table/dynamic-FH
// system instead without ever wiring this in. It encodes the FULL
// reduction (not an "extra" on top of a base), in ONE_PLY-scaled
// ticks. Checked against Crafty's actual LMR[depth][order] table at
// the remaining-depth range our own suites exercise (5-10 plies):
// d=5,m=8 gives ~2.1 plies here vs Crafty's 2.3; d=10,m=8 gives ~2.7
// here vs Crafty's 3.0 -- same ballpark, same shape, no per-bucket
// static-table judgment to be selectively wrong about (the failure
// mode that just broke the joint-table magnitude tiers above). Used
// here ONLY for magnitude (how much EXTRA beyond the existing -ONE_PLY
// base) -- admission (whether to reduce at all) stays exactly as
// GetLMRReduction already computes it (static/dynamic agreement,
// killer/countermove vetoes); this only replaces the fragile tier
// payout with Crafty's actual mechanism.
static ULONG
_FlatTableExtraPlies(IN ULONG uRemainingDepth, IN ULONG uMoveNum)
{
    ULONG uDepthIdx = MINU(uRemainingDepth / ONE_PLY, MAX_PLY_PER_SEARCH);
    ULONG uMoveIdx = MINU(uMoveNum, LMR_TABLE_MAX_MOVES);
    SCORE iTotalTicks = g_iLMRQuietReduction[uDepthIdx][uMoveIdx];
    SCORE iExtraTicks = iTotalTicks - ONE_PLY;
    if (iExtraTicks <= 0)
    {
        return 0;
    }
    return (ULONG)(iExtraTicks / ONE_PLY);
}

// data.c:1209's "Overall eligible FH%: 0.400%" -- the tries-weighted
// fail-high rate of the WHOLE fPruneReduceEligible population across
// the 500B-node joint-table collection run. Used two ways: (1) as the
// universal backstop -- a move identity whose own honest observed
// rate already exceeds what an AVERAGE leftover move does is never
// reduction-safe, regardless of context; (2) folded into the same
// decision below, additionally compared against the joint table's own
// bucket-specific prediction for the exact (depth, hang, gap, late)
// situation this move is in right now -- a strictly tighter,
// context-aware version of the same idea.
// 2026-10-03 unit unification: was (4) in per-mille, which is the SAME
// nominal 0.4% this is now expressed as directly. Not quite a no-op
// though, and the difference is worth knowing: the old comparison was
// `floor(fh*1000/attempts) > 4`, which can only become true once
// fh/attempts >= 0.005 -- i.e. truncation made the old gate behave like
// 0.5%, not the 0.400% it documented. 400 here is faithful to the
// documented intent and is a hair stricter than what actually shipped.
// The affected band is fh/attempts in [0.401%, 0.5%), which requires
// >= 200 observations of one move identity to even express and is
// essentially unpopulated per chess.h's u64FHJointHist (the dynamic
// rate is bimodal -- ~71% at exactly 0, with the next real mass not
// starting until ~1%). So: intended behavior preserved, shipped
// behavior changed by an immeasurably small amount.
#define LMR_FH_BASELINE_PCT_THOUSANDTHS (400)  // 0.400%

// 2026-10-02, one-off diagnostic support for chess.h's u64FHJointHist:
// 8 attempts bands (0,1,2,3-4,5-9,10-24,25-99,100+) and 8 rate bands in
// thousandths (0,1,2-4,5-9,10-19,20-49,50-99,100+ -- the last band
// starts exactly at the old HEAD-style 10% ceiling).

FLAG
CanWeReduceOrPruneMove(IN SEARCHER_THREAD_CONTEXT *ctx,
                       IN MOVE mv,
                       IN ULONG x,
                       IN ULONG uLegalMoves,
                       IN SCORE iExtend,
                       IN SCORE iAlpha,
                       IN FLAG fThreat,
                       IN FLAG fIsLeftoverMove)
/**

Routine description:

    2026-10-04: hoisted out of Search()'s move loop (search.c), where
    this had grown into an inline block setting fPruneReduceEligible
    plus two more exemption checks (killer-adjacency, countermove
    match) immediately below it -- EFP (since removed), LMP and LMR all
    gated on the combined result. Pulled into one function so the "is this move
    even a candidate for pruning/reduction" question has a single,
    named answer instead of three co-located but separately-maintained
    checks.

    Base eligibility (see search.c's original comment, preserved in
    spirit): a move is a candidate only if (1) it isn't the first move
    tried at this node (uLegalMoves > 1 -- there must be something to
    compare it against), (2) this isn't a PV node (a PV node must
    resolve every move exactly, not approximately), (3) it's already
    in the leftover/late tier (fIsLeftoverMove), (4) it wasn't
    independently extended (iExtend <= 0), (5) it isn't escaping check
    or (6) giving check, (7) there's no node-wide threat in play
    (fThreat), (8) alpha isn't already mate-magnitude, and (9) it's
    either a non-capture/non-promotion or a losing one (SEE-negative;
    a non-losing capture/promotion is excluded outright, matching the
    population the joint fail-high table was actually trained on --
    see lmr_testing/SPEC.md's "gate-1" section).

    On top of that, two move-identity-specific exemptions withdraw
    eligibility even if the base checks above all pass: a killer at
    this ply or two plies back (killers already proved themselves
    elsewhere in the tree and the table can change between visits, so
    this is re-checked every call, not cached), and a bare countermove
    match against the move played two plies ago (ctx->sPlyInfo[uPly-2]
    -- mv has already been made by the time this runs, so the "move
    immediately before mv" is two plies back from here, not one).

    FOUND WHILE HOISTING, FIXED HERE: the countermove check in
    search.c's inline version was `return FALSE;` -- inside Search(),
    which returns SCORE, not FLAG. That silently returned a score of
    0 for the entire node (abandoning the rest of the move loop, and
    doing so without the matching UnmakeMove) the instant the current
    move matched a countermove-table entry, rather than merely
    excluding that one move from pruning/reduction eligibility the way
    the killer check two lines above it does. Expressed here as an
    ordinary `return FALSE;` from this FLAG-returning helper, which is
    the behavior that was actually intended.

Parameters:

    ctx           : current searcher thread context. Reads uPly,
                    sPlyInfo (for eNodeType and the countermove key),
                    mvKiller, mvCounter, and the already-made move's
                    cached flags out of sMoveStack.
    mv            : the move just made (MakeMove has already returned
                    TRUE for it by the time this is called).
    x             : this move's 1-based index into ctx->sMoveStack,
                    i.e. the move loop's own loop variable -- used to
                    read sMoveStack.mvf[x - 1].bvFlags for the cached
                    MVF_SEE_NONNEGATIVE bit. x == 0 never reaches here
                    in practice (TRY_HASH_MOVE's single iteration is
                    always the first move, so uLegalMoves > 1 already
                    rules it out).
    uLegalMoves   : legal moves found at this node so far, including mv.
    iExtend       : this move's own per-move extension amount.
    iAlpha        : this node's current alpha.
    fThreat       : whether a node-wide threat extension is in play.
    fIsLeftoverMove : whether mv already sorted into the leftover/late
                    move-ordering tier.

Return value:

    FLAG : TRUE iff mv is eligible to be considered for pruning or
    reduction (LMP/LMR still each apply their own further checks
    on top of this).

**/
{
    PLY_INFO *pi = &ctx->sPlyInfo[ctx->uPly];
    FLAG fPruneReduceEligible =
        (NODE_PV != pi->eNodeType) &&
        (uLegalMoves > 1) &&
        (TRUE == fIsLeftoverMove) &&
        (iExtend <= 0) &&
        (!IS_ESCAPING_CHECK(mv)) &&
        (!IS_CHECKING_MOVE(mv)) &&
        (!fThreat) &&
        (iAlpha < +NMATE) &&
        ((!IS_CAPTURE_OR_PROMOTION(mv)) ||
         (!(ctx->sMoveStack.mvf[x - 1].bvFlags & MVF_SEE_NONNEGATIVE)));
    if (FALSE == fPruneReduceEligible)
    {
        return FALSE;
    }

    ULONG uPly = ctx->uPly;
    if (uPly >= 2)
    {
        // We have to check this every time too because the killers can
        // change any time we search recursively.
        if (IS_SAME_MOVE(mv, ctx->mvKiller[uPly - 1][0]) ||
            IS_SAME_MOVE(mv, ctx->mvKiller[uPly - 1][1]))
        {
            return FALSE;
        }

        MOVE mvPrev = ctx->sPlyInfo[uPly - 2].mv;
        if (0 != mvPrev.uMove)
        {
            ULONG uCounterIdx = MOVE_TO_INDEX(mvPrev);
            if (IS_SAME_MOVE(mv, ctx->mvCounter[uCounterIdx][0]) ||
                IS_SAME_MOVE(mv, ctx->mvCounter[uCounterIdx][1]))
            {
                return FALSE;
            }
        }

        if (uPly >= 3)
        {
            if (IS_SAME_MOVE(mv, ctx->mvKiller[uPly - 3][0]) ||
                IS_SAME_MOVE(mv, ctx->mvKiller[uPly - 3][1]))
            {
                return FALSE;
            }
        }
    }
    return TRUE;
}

INT FORCEINLINE
GetLMRReduction(IN SEARCHER_THREAD_CONTEXT *ctx,
                IN ULONG uRemainingDepth,
                IN ULONG uLegalMoves,
                IN MOVE mv,
                IN INT iExtend,
                IN ULONG uAttempts,
                IN ULONG uFHPctThousandths,
                IN ULONG uPredictedFH,
                OUT ULONG *puExtraTier)
/**

Routine description:

    Decide how much (if any) to reduce the depth of the search below
    this move.  Note: the move has already been made by the time we
    get here.

Parameters:
    ctx           : current searcher thread context.
    uRemainingDepth : remaining depth below this move.
    uLegalMoves   : legal moves tried at this node so far.
    mv            : the move just made.
    iExtend       : this move's own per-move extension amount so far
                    (ASSERTed to be 0 when a reduction is applied).
    uAttempts     : this move identity's dynamic sample count.
    uFHPctThousandths : this move identity's dynamic fail-high rate.
    uPredictedFH  : the joint table's static prediction for this
                    move's (depth, hang, gap, late) situation, or
                    JOINT_TABLE_SENTINEL if no data.
    OUT ULONG *puExtraTier : optional (may be NULL, e.g. split.c, which
        has no use for the joint-extra-tier re-search/calibration
        instrumentation keyed on this). Receives the extra-ply tier
        (0-3) actually applied, 0 whenever this function returns 0 OR
        returns only the baseline -ONE_PLY.

Return value:

    INT : 0 if no reduction, else a negative multiple of ONE_PLY (the
        FULL combined baseline+extra reduction).

**/
{
    ASSERT(ctx->uPly > 0);
    ASSERT(mv.uMove);
    ASSERT(!InCheck(&ctx->sPosition, ctx->sPosition.uToMove));

    ULONG uExtraPlies = 0;
#ifdef DISABLE_LMR
    // See GNUmakefile's DISABLE_LMR comment. Bail before any signal is
    // consulted so the no-LMR arm is a clean control: no reduction, and
    // also none of the table/history lookups that feed it.
    return(0);
#endif

    INT iLocalExtend;
    FLAG fBaseEligible;
    FLAG fDynamicDanger = (uAttempts > 0) &&
        (uFHPctThousandths > LMR_FH_BASELINE_PCT_THOUSANDTHS);

    if (JOINT_TABLE_SENTINEL == uPredictedFH)
    {
        // No static data for this exact bucket, fall back on dynamic.
        fBaseEligible = (FALSE == fDynamicDanger);
    }
    else
    {
        // Static table has an opinion: admission is now a wide-
        // open, separate threshold from the extra-tier magnitude
        // grading below (LMR_STATIC_ADMIT_PCT_THOUSANDTHS, not
        // JOINT_EXTRA_TIER1_PCT_THOUSANDTHS) -- only veto the base
        // reduction when the static table itself thinks this
        // bucket is actively bad. A dynamic-danger reading does
        // NOT veto this either -- it only caps uExtraPlies to 0
        // below.
        fBaseEligible = (uPredictedFH < LMR_STATIC_ADMIT_PCT_THOUSANDTHS);
    }
    if (FALSE == fBaseEligible)
    {
        if (NULL != puExtraTier)
        {
            *puExtraTier = 0;
        }
        return(0);
    }

    // We are going to reduce it; let's see if we want to pile on extra
    // reduction because we're pretty sure it's "safe".
    uExtraPlies = ((FALSE == fDynamicDanger)) ?
        _FlatTableExtraPlies(uRemainingDepth, uLegalMoves) : 0;

    // Clamp.  Combine with the baseline -ONE_PLY and floor the total
    // so it never leaves less than JOINT_EXTRA_MIN_REMAINING_DEPTH
    // remaining -- never rely on the move loop's own unsigned-
    // wraparound clamp to do this implicitly.
    //
    // iExtend is guaranteed 0 here (see routine description; the sole
    // caller asserts this itself at search.c:1416 right after a
    // reduction comes back), so iLocalExtend is always exactly
    // -ONE_PLY -- no need to fold a variable iExtend into it.
    ASSERT(0 == iExtend);
    iLocalExtend = -ONE_PLY;
    if (uExtraPlies > 0)
    {
        // MAX0 branchlessly floors the numerator at 0 before the
        // divide (it can go negative when uRemainingDepth is small),
        // so uMaxExtra is safely non-negative going into MINU -- both
        // macros need their inputs' high-order bit clear, true here
        // since none of uRemainingDepth/ONE_PLY/JOINT_EXTRA_MAX_PLIES
        // come anywhere near 2^31.
        INT iExtraNumerator =
            (INT)uRemainingDepth - 2 * (INT)ONE_PLY -
            (INT)JOINT_EXTRA_MIN_REMAINING_DEPTH;
        ULONG uMaxExtra = (ULONG)MAX0(iExtraNumerator) / (ULONG)ONE_PLY;
        uExtraPlies = MINU(uExtraPlies, uMaxExtra);
        uExtraPlies = MINU(uExtraPlies, (ULONG)JOINT_EXTRA_MAX_PLIES);
        iLocalExtend -= (INT)(uExtraPlies * ONE_PLY);
    }
    if (NULL != puExtraTier)
    {
        *puExtraTier = uExtraPlies;
    }
    return(iLocalExtend);
}

// 2026-10-13: LMP_BASE_MOVENUM/LMP_PER_PLY_MOVENUM/LMP_MAX_REMAINING_DEPTH
// are NOT wired into ShouldLatePrune below -- there is no move-number
// floor and no depth ceiling in this function today, despite this
// comment block and the docstring below once describing four checks.
// uLegalMoves is still a parameter (kept for signature/call-site
// stability and because MoveNumBucket already folds move number into
// uPredictedFH upstream, in search.c, before this function ever sees
// it) but it is unread here. LMP_MAX_REMAINING_DEPTH never existed as
// code, only as a comment; LMP_BASE_MOVENUM/LMP_PER_PLY_MOVENUM are
// defined and then never referenced -- dead macros, not a disabled
// feature flag. Left defined rather than deleted only because a
// future re-introduction of an explicit floor/ceiling (e.g. if the
// table's move-number axis turns out too coarse near the root once
// EFP is folded into this function -- see the EFP/LMP merge
// discussion) would want exactly these names back. If that doesn't
// happen, delete them.
#define LMP_BASE_MOVENUM                (8)    // currently unused, see above
#define LMP_PER_PLY_MOVENUM             (1)    // currently unused, see above
#define LMP_DYNAMIC_MIN_SAMPLES         (1)    // well-evidenced, not a guess
#define LMP_DYNAMIC_MAX_PCT_THOUSANDTHS (10000)


FLAG
ShouldLatePrune(IN SEARCHER_THREAD_CONTEXT *ctx,
                IN ULONG uRemainingDepth,
                IN ULONG uLegalMoves,
                IN ULONG uFHAttempts,
                IN ULONG uFHPctThousandths,
                IN ULONG uPredictedFH)
/**

Routine description:

    2026-10-04: second gate, applied by the caller (search.c) only
    after CanWeReduceOrPruneStatic has already passed -- so the
    killer-adjacency and countermove-match exemptions that used to be
    duplicated here are gone; the caller never reaches this function
    for a move either of those would have exempted. Takes the FH-table
    lookups (uFHAttempts, uFHPctThousandths, uPredictedFH) as inputs
    rather than recomputing them -- search.c's move loop already looks
    them up once per move for LMP/LMR to share.

    2026-10-13: corrected from an earlier version of this comment that
    claimed four checks including a move-number floor and a depth
    ceiling -- neither exists in the body below (see the dead-macro
    note above). As actually implemented, there are only two checks,
    either of which refuses to prune:
      1. Dynamic signal: real, well-evidenced fail-high history on
         this exact move identity that isn't essentially zero -- the
         ultra-safe tail, not "probably fine."
      2. Static signal: the joint table's own prediction
         (uPredictedFH) for this move's (depth, hang, gap, late,
         improve) situation, checked against a per-remaining-depth
         threshold (uLMPStaticMaxPctThousandths[]) that tightens as
         remaining depth grows -- unlike GetLMRReduction's more
         permissive treatment of missing data for mere reduction,
         overt pruning requires a favorable prediction.
    There is accordingly no explicit guard today against pruning the
    8th move at the root the instant the table happens to look
    favorable, nor any floor stopping this from firing arbitrarily
    deep in the tree -- both are purely emergent from
    uLMPStaticMaxPctThousandths[]'s own shape (very permissive near
    remaining depth 0, essentially 0 by remaining depth 10) rather
    than from any dedicated gate. If that turns out to be too loose in
    practice (e.g. once EFP's margin-based alpha-side pruning is
    folded into this same table-driven path and starts operating at
    the 1-2-ply horizon EFP currently owns), re-introduce an explicit
    floor/ceiling using the macros above rather than reshaping the
    static-threshold array to fake one.

    The uPredictedFH == JOINT_TABLE_SENTINEL check below is currently
    unreachable in practice: g_uJointFHThousandths (data.c) is fully
    backoff-smoothed (shrinkage to a coarser marginal rather than a
    missing-data sentinel) as of the splice-dual bake that added the
    improve axis -- "No 0xffff sentinels remain" per that table's own
    header comment. Kept as a defensive check (cheap, and correct even
    if the table is ever rebaked with real gaps again), not because
    it's expected to fire today.

Parameters:

    ctx                 : current searcher thread context (uPly only,
                          for the sanity ASSERT).
    uRemainingDepth     : remaining depth below this move.
    uLegalMoves         : legal moves tried at this node so far --
                          currently unused by this function (see the
                          dead-macro note above); kept in the
                          signature for call-site stability.
    uFHAttempts         : this move identity's dynamic sample count.
    uFHPctThousandths   : this move identity's dynamic fail-high rate.
    uPredictedFH        : the joint table's static prediction for this
                          move's (depth, hang, gap, late, improve)
                          situation, or JOINT_TABLE_SENTINEL if no data
                          (see note above on why this is effectively
                          dead today).

Return value:

    FLAG : TRUE iff mv should be pruned outright (skipped, not merely
    reduced). Live, not audit-only: search.c's move loop actually
    `continue`s past mv when this returns TRUE (the check that
    consumes fThisMoveLMPPruned), after INCrementing
    u64LMPPruned for the script-summary "late-move pruning (overt
    skip, not reduction)" line under PERF_COUNTERS.

**/
{
    static ULONG uLMPStaticMaxPctThousandths[] = {
        325, 300, 250, 200, 150, 100, 80, 25, 6, 1, 0
    };
    ASSERT(ctx->uPly > 0);
    ASSERT(IS_VALID_DEPTH(uRemainingDepth));
    ULONG uRemainingPlies = uRemainingDepth / ONE_PLY;

    // Dynamic signal: if there's real, well-evidenced history on this
    // exact move identity and it's not essentially zero, don't
    // gamble -- this is the ultra-safe tail only, not "probably fine."
    if ((uFHAttempts >= LMP_DYNAMIC_MIN_SAMPLES) &&
        (uFHPctThousandths > LMP_DYNAMIC_MAX_PCT_THOUSANDTHS))
    {
        return FALSE;
    }

    if ((JOINT_TABLE_SENTINEL == uPredictedFH) ||
        (uPredictedFH > uLMPStaticMaxPctThousandths[MINU(uRemainingPlies, 10)]))
    {
        return FALSE;
    }
    return TRUE;
}


SCORE
DecodeMoveValueEstimate(IN MOVE mv,
                        IN SCORE iRawValue,
                        IN MOVE_SCORING_SCHEME eScheme)
/**

Routine description:

    generate.c has (at least) four distinct conventions for packing
    sMoveStack[].iValue (see MOVE_SCORING_SCHEME's own comment, chess.h),
    plus two more that aren't generate.c tier encodings at all
    (RescoreMovesViaSearch's real eval-axis score, and root.c's node-
    count/score composite). This function is the one place that knows
    how to turn a raw iValue back into an eval-axis (100=1-pawn)
    material estimate, given which scheme produced it -- every caller
    that needs an actual value rather than just a tier/leftover
    classification should go through here rather than inlining its own
    guess at the encoding.

Parameters:

    IN MOVE mv,
    IN SCORE iRawValue,
    IN MOVE_SCORING_SCHEME eScheme

Return value:

    SCORE

**/
{
    switch (eScheme)
    {
        case MOVE_SCORING_IID_RESCORED:
            // Already a real, searched eval-axis score (reflects an
            // entire subtree, not just the immediate exchange) --
            // trust it exactly as-is.
            return(iRawValue);

        case MOVE_SCORING_NORMAL:
        case MOVE_SCORING_QSEARCH_NO_CHECKS:
            // Identical +120 flat move-ordering bias plus small
            // MVV-LVA tie-break nudges for winning/even captures and
            // promotions -- harmless for sorting, but wrong on the
            // eval axis until backed out.
            if ((iRawValue >= SORT_THESE_FIRST) && IS_CAPTURE_OR_PROMOTION(mv))
            {
                ASSERT(iRawValue > 0);
                iRawValue &= STRIP_OFF_FLAGS;
                iRawValue -= MOVE_SCORE_ORDERING_BIAS(mv);
                return(iRawValue);
            }

            // All quiet moves (including killer/killer-mate quiet
            // moves, which can reach SORT_THESE_FIRST or the killer-
            // tier bits via generate.c's ordering bonuses with no
            // relation to a move's real eval-axis value) collapse to
            // 0 here -- correct, since a quiet move's ordering bonus
            // carries no such estimate. A genuinely negative raw value
            // (a losing capture, scored without any tier flag) passes
            // through MIN0 unchanged, preserving its real (negative)
            // material estimate.
            //
            // FUTURE WORK: 0 is uniform across every quiet move, which
            // throws away signal we plausibly have. Two candidate
            // refinements, deliberately not implemented yet (each needs
            // its own isolated A/B, not bundled together):
            //   1. A small flat bonus (tested at +10: net wash, moved
            //      solves from confident_quick to hard_quick rather than
            //      a clear win/loss -- see RESULTS.md) for killer/
            //      killer-mate moves, on the theory that a move which
            //      already caused a cutoff elsewhere in the tree is more
            //      likely to be good than an untested quiet shuffle.
            //   2. eval.c square-delta scoring (e.g. PAWN_CENTRALITY_BONUS/
            //      KNIGHT_CENTRALITY_BONUS[cTo]-[cFrom]) for a directional,
            //      if not strictly accurate, signal on ordinary quiet
            //      moves -- eval.c's real value is far more than per-square
            //      tables (mobility, king safety, pawn structure), so this
            //      would only ever be directionally suggestive, not exact.
            return(MIN0(iRawValue));

        case MOVE_SCORING_QSEARCH_CHECKS:
            // Same +120 convention, plus two QSearch-only ordering
            // nudges baked into the same value by
            // _ScoreQSearchMovesInclChecks: +4 for a checking move,
            // +64 for a same-square recapture. The checking-move term
            // is backed out here; the same-square-recapture term isn't
            // (this function doesn't receive mvLast) -- a known,
            // small (<=64, well under a minor piece) residual
            // imprecision for that specific case, not silently wrong
            // by an unbounded amount the way the pre-fix code was for
            // escapes.
            if ((iRawValue >= SORT_THESE_FIRST) && IS_CAPTURE_OR_PROMOTION(mv))
            {
                ASSERT(iRawValue > 0);
                iRawValue &= STRIP_OFF_FLAGS;
                iRawValue -= MOVE_SCORE_ORDERING_BIAS(mv);
                if (IS_CHECKING_MOVE(mv))
                {
                    iRawValue -= 4;
                }
                return(iRawValue);
            }
            return(MIN0(iRawValue));

        case MOVE_SCORING_ESCAPE:
            // _ScoreAllEscapes' winning-capture encoding uses a
            // DIFFERENT bias than _ScoreAllMoves (no +120) plus an
            // IS_KING(mv.pMoved) right-shift that's lossy -- can't be
            // inverted exactly. Even captures are tagged FIRST_KILLER,
            // not SORT_THESE_FIRST, so they would not even reach a
            // capture-decode branch keyed on that bit. Rather than try
            // to invert either packed encoding, just recompute the
            // cheap raw material estimate directly from the move's own
            // fields -- exactly what _ScoreAllEscapes itself computes
            // as ITS OWN first-pass estimate before ever calling SEE
            // (deliberately not re-invoking SEE here -- same axis,
            // just cheaper and not dependent on reversing a lossy
            // encoding).
            if (IS_CAPTURE_OR_PROMOTION(mv))
            {
                return((SCORE)(PIECE_VALUE(mv.pCaptured) -
                               PIECE_VALUE(mv.pMoved)));
            }
            return(0);

        case MOVE_SCORING_ROOT:
        default:
            // Not a generate.c tier encoding at all -- a node-count/
            // score composite (root.c), only ever populates ply 0's
            // move stack. No current caller asks to decode a root-ply
            // move here; fail loudly rather than silently return a
            // number that looks plausible but isn't.
            ASSERT(FALSE);
            return(0);
    }
}


SCORE
ComputeMoveScore(IN SEARCHER_THREAD_CONTEXT *ctx,
                 IN MOVE mv,
                 IN ULONG uMoveNum)
{
    SCORE iMoveScore = (PIECE_VALUE(mv.pCaptured) +
                        PIECE_VALUE(mv.pPromoted));
    if (uMoveNum != (ULONG)-1)
    {
        ASSERT(uMoveNum < MAX_MOVE_STACK);
        ASSERT(IS_SAME_MOVE(mv, ctx->sMoveStack.mvf[uMoveNum].mv));
        ASSERT(ctx->uPly > 0);

        // Every current caller (EstimateHangingMaterialCp above, and
        // ComputeMoveExtension's own call site below) only
        // reaches here after MakeMove(ctx, mv) has already succeeded, so
        // ctx->uPly is always the *child's* ply here -- uMoveNum indexes
        // the parent's move list, i.e. ctx->uPly - 1, not ctx->uPly. That's
        // the ply whatever scoring pass ran (generate.c's scorers,
        // RescoreMovesViaSearch) actually scored, so that's the ply
        // whose eMoveScoringScheme is authoritative here.
        iMoveScore = DecodeMoveValueEstimate(
            mv,
            ctx->sMoveStack.mvf[uMoveNum].iValue,
            ctx->sPlyInfo[ctx->uPly - 1].eMoveScoringScheme);
    }
    return(iMoveScore);
}


SCORE
GetMoveSee(IN SEARCHER_THREAD_CONTEXT *ctx,
            IN MOVE mv,
            IN ULONG uMoveNum)
/**

Routine description:

    SEE for a checking move or a non-pawn capture, used by
    ComputeMoveExtension's callers (Search, HelpSearch, and eventually
    QSearch) to decide how much to extend/reduce a check, and (as of
    the recapture-extension soundness gate) to judge a recapture too.
    One call site, one SEE per move regardless of how many of
    ComputeMoveExtension's gates end up wanting it -- SEE is one of
    the hottest routines in the tree, so callers compute this at most
    once per move and pass the single result into ComputeMoveExtension
    via iMoveSee, rather than each gate calling it independently. Must
    be computed on the PRE-move position -- see.c's exchange walk needs
    the piece still sitting on cFrom, and by the time
    ComputeMoveExtension runs the move has already been played.

    Move generation/scoring (_ScoreAllMoves, _ScoreAllEscapes in
    generate.c) already runs a real SEE on this same (pos, mv) pair
    whenever it scores an ambiguous capture or promotion, and stashes
    the sign in the move's MVF_SEE_KNOWN/MVF_SEE_NONNEGATIVE flags.
    Reuse that instead of walking the exchange (GetAttacks()) again.
    Only the sign matters to any caller of ComputeMoveExtension, so the
    cached value is coarsened to 0/-1.

    On a cache miss, use SeeFastSign (see.c) instead of a real SEE()
    call -- same reasoning as the cache-hit path above (only the sign
    ever reaches ComputeMoveExtension, both of its own iMoveSee checks
    are plain `< 0`/`>= 0`), but for the miss case there was no cached
    value to fall back to at all, so this always used to pay for a
    full SEE() exchange walk (list-build, heap, x-ray discovery) just
    to throw away everything but the sign. SeeFastSign is
    correctness-tested against real SEE()'s sign across thousands of
    random positions (testsee.c's TestSeeFastSign) and measured at
    0.40x-0.65x SEE()'s own cycles/call, coarsened to the same 0/-1
    convention as the cache-hit path for consistency.

Parameters:

    SEARCHER_THREAD_CONTEXT *ctx : searcher thread context
    MOVE mv : the checking move or capture needing a soundness read
    ULONG uMoveNum : mv's index in ctx->sMoveStack.mvf[], or (ULONG)-1
        if mv did not come from the move stack (e.g. the hash move)

Return value:

    SCORE

**/
{
    BITV bvFlags;

    ASSERT(IS_CHECKING_MOVE(mv) || (mv.pCaptured != NULL));
    if (uMoveNum == (ULONG)-1)
    {
        return(SeeFastSign(&ctx->sPosition, mv) ? 0 : -1);
    }
    ASSERT(uMoveNum < MAX_MOVE_STACK);
    ASSERT(IS_SAME_MOVE(mv, ctx->sMoveStack.mvf[uMoveNum].mv));
    bvFlags = ctx->sMoveStack.mvf[uMoveNum].bvFlags;
    if (bvFlags & MVF_SEE_KNOWN)
    {
        return((bvFlags & MVF_SEE_NONNEGATIVE) ? 0 : -1);
    }
    return(SeeFastSign(&ctx->sPosition, mv) ? 0 : -1);
}


void FORCEINLINE
ComputeMoveExtension(IN SEARCHER_THREAD_CONTEXT *ctx,
                     IN SCORE iAlpha,
                     IN SCORE iBeta,
                     IN ULONG uMoveNum,
                     IN SCORE iRoughEval,
                     IN ULONG uDepth,
                     IN SCORE iMoveSee,
                     IN FLAG fIsLeftoverMove,
                     IN OUT INT *piExtend)
/**

Routine description:

    This routine is called by Search and by HelpSearch (in split.c).
    It's job is to assign a move-based extension for the move mv.
    This extension should be between -ONE_PLY (reduction) and +ONE_PLY
    (extension).

    Note: this code is executed after the move has already been played
    on the board!

Parameters:

    IN SEARCHER_THREAD_CONTEXT *ctx : the searcher thread's context
    IN SCORE iAlpha : current alpha
    IN SCORE iBeta : current beta
    IN ULONG uMoveNum : move number in stack
    IN ULONG uDepth : remaining depth
    IN OUT INT *piExtend : extension amount (in/out)

Return value:

    void

**/
{
    static const SCORE _window[MAX_PLY_PER_SEARCH] = {
         -1,  -1, 500, 500, 425, 425, 350, 350, 275, 275, 200, 200, // 0..11
        150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, // 12..23
        150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, // 24..35
        150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, // 36..47
        150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, // 48..59
        150, 150, 150, 150                                          // 60..63
    };
    POSITION *pos = &ctx->sPosition;
    MOVE mvLast = ctx->sPlyInfo[ctx->uPly-2].mv;
    MOVE mv = ctx->sPlyInfo[ctx->uPly-1].mv;
    ULONG uColor = GET_COLOR(mv.pMoved);
    SCORE iMoveScore;
#ifdef DEBUG
    int iM;

    //
    // Preconditions
    //
    ASSERT(IS_VALID_SCORE(iAlpha));
    ASSERT(IS_VALID_SCORE(iBeta));
    ASSERT(iAlpha < iBeta);
    ASSERT(ctx->uPly >= 2);
    ASSERT(ctx->uPly < MAX_PLY_PER_SEARCH);
    ASSERT(mv.uMove);
    ASSERT(*piExtend >= 0);
#endif

    // Checking move extension.  Crafty-style soundness gate: a check
    // that's really just a losing sacrifice (SEE < 0) still gets a small
    // consolation extension rather than none at all -- SEE can't see
    // multi-move combinations, so a "losing" sacrifice check is sometimes
    // actually a winning sham sacrifice a few moves later, and giving it
    // zero search priority risks missing exactly those.  It just doesn't
    // get to compound the way a materially sound check does.
    if (IS_CHECKING_MOVE(mv))
    {
        ASSERT(InCheck(pos, pos->uToMove));
        INC(ctx->sCounters.extension.uCheck);
        if (iMoveSee < 0)
        {
            *piExtend += QUARTER_PLY;
            INC(ctx->sCounters.extension.uCheckByQuarterPly[QUARTER_PLY / QUARTER_PLY]);
        }
        else
        {
            if (pos->uNonPawnMaterial[FLIP(pos->uToMove)] >
                (VALUE_KING + VALUE_BISHOP))
            {
                *piExtend += ONE_PLY;
                INC(ctx->sCounters.extension.uCheckByQuarterPly[ONE_PLY / QUARTER_PLY]);
            }
            else
            {
                *piExtend += QUARTER_PLY;
                INC(ctx->sCounters.extension.uCheckByQuarterPly[QUARTER_PLY / QUARTER_PLY]);
            }
        }
    }

    // Pawn push extension.  RANK7/RANK2 already mean "one step from
    // promotion", so the pawn is a passer by definition -- no separate
    // passed-pawn test needed.  Two cheap, eval-independent refinements
    // (both read only incrementally-maintained POSITION bitboards, no
    // Eval()/pawn-hash dependency, no sig-check needed):
    //
    //   1. Skip entirely if the promotion square itself is already
    //      occupied (friend or foe) -- a push that can just be captured
    //      or that's blocked from ever queening isn't worth the ply.
    //   2. The size of the bonus depends on whether the pawn's own
    //      king/rook/queen actually defends it on cTo, not just
    //      whether the king happens to be nearby (a king 2 squares
    //      away that can't recapture doesn't help this pawn at all).
    if (IS_PAWN(mv.pMoved) && (RANK7(mv.cTo) || RANK2(mv.cTo)))
    {
        ULONG uPawnColor = GET_COLOR(mv.pMoved);
        COOR cPromo = mv.cTo + ((uPawnColor == WHITE) ? 0x10 : -0x10);

        if (!(pos->bbOccupied & COOR_TO_BB(cPromo)))
        {
            *piExtend += HALF_PLY;
            if (!fIsLeftoverMove ||
                ((g_KingAttacksBB[mv.cTo] &
                  COOR_TO_BB(KingPosition(pos, uPawnColor))) ||
                 (_RookAttacksBB(mv.cTo, pos->bbOccupied) &
                  (pos->bbPieces[uPawnColor][ROOK] |
                   pos->bbPieces[uPawnColor][QUEEN])) ||
                 (_BishopAttacksBB(mv.cTo, pos->bbOccupied) &
                  pos->bbPieces[uPawnColor][QUEEN])))
            {
                *piExtend += QUARTER_PLY;
                INC(ctx->sCounters.extension.uPawnPushByQuarterPly[THREE_QUARTERS_PLY / QUARTER_PLY]);
            }
            else
            {
                INC(ctx->sCounters.extension.uPawnPushByQuarterPly[HALF_PLY / QUARTER_PLY]);
            }
            INC(ctx->sCounters.extension.uPawnPush);
        }
    }

#if 0
    // Responses to check extensions --- moved to search.c @ positional bonus
    if (IS_CHECKING_MOVE(mvLast))
    {
        ASSERT(IS_ESCAPING_CHECK(mv));
        iMoveScore = iRoughEval + ComputeMoveScore(ctx, mv, uMoveNum);

        // This is forced and cheap (1 move at the parent node).
        if (ONE_LEGAL_MOVE(ctx, ctx->uPly - 1) &&
            CountKingSafetyDefects(&ctx->sPosition, uColor) > 2)
        {
            FLAG fBigBonus = (iMoveScore + VALUE_KNIGHT > iAlpha);
            *piExtend += (QUARTER_PLY + HALF_PLY * fBigBonus);
            INC(ctx->sCounters.extension.uOneLegalMoveByQuarterPly[
                    fBigBonus ?
                    (THREE_QUARTERS_PLY / QUARTER_PLY) :
                    (QUARTER_PLY / QUARTER_PLY)]);
        }

        // One "good" way to response to check --- dead code, kill it?
        if (!fIsLeftoverMove &&
            mv.pCaptured &&
            (iRoughEval + 300 < iAlpha) &&
            (iMoveScore + 50 > iAlpha))
        {
            *piExtend += ONE_PLY;
            INC(ctx->sCounters.extension.uSingularReplyToCheck);
        }
    }
#endif

    // These last ones only happen if we are close to the root score.
    ASSERT(_window[ctx->uPly] > 0);
    if ((iRoughEval >= (g_iRootScore[uColor] - _window[ctx->uPly] * 2)) &&
        (iRoughEval <= (g_iRootScore[uColor] + _window[ctx->uPly] * 2)))
    {
        // Recapture extension. Own tighter (1x) window restored --
        // measured on ECM.721 (ringers): sharing the outer 2x window
        // grew this position's recapture-fire count 6.8x vs HEAD
        // (17,569,874 -> 34,337,674 total nodes), far more than the
        // ~2x growth every other extension category saw from stacking
        // alone -- all in refuted alternative lines, not the winning
        // PV (which has zero recaptures on it). The 2x window did
        // recover ECM.735/ECM.443 by making trade-dense *correct*
        // lines eligible, but it's a net loss on positions where the
        // expensive trades are all in the lines being ruled out
        // instead. Back to the tighter window as the better tradeoff.
        if ((iRoughEval >= (g_iRootScore[uColor] - _window[ctx->uPly])) &&
            (iRoughEval <= (g_iRootScore[uColor] + _window[ctx->uPly])) &&
            (uDepth < THREE_PLY))
        {
            if (!fIsLeftoverMove &&
                mv.pCaptured &&
                !IS_PAWN(mv.pCaptured) &&
                (iMoveSee >= 0) &&
                ((PIECE_VALUE(mv.pCaptured) == PIECE_VALUE(mvLast.pCaptured)) ||
                 ((mvLast.pPromoted) && (mv.cTo == mvLast.cTo))))
            {
                *piExtend += HALF_PLY;
                INC(ctx->sCounters.extension.uRecapture);
            }
        }
    }

    // Don't let extensions add up to > 1 ply
#ifdef DEBUG
    iM = MIN(ONE_PLY, *piExtend);
#endif
    ASSERT(!(*piExtend & 0x80000000));
    *piExtend = MINU(ONE_PLY, *piExtend);
    ASSERT(iM == *piExtend);

    // Scale back extensions that are very far from the root. Table
    // built in root.c from g_uIterateDepth (see its own construction
    // there for the exact arithmetic -- this is just a summary, keep
    // the two in sync):
    //
    // ┌─────────────────────────┬───────────┬────────────────────────────────┐
    // │  ply range (× iterate   │ reduction │ net effect                     │
    // │               depth)    │           │                                │
    // ├─────────────────────────┼───────────┼────────────────────────────────┤
    // │ u < 1.5×                │ 0         │ full extension kept            │
    // ├─────────────────────────┼───────────┼────────────────────────────────┤
    // │ 1.5× ≤ u < 1.875×       │ -1/4 ply  │                                │
    // ├─────────────────────────┼───────────┼────────────────────────────────┤
    // │ 1.875× ≤ u < 2.25×      │ -1/2 ply  │                                │
    // ├─────────────────────────┼───────────┼────────────────────────────────┤
    // │ 2.25× ≤ u < 3×          │ -3/4 ply  │ only a +1 ply extension        │
    // │                         │           │ can survive here               │
    // ├─────────────────────────┼───────────┼────────────────────────────────┤
    // │ u ≥ 3× (hard limit)     │ -all ply  │ no extensions beyond here      │
    // └─────────────────────────┴───────────┴────────────────────────────────┘
    //
    // NOTE: check extension in qsearch is handled differently, see search.c.
    //
    ASSERT(ctx->uPly != 0);
    ASSERT(ctx->uPly <= MAX_PLY_PER_SEARCH);
    *piExtend -= g_uExtensionReduction[ctx->uPly-1];
#ifdef DEBUG
    iM = MAX(0, *piExtend);
#endif
    *piExtend = MAX0(*piExtend);
    ASSERT(iM == *piExtend);
    ctx->sPlyInfo[ctx->uPly-1].iExtensionAmount = *piExtend;
    ASSERT((0 <= *piExtend) && (*piExtend <= ONE_PLY));
}




#ifdef DO_IID
SCORE
RescoreMovesViaSearch(IN SEARCHER_THREAD_CONTEXT *ctx,
                      IN ULONG uDepth,
                      IN SCORE iAlpha,
                      IN SCORE iBeta)
/**

Routine description:

    This is my implementation of "internal iterative deepening".  It's
    not really IID because it doesn't recurse on the same position.
    This code is called when we are at a PV node and have no hash move
    and no good capture from the generator.  Instead of relying on
    only history / killer heuristics to order the moves instead we
    reduce the depth by two ply and search all the moves generated.
    The scores that come out of the reduced-depth search are then used
    to order the moves at the regular-depth search.  This is somewhat
    recursive because the first move considered by the reduced-depth
    search may also have no hash move / good capture and invoke the
    whole process again.

Parameters:

    IN SEARCHER_THREAD_CONTEXT *ctx,
    IN ULONG uDepth,
    IN SCORE iAlpha,
    IN SCORE iBeta

Return value:

    SCORE

**/
{
    ULONG x, uBegin, uEnd;
    MOVE mv;
    SCORE iScore;
    SCORE iBestScore = -INFINITY_SCORE;
    ULONG uBest;
    FLAG fFailHigh = FALSE;
    SCORE rgScores[MAX_MOVES_PER_PLY];

    //
    // Preconditions
    //
    ASSERT(IS_VALID_SCORE(iAlpha));
    ASSERT(IS_VALID_SCORE(iBeta));
    ASSERT(iAlpha < iBeta);
    ASSERT(uDepth >= (IID_R_FACTOR + ONE_PLY));

    //
    // Compute next depth.
    //
    // This used to recurse here first (call itself at this same
    // ctx->uPly, before the loop below), on the theory that an even
    // shallower rescore's *side effects* -- hash/killer/history table
    // population -- would help the loop below's own -Search() calls
    // find cutoffs faster. Measured (see lmr_testing/RESULTS.md): removing
    // it entirely produced a bit-identical result on all three test
    // suites (ecm_ringers/confident_quick/hard_quick). Its own writes to
    // iValue were always fully overwritten by this same call's loop
    // right after it (same ctx->uPly, same move-stack range), so it had
    // no way to help other than those side effects, and empirically it
    // wasn't -- just wasted nodes. Removed.
    uDepth -= (IID_R_FACTOR + ONE_PLY);
    ASSERT(uDepth < MAX_DEPTH_PER_SEARCH);

    //
    // Search the moves and remember the scores in a scratch array, NOT
    // directly into mvf[].iValue -- we don't yet know if we'll get an
    // honest score for every move at this ply (a fail-high partway
    // through means we stop early, deliberately, without searching the
    // rest). Committing partial data into iValue and then patching the
    // gaps with a sentinel (this function used to write -INFINITY_SCORE into
    // every unsearched move) makes the whole ply look "rescored" to
    // downstream code when it isn't really -- see the fail-high handling
    // below for why that matters.
    //
    uBegin = ctx->sMoveStack.uBegin[ctx->uPly];
    uEnd = ctx->sMoveStack.uEnd[ctx->uPly];
    ASSERT((uEnd - uBegin) <= MAX_MOVES_PER_PLY);
    for (x = uBest = uBegin; x < uEnd; x++)
    {
        SelectBestNoHistory(ctx, x);
        mv = ctx->sMoveStack.mvf[x].mv;
        mv.bvFlags |= WouldGiveCheck(ctx, mv);
        ctx->sMoveStack.mvf[x].mv = mv;    // <-- update the move's flags, WouldGiveCheck is slow
        if (TRUE == MakeMove(ctx, mv))
        {
            if (-INFINITY_SCORE == iBestScore)
            {
                iScore = -Search(ctx, -iBeta, -iAlpha, uDepth);
            }
            else
            {
                iScore = -Search(ctx, -iAlpha - 1, -iAlpha, uDepth);
                if (iScore > iAlpha)
                {
                    iScore = -Search(ctx, -iBeta, -iAlpha, uDepth);
                }
            }
            UnmakeMove(ctx, mv);
            rgScores[x - uBegin] = iScore;
            if (iScore > iBestScore)
            {
                uBest = x;
                iBestScore = iScore;
                if (iScore >= iBeta)
                {
                    fFailHigh = TRUE;
                    break;
                }
            }
        }
        else
        {
            // Genuinely illegal (pseudo-legal but leaves king in check)
            // -- this isn't "unknown," we know for a fact it's worthless
            // and the caller will skip it too when MakeMove fails again.
            rgScores[x - uBegin] = -INFINITY_SCORE;
        }
    }

    if (FALSE == fFailHigh)
    {
        // We have an honest, fully-searched score for every move at
        // this ply -- commit them all and let downstream code
        // (ComputeMoveScore, the main search loop's move-selection
        // call) trust iValue as a real eval-axis score.
        for (x = uBegin; x < uEnd; x++)
        {
            ctx->sMoveStack.mvf[x].iValue = rgScores[x - uBegin];
        }
        ctx->sPlyInfo[ctx->uPly].eMoveScoringScheme = MOVE_SCORING_IID_RESCORED;
    }
    else
    {
        // We only know one honest thing: uBest is good enough to have
        // failed high at reduced depth. We do NOT have honest scores
        // for the rest (deliberately -- searching them would burn nodes
        // solely to confirm what we've already decided to do, which is
        // play uBest). Rather than inventing eval-axis values for moves
        // we never examined (the old code wrote -INFINITY_SCORE into all of
        // them, including -- until fixed -- overwriting uBest's own
        // just-computed score), leave every move's original generate.c
        // ordering value completely untouched and just bump uBest into
        // killer-tier territory so the normal (non-rescored) selection
        // path -- SelectBestWithHistory/NoHistory -- picks it first, the
        // same trick generate.c uses for a real killer move. Do NOT
        // change eMoveScoringScheme: this ply's iValue is back to being
        // whatever generate.c scheme originally scored it, not real
        // scores, for every move including uBest (whose bump is itself
        // just an ordering flag, not part of its own eval-axis value).
        ctx->sMoveStack.mvf[uBest].iValue |= FIRST_KILLER;
    }

    ASSERT(IS_VALID_SCORE(iBestScore));
    return(iBestScore);
}
#endif


FLAG
MateDistancePruningCutoff(IN ULONG uPly,
                          IN FLAG fInCheck,
                          IN OUT SCORE *piBestScore,
                          IN OUT SCORE *piAlpha,
                          IN OUT SCORE *piBeta)
/**

Routine description:

    This idea (shamelessly?) "borrowed" from Fruit.  The idea is that
    the worst score we can return from any node in the tree is if we
    are in checkmate right now (indeed, if we're not in check right
    now than the worst score we can return is mated-in-2-ply).

    Likewise the best score we can return from here is mate-in-1-ply.
    Use these facts to attempt to narrow the alpha..beta window.
    Indeed there are some cases where we can prune this entire tree
    branch.

Parameters:

    ULONG uPly : ply from root
    FLAG InCheck : are we in check?
    SCORE *piBestScore : pointer to bestscore
    SCORE *piAlpha : pointer to alpha
    SCORE *piBeta : pointer to beta

Return value:

    FLAG : TRUE if we can prune the branch outright, FALSE otherwise

**/
{
    SCORE iScore = MATED_SCORE(uPly + 2 * !fInCheck);

    //
    // Do the alpha side
    //
    if (*piAlpha < iScore)
    {
        *piAlpha = iScore;
        if (iScore >= *piBeta)
        {
            *piBestScore = iScore;
            return(TRUE);
        }
    }

    //
    // Do the beta side
    //
    iScore = -1 * MATED_SCORE(uPly + 1);
    if (iScore < *piBeta)
    {
        *piBeta = iScore;
        if (iScore <= *piAlpha)
        {
            *piBestScore = iScore;
            return(TRUE);
        }
    }
    return(FALSE);
}


void
DumpPlyInfoStack(IN SEARCHER_THREAD_CONTEXT *ctx,
                 IN SCORE iAlpha,
                 IN SCORE iBeta)
/**

Routine description:

    Dump some information about the current search line; mainly here as
    a debugging aide.

    Note: this will not work on an MP searcher thread that is under a
    split node.

Parameters:

    SEARCHER_THREAD_CONTEXT *ctx : searcher context to dump

Return value:

    void

**/
{
    ULONG u, v;
    POSITION *pos = GetRootPosition();
    CUMULATIVE_SEARCH_FLAGS *pf = &ctx->sSearchFlags;
    char *p = PositionToFen(pos);
    PLY_INFO *q;
    FLAG fSeenQ = FALSE;
    SCORE iEval;
    static SEARCHER_THREAD_CONTEXT temp;

    InitializeSearcherContext(pos, &temp);

    Trace("Iterate Depth: %2u\tCurrent Ply: %2u\n", g_uIterateDepth,
          ctx->uPly);
    Trace("Qsearch Check: %2u\tCurrent Qdepth: %2u\n", pf->uQsearchCheckDepth,
          pf->uQsearchDepth);
    Trace("Current a..b: %d .. %d\n", iAlpha, iBeta);
    if (NULL != p)
    {
        Trace("Root: %s\n", p);
        SystemFreeMemory(p);
    }
    Trace("\n");
    Trace("move\t number\t exten\t   eval       b.keval      w.keval   Danger Squares\n"
          "----------------------------------------------------------------------------\n");

    ASSERT(ctx->uPly < MAX_PLY_PER_SEARCH);
    for (u = 0; u < ctx->uPly; u++)
    {
        q = &ctx->sPlyInfo[u];
        ASSERT(PositionsAreEquivalent(&q->sPosition, &temp.sPosition));

        if ((FALSE == fSeenQ) && (q->fInQsearch == TRUE))
        {
            p = PositionToFen(&temp.sPosition);
            if (NULL != p)
            {
                Trace("\nHorizon: %s\n\n", p);
                SystemFreeMemory(p);
            }
            fSeenQ = TRUE;
        }

        Trace("%02u.%-6s ", u, MoveToSan(q->mv, &temp.sPosition));
        for (v = ctx->sMoveStack.uBegin[u];
             v < ctx->sMoveStack.uEnd[u];
             v++)
        {
            if (IS_SAME_MOVE(q->mv, ctx->sMoveStack.mvf[v].mv))
            {
                Trace("%u/%u", v - ctx->sMoveStack.uBegin[u] + 1,
                      MOVE_COUNT(ctx, u));
            }
        }
        Trace("\t");

        if (FALSE == MakeMove(&temp, q->mv))
        {
            Trace("Illegal move?!\n");
            return;
        }

        if (q->iExtensionAmount != 0)
        {
            Trace("%-3u\t", q->iExtensionAmount);
        }
        else
        {
            Trace("   \t");
        }

        iEval = Eval(&temp, -INFINITY_SCORE, +INFINITY_SCORE, NULL);
        Trace("%5s (%+2d) | ", ScoreToString(iEval),
              temp.sPosition.iMaterialBalance[temp.sPosition.uToMove] / 100);
        Trace("%5s (%2u) | ",
              ScoreToString(temp.sPlyInfo[temp.uPly].iKingScore[BLACK]),
              CountKingSafetyDefects(&temp.sPosition, BLACK));
        Trace("%5s (%2u)  ",
              ScoreToString(temp.sPlyInfo[temp.uPly].iKingScore[WHITE]),
              CountKingSafetyDefects(&temp.sPosition, WHITE));
        Trace("\n");
    }

    p = PositionToFen(&ctx->sPosition);
    if (NULL != p)
    {
        Trace("\n");
        Trace("Now: %s\n", p);
        SystemFreeMemory(p);
    }
}


FLAG FORCEINLINE
CommonSearchInit(IN SEARCHER_THREAD_CONTEXT *ctx,
                 IN OUT SCORE *piAlpha,
                 IN OUT SCORE *piBeta,
                 IN OUT SCORE *piScore)
/**

Routine description:

    A set of common code that is called by Search and QSearch.  It does
    the following:

       1. Increment the total node counter
       2. Clears pi->mvBest and cDanger squares
       3. Possibly check for user input or timer expiration
       4. Checks to see if the position is a draw
       5. Makes sure ctx->uPly is not too deep
       6. Sets pi->fInCheck
       7. Does mate-distance pruning

Parameters:

    IN SEARCHER_THREAD_CONTEXT *ctx,
    IN OUT SCORE *piAlpha,
    IN OUT SCORE *piBeta,
    IN OUT SCORE *piScore

Return value:

    FLAG : TRUE if the search node should be aborted (return *piScore)
           FALSE otherwise (*piAlpha, *piBeta possibly adjusted)

**/
{
    PLY_INFO *pi = &ctx->sPlyInfo[ctx->uPly];
    FLAG fRet = TRUE;

    ASSERT(*piAlpha < *piBeta);

    //
    // Increment node count and see if we need to check input / timer
    //
    ctx->sCounters.tree.u64TotalNodeCount++;
    ASSERT(ctx->sCounters.tree.u64TotalNodeCount > 0);
    if ((ctx->sCounters.tree.u64TotalNodeCount &
         g_MoveTimer.uNodeCheckMask) == 0)
    {
        (void)CheckInputAndTimers(ctx);
    }

    //
    // Make sure that the time allotted to search in has not expired
    // and (if this is an MP search) that we are still doing relevant work.
    //
    if (WE_SHOULD_STOP_SEARCHING)
    {
        // 2026-09-18: same staleness hazard as the IsDraw/too-deep
        // paths below -- clear this ply's own PV[] slot too, not just
        // mvBest. See the IsDraw branch's comment for the full
        // mechanism (an ancestor's UpdatePV blindly copies this row
        // forward assuming it's fresh).
        pi->mvBest.uMove = 0;
        pi->PV[ctx->uPly].uMove = 0;
        *piScore = INVALID_SCORE;
        goto end;
    }

    //
    // Set fInCheck in this ply info struct
    //
    pi->fInCheck = (IS_CHECKING_MOVE((pi-1)->mv) != 0);
    ASSERT((pi->fInCheck &&
            (InCheck(&ctx->sPosition, ctx->sPosition.uToMove))) ||
           (!pi->fInCheck &&
            (!InCheck(&ctx->sPosition, ctx->sPosition.uToMove))));

    //
    // See if this position is a draw -- checked before the too-deep
    // bailout below on purpose: a position can be simultaneously
    // "too deep" (hit the ply/qsearch-extend-limit ceiling) and
    // genuinely drawn (repetition/50-move), and a draw is a known,
    // exact fact about the position, not an estimate -- it would be
    // strictly worse to throw that away for an alpha/Eval()
    // approximation just because we also happened to run out of
    // search room at the same node.
    //
    if (TRUE == IsDraw(ctx))
    {
        // Every early exit from this function must clear pi->mvBest
        // itself, since the real reset further down is never reached
        // from here. Found via a DEBUG-build assertion failure:
        // TryNullmovePruning reading (pi+1)->mvBest as if it reflected
        // the null-move probe's own search, when it was actually stale
        // data left by a completely unrelated earlier node that once
        // occupied the same ply slot and bailed out via this exact path
        // without ever being cleared.
        pi->mvBest.uMove = 0;
        INC(ctx->sCounters.tree.u64LeafCount);
        *piScore = g_iDrawScore[ctx->sPosition.uToMove];
        // 2026-09-18: pi->PV[ctx->uPly] has the exact same staleness
        // hazard as pi->mvBest above, but was only ever cleared
        // conditionally, via UpdatePV(ctx, DRAWMOVE) -- and only when
        // the draw score actually falls in the open (alpha, beta)
        // window. When it doesn't, this ply's PV[] row is left
        // whatever an unrelated earlier node last wrote there.
        // sPlyInfo[] rows are shared/reused across every node that
        // ever occupies a given ply (see UpdatePV's own sentinel-case
        // comment), so a later ancestor's UpdatePV can blindly copy
        // that stale row forward via `this->PV[u] = next->PV[u]`,
        // trusting its zero-terminator as proof of freshness --
        // splicing a leftover move from a completely different
        // subtree onto the real line. This is the root cause of a
        // WalkPV/MakeMove assertion failure (move.c:881,
        // "ASSERT(!IS_EMPTY(pCaptured))" -- a move that's real
        // *somewhere* but whose capture target is empty on the
        // actual board) reproduced against tests/cross_sectional_
        // 200k.ep_. Clear unconditionally so a non-window draw score
        // can't leave this row stale.
        if ((*piAlpha < *piScore) && (*piScore < *piBeta))
        {
            UpdatePV(ctx, DRAWMOVE);
        }
        else
        {
            pi->PV[ctx->uPly].uMove = 0;
        }
        DTTRACE("<i bold=\"draw\"/>");
        goto end;
    }

    //
    // Make sure we have not exceeded max ply; note that since this
    // is checked at the beginning of search/qsearch and if we let
    // the past they will call MakeMove this must cut off one ply
    // before the hard limit.
    //
    if ((ctx->uPly >= (MAX_PLY_PER_SEARCH - 1)) ||
        (ctx->sSearchFlags.uQsearchDepth >= g_uHardExtendLimit))
    {
#ifdef PERF_COUNTERS
        if (ctx->uPly >= (MAX_PLY_PER_SEARCH - 1))
        {
            INC(ctx->sCounters.tree.u64TooDeepPlyLimit);
        }
        else
        {
            INC(ctx->sCounters.tree.u64TooDeepQsearchExtendLimit);
        }
#endif

        // Was an unconditional *piScore = *piBeta -- an unearned
        // fail-high claim ("this line is at least beta") with zero
        // evidence behind it, right at the moment we're giving up
        // because we ran out of room to actually determine anything.
        // A fail-low (return alpha) is the honest "couldn't prove
        // this helps" posture every other give-up path in this engine
        // uses. When NOT in check we can do better than a bare
        // fail-low, though: fall back to a real Eval() call, the same
        // convention normal QSearch's own stand-pat uses at its
        // horizon. NOT when in check -- IS_CHECKING_MOVE((pi-1)->mv)
        // is the same cheap (no board scan) check pi->fInCheck itself
        // uses a few lines below -- Eval() on an in-check position is
        // exactly the thing QSearchFromCheckNoStandPat's entire
        // design exists to avoid trusting (see its header comment):
        // static material/positional terms can't tell "checked with a
        // totally safe escape" from "checked and actually in danger."
        if (pi->fInCheck)
        {
            *piScore = *piAlpha;
            pi->iEval = INVALID_SCORE;
        }
        else
        {
            *piScore = Eval(ctx, *piAlpha, *piBeta, NULL);
            pi->iEval = *piScore;
        }
        // See the IsDraw branch above -- same staleness hazard, same
        // fix -- this path returns a live, legitimate score (either a
        // real Eval() call or *piAlpha) that absolutely can raise an
        // ancestor's alpha, and is reached constantly (any node
        // against the ply ceiling or qsearch-extend limit), making it
        // the most likely real source of the reproduced WalkPV
        // staleness bug (see the IsDraw branch's comment for the full
        // mechanism and the move.c:881 assert it produces).
        pi->mvBest.uMove = 0;
        pi->PV[ctx->uPly].uMove = 0;
        DTTRACE("<toodeep/>");
        goto end;
    }

    //
    // Erase deeper killer moves
    //
    if (ctx->uPly + 2 < MAX_PLY_PER_SEARCH)
    {
        ctx->mvKiller[ctx->uPly + 2][0].uMove = 0;
        ctx->mvKiller[ctx->uPly + 2][1].uMove = 0;
    }

    //
    // This code is for a debug option where I dump paths from root
    // to leaf along with extensions and evals at each node in the
    // path for debugging/brainstorming purposes.
    //
    pi->PV[ctx->uPly].uMove = 0;
    pi->mvBest.uMove = 0;
    pi->iExtensionAmount = 0;
    pi->iEval = INVALID_SCORE;
#if 0
    if ((g_uIterateDepth > 5) &&
        (ctx->uPly > 2.5 * g_uIterateDepth))
    {
        DumpPlyInfoStack(ctx, *piAlpha, *piBeta);
    }
#endif

    //
    // Do mate-distance pruning
    //
    if (TRUE == MateDistancePruningCutoff(ctx->uPly,
                                          pi->fInCheck,
                                          piScore,
                                          piAlpha,
                                          piBeta))
    {
        ASSERT(*piScore != -INFINITY_SCORE);
        ASSERT((*piScore <= *piAlpha) || (*piScore >= *piBeta));
        goto end;
    }
#ifdef DEBUG
    pi->iAlpha = *piAlpha;
    pi->iBeta = *piBeta;
#endif
    // Classic PVS node typing (see NODE_TYPE's definition in chess.h).
    // Centralized here rather than in each caller's move loop
    // (search.c, root.c, split.c) since CommonSearchInit is the one
    // place both Search() and QSearch() funnel through -- a wide
    // window is unambiguously PV regardless of move number (this
    // covers "first move of a PV node" for free, no need to track
    // which move number got us here); a narrow window's type depends
    // only on the PARENT's own type, not on move number either: a CUT
    // parent's children are ALL (expected to fail low, must search
    // everything to prove it), and both a PV parent's non-first
    // children AND an ALL parent's children are CUT (expected to fail
    // high). The ctx->uPly==0 guard is defensive only -- root is
    // always called with a wide window in practice, so the width check
    // above already handles it.
    if (*piBeta != *piAlpha + 1)
    {
        pi->eNodeType = NODE_PV;
    }
    else if (ctx->uPly == 0)
    {
        pi->eNodeType = NODE_CUT;
    }
    else
    {
        NODE_TYPE eParentType = ctx->sPlyInfo[ctx->uPly - 1].eNodeType;
        pi->eNodeType = (NODE_CUT == eParentType) ? NODE_ALL : NODE_CUT;
    }
    fRet = FALSE;

 end:
    ASSERT(IS_VALID_FLAG(fRet));
    return(fRet);
}


ULONG
SelectNullmoveRFactor(SEARCHER_THREAD_CONTEXT *ctx,
                      INT uDepth)
{
    ULONG u;
    ULONG uMaxPiecesPerSide = MAXU(TotalNonPawnCount(&ctx->sPosition, WHITE),
                                   TotalNonPawnCount(&ctx->sPosition, BLACK));
    ASSERT(uMaxPiecesPerSide <= 16);

    if (uMaxPiecesPerSide < 3)
    {
        // Sparse material on the mover's side: stay with the
        // conservative, non-growing reduction rather than risk a
        // zugzwang-prone position getting an aggressive R.  (The
        // TotalNonPawnCount < 4 verification search in
        // TryNullmovePruning is the other half of this safety net.)
        u = TWO_PLY;
    }
    else
    {
        // Crafty-style growth: R = 3 + depth / 6 (in whole plies),
        // scaled into our fractional-ply depth units.
        u = THREE_PLY + ((uDepth / (6 * ONE_PLY)) * ONE_PLY);
    }
    return(u);
}


FLAG WeShouldTryNullmovePruning(SEARCHER_THREAD_CONTEXT *ctx,
                                SCORE iAlpha,
                                SCORE iBeta,
                                SCORE iEval,
                                SCORE iImprovement,
	                            ULONG uNullDepth)
/**

Routine description:

    Two-stage try/skip decision, replacing the old flat >2-non-pawn-
    piece gate plus per-depth eval-margin table. Calibrated from a
    30K-position, sd-10, ~9-billion-attempt null-move precision/recall/
    EV harness (2026-09-24, two revisions -- see
    nullmove_calib/run_2026-09-24_sd10_30k_v2/, the second and
    authoritative one). iImprovement and uNullDepth are currently
    unused: the Stage 1 thresholds below are flat, not depth- or
    improvement-scaled, and Stage 2 doesn't need its own gate at all
    (see below). Kept in the signature to avoid touching call sites.

    Stage 1 (safety): is a null-move fail-high here even trustworthy?
    Gated on the MOVER's own non-pawn piece count -- TotalNonPawnCount
    (pos, pos->uToMove), NOT MAX(white,black) as an earlier revision of
    this gate (and of the calibration harness that measured it) used.
    Zugzwang is a property of the side being given the free "pass", so
    the opponent's material shouldn't matter -- confirmed empirically:
    (maxMaterial=6+, moverMaterial=2) measured a 0.30% false-positive
    rate, indistinguishable from the worst low-material cells overall,
    despite "6+" sounding safe. A materially-heavier opponent does not
    protect a mover that is itself thin on material.

    Measured false-positive rate (a null fail-high the real search
    didn't confirm) by mover's own material x eval-vs-beta deficit:

                      deficit<-300  -300..-100  -100..0  0..100  100..300   300+
      mover 0-1 pcs:      5.57%        1.35%      0.82%   1.02%    0.28%   0.12%
      mover 2 pcs:        3.73%        0.19%      0.31%   0.32%    0.02%   0.01%
      mover 3-5 pcs:      0.91%        0.20%      0.09%   0.002%   0.001%  0.0005%
      mover 6+ pcs:       0.02%        0.002%     0.001%  0.0002%  0.0001% 0.0001%

    6+ pieces is safe (<=0.02%) at EVERY deficit measured, even the most
    negative -- no deficit floor needed there at all. 2 pieces is
    actually salvageable (0.01-0.02%, comparable to the safest cells
    overall) once deficit >= 100, unlike a flatly-disabled <=2 rule
    would assume -- but <=1 piece never gets safe (worst case 0.12% at
    its *best* deficit band), so that tier is disabled outright rather
    than deficit-gated.

    Stage 2 (profitability/EV): given Stage 1 passes, is trying still
    worth the reduced-depth probe's node cost? Checked directly against
    the same run's EV data (EV = successRate*(realLoopCost-nullProbeCost)
    - (1-successRate)*nullProbeCost, in nodes saved per attempt) across
    every (depth, material) cell that survives the Stage 1 gate above:
    EV was strongly positive everywhere measured, from low single digits
    at shallow depth up to tens of thousands of nodes at deep probes,
    never negative. Stage 1 is already doing essentially all the
    discriminating work, so Stage 2 currently just returns TRUE
    unconditionally once Stage 1 passes -- no separate EV threshold is
    justified by this data. Revisit if a future, deeper or wider
    calibration run finds a safe-but-unprofitable pocket this one
    didn't sample.

Parameters:

    SEARCHER_THREAD_CONTEXT *ctx,
    SCORE iAlpha,
    SCORE iBeta,
    SCORE iEval,
    SCORE iImprovement,
    ULONG uNullDepth

Return value:

    FLAG

**/
{
    POSITION *pos = &ctx->sPosition;
    PLY_INFO *pi = &ctx->sPlyInfo[ctx->uPly];
    CUMULATIVE_SEARCH_FLAGS *pf = &ctx->sSearchFlags;
    ULONG uMoverPiecesPerSide;
    SCORE iDeficit;

    ASSERT(IS_VALID_SCORE(iAlpha) && IS_VALID_SCORE(iBeta));
    ASSERT(iAlpha < iBeta);
    ASSERT(IS_VALID_SCORE(iEval));
    ASSERT(uNullDepth < MAX_PLY_PER_SEARCH * ONE_PLY);

    if ((FALSE == pf->fAvoidNullmove) &&
        (FALSE == pi->fInCheck) &&
        (iBeta != +INFINITY_SCORE) &&
        (NODE_PV != pi->eNodeType))
    {
        uMoverPiecesPerSide = TotalNonPawnCount(pos, pos->uToMove);
        iDeficit = iEval - iBeta;

        // ---- Stage 1: safety ----
        if (uMoverPiecesPerSide <= 1)
        {
            return FALSE;  // never measured safe, even at its best deficit
        }
        if ((uMoverPiecesPerSide == 2) && (iDeficit < 100))
        {
            return FALSE;
        }
        if ((uMoverPiecesPerSide <= 5) && (iDeficit < -100))
        {
            return FALSE;
        }
        // 6+ pieces: no deficit floor -- safe everywhere measured.

        // ---- Stage 2: efficiency/EV ----
        // EV is strongly positive at every depth/material cell that
        // survives Stage 1 (see routine comment) -- nothing further to
        // gate on here today.
        return TRUE;
    }
    return FALSE;
}


FLAG
TryNullmovePruning(SEARCHER_THREAD_CONTEXT *ctx,
                   FLAG *pfThreat,
                   SCORE iAlpha,
                   SCORE iBeta,
                   ULONG uNullDepth,
                   INT *piOrigExtend,
                   SCORE *piNullScore,
                   ULONG uNullRBucket)
{
    static INT _bm_by_piece[7] = {
        -1, -1, QUARTER_PLY, QUARTER_PLY, HALF_PLY, HALF_PLY, -1
    };
    POSITION *pos = &ctx->sPosition;
    PLY_INFO *pi = &ctx->sPlyInfo[ctx->uPly];
    CUMULATIVE_SEARCH_FLAGS *pf = &ctx->sSearchFlags;
    SCORE iVerifyScore;
    MOVE mv;
    MOVE mvRef;

    ASSERT(IS_VALID_SCORE(iAlpha) && IS_VALID_SCORE(iBeta));
    ASSERT(iAlpha < iBeta);

    // TODO: more experiments with quick null

    // Ok, do it.
    ASSERT(!InCheck(pos, pos->uToMove));
    VERIFY(MakeMove(ctx, NULLMOVE));
    ASSERT(pos->u64NonPawnSig != pi->sPosition.u64NonPawnSig);
    ASSERT(pos->uToMove != pi->sPosition.uToMove);
    INC(ctx->sCounters.tree.u64NullMoves);

    // (Reduced depth) search under the nullmove; don't allow two
    // nullmoves in a row.
    ASSERT(pf->fAvoidNullmove == FALSE);
    pf->fAvoidNullmove = TRUE;
    *piNullScore = -Search(ctx, -iBeta, -iBeta + 1, uNullDepth);
    pf->fAvoidNullmove = FALSE;

    // Check the results
    if (*piNullScore >= iBeta)
    {
        UnmakeMove(ctx, NULLMOVE);
        ASSERT(PositionsAreEquivalent(pos, &pi->sPosition));

        // If there are very few pieces on the board, launch a
        // separate "verification search".
        if ((TotalNonPawnCount(pos, pos->uToMove) < 4) &&
            (pf->fVerifyNullmove == TRUE))
        {
            ASSERT(pf->fAvoidNullmove == FALSE);
            uNullDepth -= ONE_PLY;
            if (uNullDepth > MAX_DEPTH_PER_SEARCH) uNullDepth = 0;
            pf->fVerifyNullmove = FALSE;
            iVerifyScore = Search(ctx, iAlpha, iBeta, uNullDepth);
            pf->fVerifyNullmove = TRUE;
            if (iVerifyScore < iBeta)
            {
                // The nullmove failed high but the verify search
                // did not; we are in zug so extend.
                *piOrigExtend += ONE_PLY;
                INC(ctx->sCounters.extension.uZugzwang);
                return FALSE;
            }
        }

        // Nullmove succeeded and either no need to verify or verify
        // succeeded too.
        INC(ctx->sCounters.tree.u64NullMoveSuccess);
#ifdef PERF_COUNTERS
        INC(ctx->sCounters.tree.u64NullMoveSuccessByR[uNullRBucket]);
#endif
        if (*piNullScore > +NMATE) *piNullScore = +NMATE;
        return TRUE;
    }

    // Nullmove failed...
    mv = (pi+1)->mvBest;
    if (mv.uMove)
    {
        // See what we can learn from the move that refuted our nullmove.
        ASSERT(SanityCheckMove(pos, mv));
        ASSERT(GET_COLOR(mv.pMoved) == pos->uToMove);
        ASSERT(ctx->uPly >= 2);

        // If we make a nullmove that fails because we lose a
        // piece, remember that the piece in question is in danger.
        if ((mv.pCaptured) && !IS_PAWN(mv.pCaptured))
        {
            ASSERT(GET_COLOR(mv.pCaptured) == FLIP(pos->uToMove));
            ASSERT(mv.pCaptured == pos->rgSquare[mv.cTo].pPiece);

            // Victim belongs to FLIP(pos->uToMove) here, i.e. the
            // mover at ctx->uPly - 1 (see RecordEnprisePieceAtPly).
            RecordEnprisePieceAtPly(ctx, ctx->uPly - 1, mv.cTo);
#if 0
            mvRef = ctx->mvNullmoveRefutations[ctx->uPly - 2];
            if ((mvRef.uMove) &&
                (mvRef.pCaptured == mv.pCaptured) &&
                (mvRef.pMoved == mv.pMoved) &&
                (mvRef.cTo != mv.cTo))
            {
                ASSERT(GET_COLOR(mvRef.pCaptured) == FLIP(pos->uToMove));
                ASSERT(mvRef.pCaptured);
                ASSERT(_bm_by_piece[PIECE_TYPE(mv.pCaptured)] > 0);
                ASSERT(_bm_by_piece[PIECE_TYPE(mv.pCaptured)] <=
                       ONE_PLY);
                *piOrigExtend += _bm_by_piece[PIECE_TYPE(mv.pCaptured)];
                INC(ctx->sCounters.extension.uBotvinnikMarkoff);
            }
#endif
            ctx->mvNullmoveRefutations[ctx->uPly] = mv;
        }
        else if (!IS_CAPTURE_OR_PROMOTION(mv))
        {
            // A quiet move refuting our nullmove is itself decent
            // evidence that the move is strong here -- not enough to
            // extend on (that's the capture-only Botvinnik-Markoff
            // case above), but worth remembering as a fallback guess
            // for _NewKillerMove's empty-slot backfill, which is only
            // useful when this is actually a quiet move: a killer
            // slot only ever gets matched against generated quiet
            // candidates (IS_SAME_MOVE compares the pCaptured/
            // pPromoted bits too), so storing a capture there (the
            // old unconditional behavior) could never match anything
            // and was silently dead.
            //
            // Deliberately a *separate* array from mvNullmoveRefutations,
            // not a shared slot -- that one is read two plies later
            // (ctx->uPly - 2, above) expecting a capture, to detect the
            // same-piece-two-different-squares Botvinnik-Markoff pattern.
            // Writing a quiet move into that same slot would silently
            // clobber the capture history the extension depends on.
            ctx->mvNullmoveQuietRefutations[ctx->uPly] = mv;
        }

        // This is an idea from Tord Romstad on ccc: if we are below a
        // history reduced node and we try a nullmove and the nullmove
        // fails low and the move that refuted the nullmove involves
        // the same piece moved in the reduced move at ply-1 then bail
        // out of the reduced depth search now and research at full
        // depth.  The move that was reduced had some tactical
        // significance.
        ASSERT(IS_ON_BOARD(mv.cFrom));
        if ((mv.cFrom == (pi-1)->mv.cTo) && ((pi-1)->iExtensionAmount < 0))
        {
            ASSERT(GET_COLOR(mv.pMoved) == GET_COLOR((pi-1)->mv.pMoved));
            UnmakeMove(ctx, NULLMOVE);
            ASSERT(PositionsAreEquivalent(pos, &pi->sPosition));
            *piNullScore = iAlpha - 1;
            return TRUE;
        }
    }

    // If we do nothing we are mated-in-n, therefore this is a
    // dangerous position so extend.  This is Bruce Moreland's idea
    // originally.
    if (*piNullScore <= -NMATE)
    {
        if (mv.uMove && !IS_CAPTURE_OR_PROMOTION(mv))
        {
            ASSERT(SanityCheckMove(pos, mv));
            ASSERT(GET_COLOR(mv.pMoved) == pos->uToMove);
            UpdateDynamicMoveOrdering(ctx,
                                      uNullDepth + TWO_PLY,
                                      mv,
                                      *piNullScore,
                                      0);
        }
        *pfThreat = TRUE;
    }
    UnmakeMove(ctx, NULLMOVE);
    ASSERT(PositionsAreEquivalent(pos, &pi->sPosition));
    return FALSE;
}


#ifdef DEBUG
FLAG
SanityCheckMoves(IN SEARCHER_THREAD_CONTEXT *ctx,
                 IN ULONG uCurrent,
                 IN ULONG uType)
/**

Routine description:

    Support routine to sanity check that:

        1. The moves before uCurrent on the move stack were all marked
           as searched (or pruned)
        2. The moves after uCurrent on the move stack are all zero
           value moves and not checking moves.

Parameters:

    SEARCHER_THREAD_CONTEXT *ctx,
    ULONG uCurrent,
    ULONG uType

Return value:

    FLAG

**/
{
    ULONG x;

    if (WE_SHOULD_STOP_SEARCHING)
    {
        return(TRUE);
    }

    //
    // Check moves yet to be searched
    //
    if (uType & VERIFY_AFTER)
    {
        for (x = uCurrent; x < ctx->sMoveStack.uEnd[ctx->uPly]; x++)
        {
            ASSERT(ctx->sMoveStack.mvf[x].iValue <= 0);
            ASSERT(!IS_CHECKING_MOVE(ctx->sMoveStack.mvf[x].mv));
        }
    }

    //
    // Check moves already searched
    //
    if (uType & VERIFY_BEFORE)
    {
        for (x = uCurrent - 1;
             ((x >= ctx->sMoveStack.uBegin[ctx->uPly]) && (x != (ULONG)-1));
             x--)
        {
            ASSERT(ctx->sMoveStack.mvf[x].bvFlags & MVF_MOVE_SEARCHED);
        }
    }
    return(TRUE);
}
#endif