voroskoi/pistike - Change YCH5WGGP3PPG2PUNVJIJ6SQXDPYU7NGCVQEJYN27B6FYV5JYQOMQC

Change BitBoard representation

Created by voroskoi on January 5, 2023

YCH5WGGP3PPG2PUNVJIJ6SQXDPYU7NGCVQEJYN27B6FYV5JYQOMQC

Dependencies

In channels

main

Change contents

Deletion in src/attacks.zig at line 108 [4.204]
B:BD[4.740] → [4.740:774]
```
    var bb: Chess.BitBoard = .{};
```
Replacement in src/attacks.zig at line 112 [4.204]
B:BD[4.833] → [4.833:859]
```
            bb.board = 0;
```
[4.833]
[4.859]
```
            var bb = Chess.BitBoard{};
```

Replacement in src/attacks.zig at line 115 [4.204]

B:BD[4.955] → [4.955:981]

                bb.board,

[4.955]

[4.981]

                @bitCast(Chess.BoardType, bb),

Replacement in src/attacks.zig at line 121 [4.204]

B:BD[4.1127] → [4.1127:1178]

            bb.board = 0;
            bb.set(.b5);

[4.1127]

[4.1178]

            var bb = Chess.BitBoard{};
            bb.b5 = true;

Replacement in src/attacks.zig at line 124 [4.204]

B:BD[4.1219] → [4.1219:1245]

                bb.board,

[4.1219]

[4.1245]

                @bitCast(Chess.BoardType, bb),

Replacement in src/attacks.zig at line 130 [4.204]

B:BD[4.1392] → [4.1392:1443]

            bb.board = 0;
            bb.set(.g5);

[4.1392]

[4.1443]

            var bb = Chess.BitBoard{};
            bb.g5 = true;

Replacement in src/attacks.zig at line 133 [4.204]

B:BD[4.1484] → [4.1484:1510]

                bb.board,

[4.1484]

[4.1510]

                @bitCast(Chess.BoardType, bb),

Replacement in src/attacks.zig at line 140 [4.204]
B:BD[4.1647] → [4.1647:1673]
```
            bb.board = 0;
```
[4.1647]
[4.1673]
```
            var bb = Chess.BitBoard{};
```

Replacement in src/attacks.zig at line 143 [4.204]

B:BD[4.1769] → [4.1769:1795]

                bb.board,

[4.1769]

[4.1795]

                @bitCast(Chess.BoardType, bb),

Replacement in src/attacks.zig at line 149 [4.204]

B:BD[4.1941] → [4.1941:1992]

            bb.board = 0;
            bb.set(.b3);

[4.1941]

[4.1992]

            var bb = Chess.BitBoard{};
            bb.b3 = true;

Replacement in src/attacks.zig at line 152 [4.204]

B:BD[4.2033] → [4.2033:2059]

                bb.board,

[4.2033]

[4.2059]

                @bitCast(Chess.BoardType, bb),

Replacement in src/attacks.zig at line 158 [4.204]

B:BD[4.2206] → [4.2206:2257]

            bb.board = 0;
            bb.set(.g3);

[4.2206]

[4.2257]

            var bb = Chess.BitBoard{};
            bb.g3 = true;

Replacement in src/attacks.zig at line 161 [4.204]

B:BD[4.2298] → [4.2298:2324]

                bb.board,

[4.2298]

[4.2324]

                @bitCast(Chess.BoardType, bb),

