voroskoi/pistike - Change LJY2HRZ3XGWIDIBYPOZFKC3555AZEROKSVDNELII6UQIUMGLOVEQC

update to zig master

Created by voroskoi on July 29, 2023

LJY2HRZ3XGWIDIBYPOZFKC3555AZEROKSVDNELII6UQIUMGLOVEQC

Dependencies

In channels

main

Change contents

Replacement in src/zobrist.zig at line 17 [4.36]

B:BD[4.509] → [4.509:587]

    var rnd = std.rand.DefaultPrng.init(@intCast(u64, std.time.timestamp()));

[4.509]

[4.587]

    var rnd = std.rand.DefaultPrng.init(@as(u64, @intCast(std.time.timestamp())));

Replacement in src/zobrist.zig at line 40 [4.36]

∅:D[3.192] → [4.999:1053]

B:BD[4.999] → [4.999:1053]

        var bitboard = @bitCast(Board.BoardType, bb);

[3.192]

[4.1053]

        var bitboard = @as(Board.BoardType, @bitCast(bb));

Replacement in src/zobrist.zig at line 47 [4.36]

B:BD[4.1183] → [4.1183:1258]

            bitboard ^= @as(u64, 1) << @intCast(Board.SquareType, square);

[4.1183]

[4.1258]

            bitboard ^= @as(u64, 1) << @as(Board.SquareType, @intCast(square));

Replacement in src/zobrist.zig at line 55 [4.36]

B:BD[4.1379] → [5.0:73]

    gs.hash ^= castle_hashes[@bitCast(Board.CastlingType, gs.castling)];

[4.1379]

[4.1520]

    gs.hash ^= castle_hashes[@as(Board.CastlingType, @bitCast(gs.castling))];

Replacement in src/uci.zig at line 211 [6.32]

B:BD[6.2041] → [3.261:429]

    move.source = @enumFromInt(Square, (in[0] - 'a' + (8 - (in[1] - '0')) * SIZE));
    move.target = @enumFromInt(Square, (in[2] - 'a' + (8 - (in[3] - '0')) * SIZE));

[6.2041]

[6.2205]

    move.source = @as(Square, @enumFromInt((in[0] - 'a' + (8 - (in[1] - '0')) * SIZE)));
    move.target = @as(Square, @enumFromInt((in[2] - 'a' + (8 - (in[3] - '0')) * SIZE)));

Replacement in src/score.zig at line 34 [8.2114]

