defer {
        if (search != null) {
            search.?.deinit();
        }
    }

                    std.log.debug("initializing new uci game", .{});
                    std.log.debug("clearing transposition table", .{});
                    search.?.tt.clear();

    _ = @import("Transposition.zig");

const std = @import("std");
const BitMove = @import("Board.zig").BitMove;
const BitMoveType = @import("Board.zig").BitMoveType;
const Chess = @import("Chess.zig");
const Square = @import("Board.zig").Square;
pub const Flag = enum {
    empty,
    exact,
    lower,
    upper,
};
pub const Item = struct {
    key: u64,
    value: isize,
    depth: u8,
    flag: Flag,
};
pub const Table = struct {
    data: std.ArrayList(Item),
    size: usize,
    pub fn init(allocator: std.mem.Allocator, max_size: usize) !@This() {
        const size = max_size / @sizeOf(Item);
        var ret = std.ArrayList(Item).init(allocator);
        try ret.ensureTotalCapacity(size);
        ret.expandToCapacity();
        return @This(){
            .data = ret,
            .size = size,
        };
    }
    pub fn deinit(self: @This()) void {
        self.data.deinit();
    }
    pub fn clear(self: *@This()) void {
        for (self.data.items) |*item| {
            item.* = Item{
                .key = 0,
                .value = 0,
                .depth = 0,
                .flag = .empty,
            };
        }
    }
    pub fn get(self: *const @This(), hash: u64) ?Item {
        const entry = self.data.items[hash % self.size];
        if (entry.flag == .empty or entry.key != hash) {
            return null;
        }
        return entry;
    }
    pub fn set(self: *@This(), entry: Item) void {
        self.data.items[entry.key % self.size] = entry;
    }
};
test "Transposition Table" {
    var tt = try Table.init(std.testing.allocator, 16 * (1 << 10));
    defer tt.deinit();
    tt.clear();
    tt.set(Item{
        .key = std.math.maxInt(u64),
        .value = 3000,
        .depth = 8,
        .flag = .exact,
    });
    const got = tt.get(std.math.maxInt(u64));
    try std.testing.expect(got != null);
    try std.testing.expectEqual(got.?.value, 3000);
}

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

    // UCI time control

    node_limit: usize = 0,

    node_limit: usize = 0,

    // Transposition Table
    tt: Transposition.Table = undefined,

        return Search{ .state = gs };

        return Search{
            .state = gs,
            .tt = try Transposition.Table.init(gs.allocator, 16 * (1 << 20)),
        };
    }
    pub fn deinit(self: @This()) void {
        self.tt.deinit();

        // TT probe
        if (self.tt.get(self.state.hash)) |entry| {
            if (entry.depth >= depth_orig) {
                switch (entry.flag) {
                    .empty => unreachable,
                    .exact => return entry.value,
                    .lower => {
                        if (entry.value <= alpha_orig) return alpha_orig;
                    },
                    .upper => {
                        if (entry.value >= beta) return beta;
                    },
                }
            }
        }

        var scr: isize = undefined;
        var tt_flag: Transposition.Flag = .lower;

            var scr: isize = undefined;

                // Continue PVS code

                // PVS code

                self.tt.set(.{
                    .key = self.state.hash,
                    .value = beta,
                    .depth = @intCast(u8, depth),
                    .flag = .upper,
                });

                tt_flag = .exact;

                // PV (principal valuation) node

                // PV (principal variation) node

        self.tt.set(.{
            .key = self.state.hash,
            .value = alpha,
            .depth = @intCast(u8, depth),
            .flag = tt_flag,
        });

        if (self.tt.get(self.state.hash)) |entry| {
            switch (entry.flag) {
                .empty => unreachable,
                .exact => return entry.value,
                .lower => {
                    if (entry.value <= alpha_orig) return alpha_orig;
                },
                .upper => {
                    if (entry.value >= beta) return beta;
                },
            }
        }

[Bruce Moreland](https://web.archive.org/web/20070922181832/http://www.brucemo.com/compchess/programming/index.htm)

### Soon
- Check [SEE - Static Exchange Evaluation](https://web.archive.org/web/20070606043300/http://www.brucemo.com/compchess/programming/quiescent.htm)