Deletion in src/attacks.zig at line 179 [4.204]
B:BD[4.2755] → [4.2755:2789]
```
    var bb: Chess.BitBoard = .{};
```
Replacement in src/attacks.zig at line 182 [4.204]
B:BD[4.2844] → [4.2844:2866]
```
        bb.board = 0;
```
[4.2844]
[4.2866]
```
        var bb = Chess.BitBoard{};
```
Replacement in src/attacks.zig at line 185 [4.204]
B:BD[4.2984] → [4.2984:3006]
```
            bb.board,
```
[4.2984]
[4.3006]
```
            @bitCast(Chess.BoardType, bb),
```
Replacement in src/attacks.zig at line 190 [4.204]
B:BD[4.3089] → [4.3089:3111]
```
        bb.board = 0;
```
[4.3089]
[4.3111]
```
        var bb = Chess.BitBoard{};
```
Replacement in src/attacks.zig at line 193 [4.204]
B:BD[4.3219] → [4.3219:3241]
```
            bb.board,
```
[4.3219]
[4.3241]
```
            @bitCast(Chess.BoardType, bb),
```
Replacement in src/attacks.zig at line 198 [4.204]
B:BD[4.3324] → [4.3324:3346]
```
        bb.board = 0;
```
[4.3324]
[4.3346]
```
        var bb = Chess.BitBoard{};
```
Replacement in src/attacks.zig at line 201 [4.204]
B:BD[4.3444] → [4.3444:3466]
```
            bb.board,
```
[4.3444]
[4.3466]
```
            @bitCast(Chess.BoardType, bb),
```
Deletion in src/attacks.zig at line 218 [4.204]
B:BD[4.3841] → [4.3841:3875]
```
    var bb: Chess.BitBoard = .{};
```
Replacement in src/attacks.zig at line 221 [4.204]
B:BD[4.3928] → [4.3928:3950]
```
        bb.board = 0;
```
[4.3928]
[4.3950]
```
        var bb = Chess.BitBoard{};
```
Replacement in src/attacks.zig at line 224 [4.204]
B:BD[4.4068] → [4.4068:4090]
```
            bb.board,
```
[4.4068]
[4.4090]
```
            @bitCast(Chess.BoardType, bb),
```
Replacement in src/attacks.zig at line 229 [4.204]
B:BD[4.4177] → [4.4177:4199]
```
        bb.board = 0;
```
[4.4177]
[4.4199]
```
        var bb = Chess.BitBoard{};
```
Replacement in src/attacks.zig at line 232 [4.204]
B:BD[4.4302] → [4.4302:4324]
```
            bb.board,
```
[4.4302]
[4.4324]
```
            @bitCast(Chess.BoardType, bb),
```
Replacement in src/attacks.zig at line 237 [4.204]
B:BD[4.4411] → [4.4411:4433]
```
        bb.board = 0;
```
[4.4411]
[4.4433]
```
        var bb = Chess.BitBoard{};
```
Replacement in src/attacks.zig at line 240 [4.204]
B:BD[4.4536] → [4.4536:4558]
```
            bb.board,
```
[4.4536]
[4.4558]
```
            @bitCast(Chess.BoardType, bb),
```
Replacement in src/attacks.zig at line 245 [4.204]
B:BD[4.4646] → [4.4646:4668]
```
        bb.board = 0;
```
[4.4646]
[4.4668]
```
        var bb = Chess.BitBoard{};
```
Replacement in src/attacks.zig at line 248 [4.204]
B:BD[4.4761] → [4.4761:4783]
```
            bb.board,
```
[4.4761]
[4.4783]
```
            @bitCast(Chess.BoardType, bb),
```
Deletion in src/attacks.zig at line 265 [4.204]
∅:D[5.6524] → [6.0:34]
B:BD[4.5164] → [6.0:34]
```
    var bb: Chess.BitBoard = .{};
```
Replacement in src/attacks.zig at line 268 [4.204]
B:BD[4.5206] → [6.35:57]
```
        bb.board = 0;
```
[4.5206]
[6.57]
```
        var bb = Chess.BitBoard{};
```
Replacement in src/attacks.zig at line 271 [4.204]
B:BD[4.5375] → [4.5375:5397]
```
            bb.board,
```
[4.5375]
[4.5397]
```
            @bitCast(Chess.BoardType, bb),
```
Deletion in src/attacks.zig at line 288 [4.204]
∅:D[5.6656] → [6.439:473]
B:BD[6.439] → [6.439:473]
```
    var bb: Chess.BitBoard = .{};
```
Replacement in src/attacks.zig at line 291 [4.204]
B:BD[6.513] → [6.513:535]
```
        bb.board = 0;
```
[6.513]
[6.535]
```
        var bb = Chess.BitBoard{};
```
Replacement in src/attacks.zig at line 294 [4.204]
B:BD[6.668] → [6.668:690]
```
            bb.board,
```
[6.668]
[6.690]
```
            @bitCast(Chess.BoardType, bb),
```
Replacement in src/attacks.zig at line 299 [4.204]
B:BD[6.758] → [6.758:780]
```
        bb.board = 0;
```
[6.758]
[6.780]
```
        var bb = Chess.BitBoard{};
```
Replacement in src/attacks.zig at line 302 [4.204]
B:BD[6.918] → [6.918:940]
```
            bb.board,
```
[6.918]
[6.940]
```
            @bitCast(Chess.BoardType, bb),
```

