// PVS
    var found_pv: bool = false;

        // 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 (scr > alpha and scr < beta) {
                scr = -try negamax(gs, -beta, -alpha, depth - 1);
            }

        // Normal negamax without PVS or LMR
        if (moves_searched == 0) {
            scr = -try negamax(gs, -beta, -alpha, depth - 1);

            // Normal negamax without PVS
            if (moves_searched == 0) {
                scr = -try negamax(gs, -beta, -alpha, depth - 1);

            // Conditions to consider LMR
            if (moves_searched >= FULL_DEPTH_MOVES and
                gs.ply >= 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 -| 3);

                // 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);
                } else {
                    // hack to ensure that full-depth search is done
                    scr = alpha + 1;
                }

                // hack to ensure that we continue with PVS code below
                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);

            // Continue PVS code
            if (scr > alpha) {
                // 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 LRM fails do a full search
                    if (scr > alpha and scr < beta) {
                        scr = -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);

            found_pv = true;

        try search.bestMove(&gs, 6);

        try search.bestMove(&gs, 8);