B:BD[7.255] → [7.255:325]

    if (@bitCast(BitMoveType, move) == @bitCast(BitMoveType, best)) {

[7.255]

[7.325]

    if (@as(BitMoveType, @bitCast(move)) == @as(BitMoveType, @bitCast(best))) {

Replacement in src/score.zig at line 54 [8.2114]

B:BD[8.3182] → [9.2912:3009]

        if (@bitCast(BitMoveType, killer_moves[0][search.ply]) == @bitCast(BitMoveType, move)) {

[8.3182]

[8.3319]

        if (@as(BitMoveType, @bitCast(killer_moves[0][search.ply])) == @as(BitMoveType, @bitCast(move))) {

Replacement in src/score.zig at line 59 [8.2114]

B:BD[8.3396] → [9.3010:3112]

        else if (@bitCast(BitMoveType, killer_moves[1][search.ply]) == @bitCast(BitMoveType, move)) {

[8.3396]

[8.3538]

        else if (@as(BitMoveType, @bitCast(killer_moves[1][search.ply])) == @as(BitMoveType, @bitCast(move))) {

Replacement in src/score.zig at line 65 [8.2114]
B:BD[8.3629] → [8.3629:3658]
```
            return @intCast(
```
[8.3629]
[8.3658]
```
            return @as(
```

Replacement in src/score.zig at line 67 [8.2114]

B:BD[8.3681] → [3.608:692]

                history_moves[@intFromEnum(move.piece)][@intFromEnum(move.target)],

[8.3681]

[8.3761]

                @intCast(history_moves[@intFromEnum(move.piece)][@intFromEnum(move.target)]),

Replacement in src/nnue.zig at line 71 [10.33]
∅:D[3.843] → [10.2049:2099]
B:BD[10.2049] → [10.2049:2099]
```
        bitboard = @bitCast(Board.BoardType, bb);
```
[3.843]
[10.2099]
```
        bitboard = @as(Board.BoardType, @bitCast(bb));
```

Replacement in src/nnue.zig at line 73 [10.33]

B:BD[10.2131] → [3.844:899]

            const piece = @enumFromInt(Chess.PE, idx);

[10.2131]

[10.2184]

            const piece = @as(Chess.PE, @enumFromInt(idx));

Replacement in src/nnue.zig at line 92 [10.33]

B:BD[10.2854] → [10.2854:2941]

            bitboard ^= @as(Board.BoardType, 1) << @intCast(Board.SquareType, square);

[10.2854]

[10.2941]

            bitboard ^= @as(Board.BoardType, 1) << @as(Board.SquareType, @intCast(square));

Replacement in src/nnue.zig at line 106 [10.33]

B:BD[11.1294] → [12.0:47]

    return @intCast(isize, nnue.nnue_evaluate(

[11.1294]

[3.1334]

    return @as(isize, @intCast(nnue.nnue_evaluate(

Replacement in src/nnue.zig at line 110 [10.33]
B:BD[12.117] → [12.117:158]
```
    )) * @divTrunc(100 - gs.fifty, 100);
```
[12.117]
[11.1388]
```
    ))) * @divTrunc(100 - gs.fifty, 100);
```

Replacement in src/eval.zig at line 111 [14.33]

∅:D[3.1406] → [13.246:297]

B:BD[13.246] → [13.246:297]

        var board = @bitCast(Board.BoardType, bb);

[3.1406]

[13.297]

        var board = @as(Board.BoardType, @bitCast(bb));

Replacement in src/eval.zig at line 119 [14.33]

B:BD[10.3941] → [3.1407:1467]

            score += switch (@enumFromInt(Chess.PE, idx)) {

[10.3941]

[13.508]

            score += switch (@as(Chess.PE, @enumFromInt(idx))) {

Replacement in src/eval.zig at line 135 [14.33]

B:BD[10.4693] → [13.1142:1209]

            board ^= @as(Board.BoardType, 1) << @intCast(u6, bit);

[10.4693]

[10.4778]

            board ^= @as(Board.BoardType, 1) << @as(u6, @intCast(bit));

Replacement in src/Transposition.zig at line 47 [16.354]

B:BD[15.254] → [7.384:448]

                .best = @bitCast(BitMove, @as(BitMoveType, 0)),

[15.254]

[16.1386]

                .best = @as(BitMove, @bitCast(@as(BitMoveType, 0))),

Replacement in src/Transposition.zig at line 78 [16.354]

B:BD[16.2088] → [3.1813:1869]

        .best = @bitCast(BitMove, @as(BitMoveType, 0)),

[16.2088]

        .best = @as(BitMove, @bitCast(@as(BitMoveType, 0))),

Replacement in src/Search.zig at line 127 [17.35]

B:BD[9.4312] → [9.4312:4391]

                [_]BitMove{@bitCast(BitMove, @as(BitMoveType, 0))} ** MAX_PLY,

[9.4312]

[9.4391]

                [_]BitMove{@as(BitMove, @bitCast(@as(BitMoveType, 0)))} ** MAX_PLY,

Replacement in src/Search.zig at line 132 [17.35]

B:BD[9.4576] → [9.4576:4655]

                [_]BitMove{@bitCast(BitMove, @as(BitMoveType, 0))} ** MAX_PLY,

[9.4576]

[9.4655]

                [_]BitMove{@as(BitMove, @bitCast(@as(BitMoveType, 0)))} ** MAX_PLY,

Replacement in src/Search.zig at line 202 [17.35]

B:BD[15.519] → [15.519:569]

            return s + @intCast(isize, self.ply);

[15.519]

[15.569]

            return s + @as(isize, @intCast(self.ply));

Replacement in src/Search.zig at line 204 [17.35]

B:BD[15.616] → [15.616:666]

            return s - @intCast(isize, self.ply);

[15.616]

[15.666]

            return s - @as(isize, @intCast(self.ply));

Replacement in src/Search.zig at line 212 [17.35]

B:BD[15.834] → [15.834:884]

            return s - @intCast(isize, self.ply);

[15.834]

[15.884]

            return s - @as(isize, @intCast(self.ply));

Replacement in src/Search.zig at line 214 [17.35]

B:BD[15.931] → [15.931:981]

            return s + @intCast(isize, self.ply);

[15.931]

[15.981]

            return s + @as(isize, @intCast(self.ply));

Replacement in src/Search.zig at line 240 [17.35]

B:BD[15.1058] → [7.449:522]

        var best_move: BitMove = @bitCast(BitMove, @as(BitMoveType, 0));

[15.1058]

[18.140]

        var best_move: BitMove = @as(BitMove, @bitCast(@as(BitMoveType, 0)));

Replacement in src/Search.zig at line 323 [17.35]

B:BD[9.7442] → [9.7442:7544]

                if (@bitCast(BitMoveType, pv_table[0][self.ply]) == @bitCast(BitMoveType, mp.move)) {

[9.7442]

[9.7544]

                if (@as(BitMoveType, @bitCast(pv_table[0][self.ply])) == @as(BitMoveType, @bitCast(mp.move))) {

Replacement in src/Search.zig at line 424 [17.35]

∅:D[7.711] → [15.2156:2210]

B:BD[15.2156] → [15.2156:2210]

                        .depth = @intCast(u8, depth),

[7.711]

[15.2210]

                        .depth = @as(u8, @intCast(depth)),

Replacement in src/Search.zig at line 444 [17.35]

B:BD[9.11594] → [15.2640:2709]

                return -eval.MATE_VALUE + @intCast(isize, self.ply);

[9.11594]

[9.11667]

                return -eval.MATE_VALUE + @as(isize, @intCast(self.ply));

Replacement in src/Search.zig at line 454 [17.35]
∅:D[7.743] → [16.3673:3715]
∅:D[15.2761] → [16.3673:3715]
B:BD[16.3673] → [16.3673:3715]
```
            .depth = @intCast(u8, depth),
```
[7.743]
[16.3715]
```
            .depth = @as(u8, @intCast(depth)),
```

Replacement in src/Search.zig at line 505 [17.35]

B:BD[9.12356] → [7.778:850]

        score.moves(self, &ml, @bitCast(BitMove, @as(BitMoveType, 0)));

[9.12356]

[3.2161]

        score.moves(self, &ml, @as(BitMove, @bitCast(@as(BitMoveType, 0))));

Replacement in src/Search.zig at line 545 [17.35]

B:BD[19.3090] → [3.2238:2319]

        const time = @floatFromInt(f32, self.timer.read()) / std.time.ns_per_ms;

[19.3090]

[18.232]

        const time = @as(f32, @floatFromInt(self.timer.read())) / std.time.ns_per_ms;

Replacement in src/Search.zig at line 550 [17.35]

B:BD[18.468] → [3.2320:2422]

                .{ scr, depth, nodes, time, (@floatFromInt(f32, nodes) / time) * std.time.ms_per_s },

[18.468]

[18.568]

                .{ scr, depth, nodes, time, (@as(f32, @floatFromInt(nodes)) / time) * std.time.ms_per_s },

Replacement in src/Search.zig at line 557 [17.35]

B:BD[18.810] → [3.2423:2525]

                .{ scr, depth, nodes, time, (@floatFromInt(f32, nodes) / time) * std.time.ms_per_s },

[18.810]

[18.910]

                .{ scr, depth, nodes, time, (@as(f32, @floatFromInt(nodes)) / time) * std.time.ms_per_s },

Replacement in src/Board.zig at line 28 [20.16071]

B:BD[20.16817] → [3.2526:2582]

        return @intCast(u3, @intFromEnum(self) / SIZE);

[20.16817]

[20.16865]

        return @as(u3, @intCast(@intFromEnum(self) / SIZE));

Replacement in src/Board.zig at line 32 [20.16071]

B:BD[20.16908] → [3.2583:2639]

        return @intCast(u3, @intFromEnum(self) % SIZE);

[20.16908]

[20.16956]

        return @as(u3, @intCast(@intFromEnum(self) % SIZE));

Replacement in src/Board.zig at line 50 [20.16071]

∅:D[21.82] → [20.18122:18180]

B:BD[20.18122] → [20.18122:18180]

        var ret: BoardType = @bitCast(BoardType, self.*);

[21.82]

[3.2640]

        var ret: BoardType = @as(BoardType, @bitCast(self.*));

Replacement in src/Board.zig at line 52 [20.16071]
∅:D[21.134] → [20.18219:18261]
∅:D[3.2693] → [20.18219:18261]
B:BD[20.18219] → [20.18219:18261]
```
        self.* = @bitCast(BitBoard, ret);
```
[3.2693]
[20.18261]
```
        self.* = @as(BitBoard, @bitCast(ret));
```

Replacement in src/Board.zig at line 56 [20.16071]

B:BD[20.18336] → [20.18336:18383]

        var ret = @bitCast(BoardType, self.*);

[20.18336]

[20.18383]

        var ret = @as(BoardType, @bitCast(self.*));

Replacement in src/Board.zig at line 60 [20.16071]

B:BD[20.18480] → [20.18480:18522]

        self.* = @bitCast(BitBoard, ret);

[20.18480]

[21.135]

        self.* = @as(BitBoard, @bitCast(ret));

Replacement in src/Board.zig at line 64 [20.16071]
∅:D[22.2657] → [21.188:233]
B:BD[21.188] → [21.188:233]
```
        var ret = @bitCast(BoardType, self);
```
[22.2657]
[3.2757]
```
        var ret = @as(BoardType, @bitCast(self));
```

Replacement in src/Board.zig at line 69 [20.16071]

B:BD[21.343] → [21.343:390]

        var ret = @bitCast(BoardType, self.*);

[21.343]

[3.2824]

        var ret = @as(BoardType, @bitCast(self.*));

Replacement in src/Board.zig at line 71 [20.16071]
∅:D[3.2877] → [21.441:483]
B:BD[21.441] → [21.441:483]
```
        self.* = @bitCast(BitBoard, ret);
```
[3.2877]
[21.483]
```
        self.* = @as(BitBoard, @bitCast(ret));
```

Replacement in src/Board.zig at line 75 [20.16071]

B:BD[23.47] → [23.47:94]

        var ret = @bitCast(BoardType, self.*);

[23.47]

[3.2878]

        var ret = @as(BoardType, @bitCast(self.*));

Replacement in src/Board.zig at line 77 [20.16071]
∅:D[3.2934] → [23.148:190]
B:BD[23.148] → [23.148:190]
```
        self.* = @bitCast(BitBoard, ret);
```
[3.2934]
[23.190]
```
        self.* = @as(BitBoard, @bitCast(ret));
```

Replacement in src/Board.zig at line 90 [20.16071]

B:BD[20.18944] → [20.18944:19131]

                const square = @intCast(SquareType, rank * SIZE + file);
                const mask: usize = if (@bitCast(BoardType, self) & (@as(BoardType, 1) << square) != 0) 1 else 0;

[20.18944]

[20.19131]

                const square = @as(SquareType, @intCast(rank * SIZE + file));
                const mask: usize = if (@as(BoardType, @bitCast(self)) & (@as(BoardType, 1) << square) != 0) 1 else 0;

Replacement in src/Board.zig at line 99 [20.16071]

B:BD[20.19381] → [20.19381:19457]

        std.debug.print("\nBitBoard: {d}\n", .{@bitCast(BoardType, self)});

[20.19381]

[20.19457]

        std.debug.print("\nBitBoard: {d}\n", .{@as(BoardType, @bitCast(self))});

Replacement in src/Board.zig at line 181 [20.16071]

B:BD[24.1126] → [5.562:631]

B:BD[5.631] → [3.2935:2987]

        self.* = @bitCast(Castling, @bitCast(CastlingType, self.*) &
            CASTLING_RIGHTS[@intFromEnum(square)]);

[24.1126]

[24.1269]

        self.* = @as(Castling, @bitCast(@as(CastlingType, @bitCast(self.*)) &
            CASTLING_RIGHTS[@intFromEnum(square)]));

Replacement in src/Board.zig at line 216 [20.16071]

B:BD[25.1332] → [25.1332:1372]

            return @truncate(u32, key);

[25.1332]

[25.1372]

            return @as(u32, @truncate(key));

Replacement in src/Board.zig at line 280 [20.16071]

B:BD[26.1966] → [3.3316:3490]

        return @bitCast(BoardType, self.occupancies[@intFromEnum(Chess.Colors.white)]) |
            @bitCast(BoardType, self.occupancies[@intFromEnum(Chess.Colors.black)]);

[26.1966]

[20.21934]

        return @as(BoardType, @bitCast(self.occupancies[@intFromEnum(Chess.Colors.white)])) |
            @as(BoardType, @bitCast(self.occupancies[@intFromEnum(Chess.Colors.black)]));

Replacement in src/Board.zig at line 292 [20.16071]

B:BD[20.22245] → [20.22245:22318]

                const square = @intCast(SquareType, rank * SIZE + file);

[20.22245]

[20.22318]

                const square = @as(SquareType, @intCast(rank * SIZE + file));

Replacement in src/Board.zig at line 295 [20.16071]

∅:D[3.3545] → [20.22368:22456]

B:BD[20.22368] → [20.22368:22456]

B:BD[20.22456] → [3.3546:3634]

                    if (@bitCast(BoardType, bb) & (@as(BoardType, 1) << square) != 0) {
                        std.debug.print("{c} ", .{@enumFromInt(Chess.PE, idx).char()});

[3.3545]

[20.22542]

                    if (@as(BoardType, @bitCast(bb)) & (@as(BoardType, 1) << square) != 0) {
                        std.debug.print("{c} ", .{@as(Chess.PE, @enumFromInt(idx)).char()});

Replacement in src/Board.zig at line 337 [20.16071]

B:BD[27.1546] → [3.3635:3712]

                    const square = @enumFromInt(Square, rank * SIZE + file);

[27.1546]

[3.3712]

                    const square = @as(Square, @enumFromInt(rank * SIZE + file));

Replacement in src/Board.zig at line 350 [20.16071]

B:BD[27.1610] → [3.4308:4385]

                    const square = @enumFromInt(Square, rank * SIZE + file);

[27.1610]

[3.4385]

                    const square = @as(Square, @enumFromInt(rank * SIZE + file));

Replacement in src/Board.zig at line 403 [20.16071]
B:BD[20.26845] → [20.26845:26884]
```
            const r = SIZE - @intCast(
```
[20.26845]
[20.26884]
```
            const r = SIZE - @as(
```

Replacement in src/Board.zig at line 405 [20.16071]

B:BD[20.26912] → [20.26912:26979]

                try std.fmt.parseUnsigned(u3, enpassant[1..], 10),

[20.26912]

[20.26979]

                @intCast(try std.fmt.parseUnsigned(u3, enpassant[1..], 10)),

Replacement in src/Board.zig at line 407 [20.16071]

B:BD[20.26994] → [3.4981:5046]

            self.enpassant = @enumFromInt(Square, r * SIZE + f);

[20.26994]

[4.3087]

            self.enpassant = @as(Square, @enumFromInt(r * SIZE + f));

Replacement in src/Board.zig at line 423 [20.16071]

B:BD[3.5143] → [3.5143:5249]

                if (pa & @bitCast(BoardType, self.bitboards[@intFromEnum(Chess.PE.P)]) != 0) return true;

[3.5143]

[20.27464]

                if (pa & @as(BoardType, @bitCast(self.bitboards[@intFromEnum(Chess.PE.P)])) != 0) return true;

Replacement in src/Board.zig at line 427 [20.16071]

B:BD[3.5346] → [3.5346:5452]

                if (pa & @bitCast(BoardType, self.bitboards[@intFromEnum(Chess.PE.p)]) != 0) return true;

[3.5346]

[20.27701]

                if (pa & @as(BoardType, @bitCast(self.bitboards[@intFromEnum(Chess.PE.p)])) != 0) return true;

Replacement in src/Board.zig at line 437 [20.16071]

B:BD[20.27979] → [20.27979:28040]

        if (na & @bitCast(BoardType, nbb) != 0) return true;

[20.27979]

[20.28040]

        if (na & @as(BoardType, @bitCast(nbb)) != 0) return true;

Replacement in src/Board.zig at line 445 [20.16071]

B:BD[20.28289] → [20.28289:28350]

        if (ka & @bitCast(BoardType, kbb) != 0) return true;

[20.28289]

[2.0]

        if (ka & @as(BoardType, @bitCast(kbb)) != 0) return true;

Replacement in src/Board.zig at line 455 [20.16071]

B:BD[20.28617] → [28.451:514]

        if (ba.* & @bitCast(BoardType, bbb) != 0) return true;

[20.28617]

[20.28678]

        if (ba.* & @as(BoardType, @bitCast(bbb)) != 0) return true;

Replacement in src/Board.zig at line 463 [20.16071]

B:BD[20.28941] → [28.515:578]

        if (ra.* & @bitCast(BoardType, rbb) != 0) return true;

[20.28941]

[20.29002]

        if (ra.* & @as(BoardType, @bitCast(rbb)) != 0) return true;

Replacement in src/Board.zig at line 470 [20.16071]

B:BD[20.29267] → [28.579:651]

        if ((ba.* | ra.*) & @bitCast(BoardType, qbb) != 0) return true;

[20.29267]

[20.29328]

        if ((ba.* | ra.*) & @as(BoardType, @bitCast(qbb)) != 0) return true;

Replacement in src/Board.zig at line 482 [20.16071]

B:BD[20.29897] → [3.6098:6182]

            const board = @bitCast(BoardType, self.bitboards[@intFromEnum(piece)]);

[20.29897]

[20.29973]

            const board = @as(BoardType, @bitCast(self.bitboards[@intFromEnum(piece)]));

Replacement in src/Board.zig at line 508 [20.16071]

B:BD[20.31023] → [20.31023:31086]

            source_square = @intCast(SquareType, @ctz(board));

[20.31023]

[20.31086]

            source_square = @as(SquareType, @intCast(@ctz(board)));

Replacement in src/Board.zig at line 546 [20.16071]

B:BD[22.3285] → [3.6740:6890]

                            .source = @enumFromInt(Square, source_square),
                            .target = @enumFromInt(Square, target_square),

[22.3285]

[20.32724]

                            .source = @as(Square, @enumFromInt(source_square)),
                            .target = @as(Square, @enumFromInt(target_square)),

Replacement in src/Board.zig at line 557 [20.16071]

B:BD[22.3475] → [3.6891:7041]

                            .source = @enumFromInt(Square, source_square),
                            .target = @enumFromInt(Square, target_square),

[22.3475]

[22.3621]

                            .source = @as(Square, @enumFromInt(source_square)),
                            .target = @as(Square, @enumFromInt(target_square)),

Replacement in src/Board.zig at line 571 [20.16071]

B:BD[22.3847] → [3.7042:7192]

                            .source = @enumFromInt(Square, source_square),
                            .target = @enumFromInt(Square, double_target),

[22.3847]

[20.33678]

                            .source = @as(Square, @enumFromInt(source_square)),
                            .target = @as(Square, @enumFromInt(double_target)),

Replacement in src/Board.zig at line 584 [20.16071]

B:BD[3.7277] → [3.7277:7365]

                @bitCast(BoardType, self.occupancies[@intFromEnum(self.side.enemy())]);

[3.7277]

[20.34043]

                @as(BoardType, @bitCast(self.occupancies[@intFromEnum(self.side.enemy())]));

Replacement in src/Board.zig at line 586 [20.16071]

B:BD[20.34078] → [20.34078:34147]

                target_square = @intCast(SquareType, @ctz(attacks));

[20.34078]

[20.34147]

                target_square = @as(SquareType, @intCast(@ctz(attacks)));

Replacement in src/Board.zig at line 591 [20.16071]

B:BD[22.4008] → [3.7366:7516]

                            .source = @enumFromInt(Square, source_square),
                            .target = @enumFromInt(Square, target_square),

[22.4008]

[20.34441]

                            .source = @as(Square, @enumFromInt(source_square)),
                            .target = @as(Square, @enumFromInt(target_square)),

Replacement in src/Board.zig at line 601 [20.16071]

B:BD[22.4165] → [3.7517:7659]

                        .source = @enumFromInt(Square, source_square),
                        .target = @enumFromInt(Square, target_square),

[22.4165]

[20.34836]

                        .source = @as(Square, @enumFromInt(source_square)),
                        .target = @as(Square, @enumFromInt(target_square)),

Replacement in src/Board.zig at line 619 [20.16071]

B:BD[20.35387] → [20.35387:35483]

                    const target_enpassant: SquareType = @intCast(u6, @ctz(enpassant_attacks));

[20.35387]

[22.4272]

                    const target_enpassant: SquareType = @as(u6, @intCast(@ctz(enpassant_attacks)));

Replacement in src/Board.zig at line 621 [20.16071]

B:BD[22.4314] → [3.7844:7989]

                        .source = @enumFromInt(Square, source_square),
                        .target = @enumFromInt(Square, target_enpassant),

[22.4314]

[20.35675]

                        .source = @as(Square, @enumFromInt(source_square)),
                        .target = @as(Square, @enumFromInt(target_enpassant)),

Replacement in src/Board.zig at line 723 [20.16071]

B:BD[20.38966] → [20.38966:39029]

            source_square = @intCast(SquareType, @ctz(board));

[20.38966]

[20.39029]

            source_square = @as(SquareType, @intCast(@ctz(board)));

Replacement in src/Board.zig at line 735 [20.16071]

B:BD[20.39819] → [3.8440:8521]

                ~@bitCast(BoardType, self.occupancies[@intFromEnum(self.side)]);

[20.39819]

[20.39877]

                ~@as(BoardType, @bitCast(self.occupancies[@intFromEnum(self.side)]));

Replacement in src/Board.zig at line 738 [20.16071]

B:BD[20.39913] → [20.39913:39982]

                target_square = @intCast(SquareType, @ctz(attacks));

[20.39913]

[20.39982]

                target_square = @as(SquareType, @intCast(@ctz(attacks)));

Replacement in src/Board.zig at line 740 [20.16071]

B:BD[20.39983] → [3.8522:8638]

                if (self.occupancies[@intFromEnum(self.side.enemy())].isSet(@enumFromInt(Square, target_square))) {

[20.39983]

[22.4719]

                if (self.occupancies[@intFromEnum(self.side.enemy())].isSet(@as(Square, @enumFromInt(target_square)))) {

Replacement in src/Board.zig at line 742 [20.16071]

B:BD[22.4761] → [3.8639:8781]

                        .source = @enumFromInt(Square, source_square),
                        .target = @enumFromInt(Square, target_square),

[22.4761]

[20.40314]

                        .source = @as(Square, @enumFromInt(source_square)),
                        .target = @as(Square, @enumFromInt(target_square)),

Replacement in src/Board.zig at line 750 [20.16071]

B:BD[22.4910] → [3.8782:8924]

                        .source = @enumFromInt(Square, source_square),
                        .target = @enumFromInt(Square, target_square),

[22.4910]

[20.40633]

                        .source = @as(Square, @enumFromInt(source_square)),
                        .target = @as(Square, @enumFromInt(target_square)),

Replacement in src/Board.zig at line 849 [20.16071]

B:BD[3.10042] → [3.10042:10137]

                                    .pop(@enumFromInt(Square, @intFromEnum(move.target) + 8));

[3.10042]

[5.1678]

                                    .pop(@as(Square, @enumFromInt(@intFromEnum(move.target) + 8)));

Replacement in src/Board.zig at line 856 [20.16071]

B:BD[3.10327] → [3.10327:10422]

                                    .pop(@enumFromInt(Square, @intFromEnum(move.target) - 8));

[3.10327]

[5.2110]

                                    .pop(@as(Square, @enumFromInt(@intFromEnum(move.target) - 8)));

Replacement in src/Board.zig at line 873 [20.16071]

B:BD[29.2994] → [3.10635:10817]

                            .white => @enumFromInt(Square, @intFromEnum(move.target) + 8),
                            .black => @enumFromInt(Square, @intFromEnum(move.target) - 8),

[29.2994]

[29.3168]

                            .white => @as(Square, @enumFromInt(@intFromEnum(move.target) + 8)),
                            .black => @as(Square, @enumFromInt(@intFromEnum(move.target) - 8)),

Replacement in src/Board.zig at line 931 [20.16071]

B:BD[5.3835] → [5.3835:3930]

                    self.hash ^= zobrist.castle_hashes[@bitCast(CastlingType, self.castling)];

[5.3835]

[24.2505]

                    self.hash ^= zobrist.castle_hashes[@as(CastlingType, @bitCast(self.castling))];

Replacement in src/Board.zig at line 938 [20.16071]

B:BD[5.4078] → [5.4078:4173]

                    self.hash ^= zobrist.castle_hashes[@bitCast(CastlingType, self.castling)];

[5.4078]

[29.3270]

                    self.hash ^= zobrist.castle_hashes[@as(CastlingType, @bitCast(self.castling))];

Replacement in src/Board.zig at line 945 [20.16071]

B:BD[29.3500] → [3.12571:12662]

                        white |= @bitCast(BoardType, self.bitboards[@intFromEnum(piece)]);

[29.3500]

[29.3583]

                        white |= @as(BoardType, @bitCast(self.bitboards[@intFromEnum(piece)]));

Replacement in src/Board.zig at line 948 [20.16071]

B:BD[29.3679] → [3.12663:12754]

                        black |= @bitCast(BoardType, self.bitboards[@intFromEnum(piece)]);

[29.3679]

[30.7745]

                        black |= @as(BoardType, @bitCast(self.bitboards[@intFromEnum(piece)]));

Replacement in src/Board.zig at line 951 [20.16071]

B:BD[30.7768] → [3.12755:12955]

                    self.occupancies[@intFromEnum(Chess.Colors.white)] = @bitCast(BitBoard, white);
                    self.occupancies[@intFromEnum(Chess.Colors.black)] = @bitCast(BitBoard, black);

[30.7768]

[29.3959]

                    self.occupancies[@intFromEnum(Chess.Colors.white)] = @as(BitBoard, @bitCast(white));
                    self.occupancies[@intFromEnum(Chess.Colors.black)] = @as(BitBoard, @bitCast(black));

Replacement in src/Board.zig at line 972 [20.16071]

B:BD[31.2479] → [3.12956:13084]

∅:D[3.13084] → [31.2603:2619]

B:BD[31.2603] → [31.2603:2619]

B:BD[31.2619] → [3.13085:13213]

∅:D[3.13213] → [31.2743:2759]

B:BD[31.2743] → [31.2743:2759]

            .white => @enumFromInt(Square, @ctz(
                @bitCast(BoardType, self.bitboards[@intFromEnum(Chess.PE.K)]),
            )),
            .black => @enumFromInt(Square, @ctz(
                @bitCast(BoardType, self.bitboards[@intFromEnum(Chess.PE.k)]),
            )),

[31.2479]

[31.2759]

            .white => @as(Square, @enumFromInt(@ctz(
                @as(BoardType, @bitCast(self.bitboards[@intFromEnum(Chess.PE.K)])),
            ))),
            .black => @as(Square, @enumFromInt(@ctz(
                @as(BoardType, @bitCast(self.bitboards[@intFromEnum(Chess.PE.k)])),
            ))),

Replacement in src/Board.zig at line 1030 [20.16071]

B:BD[20.41945] → [20.41945:42022]

    try std.testing.expectEqual(@as(u4, 0b1111), @bitCast(u4, gs.castling));

[20.41945]

[32.2083]

    try std.testing.expectEqual(@as(u4, 0b1111), @as(u4, @bitCast(gs.castling)));

Replacement in src/Attacks.zig at line 45 [34.204]

B:BD[33.3794] → [20.3025:3129]

            const occupancy_idx = @as(Board.BoardType, 1) << @intCast(Board.SquareType, relevant_bits);

[33.3794]

[33.3884]

            const occupancy_idx = @as(Board.BoardType, 1) << @as(Board.SquareType, @intCast(relevant_bits));

Replacement in src/Attacks.zig at line 54 [34.204]

B:BD[33.4348] → [26.250:354]

                            @intCast(Board.SquareType, @as(u7, 64) - bishop_relevant_bits[square_int]);

[33.4348]

[33.4440]

                            @as(Board.SquareType, @intCast(@as(u7, 64) - bishop_relevant_bits[square_int]));

Replacement in src/Attacks.zig at line 63 [34.204]

B:BD[33.4946] → [26.523:625]

                            @intCast(Board.SquareType, @as(u7, 64) - rook_relevant_bits[square_int]);

[33.4946]

[33.5036]

                            @as(Board.SquareType, @intCast(@as(u7, 64) - rook_relevant_bits[square_int]));

Replacement in src/Attacks.zig at line 80 [34.204]

∅:D[26.937] → [35.280:347]

B:BD[35.280] → [35.280:347]

B:BD[35.347] → [26.938:981]

        mut_occupancy >>= @intCast(Board.SquareType, @as(u7, 64) -
            bishop_relevant_bits[square]);

[26.937]

[33.5667]

        mut_occupancy >>= @as(Board.SquareType, @intCast(@as(u7, 64) -
            bishop_relevant_bits[square]));

Replacement in src/Attacks.zig at line 92 [34.204]

∅:D[26.1278] → [35.483:550]

B:BD[35.483] → [35.483:550]

B:BD[35.550] → [26.1279:1320]

        mut_occupancy >>= @intCast(Board.SquareType, @as(u7, 64) -
            rook_relevant_bits[square]);

[26.1278]

[33.6105]

        mut_occupancy >>= @as(Board.SquareType, @intCast(@as(u7, 64) -
            rook_relevant_bits[square]));

Replacement in src/Attacks.zig at line 112 [34.204]
∅:D[3.13774] → [26.1567:1613]
B:BD[26.1567] → [26.1567:1613]
```
        @bitCast(Board.BoardType, occupancy),
```
[3.13774]
[26.1613]
```
        @as(Board.BoardType, @bitCast(occupancy)),
```

Replacement in src/Attacks.zig at line 118 [34.204]

B:BD[36.937] → [20.4920:4995]

    try std.testing.expectEqual(@bitCast(Board.BoardType, expected), got);

[36.937]

[36.1012]

    try std.testing.expectEqual(@as(Board.BoardType, @bitCast(expected)), got);

Replacement in src/Attacks.zig at line 141 [34.204]

B:BD[34.955] → [20.5365:5412]

                @bitCast(Board.BoardType, bb),

[34.955]

[3.13869]

                @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 150 [34.204]

B:BD[34.1219] → [20.5534:5581]

                @bitCast(Board.BoardType, bb),

[34.1219]

[3.13955]

                @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 159 [34.204]

B:BD[34.1484] → [20.5703:5750]

                @bitCast(Board.BoardType, bb),

[34.1484]

[3.14041]

                @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 169 [34.204]

B:BD[34.1769] → [20.5927:5974]

                @bitCast(Board.BoardType, bb),

[34.1769]

[3.14127]

                @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 178 [34.204]

B:BD[34.2033] → [20.6096:6143]

                @bitCast(Board.BoardType, bb),

[34.2033]

[3.14213]

                @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 187 [34.204]

B:BD[34.2298] → [20.6265:6312]

                @bitCast(Board.BoardType, bb),

[34.2298]

[3.14299]

                @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 211 [34.204]

B:BD[34.2984] → [20.6710:6753]

            @bitCast(Board.BoardType, bb),

[34.2984]

[3.14457]

            @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 219 [34.204]

B:BD[34.3219] → [20.6906:6949]

            @bitCast(Board.BoardType, bb),

[34.3219]

[3.14505]

            @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 227 [34.204]

B:BD[34.3444] → [20.7092:7135]

            @bitCast(Board.BoardType, bb),

[34.3444]

[3.14553]

            @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 250 [34.204]

B:BD[34.4068] → [20.7495:7538]

            @bitCast(Board.BoardType, bb),

[34.4068]

[3.14671]

            @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 258 [34.204]

B:BD[34.4302] → [20.7686:7729]

            @bitCast(Board.BoardType, bb),

[34.4302]

[3.14719]

            @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 266 [34.204]

B:BD[34.4536] → [20.7877:7920]

            @bitCast(Board.BoardType, bb),

[34.4536]

[3.14767]

            @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 274 [34.204]

B:BD[34.4761] → [20.8058:8101]

            @bitCast(Board.BoardType, bb),

[34.4761]

[3.14815]

            @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 297 [34.204]

B:BD[34.5375] → [20.8451:8494]

            @bitCast(Board.BoardType, bb),

[34.5375]

[3.14935]

            @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 320 [34.204]

B:BD[37.668] → [20.8867:8910]

            @bitCast(Board.BoardType, bb),

[37.668]

[3.15053]

            @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 328 [34.204]

B:BD[37.918] → [20.9093:9136]

            @bitCast(Board.BoardType, bb),

[37.918]

[3.15101]

            @as(Board.BoardType, @bitCast(bb)),

Replacement in src/Attacks.zig at line 335 [34.204]
∅:D[38.98] → [34.5557:5655]
∅:D[39.99] → [34.5557:5655]
∅:D[33.6783] → [34.5557:5655]
∅:D[20.9276] → [34.5557:5655]
B:BD[34.5557] → [34.5557:5655]
```
    const rank = @intCast(isize, square.rank());
    const file = @intCast(isize, square.file());
```
[20.9276]
[34.5655]
```
    const rank = @as(isize, @intCast(square.rank()));
    const file = @as(isize, @intCast(square.file()));
```

Replacement in src/Attacks.zig at line 383 [34.204]

B:BD[34.7262] → [20.9367:9439]

            const s = @intCast(Board.SquareType, dr * Board.SIZE + df);

[34.7262]

[34.7320]

            const s = @as(Board.SquareType, @intCast(dr * Board.SIZE + df));

Replacement in src/Attacks.zig at line 394 [34.204]

∅:D[20.9601] → [40.137:235]

B:BD[40.137] → [40.137:235]

    const rank = @intCast(isize, square.rank());
    const file = @intCast(isize, square.file());

[20.9601]

[40.235]

    const rank = @as(isize, @intCast(square.rank()));
    const file = @as(isize, @intCast(square.file()));

Replacement in src/Attacks.zig at line 426 [34.204]

B:BD[40.977] → [20.9692:9764]

            const s = @intCast(Board.SquareType, dr * Board.SIZE + df);

[40.977]

[20.9764]

            const s = @as(Board.SquareType, @intCast(dr * Board.SIZE + df));

Replacement in src/Attacks.zig at line 444 [34.204]

B:BD[40.1405] → [20.9920:10008]

        const got = attackWithBlocker(@bitCast(Board.BoardType, blocks), .d4, .bishop);

[40.1405]

[40.1468]

        const got = attackWithBlocker(@as(Board.BoardType, @bitCast(blocks)), .d4, .bishop);

Replacement in src/Attacks.zig at line 449 [34.204]

B:BD[41.3] → [20.10131:10203]

        try std.testing.expectEqual(bb, @bitCast(Board.BitBoard, got));

[41.3]

[40.1630]

        try std.testing.expectEqual(bb, @as(Board.BitBoard, @bitCast(got)));

Replacement in src/Attacks.zig at line 456 [34.204]

B:BD[40.1733] → [20.10304:10390]

        const got = attackWithBlocker(@bitCast(Board.BoardType, blocks), .d4, .rook);

[40.1733]

[40.1794]

        const got = attackWithBlocker(@as(Board.BoardType, @bitCast(blocks)), .d4, .rook);

Replacement in src/Attacks.zig at line 461 [34.204]

B:BD[40.1899] → [20.10508:10580]

        try std.testing.expectEqual(bb, @bitCast(Board.BitBoard, got));

[40.1899]

[40.1951]

        try std.testing.expectEqual(bb, @as(Board.BitBoard, @bitCast(got)));

Replacement in src/Attacks.zig at line 468 [34.204]

B:BD[40.2042] → [20.10669:10755]

        const got = attackWithBlocker(@bitCast(Board.BoardType, blocks), .h8, .rook);

[40.2042]

[40.2103]

        const got = attackWithBlocker(@as(Board.BoardType, @bitCast(blocks)), .h8, .rook);

Replacement in src/Attacks.zig at line 473 [34.204]

B:BD[40.2233] → [20.10898:10970]

        try std.testing.expectEqual(bb, @bitCast(Board.BitBoard, got));

[40.2233]

[40.2285]

        try std.testing.expectEqual(bb, @as(Board.BitBoard, @bitCast(got)));

Replacement in src/Attacks.zig at line 484 [34.204]

B:BD[41.288] → [20.11207:11272]

        const square = @intCast(Board.SquareType, @ctz(attack));

[41.288]

[41.331]

        const square = @as(Board.SquareType, @intCast(@ctz(attack)));

Replacement in src/Attacks.zig at line 507 [34.204]

B:BD[41.901] → [20.11698:11778]

    try std.testing.expectEqual(expected, @bitCast(Board.BitBoard, occupancy));

[41.901]

[41.955]

    try std.testing.expectEqual(expected, @as(Board.BitBoard, @bitCast(occupancy)));

Replacement in src/Attacks.zig at line 515 [34.204]

B:BD[41.1206] → [3.15149:15206]

        ret[@intFromEnum(square)] = @intCast(u4, count);

[41.1206]

[41.1261]

        ret[@intFromEnum(square)] = @as(u4, @intCast(count));

Replacement in src/Attacks.zig at line 597 [34.204]

B:BD[35.851] → [35.851:981]

            var magic_index: usize = @intCast(usize, tmp2 >>
                @intCast(Board.SquareType, @as(u7, 64) - relevant));

[35.851]

[41.4032]

            var magic_index: usize = @as(usize, @intCast(tmp2 >>
                @as(Board.SquareType, @intCast(@as(u7, 64) - relevant))));