Replacement in src/attacks.zig at line 359 [4.204]

B:BD[4.7321] → [4.7321:7401]

            attacks |= @intCast(Chess.BoardType, @as(Chess.BoardType, 1) << s);

[4.7321]

[4.7401]

            attacks |= @as(Chess.BoardType, 1) << s;

Replacement in src/attacks.zig at line 401 [4.204]

B:BD[2.1035] → [2.1035:1117]

            const mask = @intCast(Chess.BoardType, @as(Chess.BoardType, 1) << s);

[2.1035]

[2.1117]

            const mask = @as(Chess.BoardType, 1) << s;

Deletion in src/attacks.zig at line 414 [4.204]
B:BD[2.1272] → [2.1272:1307]
```
    var bb: Chess.BitBoard = .{};
```

Replacement in src/attacks.zig at line 415 [4.204]

B:BD[2.1326] → [2.1326:1404]

        bb.board = 0;
        bb.setSlice(&[_]Chess.Square{ .c3, .b6, .f2 });

[2.1326]

[2.1404]

        var blocks = Chess.BitBoard{};
        blocks.setSlice(&[_]Chess.Square{ .c3, .b6, .f2 });

Replacement in src/attacks.zig at line 418 [4.204]

B:BD[2.1405] → [2.1405:1468]

        const got = attackWithBlocker(bb.board, .d4, .bishop);

[2.1405]

[2.1468]

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

Replacement in src/attacks.zig at line 420 [4.204]
B:BD[2.1469] → [2.1469:1491]
```
        bb.board = 0;
```
[2.1469]
[2.1491]
```
        var bb = Chess.BitBoard{};
```

Replacement in src/attacks.zig at line 423 [4.204]

B:BD[7.3] → [2.1578:1630]

        try std.testing.expectEqual(bb.board, got);

[7.3]

[2.1630]

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

Replacement in src/attacks.zig at line 427 [4.204]

B:BD[2.1654] → [2.1654:1732]

        bb.board = 0;
        bb.setSlice(&[_]Chess.Square{ .b4, .d3, .d5 });

[2.1654]

[2.1732]

        var blocks = Chess.BitBoard{};
        blocks.setSlice(&[_]Chess.Square{ .b4, .d3, .d5 });

Replacement in src/attacks.zig at line 430 [4.204]

B:BD[2.1733] → [2.1733:1794]

        const got = attackWithBlocker(bb.board, .d4, .rook);

[2.1733]

[2.1794]

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

Replacement in src/attacks.zig at line 432 [4.204]
B:BD[2.1795] → [2.1795:1817]
```
        bb.board = 0;
```
[2.1795]
[2.1817]
```
        var bb = Chess.BitBoard{};
```

Replacement in src/attacks.zig at line 435 [4.204]

B:BD[2.1899] → [2.1899:1951]

        try std.testing.expectEqual(bb.board, got);

[2.1899]

[2.1951]

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

Replacement in src/attacks.zig at line 439 [4.204]

B:BD[2.1975] → [2.1975:2041]

        bb.board = 0;
        bb.setSlice(&[_]Chess.Square{.b8});

[2.1975]

[2.2041]

        var blocks = Chess.BitBoard{};
        blocks.setSlice(&[_]Chess.Square{.b8});

Replacement in src/attacks.zig at line 442 [4.204]

B:BD[2.2042] → [2.2042:2103]

        const got = attackWithBlocker(bb.board, .h8, .rook);

[2.2042]

[2.2103]

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

Replacement in src/attacks.zig at line 444 [4.204]
B:BD[2.2104] → [2.2104:2126]
```
        bb.board = 0;
```
[2.2104]
[2.2126]
```
        var bb = Chess.BitBoard{};
```

