voroskoi/pistike - Change IFTGZLOBWFXQPOKZFLNKDMFBQJLDI5BC5UXICLHKVHZB5LEVLEIQC

update to zig master

Created by voroskoi on June 27, 2023

IFTGZLOBWFXQPOKZFLNKDMFBQJLDI5BC5UXICLHKVHZB5LEVLEIQC

Dependencies

In channels

main

Change contents

Replacement in src/zobrist.zig at line 19 [5.36]

B:BD[5.588] → [5.588:655]

    for (piece_hashes) |pieces, i| {
        for (pieces) |_, j| {

[5.588]

[5.655]

    for (piece_hashes, 0..) |pieces, i| {
        for (pieces, 0..) |_, j| {

Replacement in src/zobrist.zig at line 25 [5.36]
B:BD[5.717] → [5.717:752]
```
    for (enpassant_hashes) |*ep| {
```
[5.717]
[5.752]
```
    for (&enpassant_hashes) |*ep| {
```
Replacement in src/zobrist.zig at line 29 [5.36]
B:BD[5.786] → [5.786:819]
```
    for (castle_hashes) |*cas| {
```
[5.786]
[5.819]
```
    for (&castle_hashes) |*cas| {
```
Replacement in src/zobrist.zig at line 39 [5.36]
B:BD[5.962] → [5.962:999]
```
    for (gs.bitboards) |bb, piece| {
```
[5.962]
[5.999]
```
    for (gs.bitboards, 0..) |bb, piece| {
```

Replacement in src/zobrist.zig at line 52 [5.36]

B:BD[5.1307] → [5.1307:1372]

        gs.hash ^= enpassant_hashes[@enumToInt(gs.enpassant.?)];

[5.1307]

[5.1372]

        gs.hash ^= enpassant_hashes[@intFromEnum(gs.enpassant.?)];

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

B:BD[6.2041] → [6.2041:2205]

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

[6.2041]

[6.2205]

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

Replacement in src/score.zig at line 46 [7.2114]

B:BD[7.2891] → [8.2831:2911]

            if (search.state.bitboards[@enumToInt(piece)].isSet(move.target)) {

[7.2891]

[7.2961]

            if (search.state.bitboards[@intFromEnum(piece)].isSet(move.target)) {

Replacement in src/score.zig at line 51 [7.2114]

B:BD[7.3046] → [7.3046:3136]

        return MVV_LVA[@enumToInt(move.piece)][@enumToInt(target_piece)] + CAPTURE_BOOST;

[7.3046]

[7.3136]

        return MVV_LVA[@intFromEnum(move.piece)][@intFromEnum(target_piece)] + CAPTURE_BOOST;

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

B:BD[7.3681] → [7.3681:3761]

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

[7.3681]

[7.3761]

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

Replacement in src/nnue.zig at line 32 [9.33]

B:BD[9.1122] → [9.1122:1174]

        const square = @enumToInt(Board.Square.a8);

[9.1122]

[9.1174]

        const square = @intFromEnum(Board.Square.a8);

Replacement in src/nnue.zig at line 37 [9.33]

B:BD[9.1304] → [9.1304:1356]

        const square = @enumToInt(Board.Square.f3);

[9.1304]

[9.1356]

        const square = @intFromEnum(Board.Square.f3);

Replacement in src/nnue.zig at line 70 [9.33]
B:BD[9.2014] → [9.2014:2049]
```
    for (gs.bitboards) |bb, idx| {
```
[9.2014]
[9.2049]
```
    for (gs.bitboards, 0..) |bb, idx| {
```

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

B:BD[9.2131] → [9.2131:2184]

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

[9.2131]

[9.2184]

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

Replacement in src/nnue.zig at line 78 [9.33]

B:BD[9.2281] → [9.2281:2418]

                    sf_pieces[0] = NNUE_PIECES[@enumToInt(piece)];
                    sf_squares[0] = @enumToInt(NNUE_SQUARES[square]);

[9.2281]

[9.2418]

                    sf_pieces[0] = NNUE_PIECES[@intFromEnum(piece)];
                    sf_squares[0] = @intFromEnum(NNUE_SQUARES[square]);

Replacement in src/nnue.zig at line 82 [9.33]

B:BD[9.2461] → [9.2461:2598]

                    sf_pieces[1] = NNUE_PIECES[@enumToInt(piece)];
                    sf_squares[1] = @enumToInt(NNUE_SQUARES[square]);

[9.2461]

[9.2598]

                    sf_pieces[1] = NNUE_PIECES[@intFromEnum(piece)];
                    sf_squares[1] = @intFromEnum(NNUE_SQUARES[square]);

Replacement in src/nnue.zig at line 86 [9.33]

B:BD[9.2643] → [9.2643:2788]

                    sf_pieces[index] = NNUE_PIECES[@enumToInt(piece)];
                    sf_squares[index] = @enumToInt(NNUE_SQUARES[square]);

[9.2643]

[9.2788]

                    sf_pieces[index] = NNUE_PIECES[@intFromEnum(piece)];
                    sf_squares[index] = @intFromEnum(NNUE_SQUARES[square]);

Replacement in src/nnue.zig at line 107 [9.33]
B:BD[3.47] → [3.47:76]
```
        @enumToInt(gs.side),
```
[3.47]
[3.76]
```
        @intFromEnum(gs.side),
```
Replacement in src/eval.zig at line 110 [10.33]
B:BD[2.211] → [2.211:246]
```
    for (gs.bitboards) |bb, idx| {
```
[2.211]
[2.246]
```
    for (gs.bitboards, 0..) |bb, idx| {
```

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

B:BD[9.3941] → [2.450:508]

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

[9.3941]

[2.508]

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

Replacement in src/eval.zig at line 126 [10.33]

B:BD[2.736] → [2.736:1070]

                .p => -PAWN_SCORE[@enumToInt(MIRROR_SCORE[bit])],
                .n => -KNIGHT_SCORE[@enumToInt(MIRROR_SCORE[bit])],
                .b => -BISHOP_SCORE[@enumToInt(MIRROR_SCORE[bit])],
                .r => -ROOK_SCORE[@enumToInt(MIRROR_SCORE[bit])],
                .k => -KING_SCORE[@enumToInt(MIRROR_SCORE[bit])],

[2.736]

[2.1070]

                .p => -PAWN_SCORE[@intFromEnum(MIRROR_SCORE[bit])],
                .n => -KNIGHT_SCORE[@intFromEnum(MIRROR_SCORE[bit])],
                .b => -BISHOP_SCORE[@intFromEnum(MIRROR_SCORE[bit])],
                .r => -ROOK_SCORE[@intFromEnum(MIRROR_SCORE[bit])],
                .k => -KING_SCORE[@intFromEnum(MIRROR_SCORE[bit])],

Insertion in src/Transposition.zig at line 78 [11.354]
[11.2088]
[11.2088]
```
        .best = @bitCast(BitMove, @as(BitMoveType, 0)),
```

Replacement in src/Search.zig at line 296 [13.35]

B:BD[12.94] → [12.94:195]

                    self.state.hash ^= zobrist.enpassant_hashes[@enumToInt(self.state.enpassant.?)];

[12.94]

[12.195]

                    self.state.hash ^= zobrist.enpassant_hashes[@intFromEnum(self.state.enpassant.?)];

Replacement in src/Search.zig at line 331 [13.35]

B:BD[14.428] → [8.7675:7752]

        std.sort.sort(MovePrio, ml.slice(), {}, comptime MovePrio.moreThan);

[14.428]

[11.3164]

        std.mem.sort(MovePrio, ml.slice(), {}, comptime MovePrio.moreThan);

Replacement in src/Search.zig at line 398 [13.35]

B:BD[8.10675] → [8.10675:10780]

                    score.history_moves[@enumToInt(mp.move.piece)][@enumToInt(mp.move.target)] += depth;

[8.10675]

[8.10780]

                    score.history_moves[@intFromEnum(mp.move.piece)][@intFromEnum(mp.move.target)] += depth;

Replacement in src/Search.zig at line 506 [13.35]

∅:D[4.850] → [8.12388:12465]

B:BD[8.12388] → [8.12388:12465]

        std.sort.sort(MovePrio, ml.slice(), {}, comptime MovePrio.moreThan);

[4.850]

[13.4435]

        std.mem.sort(MovePrio, ml.slice(), {}, comptime MovePrio.moreThan);

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

B:BD[15.3090] → [16.2018:2097]

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

[15.3090]

[17.232]

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

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

B:BD[17.468] → [17.468:568]

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

[17.468]

[17.568]

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

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

B:BD[17.810] → [17.810:910]

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

[17.810]

[17.910]

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

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

B:BD[18.16817] → [19.1747:1801]

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

[18.16817]

[18.16865]

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

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

B:BD[18.16908] → [19.1802:1856]

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

[18.16908]

[18.16956]

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

Replacement in src/Board.zig at line 51 [18.16071]

B:BD[18.18180] → [20.83:134]

        ret |= @as(BoardType, 1) << @enumToInt(s);

[18.18180]

[18.18219]

        ret |= @as(BoardType, 1) << @intFromEnum(s);

Replacement in src/Board.zig at line 58 [18.16071]

B:BD[18.18416] → [19.1857:1917]

            ret |= @as(BoardType, 1) << @enumToInt(square);

[18.18416]

[18.18470]

            ret |= @as(BoardType, 1) << @intFromEnum(square);

Replacement in src/Board.zig at line 65 [18.16071]

B:BD[20.233] → [20.233:297]

        return (ret & @as(BoardType, 1) << @enumToInt(s) != 0);

[20.233]

[18.18522]

        return (ret & @as(BoardType, 1) << @intFromEnum(s) != 0);

Replacement in src/Board.zig at line 70 [18.16071]

B:BD[20.390] → [20.390:441]

        ret ^= @as(BoardType, 1) << @enumToInt(s);

[20.390]

[20.441]

        ret ^= @as(BoardType, 1) << @intFromEnum(s);

Replacement in src/Board.zig at line 76 [18.16071]

B:BD[21.94] → [21.94:148]

        ret &= ~(@as(BoardType, 1) << @enumToInt(s));

[21.94]

[21.148]

        ret &= ~(@as(BoardType, 1) << @intFromEnum(s));

Replacement in src/Board.zig at line 182 [18.16071]

B:BD[22.631] → [22.631:681]

            CASTLING_RIGHTS[@enumToInt(square)]);

[22.631]

[23.1269]

            CASTLING_RIGHTS[@intFromEnum(square)]);

Replacement in src/Board.zig at line 189 [18.16071]
B:BD[18.19984] → [18.19984:20010]
```
        for (bbs) |*bb| {
```
[18.19984]
[18.20010]
```
        for (&bbs) |*bb| {
```
Replacement in src/Board.zig at line 197 [18.16071]
B:BD[21.316] → [21.316:342]
```
        for (bbs) |*bb| {
```
[21.316]
[21.342]
```
        for (&bbs) |*bb| {
```
Replacement in src/Board.zig at line 227 [18.16071]
B:BD[18.20507] → [18.20507:20544]
```
        for (self.bitboards) |*bb| {
```
[18.20507]
[21.415]
```
        for (&self.bitboards) |*bb| {
```
Replacement in src/Board.zig at line 230 [18.16071]
B:BD[21.449] → [21.449:488]
```
        for (self.occupancies) |*bb| {
```
[21.449]
[18.20544]
```
        for (&self.occupancies) |*bb| {
```
Replacement in src/Board.zig at line 252 [18.16071]
∅:D[24.976] → [18.21077:21118]
B:BD[18.21077] → [18.21077:21118]
```
        for (self.bitboards) |bb, idx| {
```
[24.976]
[18.21118]
```
        for (self.bitboards, 0..) |bb, idx| {
```

Replacement in src/Board.zig at line 255 [18.16071]

B:BD[18.21168] → [18.21168:21212]

        for (self.occupancies) |occ, idx| {

[18.21168]

[18.21212]

        for (self.occupancies, 0..) |occ, idx| {

Replacement in src/Board.zig at line 266 [18.16071]
∅:D[24.1040] → [18.21465:21505]
∅:D[25.3009] → [18.21465:21505]
B:BD[18.21465] → [18.21465:21505]
```
        for (bck.bitboards) |bb, idx| {
```
[24.1040]
[18.21505]
```
        for (bck.bitboards, 0..) |bb, idx| {
```

Replacement in src/Board.zig at line 269 [18.16071]

B:BD[18.21553] → [18.21553:21596]

        for (bck.occupancies) |occ, idx| {

[18.21553]

[18.21596]

        for (bck.occupancies, 0..) |occ, idx| {

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

∅:D[19.1966] → [21.489:659]

B:BD[18.21806] → [21.489:659]

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

[19.1966]

[18.21934]

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

Replacement in src/Board.zig at line 294 [18.16071]

B:BD[18.22319] → [18.22319:22368]

                for (self.bitboards) |bb, idx| {

[18.22319]

[18.22368]

                for (self.bitboards, 0..) |bb, idx| {

Replacement in src/Board.zig at line 296 [18.16071]

B:BD[18.22456] → [18.22456:22542]

                        std.debug.print("{c} ", .{@intToEnum(Chess.PE, idx).char()});

[18.22456]

[18.22542]

                        std.debug.print("{c} ", .{@enumFromInt(Chess.PE, idx).char()});

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

∅:D[26.1546] → [20.1073:1148]

B:BD[18.24068] → [20.1073:1148]

B:BD[20.1148] → [21.660:742]

                    const square = @intToEnum(Square, rank * SIZE + file);
                    self.occupancies[@enumToInt(Chess.Colors.white)].set(square);

[26.1546]

[18.24068]

                    const square = @enumFromInt(Square, rank * SIZE + file);
                    self.occupancies[@intFromEnum(Chess.Colors.white)].set(square);

Replacement in src/Board.zig at line 340 [18.16071]

B:BD[18.24102] → [19.1967:2465]

                        'P' => self.bitboards[@enumToInt(Chess.PE.P)].set(square),
                        'N' => self.bitboards[@enumToInt(Chess.PE.N)].set(square),
                        'B' => self.bitboards[@enumToInt(Chess.PE.B)].set(square),
                        'R' => self.bitboards[@enumToInt(Chess.PE.R)].set(square),
                        'Q' => self.bitboards[@enumToInt(Chess.PE.Q)].set(square),
                        'K' => self.bitboards[@enumToInt(Chess.PE.K)].set(square),

[18.24102]

[18.24636]

                        'P' => self.bitboards[@intFromEnum(Chess.PE.P)].set(square),
                        'N' => self.bitboards[@intFromEnum(Chess.PE.N)].set(square),
                        'B' => self.bitboards[@intFromEnum(Chess.PE.B)].set(square),
                        'R' => self.bitboards[@intFromEnum(Chess.PE.R)].set(square),
                        'Q' => self.bitboards[@intFromEnum(Chess.PE.Q)].set(square),
                        'K' => self.bitboards[@intFromEnum(Chess.PE.K)].set(square),

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

∅:D[26.1610] → [20.1612:1687]

B:BD[18.24904] → [20.1612:1687]

B:BD[20.1687] → [21.743:825]

                    const square = @intToEnum(Square, rank * SIZE + file);
                    self.occupancies[@enumToInt(Chess.Colors.black)].set(square);

[26.1610]

[18.24904]

                    const square = @enumFromInt(Square, rank * SIZE + file);
                    self.occupancies[@intFromEnum(Chess.Colors.black)].set(square);

Replacement in src/Board.zig at line 353 [18.16071]

B:BD[18.24938] → [19.2466:2964]

                        'p' => self.bitboards[@enumToInt(Chess.PE.p)].set(square),
                        'n' => self.bitboards[@enumToInt(Chess.PE.n)].set(square),
                        'b' => self.bitboards[@enumToInt(Chess.PE.b)].set(square),
                        'r' => self.bitboards[@enumToInt(Chess.PE.r)].set(square),
                        'q' => self.bitboards[@enumToInt(Chess.PE.q)].set(square),
                        'k' => self.bitboards[@enumToInt(Chess.PE.k)].set(square),

[18.24938]

[18.25472]

                        'p' => self.bitboards[@intFromEnum(Chess.PE.p)].set(square),
                        'n' => self.bitboards[@intFromEnum(Chess.PE.n)].set(square),
                        'b' => self.bitboards[@intFromEnum(Chess.PE.b)].set(square),
                        'r' => self.bitboards[@intFromEnum(Chess.PE.r)].set(square),
                        'q' => self.bitboards[@intFromEnum(Chess.PE.q)].set(square),
                        'k' => self.bitboards[@intFromEnum(Chess.PE.k)].set(square),

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

B:BD[18.26994] → [18.26994:27057]

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

[18.26994]

[5.3087]

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

Replacement in src/Board.zig at line 422 [18.16071]

B:BD[18.27266] → [19.3064:3262]

                const pa = self.attacks.pawn_attacks[@enumToInt(Chess.Colors.black)][square];
                if (pa & @bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.P)]) != 0) return true;

[18.27266]

[18.27464]

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

Replacement in src/Board.zig at line 426 [18.16071]

B:BD[18.27503] → [19.3263:3461]

                const pa = self.attacks.pawn_attacks[@enumToInt(Chess.Colors.white)][square];
                if (pa & @bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.p)]) != 0) return true;

[18.27503]

[18.27701]

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

Replacement in src/Board.zig at line 434 [18.16071]

B:BD[18.27856] → [19.3519:3643]

            .white => self.bitboards[@enumToInt(Chess.PE.N)],
            .black => self.bitboards[@enumToInt(Chess.PE.n)],

[18.27856]

[18.27968]

            .white => self.bitboards[@intFromEnum(Chess.PE.N)],
            .black => self.bitboards[@intFromEnum(Chess.PE.n)],

Replacement in src/Board.zig at line 442 [18.16071]

B:BD[18.28166] → [19.3699:3823]

            .white => self.bitboards[@enumToInt(Chess.PE.K)],
            .black => self.bitboards[@enumToInt(Chess.PE.k)],

[18.28166]

[18.28278]

            .white => self.bitboards[@intFromEnum(Chess.PE.K)],
            .black => self.bitboards[@intFromEnum(Chess.PE.k)],

Replacement in src/Board.zig at line 452 [18.16071]

B:BD[18.28494] → [19.3824:3948]

            .white => self.bitboards[@enumToInt(Chess.PE.B)],
            .black => self.bitboards[@enumToInt(Chess.PE.b)],

[18.28494]

[18.28606]

            .white => self.bitboards[@intFromEnum(Chess.PE.B)],
            .black => self.bitboards[@intFromEnum(Chess.PE.b)],

Replacement in src/Board.zig at line 460 [18.16071]

B:BD[18.28818] → [19.3949:4073]

            .white => self.bitboards[@enumToInt(Chess.PE.R)],
            .black => self.bitboards[@enumToInt(Chess.PE.r)],

[18.28818]

[18.28930]

            .white => self.bitboards[@intFromEnum(Chess.PE.R)],
            .black => self.bitboards[@intFromEnum(Chess.PE.r)],

Replacement in src/Board.zig at line 467 [18.16071]

B:BD[18.29144] → [19.4074:4198]

            .white => self.bitboards[@enumToInt(Chess.PE.Q)],
            .black => self.bitboards[@enumToInt(Chess.PE.q)],

[18.29144]

[18.29256]

            .white => self.bitboards[@intFromEnum(Chess.PE.Q)],
            .black => self.bitboards[@intFromEnum(Chess.PE.q)],

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

B:BD[18.29897] → [19.4347:4429]

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

[18.29897]

[18.29973]

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

Replacement in src/Board.zig at line 525 [18.16071]

B:BD[18.31490] → [18.31490:31748]

                .white => source_square >= @enumToInt(Square.a7) and
                    source_square <= @enumToInt(Square.h7),
                .black => source_square >= @enumToInt(Square.a2) and
                    source_square <= @enumToInt(Square.h2),

[18.31490]

[18.31748]

                .white => source_square >= @intFromEnum(Square.a7) and
                    source_square <= @intFromEnum(Square.h7),
                .black => source_square >= @intFromEnum(Square.a2) and
                    source_square <= @intFromEnum(Square.h2),

Replacement in src/Board.zig at line 534 [18.16071]

B:BD[18.31947] → [18.31947:32087]

                    .white => source_square >= @enumToInt(Square.a2) and
                        source_square <= @enumToInt(Square.h2) and

[18.31947]

[18.32087]

                    .white => source_square >= @intFromEnum(Square.a2) and
                        source_square <= @intFromEnum(Square.h2) and

Replacement in src/Board.zig at line 537 [18.16071]

B:BD[18.32179] → [18.32179:32319]

                    .black => source_square >= @enumToInt(Square.a7) and
                        source_square <= @enumToInt(Square.h7) and

[18.32179]

[18.32319]

                    .black => source_square >= @intFromEnum(Square.a7) and
                        source_square <= @intFromEnum(Square.h7) and

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

∅:D[27.3285] → [18.32578:32724]

∅:D[25.3687] → [18.32578:32724]

B:BD[18.32578] → [18.32578:32724]

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

[27.3285]

[18.32724]

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

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

B:BD[27.3475] → [27.3475:3621]

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

[27.3475]

[27.3621]

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

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

∅:D[25.3779] → [18.33532:33678]

∅:D[27.3847] → [18.33532:33678]

B:BD[18.33532] → [18.33532:33678]

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

[27.3847]

[18.33678]

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

Replacement in src/Board.zig at line 583 [18.16071]

B:BD[18.33903] → [18.33903:33985]

B:BD[18.33985] → [25.3780:3866]

                self.attacks.pawn_attacks[@enumToInt(self.side)][source_square] &
                @bitCast(BoardType, self.occupancies[@enumToInt(self.side.enemy())]);

[18.33903]

[18.34043]

                self.attacks.pawn_attacks[@intFromEnum(self.side)][source_square] &
                @bitCast(BoardType, self.occupancies[@intFromEnum(self.side.enemy())]);

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

∅:D[25.3914] → [18.34295:34441]

∅:D[27.4008] → [18.34295:34441]

B:BD[18.34295] → [18.34295:34441]

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

[27.4008]

[18.34441]

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

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

∅:D[25.3958] → [18.34698:34836]

∅:D[27.4165] → [18.34698:34836]

B:BD[18.34698] → [18.34698:34836]

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

[27.4165]

[18.34836]

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

Replacement in src/Board.zig at line 615 [18.16071]

B:BD[18.35167] → [18.35167:35275]

B:BD[18.35275] → [19.4430:4501]

                const enpassant_attacks = self.attacks.pawn_attacks[@enumToInt(self.side)][source_square] &
                    @as(BoardType, 1) << @enumToInt(self.enpassant.?);

[18.35167]

[18.35340]

                const enpassant_attacks = self.attacks.pawn_attacks[@intFromEnum(self.side)][source_square] &
                    @as(BoardType, 1) << @intFromEnum(self.enpassant.?);

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

∅:D[25.4002] → [18.35534:35675]

∅:D[27.4314] → [18.35534:35675]

B:BD[18.35534] → [18.35534:35675]

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

[27.4314]

[18.35675]

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

Replacement in src/Board.zig at line 653 [18.16071]

B:BD[18.36623] → [19.4502:4613]

                        if (self.occupBoth() & @as(BoardType, 1) << @enumToInt(square) != 0) break :blk false;

[18.36623]

[18.36728]

                        if (self.occupBoth() & @as(BoardType, 1) << @intFromEnum(square) != 0) break :blk false;

Replacement in src/Board.zig at line 658 [18.16071]

B:BD[18.36870] → [19.4614:4722]

                        if (self.isSquareAttacked(@enumToInt(square), self.side.enemy())) break :blk false;

[18.36870]

[18.36959]

                        if (self.isSquareAttacked(@intFromEnum(square), self.side.enemy())) break :blk false;

Replacement in src/Board.zig at line 692 [18.16071]

B:BD[18.37973] → [19.4723:4834]

                        if (self.occupBoth() & @as(BoardType, 1) << @enumToInt(square) != 0) break :blk false;

[18.37973]

[18.38078]

                        if (self.occupBoth() & @as(BoardType, 1) << @intFromEnum(square) != 0) break :blk false;

Replacement in src/Board.zig at line 697 [18.16071]

B:BD[18.38221] → [19.4835:4943]

                        if (self.isSquareAttacked(@enumToInt(square), self.side.enemy())) break :blk false;

[18.38221]

[18.38310]

                        if (self.isSquareAttacked(@intFromEnum(square), self.side.enemy())) break :blk false;

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

B:BD[18.39819] → [21.906:985]

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

[18.39819]

[18.39877]

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

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

B:BD[18.39983] → [25.4457:4569]

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

[18.39983]

[27.4719]

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

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

∅:D[25.4612] → [18.40176:40314]

∅:D[27.4761] → [18.40176:40314]

B:BD[18.40176] → [18.40176:40314]

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

[27.4761]

[18.40314]

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

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

∅:D[25.4656] → [18.40495:40633]

∅:D[27.4910] → [18.40495:40633]

B:BD[18.40495] → [18.40495:40633]

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

[27.4910]

[18.40633]

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

Replacement in src/Board.zig at line 776 [18.16071]

B:BD[20.2434] → [19.5216:5362]

                self.bitboards[@enumToInt(move.piece)].pop(move.source);
                self.bitboards[@enumToInt(move.piece)].set(move.target);

[20.2434]

[22.747]

                self.bitboards[@intFromEnum(move.piece)].pop(move.source);
                self.bitboards[@intFromEnum(move.piece)].set(move.target);

Replacement in src/Board.zig at line 780 [18.16071]

B:BD[22.794] → [22.794:994]

                self.hash ^= zobrist.piece_hashes[@enumToInt(move.piece)][@enumToInt(move.source)];
                self.hash ^= zobrist.piece_hashes[@enumToInt(move.piece)][@enumToInt(move.target)];

[22.794]

[3.834]

                self.hash ^= zobrist.piece_hashes[@intFromEnum(move.piece)][@intFromEnum(move.source)];
                self.hash ^= zobrist.piece_hashes[@intFromEnum(move.piece)][@intFromEnum(move.target)];

Replacement in src/Board.zig at line 820 [18.16071]

B:BD[28.1633] → [19.5363:5535]

                            if (self.bitboards[@enumToInt(piece)].isSet(move.target)) {
                                self.bitboards[@enumToInt(piece)].pop(move.target);

[28.1633]

[22.995]

                            if (self.bitboards[@intFromEnum(piece)].isSet(move.target)) {
                                self.bitboards[@intFromEnum(piece)].pop(move.target);

Replacement in src/Board.zig at line 824 [18.16071]

B:BD[22.1060] → [22.1060:1171]

                                self.hash ^= zobrist.piece_hashes[@enumToInt(piece)][@enumToInt(move.target)];

[22.1060]

[28.1793]

                                self.hash ^= zobrist.piece_hashes[@intFromEnum(piece)][@intFromEnum(move.target)];

Replacement in src/Board.zig at line 835 [18.16071]

B:BD[28.2057] → [19.5536:5617]

                        self.bitboards[@enumToInt(move.piece)].pop(move.target);

[28.2057]

[28.2132]

                        self.bitboards[@intFromEnum(move.piece)].pop(move.target);

Replacement in src/Board.zig at line 837 [18.16071]

B:BD[28.2193] → [19.5618:5698]

                        self.bitboards[@enumToInt(move.prom)].set(move.target);

[28.2193]

[22.1172]

                        self.bitboards[@intFromEnum(move.prom)].set(move.target);

Replacement in src/Board.zig at line 840 [18.16071]

B:BD[22.1208] → [22.1208:1423]

                        self.hash ^= zobrist.piece_hashes[@enumToInt(move.piece)][@enumToInt(move.target)];
                        self.hash ^= zobrist.piece_hashes[@enumToInt(move.prom)][@enumToInt(move.target)];

[22.1208]

[28.2267]

                        self.hash ^= zobrist.piece_hashes[@intFromEnum(move.piece)][@intFromEnum(move.target)];
                        self.hash ^= zobrist.piece_hashes[@intFromEnum(move.prom)][@intFromEnum(move.target)];

Replacement in src/Board.zig at line 848 [18.16071]

B:BD[22.1516] → [22.1516:1678]

                                self.bitboards[@enumToInt(Chess.PE.p)]
                                    .pop(@intToEnum(Square, @enumToInt(move.target) + 8));

[22.1516]

[22.1678]

                                self.bitboards[@intFromEnum(Chess.PE.p)]
                                    .pop(@enumFromInt(Square, @intFromEnum(move.target) + 8));

Replacement in src/Board.zig at line 852 [18.16071]

B:BD[22.1766] → [22.1766:1877]

                                    zobrist.piece_hashes[@enumToInt(Chess.PE.p)][@enumToInt(move.target) + 8];

[22.1766]

[22.1877]

                                    zobrist.piece_hashes[@intFromEnum(Chess.PE.p)][@intFromEnum(move.target) + 8];

Replacement in src/Board.zig at line 855 [18.16071]

B:BD[22.1948] → [22.1948:2110]

                                self.bitboards[@enumToInt(Chess.PE.P)]
                                    .pop(@intToEnum(Square, @enumToInt(move.target) - 8));

[22.1948]

[22.2110]

                                self.bitboards[@intFromEnum(Chess.PE.P)]
                                    .pop(@enumFromInt(Square, @intFromEnum(move.target) - 8));

Replacement in src/Board.zig at line 859 [18.16071]

B:BD[22.2198] → [22.2198:2309]

                                    zobrist.piece_hashes[@enumToInt(Chess.PE.P)][@enumToInt(move.target) - 8];

[22.2198]

[22.2309]

                                    zobrist.piece_hashes[@intFromEnum(Chess.PE.P)][@intFromEnum(move.target) - 8];

Replacement in src/Board.zig at line 865 [18.16071]

B:BD[22.2443] → [22.2443:2536]

                        self.hash ^= zobrist.enpassant_hashes[@enumToInt(self.enpassant.?)];

[22.2443]

[22.2536]

                        self.hash ^= zobrist.enpassant_hashes[@intFromEnum(self.enpassant.?)];

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

B:BD[28.2994] → [28.2994:3168]

                            .white => @intToEnum(Square, @enumToInt(move.target) + 8),
                            .black => @intToEnum(Square, @enumToInt(move.target) - 8),

[28.2994]

[28.3168]

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

Replacement in src/Board.zig at line 878 [18.16071]

B:BD[22.2593] → [22.2593:2679]

                        self.hash ^= zobrist.enpassant_hashes[@enumToInt(enpassant)];

[22.2593]

[28.3247]

                        self.hash ^= zobrist.enpassant_hashes[@intFromEnum(enpassant)];

Replacement in src/Board.zig at line 887 [18.16071]

B:BD[23.1525] → [19.5855:6029]

                                self.bitboards[@enumToInt(Chess.PE.R)].pop(Square.h1);
                                self.bitboards[@enumToInt(Chess.PE.R)].set(Square.f1);

[23.1525]

[25.6185]

                                self.bitboards[@intFromEnum(Chess.PE.R)].pop(Square.h1);
                                self.bitboards[@intFromEnum(Chess.PE.R)].set(Square.f1);

Replacement in src/Board.zig at line 893 [18.16071]

B:BD[22.2724] → [22.2724:2952]

                                self.hash ^= zobrist.piece_hashes[@enumToInt(Chess.PE.R)][@enumToInt(Square.h1)];
                                self.hash ^= zobrist.piece_hashes[@enumToInt(Chess.PE.R)][@enumToInt(Square.f1)];

[22.2724]

[23.1687]

                                self.hash ^= zobrist.piece_hashes[@intFromEnum(Chess.PE.R)][@intFromEnum(Square.h1)];
                                self.hash ^= zobrist.piece_hashes[@intFromEnum(Chess.PE.R)][@intFromEnum(Square.f1)];

Replacement in src/Board.zig at line 897 [18.16071]

B:BD[23.1755] → [19.6030:6204]

                                self.bitboards[@enumToInt(Chess.PE.R)].pop(Square.a1);
                                self.bitboards[@enumToInt(Chess.PE.R)].set(Square.d1);

[23.1755]

[25.6386]

                                self.bitboards[@intFromEnum(Chess.PE.R)].pop(Square.a1);
                                self.bitboards[@intFromEnum(Chess.PE.R)].set(Square.d1);

Replacement in src/Board.zig at line 903 [18.16071]

B:BD[22.2997] → [22.2997:3225]

                                self.hash ^= zobrist.piece_hashes[@enumToInt(Chess.PE.R)][@enumToInt(Square.a1)];
                                self.hash ^= zobrist.piece_hashes[@enumToInt(Chess.PE.R)][@enumToInt(Square.d1)];

[22.2997]

[23.1917]

                                self.hash ^= zobrist.piece_hashes[@intFromEnum(Chess.PE.R)][@intFromEnum(Square.a1)];
                                self.hash ^= zobrist.piece_hashes[@intFromEnum(Chess.PE.R)][@intFromEnum(Square.d1)];

Replacement in src/Board.zig at line 907 [18.16071]

B:BD[23.1985] → [19.6205:6379]

                                self.bitboards[@enumToInt(Chess.PE.r)].pop(Square.h8);
                                self.bitboards[@enumToInt(Chess.PE.r)].set(Square.f8);

[23.1985]

[25.6587]

                                self.bitboards[@intFromEnum(Chess.PE.r)].pop(Square.h8);
                                self.bitboards[@intFromEnum(Chess.PE.r)].set(Square.f8);

Replacement in src/Board.zig at line 913 [18.16071]

B:BD[22.3270] → [22.3270:3498]

                                self.hash ^= zobrist.piece_hashes[@enumToInt(Chess.PE.r)][@enumToInt(Square.h8)];
                                self.hash ^= zobrist.piece_hashes[@enumToInt(Chess.PE.r)][@enumToInt(Square.f8)];

[22.3270]

[23.2147]

                                self.hash ^= zobrist.piece_hashes[@intFromEnum(Chess.PE.r)][@intFromEnum(Square.h8)];
                                self.hash ^= zobrist.piece_hashes[@intFromEnum(Chess.PE.r)][@intFromEnum(Square.f8)];

Replacement in src/Board.zig at line 917 [18.16071]

B:BD[23.2215] → [19.6380:6554]

                                self.bitboards[@enumToInt(Chess.PE.r)].pop(Square.a8);
                                self.bitboards[@enumToInt(Chess.PE.r)].set(Square.d8);

[23.2215]

[25.6788]

                                self.bitboards[@intFromEnum(Chess.PE.r)].pop(Square.a8);
                                self.bitboards[@intFromEnum(Chess.PE.r)].set(Square.d8);

Replacement in src/Board.zig at line 923 [18.16071]

B:BD[22.3543] → [22.3543:3771]

                                self.hash ^= zobrist.piece_hashes[@enumToInt(Chess.PE.r)][@enumToInt(Square.a8)];
                                self.hash ^= zobrist.piece_hashes[@enumToInt(Chess.PE.r)][@enumToInt(Square.d8)];

[22.3543]

[23.2377]

                                self.hash ^= zobrist.piece_hashes[@intFromEnum(Chess.PE.r)][@intFromEnum(Square.a8)];
                                self.hash ^= zobrist.piece_hashes[@intFromEnum(Chess.PE.r)][@intFromEnum(Square.d8)];

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

B:BD[28.3500] → [19.6555:6644]

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

[28.3500]

[28.3583]

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

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

B:BD[28.3679] → [19.6645:6734]

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

[28.3679]

[25.7745]

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

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

B:BD[25.7768] → [28.3763:3959]

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

[25.7768]

[28.3959]

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

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

B:BD[29.2479] → [29.2479:2603]

            .white => @intToEnum(Square, @ctz(
                @bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.K)]),

[29.2479]

[29.2603]

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

Replacement in src/Board.zig at line 975 [18.16071]

B:BD[29.2619] → [29.2619:2743]

            .black => @intToEnum(Square, @ctz(
                @bitCast(BoardType, self.bitboards[@enumToInt(Chess.PE.k)]),

[29.2619]

[29.2743]

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

Replacement in src/Board.zig at line 980 [18.16071]

B:BD[29.2771] → [29.2771:2863]

        if (self.isSquareAttacked(@enumToInt(king_square), self.side.enemy())) return true;

[29.2771]

[29.2863]

        if (self.isSquareAttacked(@intFromEnum(king_square), self.side.enemy())) return true;

Replacement in src/Board.zig at line 994 [18.16071]

B:BD[6.4945] → [6.4945:5070]

        if (game.isSquareAttacked(@enumToInt(square), .white)) {
            got |= @as(BoardType, 1) << @enumToInt(square);

[6.4945]

[6.5070]

        if (game.isSquareAttacked(@intFromEnum(square), .white)) {
            got |= @as(BoardType, 1) << @intFromEnum(square);

Replacement in src/Board.zig at line 1021 [18.16071]

B:BD[18.41668] → [19.7009:7061]

    gs.bitboards[@enumToInt(Chess.PE.P)].b8 = true;

[18.41668]

[18.41714]

    gs.bitboards[@intFromEnum(Chess.PE.P)].b8 = true;

Replacement in src/Board.zig at line 1028 [18.16071]

B:BD[18.41810] → [19.7062:7143]

    try std.testing.expectEqual(false, gs.bitboards[@enumToInt(Chess.PE.P)].h8);

[18.41810]

[18.41885]

    try std.testing.expectEqual(false, gs.bitboards[@intFromEnum(Chess.PE.P)].h8);

Replacement in src/Attacks.zig at line 35 [30.204]

B:BD[18.3024] → [19.0:51]

            const square_int = @enumToInt(square);

[18.3024]

[31.3478]

            const square_int = @intFromEnum(square);

Replacement in src/Attacks.zig at line 61 [30.204]

B:BD[31.4727] → [19.422:522]

                        const res = @mulWithOverflow(occupancy, rook_magic[@enumToInt(square)])[0];

[31.4727]

[31.4895]

                        const res = @mulWithOverflow(occupancy, rook_magic[@intFromEnum(square)])[0];

Replacement in src/Attacks.zig at line 111 [30.204]
B:BD[19.1530] → [19.1530:1567]
```
        @enumToInt(Board.Square.d4),
```
[19.1530]
[19.1567]
```
        @intFromEnum(Board.Square.d4),
```

Replacement in src/Attacks.zig at line 126 [30.204]

∅:D[18.5269] → [30.594:683]

B:BD[30.594] → [30.594:683]

            ret[@enumToInt(color)][@enumToInt(square)] = genSteps(square, .pawn, color);

[18.5269]

[30.683]

            ret[@intFromEnum(color)][@intFromEnum(square)] = genSteps(square, .pawn, color);

Replacement in src/Attacks.zig at line 142 [30.204]

B:BD[18.5412] → [18.5412:5493]

                pa[@enumToInt(Chess.Colors.white)][@enumToInt(Board.Square.d4)],

[18.5412]

[30.1062]

                pa[@intFromEnum(Chess.Colors.white)][@intFromEnum(Board.Square.d4)],

Replacement in src/Attacks.zig at line 151 [30.204]

B:BD[18.5581] → [18.5581:5662]

                pa[@enumToInt(Chess.Colors.white)][@enumToInt(Board.Square.a4)],

[18.5581]

[30.1326]

                pa[@intFromEnum(Chess.Colors.white)][@intFromEnum(Board.Square.a4)],

Replacement in src/Attacks.zig at line 160 [30.204]

B:BD[18.5750] → [18.5750:5831]

                pa[@enumToInt(Chess.Colors.white)][@enumToInt(Board.Square.h4)],

[18.5750]

[30.1591]

                pa[@intFromEnum(Chess.Colors.white)][@intFromEnum(Board.Square.h4)],

Replacement in src/Attacks.zig at line 170 [30.204]

B:BD[18.5974] → [18.5974:6055]

                pa[@enumToInt(Chess.Colors.black)][@enumToInt(Board.Square.d4)],

[18.5974]

[30.1876]

                pa[@intFromEnum(Chess.Colors.black)][@intFromEnum(Board.Square.d4)],

Replacement in src/Attacks.zig at line 179 [30.204]

B:BD[18.6143] → [18.6143:6224]

                pa[@enumToInt(Chess.Colors.black)][@enumToInt(Board.Square.a4)],

[18.6143]

[30.2140]

                pa[@intFromEnum(Chess.Colors.black)][@intFromEnum(Board.Square.a4)],

Replacement in src/Attacks.zig at line 188 [30.204]

B:BD[18.6312] → [18.6312:6393]

                pa[@enumToInt(Chess.Colors.black)][@enumToInt(Board.Square.h4)],

[18.6312]

[30.2405]

                pa[@intFromEnum(Chess.Colors.black)][@intFromEnum(Board.Square.h4)],

Replacement in src/Attacks.zig at line 198 [30.204]

∅:D[18.6592] → [30.2637:2706]

B:BD[30.2637] → [30.2637:2706]

        ret[@enumToInt(square)] = genSteps(square, .knight, .white);

[18.6592]

[30.2706]

        ret[@intFromEnum(square)] = genSteps(square, .knight, .white);

Replacement in src/Attacks.zig at line 212 [30.204]

B:BD[18.6753] → [18.6753:6798]

            ka[@enumToInt(Board.Square.d5)],

[18.6753]

[30.3051]

            ka[@intFromEnum(Board.Square.d5)],

Replacement in src/Attacks.zig at line 220 [30.204]

B:BD[18.6949] → [18.6949:6994]

            ka[@enumToInt(Board.Square.g5)],

[18.6949]

[30.3286]

            ka[@intFromEnum(Board.Square.g5)],

Replacement in src/Attacks.zig at line 228 [30.204]

B:BD[18.7135] → [18.7135:7180]

            ka[@enumToInt(Board.Square.a5)],

[18.7135]

[30.3511]

            ka[@intFromEnum(Board.Square.a5)],

Replacement in src/Attacks.zig at line 237 [30.204]

∅:D[18.7377] → [30.3727:3794]

B:BD[30.3727] → [30.3727:3794]

        ret[@enumToInt(square)] = genSteps(square, .king, .white);

[18.7377]

[30.3794]

        ret[@intFromEnum(square)] = genSteps(square, .king, .white);

Replacement in src/Attacks.zig at line 251 [30.204]

B:BD[18.7538] → [18.7538:7583]

            ka[@enumToInt(Board.Square.d4)],

[18.7538]

[30.4135]

            ka[@intFromEnum(Board.Square.d4)],

Replacement in src/Attacks.zig at line 259 [30.204]

B:BD[18.7729] → [18.7729:7774]

            ka[@enumToInt(Board.Square.a4)],

[18.7729]

[30.4369]

            ka[@intFromEnum(Board.Square.a4)],

Replacement in src/Attacks.zig at line 267 [30.204]

B:BD[18.7920] → [18.7920:7965]

            ka[@enumToInt(Board.Square.d8)],

[18.7920]

[30.4603]

            ka[@intFromEnum(Board.Square.d8)],

Replacement in src/Attacks.zig at line 275 [30.204]

B:BD[18.8101] → [18.8101:8146]

            ka[@enumToInt(Board.Square.h1)],

[18.8101]

[30.4828]

            ka[@intFromEnum(Board.Square.h1)],

Replacement in src/Attacks.zig at line 284 [30.204]

∅:D[18.8343] → [30.5046:5115]

B:BD[30.5046] → [30.5046:5115]

        ret[@enumToInt(square)] = genSteps(square, .bishop, .white);

[18.8343]

[30.5115]

        ret[@intFromEnum(square)] = genSteps(square, .bishop, .white);

Replacement in src/Attacks.zig at line 298 [30.204]

B:BD[18.8494] → [18.8494:8539]

            ba[@enumToInt(Board.Square.a1)],

[18.8494]

[30.5442]

            ba[@intFromEnum(Board.Square.a1)],

Replacement in src/Attacks.zig at line 307 [30.204]

∅:D[18.8734] → [32.325:392]

B:BD[32.325] → [32.325:392]

        ret[@enumToInt(square)] = genSteps(square, .rook, .white);

[18.8734]

[32.392]

        ret[@intFromEnum(square)] = genSteps(square, .rook, .white);

Replacement in src/Attacks.zig at line 321 [30.204]

B:BD[18.8910] → [18.8910:8955]

            ra[@enumToInt(Board.Square.g1)],

[18.8910]

[32.735]

            ra[@intFromEnum(Board.Square.g1)],

Replacement in src/Attacks.zig at line 329 [30.204]

B:BD[18.9136] → [18.9136:9181]

            ra[@enumToInt(Board.Square.h1)],

[18.9136]

[32.985]

            ra[@intFromEnum(Board.Square.h1)],

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

B:BD[33.1206] → [33.1206:1261]

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

[33.1206]

[33.1261]

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

Replacement in src/Attacks.zig at line 621 [30.204]

B:BD[18.12733] → [18.12733:12790]

    for (std.enums.values(Board.Square)) |square, idx| {

[18.12733]

[33.5238]

    for (std.enums.values(Board.Square), 0..) |square, idx| {

Replacement in src/Attacks.zig at line 624 [30.204]

B:BD[33.5303] → [19.1621:1684]

            genRelevantOccupancy(.bishop)[@enumToInt(square)],

[33.5303]

[33.5360]

            genRelevantOccupancy(.bishop)[@intFromEnum(square)],

Replacement in src/Attacks.zig at line 638 [30.204]

B:BD[18.14264] → [18.14264:14321]

    for (std.enums.values(Board.Square)) |square, idx| {

[18.14264]

[33.5392]

    for (std.enums.values(Board.Square), 0..) |square, idx| {

Replacement in src/Attacks.zig at line 641 [30.204]

B:BD[33.5455] → [19.1685:1746]

            genRelevantOccupancy(.rook)[@enumToInt(square)],

[33.5455]

[33.5510]

            genRelevantOccupancy(.rook)[@intFromEnum(square)],

Replacement in build.zig at line 13 [34.3504]

B:BD[34.4064] → [34.4064:4109]

    const mode = b.standardReleaseOptions();

[34.4064]

[35.173]

    const optimize = b.standardOptimizeOption(.{});

Replacement in build.zig at line 58 [34.3504]

∅:D[36.54457] → [34.4110:4170]

B:BD[34.4110] → [34.4110:4170]

    const exe = b.addExecutable("pistike", "src/main.zig");

[36.54457]

[35.323]

    const exe = b.addExecutable(std.build.ExecutableOptions{
        .name = "pistike",
        .root_source_file = .{ .path = "src/main.zig" },
        .target = target,
        .optimize = optimize,
    });

Replacement in build.zig at line 70 [34.3504]
∅:D[35.553] → [34.4170:4244]
∅:D[37.1507] → [34.4170:4244]
∅:D[7.7071] → [34.4170:4244]
∅:D[36.54642] → [34.4170:4244]
B:BD[34.4170] → [34.4170:4244]
```
    exe.setTarget(target);
    exe.setBuildMode(mode);
    exe.install();
```
[35.553]
[34.4244]
```
    b.installArtifact(exe);
```
Replacement in build.zig at line 73 [34.3504]
B:BD[34.4245] → [34.4245:4276]
```
    const run_cmd = exe.run();
```
[34.4245]
[34.4276]
```
    const run_cmd = b.addRunArtifact(exe);
```

Replacement in build.zig at line 82 [34.3504]

B:BD[34.4476] → [34.4476:4525]

    const exe_tests = b.addTest("src/main.zig");

[34.4476]

[35.554]

    const exe_tests = b.addTest(std.build.TestOptions{
        .root_source_file = .{ .path = "src/main.zig" },
    });

Replacement in build.zig at line 91 [34.3504]
∅:D[35.808] → [34.4525:4592]
∅:D[37.1606] → [34.4525:4592]
∅:D[36.54857] → [34.4525:4592]
B:BD[34.4525] → [34.4525:4592]
```
    exe_tests.setTarget(target);
    exe_tests.setBuildMode(mode);
```
[35.808]
[34.4592]
```
    b.installArtifact(exe_tests);
```