var nodes: usize = 0;

    std.debug.print("info score cp {d} depth {d}\n", .{ score, depth });

    std.debug.print("info score cp {d} depth {d} nodes: {d}\n", .{ score, depth, nodes });

    // TODO
    // nodes += 1;

    nodes += 1;

    const evaluation = eval.evaluate(gs);

    nodes += 1;
    const evaluation = nnue.evaluate(gs);

test "NNUE" {
    nnue.nnue_init(NNUE_FILE);

    try std.testing.expectEqual(
        @as(c_int, 57),
        nnue.nnue_evaluate_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"),
    );
}

        std.debug.assert(@as(c_int, 57) ==
            nnue.nnue_evaluate_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"));

const search = @import("search.zig");

var debug = false;

    try handleUCI();

    if (debug) {
        var gs = try Board.GameState.init("r2q1rk1/ppp2ppp/2n1bn2/2b1p3/3pP3/3P1NPP/PPP1NPB1/R1BQ1RK1 b - - 0 9");
        gs.show();
        std.debug.print("{s}\n", .{search.bestMove(&gs, 3)});
    } else try handleUCI();

    // TODO: piece+square defines the relevant bits
    // TODO: this is for rooks, bishop needs less

    // this is for rooks, bishop needs less

## Architecture
### Basics
Every chess engine consists of 3 major parts:
- Move generator (which is tightly coupled with Board representation): Move generators
just generate all the possible moves for a given state.
- Evaluation: Evaluation tells our engine if a given state is good or bad for us. Is it worth
taking that piece? Should I move my pawn instead? etc.
- Search: A chess engine just dumbly creates every move and evaluates the position after
every move. Searching is about ruling out moves and ordering them to find the _best move_.
### Move generator
#### BitBoard
This engine uses a bitboard representation. A chess board got 8x8 squares, so a `u6`
number can represent the whole board.
You have to separate the pieces (pawn, knight, bishop, rook, queen, king) and colors, which
gives means 12 `u6` numbers.
It is also convenient to store the occupied squares for each side, that takes 2x`u6`.
see BitBoard and GameState in Board.zig
#### Attacks
Based on the rules for each piece You just generate all possibilities for a given square.
For leaper pieces (pawn, knight and king) it is not that hard, but the sliding pieces
(bishop, rook, and queen) have a lot of possibilities.
To calculate bishop and rook attacks the state of the art method is using
[Magic Bitboards](https://www.chessprogramming.org/Magic_Bitboards).
This engine uses the [Plain](https://www.chessprogramming.org/Magic_Bitboards#Plain) method,
which is the simplest one.
The Attacks.zig file contains everything for attacks. Note, that we have to initialize
bishop and rook attacks with `initSliderAttacks()` before using them with `getBishopAttacks()`,
`getRookAttacks()` and `genQueenAttacks()`.
The `findMagicNumber()` function finds magic numbers. You should only run that once and
just paste it in Your code, it makes no sense to regenerate the same numbers every time.
### Evaluation

In chess for years the only option for evaluation was a bunch of handcrafted rules. This
engine can use a _very_ simple table-based evaluation in `eval.zig`. That is the default
for development as its simplicity makes it predictable which makes debugging easier.
However You can replace `eval.evaluate()` in `search.zig` with `nnue.evaluate()`. Download
the nnue file from [here](https://tests.stockfishchess.org/api/nn/nn-62ef826d1a6d.nnue) put
it next to the engine binary and it will use Stockfish's NNUE from that point.
NOTE: It can only read SFNNv1 files, so do not try to use later networks, they will not work.