Replacement in src/attacks.zig at line 447 [4.204]

B:BD[2.2233] → [2.2233:2285]

        try std.testing.expectEqual(bb.board, got);

[2.2233]

[2.2285]

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

Replacement in src/attacks.zig at line 452 [4.204]
B:BD[7.112] → [7.112:153]
```
    var occupancy: Chess.BitBoard = .{};
```
[7.112]
[7.153]
```
    var occupancy: Chess.BoardType = 0;
```

Replacement in src/attacks.zig at line 454 [4.204]

B:BD[7.154] → [7.154:214]

    var attack: Chess.BitBoard = .{ .board = attack_mask };

[7.154]

[7.214]

    var attack: Chess.BoardType = attack_mask;

Replacement in src/attacks.zig at line 458 [4.204]

B:BD[7.288] → [7.288:331]

        const square = @ctz(attack.board);

[7.288]

[7.331]

        const square = @intCast(u6, @ctz(attack));

Replacement in src/attacks.zig at line 460 [4.204]

B:BD[7.332] → [7.332:386]

        attack.pop(@intToEnum(Chess.Square, square));

[7.332]

[7.386]

        // pop square bit
        // if (attack & @as(Chess.BoardType, 1) << square != 0)
        attack ^= @as(Chess.BoardType, 1) << square;

Replacement in src/attacks.zig at line 465 [4.204]

B:BD[7.448] → [7.448:509]

            occupancy.set(@intToEnum(Chess.Square, square));

[7.448]

[7.509]

            occupancy |= @as(Chess.BoardType, 1) << square;

Replacement in src/attacks.zig at line 469 [4.204]
B:BD[7.526] → [7.526:554]
```
    return occupancy.board;
```
[7.526]
[7.554]
```
    return occupancy;
```

Replacement in src/attacks.zig at line 475 [4.204]

B:BD[7.636] → [7.636:756]

    var occupancy: Chess.BitBoard = .{};
    occupancy.board = setOccupancy(4095, @popCount(attack_mask), attack_mask);

[7.636]

[7.756]

    var occupancy: Chess.BoardType = 0;
    occupancy = setOccupancy(4095, @popCount(attack_mask), attack_mask);

Replacement in src/attacks.zig at line 481 [4.204]

B:BD[7.901] → [7.901:955]

    try std.testing.expectEqual(expected, occupancy);

[7.901]

[7.955]

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

Deletion in src/attacks.zig at line 549 [4.204]
B:BD[7.2941] → [7.2941:2973]
```
    var bb = Chess.BitBoard{};
```

Replacement in src/attacks.zig at line 553 [4.204]

B:BD[7.3114] → [7.3114:3221]

        bb.board = occupancies[idx]; // FIXME UGLY
        attacks[idx] = bb.riderBlocker(square, piece);

[7.3114]

[7.3221]

        attacks[idx] = attackWithBlocker(occupancies[idx], square, piece);

Deletion in src/Chess.zig at line 22 [4.7502]

B:BD[3.381] → [3.381:646]

// 8  ♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜
// 7  ♟︎ ♟︎ ♟︎ ♟︎ ♟︎ ♟︎ ♟︎ ♟︎
// 6  . . . . . . . .
// 5  . . . . . . . .
// 4  . . . . . . . .
// 3  . . . . . . . .
// 2  ♙ ♙ ♙ ♙ ♙ ♙ ♙ ♙
// 1  ♖ ♘ ♗ ♕ ♔ ♗ ♘ ♖

Replacement in src/Chess.zig at line 91 [4.7502]

B:BD[4.9021] → [4.9021:9165]

    board: BoardType = 0,
    pub fn set(self: *@This(), square: Square) void {
        self.board |= @as(BoardType, 1) << square.int();
    }

[4.9021]

