// Late move reduction
const FULL_DEPTH_MOVES = 4;
const REDUCTION_LIMIT = 3;

    var moves_searched: usize = 0;

        const scr = blk: {
            // PVS
            if (found_pv) {
                // Once you've found a move with a score that is between alpha and beta,
                // the rest of the moves are searched with the goal of proving that they are all bad.
                // It's possible to do this a bit faster than a search that worries that one
                // of the remaining moves might be good.
                const s = -try negamax(gs, -alpha - 1, -alpha, depth - 1);

        var scr: isize = undefined;
        // PVS
        if (found_pv) {
            // Once you've found a move with a score that is between alpha and beta,
            // the rest of the moves are searched with the goal of proving that they are all bad.
            // It's possible to do this a bit faster than a search that worries that one
            // of the remaining moves might be good.
            scr = -try negamax(gs, -alpha - 1, -alpha, depth - 1);

                // If the algorithm finds out that it was wrong, and that one of the
                // subsequent moves was better than the first PV move, it has to search again,
                // in the normal alpha-beta manner.  This happens sometimes, and it's a waste of time,
                // but generally not often enough to counteract the savings gained from doing the
                // "bad move proof" search referred to earlier.
                if (s > alpha and s < beta) {
                    break :blk -try negamax(gs, -beta, -alpha, depth - 1);

            // If the algorithm finds out that it was wrong, and that one of the
            // subsequent moves was better than the first PV move, it has to search again,
            // in the normal alpha-beta manner.  This happens sometimes, and it's a waste of time,
            // but generally not often enough to counteract the savings gained from doing the
            // "bad move proof" search referred to earlier.
            if (scr > alpha and scr < beta) {
                scr = -try negamax(gs, -beta, -alpha, depth - 1);
            }
        } else {
            // Normal negamax without PVS
            if (moves_searched == 0) {
                scr = -try negamax(gs, -beta, -alpha, depth - 1);
            } else {
                // Conditions to consider LMR
                if (moves_searched >= FULL_DEPTH_MOVES and
                    depth >= REDUCTION_LIMIT and
                    !mp.move.capture and mp.move.prom == .none and
                    !gs.inCheck())
                {
                    // reduced-depth, narrow score search for lame moves
                    scr = -try negamax(gs, -alpha - 1, -alpha, depth - 2);

                    // Keep the fast search score
                    break :blk s;

                    // hack to ensure that full-depth search is done
                    scr = alpha + 1;
                }
                // Found a good move during LMR
                if (scr > alpha) {
                    // full depth with narrowed score
                    scr = -try negamax(gs, -alpha - 1, -alpha, depth - 1);
                    // if LRM fails do a full search
                    if (scr > alpha and scr < beta) {
                        scr = -try negamax(gs, -beta, -alpha, depth - 1);
                    }

            } else {
                // Normal negamax without PVS
                break :blk -try negamax(gs, -beta, -alpha, depth - 1);

        };

        }

        moves_searched += 1;

                // preserve board state, so we can rewind illegal moves
                // const bckup = self.backup();

                    const king_square = switch (self.side) {
                        .white => @intToEnum(Square, @ctz(
                            @bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.K)]),
                        )),
                        .black => @intToEnum(Square, @ctz(
                            @bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.k)]),
                        )),
                    };
                    if (self.isSquareAttacked(@enumToInt(king_square), self.side.enemy())) {
                        // self.restore(bckup);
                        return false;
                    }

                    if (self.inCheck()) return false;

    pub fn inCheck(self: *const @This()) bool {
        const king_square = switch (self.side) {
            .white => @intToEnum(Square, @ctz(
                @bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.K)]),
            )),
            .black => @intToEnum(Square, @ctz(
                @bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.k)]),
            )),
        };
        if (self.isSquareAttacked(@enumToInt(king_square), self.side.enemy())) return true;
        return false;
    }

    - [Late Move Reduction - LMR](https://www.chessprogramming.org/Late_Move_Reductions)