[4.9165]

    // zig fmt: off
    a8:bool=false, b8:bool=false, c8:bool=false, d8:bool=false, e8:bool=false, f8:bool=false, g8:bool=false, h8:bool=false,
    a7:bool=false, b7:bool=false, c7:bool=false, d7:bool=false, e7:bool=false, f7:bool=false, g7:bool=false, h7:bool=false,
    a6:bool=false, b6:bool=false, c6:bool=false, d6:bool=false, e6:bool=false, f6:bool=false, g6:bool=false, h6:bool=false,
    a5:bool=false, b5:bool=false, c5:bool=false, d5:bool=false, e5:bool=false, f5:bool=false, g5:bool=false, h5:bool=false,
    a4:bool=false, b4:bool=false, c4:bool=false, d4:bool=false, e4:bool=false, f4:bool=false, g4:bool=false, h4:bool=false,
    a3:bool=false, b3:bool=false, c3:bool=false, d3:bool=false, e3:bool=false, f3:bool=false, g3:bool=false, h3:bool=false,
    a2:bool=false, b2:bool=false, c2:bool=false, d2:bool=false, e2:bool=false, f2:bool=false, g2:bool=false, h2:bool=false,
    a1:bool=false, b1:bool=false, c1:bool=false, d1:bool=false, e1:bool=false, f1:bool=false, g1:bool=false, h1:bool=false,
    // zig fmt: on

Insertion in src/Chess.zig at line 103 [4.7502]
[4.9234]
[4.9234]
```
        var ret = @bitCast(BoardType, self.*);
```

Replacement in src/Chess.zig at line 105 [4.7502]

B:BD[4.9267] → [4.9267:9297]

            self.set(square);

[4.9267]

[4.9297]

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

Replacement in src/Chess.zig at line 107 [4.7502]

B:BD[4.9307] → [4.9307:9559]

    }
    pub fn isSet(self: @This(), square: Square) bool {
        return (self.board & @as(BoardType, 1) << square.int() != 0);
    }
    pub fn unSet(self: *@This(), square: Square) void {
        self.board &= @as(BoardType, 0) << square.int();

[4.9307]

[4.9559]

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

Deletion in src/Chess.zig at line 110 [4.7502]

B:BD[4.9566] → [4.9566:9873]

    pub fn flip(self: *@This(), square: Square) void {
        self.board ^= @as(BoardType, 1) << square.int();
    }
    // pop removes the bit if set
    pub fn pop(self: *@This(), square: Square) void {
        if (self.isSet(square))
            self.board ^= @as(BoardType, 1) << square.int();
    }

Replacement in src/Chess.zig at line 121 [4.7502]

B:BD[4.10353] → [4.10353:10452]

                const mask: usize = if (self.board & (@as(BoardType, 1) << square) != 0) 1 else 0;

[4.10353]

[4.10452]

                const mask: usize = if (@bitCast(BoardType, self) & (@as(BoardType, 1) << square) != 0) 1 else 0;

Replacement in src/Chess.zig at line 129 [4.7502]

B:BD[4.10702] → [4.10702:10763]

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

[4.10702]

[8.1292]

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

Deletion in src/Chess.zig at line 132 [4.7502]

B:BD[4.10772] → [4.10772:10909]


test "BitBoard" {
    { // set, unSet
        var bb: BitBoard = .{};
        try std.testing.expectEqual(@as(BoardType, 0), bb.board);

Deletion in src/Chess.zig at line 133 [4.7502]

B:BD[4.10910] → [4.10910:12112]

B:BD[4.12112] → [8.1299:1307]

B:BD[8.1307] → [3.1212:1213]

        bb.set(.a8);
        try std.testing.expectEqual(@as(BoardType, 1), bb.board);
        bb.unSet(.a8);
        bb.set(.h1);
        const exp = @as(BoardType, 1) << @as(u6, 63);
        try std.testing.expectEqual(exp, bb.board);
    }
    { // flip
        var bb: BitBoard = .{};
        bb.set(.e4);
        try std.testing.expect(bb.isSet(.e4));
        bb.set(.f1);
        try std.testing.expect(bb.isSet(.f1));
        bb.flip(.e4);
        bb.flip(.f1);
        try std.testing.expectEqual(@as(BoardType, 0), bb.board);
        bb.flip(.f1); // sets f1 again
        try std.testing.expectEqual(
            @as(BoardType, @as(BoardType, 1) << @enumToInt(Square.f1)),
            bb.board,
        );
    }
    { // pop
        var bb: BitBoard = .{};
        bb.set(.e4);
        bb.set(.f1);
        bb.pop(.e4);
        bb.pop(.f1);
        bb.set(.g3);
        try std.testing.expectEqual(
            @as(BoardType, @as(BoardType, 1) << @enumToInt(Square.g3)),
            bb.board,
        );
        bb.pop(.e4); // does nothing
        try std.testing.expectEqual(
            @as(BoardType, @as(BoardType, 1) << @enumToInt(Square.g3)),
            bb.board,
        );
    }
}

Replacement in src/Chess.zig at line 162 [4.7502]

B:BD[3.2012] → [3.2012:2057]

        self.bitboards[PE.Q.int()].set(.d1);

[3.2012]

[3.2057]

        self.bitboards[PE.Q.int()].d1 = true;

Replacement in src/Chess.zig at line 164 [4.7502]

B:BD[3.2079] → [3.2079:2124]

        self.bitboards[PE.K.int()].set(.e1);

[3.2079]

[3.2124]

        self.bitboards[PE.K.int()].e1 = true;

Replacement in src/Chess.zig at line 175 [4.7502]

B:BD[3.2550] → [3.2550:2595]

        self.bitboards[PE.q.int()].set(.d8);

[3.2550]

[3.2595]

        self.bitboards[PE.q.int()].d8 = true;

Replacement in src/Chess.zig at line 177 [4.7502]

B:BD[3.2617] → [3.2617:2662]

        self.bitboards[PE.k.int()].set(.e8);

[3.2617]

[3.2662]

        self.bitboards[PE.k.int()].e8 = true;

Replacement in src/Chess.zig at line 191 [4.7502]

B:BD[3.3088] → [3.3088:3161]

                    if (bb.board & (@as(BoardType, 1) << square) != 0) {

[3.3088]

[3.3161]

                    if (@bitCast(BoardType, bb) & (@as(BoardType, 1) << square) != 0) {

Change BitBoard representation

Dependencies

In channels

Change contents

Deletion in src/attacks.zig at line 108 [4.204]

Replacement in src/attacks.zig at line 112 [4.204]

Replacement in src/attacks.zig at line 115 [4.204]

Replacement in src/attacks.zig at line 121 [4.204]

Replacement in src/attacks.zig at line 124 [4.204]

Replacement in src/attacks.zig at line 130 [4.204]

Replacement in src/attacks.zig at line 133 [4.204]

Replacement in src/attacks.zig at line 140 [4.204]

Replacement in src/attacks.zig at line 143 [4.204]

Replacement in src/attacks.zig at line 149 [4.204]

Replacement in src/attacks.zig at line 152 [4.204]

Replacement in src/attacks.zig at line 158 [4.204]

Replacement in src/attacks.zig at line 161 [4.204]

Deletion in src/attacks.zig at line 179 [4.204]

Replacement in src/attacks.zig at line 182 [4.204]

Replacement in src/attacks.zig at line 185 [4.204]

Replacement in src/attacks.zig at line 190 [4.204]

Replacement in src/attacks.zig at line 193 [4.204]

Replacement in src/attacks.zig at line 198 [4.204]

Replacement in src/attacks.zig at line 201 [4.204]

Deletion in src/attacks.zig at line 218 [4.204]

Replacement in src/attacks.zig at line 221 [4.204]

Replacement in src/attacks.zig at line 224 [4.204]

Replacement in src/attacks.zig at line 229 [4.204]

Replacement in src/attacks.zig at line 232 [4.204]

Replacement in src/attacks.zig at line 237 [4.204]

Replacement in src/attacks.zig at line 240 [4.204]

Replacement in src/attacks.zig at line 245 [4.204]

Replacement in src/attacks.zig at line 248 [4.204]

Deletion in src/attacks.zig at line 265 [4.204]

Replacement in src/attacks.zig at line 268 [4.204]

Replacement in src/attacks.zig at line 271 [4.204]

Deletion in src/attacks.zig at line 288 [4.204]

Replacement in src/attacks.zig at line 291 [4.204]

Replacement in src/attacks.zig at line 294 [4.204]

Replacement in src/attacks.zig at line 299 [4.204]

Replacement in src/attacks.zig at line 302 [4.204]