PRNG rng(1070372);

for (Piece pc : Pieces)

for (Square s = SQ_A1; s <= SQ_H8; ++s)

Zobrist::psq[pc][s] = rng.rand<Key>();

// pawns on these squares will promote

std::fill_n(Zobrist::psq[W_PAWN] + SQ_A8, 8, 0);

std::fill_n(Zobrist::psq[B_PAWN], 8, 0);

for (File f = FILE_A; f <= FILE_H; ++f)

Zobrist::enpassant[f] = rng.rand<Key>();

for (int cr = NO_CASTLING; cr <= ANY_CASTLING; ++cr)

Zobrist::castling[cr] = rng.rand<Key>();

Zobrist::side = rng.rand<Key>();

Zobrist::noPawns = rng.rand<Key>();

// Prepare the cuckoo tables

cuckoo.fill(0);

cuckooMove.fill(Move::none());

[[maybe_unused]] int count = 0;

for (Piece pc : Pieces)

for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)

for (Square s2 = Square(s1 + 1); s2 <= SQ_H8; ++s2)

if ((type_of(pc) != PAWN) && (attacks_bb(type_of(pc), s1, 0) & s2))

{

Move move = Move(s1, s2);

Key key = Zobrist::psq[pc][s1] ^ Zobrist::psq[pc][s2] ^ Zobrist::side;

int i = H1(key);

while (true)

{

std::swap(cuckoo[i], key);

std::swap(cuckooMove[i], move);

if (move == Move::none()) // Arrived at empty slot?

break;

i = (i == H1(key)) ? H2(key) : H1(key); // Push victim to alternative slot

}

count++;

}

assert(count == 3668);

/*

unsigned char token;

std::istringstream ss(fenStr);

std::memset(reinterpret_cast<char*>(this), 0, sizeof(Position));

std::memset(si, 0, sizeof(StateInfo));

st = si;

ss >> std::noskipws;

int numPieces = 0;

int file = FILE_A;

int rank = RANK_8;

// 1. Piece placement

for (;;)

{

if (!(ss >> token))

return PositionSetError("Invalid FEN. Unexpected end of stream.");

if (isspace(token))

break;

if (isdigit(token))

{

const int diff = (token - '0');

if (diff < 1 || diff > 8)

return PositionSetError("Invalid FEN. Invalid number of squares to skip.");

file += diff;

if (file > FILE_NB)

return PositionSetError("Invalid FEN. Invalid file reached.");

}

else if (token == '/')

{

if (file != FILE_NB)

return PositionSetError(

"Invalid FEN. Trying to end rank when not at the end of it.");

--rank;

file = FILE_A;

if (rank < RANK_1)

return PositionSetError("Invalid FEN. Invalid rank reached.");

}

else

{

if (file >= FILE_NB)

return PositionSetError("Invalid FEN. Invalid file reached.");

const size_t idx = PieceToChar.find(token);

if (idx == string::npos)

return PositionSetError(std::string("Invalid FEN. Invalid piece: ")

+ std::string(1, token));

if (++numPieces > 32)

return PositionSetError("Invalid FEN. More than 32 pieces on the board.");

const Square sq = make_square(File(file), Rank(rank));

put_piece(Piece(idx), sq);

++file;

}

}

if (rank != RANK_1 || file != FILE_NB)

return PositionSetError("Invalid FEN. Board state encoding ended but cursor not at end.");

if (pieces(PAWN) & (RANK_1 | RANK_8))

return PositionSetError("Unsupported position. Pawns on the first or eighth rank.");

if (count<KING>(WHITE) != 1 || count<KING>(BLACK) != 1)

return PositionSetError("Unsupported position. Incorrect number of kings.");

const int wPawns = count<PAWN>(WHITE);

const int bPawns = count<PAWN>(BLACK);

if (wPawns > 8)

return PositionSetError("Unsupported position. WHITE has more than 8 pawns.");

if (bPawns > 8)

return PositionSetError("Unsupported position. BLACK has more than 8 pawns.");

const int wAdditionalKnights = std::max((int) count<KNIGHT>(WHITE) - 2, 0);

const int bAdditionalKnights = std::max((int) count<KNIGHT>(BLACK) - 2, 0);

const int wAdditionalBishops = std::max((int) count<BISHOP>(WHITE) - 2, 0);

const int bAdditionalBishops = std::max((int) count<BISHOP>(BLACK) - 2, 0);

const int wAdditionalRooks = std::max((int) count<ROOK>(WHITE) - 2, 0);

const int bAdditionalRooks = std::max((int) count<ROOK>(BLACK) - 2, 0);

const int wAdditionalQueens = std::max((int) count<QUEEN>(WHITE) - 1, 0);

const int bAdditionalQueens = std::max((int) count<QUEEN>(BLACK) - 1, 0);

if (wAdditionalKnights + wAdditionalBishops + wAdditionalRooks + wAdditionalQueens > 8 - wPawns)

return PositionSetError("Unsupported position. Too many pieces for WHITE.");

if (bAdditionalKnights + bAdditionalBishops + bAdditionalRooks + bAdditionalQueens > 8 - bPawns)

return PositionSetError("Unsupported position. Too many pieces for BLACK.");

// 2. Active color

if (!(ss >> token))

return PositionSetError("Invalid FEN. Unexpected end of stream.");

if (token != 'w' && token != 'b')

return PositionSetError(std::string("Invalid FEN. Invalid side to move: ")

+ std::string(1, token));

sideToMove = (token == 'w' ? WHITE : BLACK);

if (!(ss >> token) || !isspace(token) || ss.eof())

return PositionSetError("Invalid FEN. Expected whitespace after side to move.");

// 3. Castling availability. Compatible with 3 standards: Normal FEN standard,

// Shredder-FEN that uses the letters of the columns on which the rooks began

// the game instead of KQkq and also X-FEN standard that, in case of Chess960,

// if an inner rook is associated with the castling right, the castling tag is

// replaced by the file letter of the involved rook, as for the Shredder-FEN.

//

// NOTE: Due to the prevalnce of incorrect (or missing) castling rights the

// validation is less strict. However, incorrect castling rights are still sanitized.

int num_castling_rights = 0;

for (;;)

{

if (!(ss >> token))

break;

if (isspace(token))

break;

if (num_castling_rights == 0 && token == '-')

{

ss >> std::ws;

break;

}

if (++num_castling_rights > 4)

return PositionSetError("Invalid FEN. Maximum of 4 castling rights can be specified.");

Square rsq = SQ_NONE;

Square ksq = SQ_NONE;

Color c = islower(token) ? BLACK : WHITE;

Piece rook = make_piece(c, ROOK);

Piece king = make_piece(c, KING);

token = char(toupper(token));

if (token == 'K' || token == 'Q')

{

const int dir = token == 'K' ? -1 : 1;

Square sq = relative_square(c, token == 'K' ? SQ_H1 : SQ_A1);

// Look for a rook and a king for the castling. King must come later.

// Only the first rook is noted.

// If the castling rights are available the king must always be between files 2 and 7 inclusive

// so there is no need to check the last square.

for (int i = 0; i < 7; ++i, sq = Square(sq + dir))

{

const Piece pc = piece_on(sq);

if (pc == king)

{

ksq = sq;

break;

}

else if (pc == rook && rsq == SQ_NONE)

{

rsq = sq;

}

}

}

else if (token >= 'A' && token <= 'H')

{

const Square rsqCandidate = make_square(File(token - 'A'), relative_rank(c, RANK_1));

if (piece_on(rsqCandidate) == rook)

rsq = rsqCandidate;

// If the castling rights are available the king must always be between files 2 and 7 inclusive.

Square sq = relative_square(c, SQ_B1);

for (int i = 0; i < 6; ++i, ++sq)

{

if (piece_on(sq) == king)

ksq = sq;

}

}

else

{

return PositionSetError(std::string("Invalid FEN. Expected castling rights. Got: ")

+ std::string(1, token));

}

// Only apply castling rights if they can be valid.

if (ksq != SQ_NONE && rsq != SQ_NONE)

set_castling_right(c, rsq);

}

// 4. En passant square.

// Ignore if square is invalid or not on side to move relative rank 6.

bool enpassant = false, legalEP = false;

unsigned char col = '-', row;

ss >> col;

if (col != '-')

{

if (!(ss >> row))

return PositionSetError("Invalid FEN. Unexpected end of stream.");

if ((col >= 'a' && col <= 'h') && (row == (sideToMove == WHITE ? '6' : '3')))

{

st->epSquare = make_square(File(col - 'a'), Rank(row - '1'));

Bitboard pawns = attacks_bb<PAWN>(st->epSquare, ~sideToMove) & pieces(sideToMove, PAWN);

Bitboard target = (pieces(~sideToMove, PAWN) & (st->epSquare + pawn_push(~sideToMove)));

Bitboard occ = pieces() ^ target ^ st->epSquare;

// En passant square will be considered only if

// a) side to move have a pawn threatening epSquare

// b) there is an enemy pawn in front of epSquare

// c) there is no piece on epSquare or behind epSquare

enpassant = pawns && target

&& !(pieces() & (st->epSquare | (st->epSquare + pawn_push(sideToMove))));

// If no pawn can execute the en passant capture without leaving the king in check, don't record the epSquare

while (pawns)

legalEP |= !(attackers_to(square<KING>(sideToMove), occ ^ pop_lsb(pawns))

& pieces(~sideToMove) & ~target);

}

else

return PositionSetError("Invalid FEN. Invalid en-passant square.");

}

if (!enpassant || !legalEP)

st->epSquare = SQ_NONE;

// 5-6. Halfmove clock and fullmove number

ss >> std::skipws >> st->rule50 >> gamePly;

// Normally values larger than 99 would be pointless but we do support ignoring 50 move rule for TB purposes.

// Limit at 2**15 as it's used multiplicativly with position evaluation during search.

if (st->rule50 < 0 || st->rule50 > 32767)

return PositionSetError("Unsupported position. Rule50 counter out of range.");

if (gamePly < 0 || gamePly > 100000)

return PositionSetError("Unsupported position. Game ply out of range.");

// Convert from fullmove starting from 1 to gamePly starting from 0,

// handle also common incorrect FEN with fullmove = 0.

gamePly = std::max(2 * (gamePly - 1), 0) + (sideToMove == BLACK);

chess960 = isChess960;

set_state();

if (attackers_to_exist(square<KING>(~sideToMove), pieces(), sideToMove))

return PositionSetError("Unsupported position. King can be captured.");

assert(pos_is_ok());

return std::nullopt;

Square kfrom = square<KING>(c);

CastlingRights cr = c & (kfrom < rfrom ? KING_SIDE : QUEEN_SIDE);

st->castlingRights |= cr;

castlingRightsMask[kfrom] |= cr;

castlingRightsMask[rfrom] |= cr;

castlingRookSquare[cr] = rfrom;

Square kto = relative_square(c, cr & KING_SIDE ? SQ_G1 : SQ_C1);

Square rto = relative_square(c, cr & KING_SIDE ? SQ_F1 : SQ_D1);

castlingPath[cr] = (between_bb(rfrom, rto) | between_bb(kfrom, kto)) & ~(kfrom | rfrom);

update_slider_blockers(WHITE);

update_slider_blockers(BLACK);

Square ksq = square<KING>(~sideToMove);

st->checkSquares[PAWN] = attacks_bb<PAWN>(ksq, ~sideToMove);

st->checkSquares[KNIGHT] = attacks_bb<KNIGHT>(ksq);

st->checkSquares[BISHOP] = attacks_bb<BISHOP>(ksq, pieces());

st->checkSquares[ROOK] = attacks_bb<ROOK>(ksq, pieces());

st->checkSquares[QUEEN] = st->checkSquares[BISHOP] | st->checkSquares[ROOK];

st->checkSquares[KING] = 0;

st->key = 0;

st->minorPieceKey = 0;

st->nonPawnKey[WHITE] = st->nonPawnKey[BLACK] = 0;

st->pawnKey = Zobrist::noPawns;

st->nonPawnMaterial[WHITE] = st->nonPawnMaterial[BLACK] = VALUE_ZERO;

st->checkersBB = attackers_to(square<KING>(sideToMove)) & pieces(~sideToMove);

set_check_info();

for (Bitboard b = pieces(); b;)

{

Square s = pop_lsb(b);

Piece pc = piece_on(s);

st->key ^= Zobrist::psq[pc][s];

if (type_of(pc) == PAWN)

st->pawnKey ^= Zobrist::psq[pc][s];

else

{

st->nonPawnKey[color_of(pc)] ^= Zobrist::psq[pc][s];

if (type_of(pc) != KING)

{

st->nonPawnMaterial[color_of(pc)] += PieceValue[pc];

if (type_of(pc) <= BISHOP)

st->minorPieceKey ^= Zobrist::psq[pc][s];

}

}

}

if (st->epSquare != SQ_NONE)

st->key ^= Zobrist::enpassant[file_of(st->epSquare)];

if (sideToMove == BLACK)

st->key ^= Zobrist::side;

st->key ^= Zobrist::castling[st->castlingRights];

st->materialKey = compute_material_key();

Key k = 0;

for (Piece pc : Pieces)

for (int cnt = 0; cnt < pieceCount[pc]; ++cnt)

k ^= Zobrist::psq[pc][8 + cnt];

return k;

assert(code[0] == 'K');

string sides[] = {code.substr(code.find('K', 1)), // Weak

code.substr(0, std::min(code.find('v'), code.find('K', 1)))}; // Strong

assert(sides[0].length() > 0 && sides[0].length() < 8);

assert(sides[1].length() > 0 && sides[1].length() < 8);

std::transform(sides[c].begin(), sides[c].end(), sides[c].begin(), tolower);

string fenStr = "8/" + sides[0] + char(8 - sides[0].length() + '0') + "/8/8/8/8/" + sides[1]

+ char(8 - sides[1].length() + '0') + "/8 w - - 0 10";

return set(fenStr, false, si);

int emptyCnt;

std::ostringstream ss;

for (Rank r = RANK_8;; --r)

{

for (File f = FILE_A; f <= FILE_H; ++f)

{

for (emptyCnt = 0; f <= FILE_H && empty(make_square(f, r)); ++f)

++emptyCnt;

if (emptyCnt)

ss << emptyCnt;

if (f <= FILE_H)

ss << PieceToChar[piece_on(make_square(f, r))];

}

if (r == RANK_1)

break;

ss << '/';

}

ss << (sideToMove == WHITE ? " w " : " b ");

if (can_castle(WHITE_OO))

ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE_OO))) : 'K');

if (can_castle(WHITE_OOO))

ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE_OOO))) : 'Q');

if (can_castle(BLACK_OO))

ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK_OO))) : 'k');

if (can_castle(BLACK_OOO))

ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK_OOO))) : 'q');

if (!can_castle(ANY_CASTLING))

ss << '-';

ss << (ep_square() == SQ_NONE ? " - " : " " + UCIEngine::square(ep_square()) + " ")

<< st->rule50 << " " << 1 + (gamePly - (sideToMove == BLACK)) / 2;

return ss.str();

Square ksq = square<KING>(c);

st->blockersForKing[c] = 0;

st->pinners[~c] = 0;

// Snipers are sliders that attack 's' when a piece and other snipers are removed

Bitboard snipers = ((attacks_bb<ROOK>(ksq) & pieces(QUEEN, ROOK))

| (attacks_bb<BISHOP>(ksq) & pieces(QUEEN, BISHOP)))

& pieces(~c);

Bitboard occupancy = pieces() ^ snipers;

while (snipers)

{

Square sniperSq = pop_lsb(snipers);

Bitboard b = between_bb(ksq, sniperSq) & occupancy;

if (b && !more_than_one(b))

{

st->blockersForKing[c] |= b;

if (b & pieces(c))

st->pinners[~c] |= sniperSq;

}

}

return (attacks_bb<ROOK>(s, occupied) & pieces(ROOK, QUEEN))

| (attacks_bb<BISHOP>(s, occupied) & pieces(BISHOP, QUEEN))

| (attacks_bb<PAWN>(s, BLACK) & pieces(WHITE, PAWN))

| (attacks_bb<PAWN>(s, WHITE) & pieces(BLACK, PAWN))

| (attacks_bb<KNIGHT>(s) & pieces(KNIGHT)) | (attacks_bb<KING>(s) & pieces(KING));

return (attacks_bb<ROOK>(s, occupied) & pieces(c, ROOK, QUEEN))

|| (attacks_bb<BISHOP>(s, occupied) & pieces(c, BISHOP, QUEEN))

|| (attacks_bb<PAWN>(s, ~c) & pieces(c, PAWN))

|| (attacks_bb<KNIGHT>(s) & pieces(c, KNIGHT)) || (attacks_bb<KING>(s) & pieces(c, KING));

assert(m.is_ok());

Color us = sideToMove;

Square from = m.from_sq();

Square to = m.to_sq();

assert(color_of(moved_piece(m)) == us);

assert(piece_on(square<KING>(us)) == make_piece(us, KING));

// Castling moves generation does not check if the castling path is clear of

// enemy attacks, it is delayed at a later time: now!

if (m.type_of() == CASTLING)

{

// After castling, the rook and king final positions are the same in

// Chess960 as they would be in standard chess.

to = relative_square(us, to > from ? SQ_G1 : SQ_C1);

Direction step = to > from ? WEST : EAST;

for (Square s = to; s != from; s += step)

if (attackers_to_exist(s, pieces(), ~us))

return false;

// In case of Chess960, verify if the Rook blocks some checks.

// For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.

return !chess960 || !(blockers_for_king(us) & m.to_sq());

}

// If the moving piece is a king, check whether the destination square is

// attacked by the opponent.

if (type_of(piece_on(from)) == KING)

return !(attackers_to_exist(to, pieces() ^ from, ~us));

// A non-king move is legal if and only if it is not pinned or it

// is moving along the ray towards or away from the king.

return !(blockers_for_king(us) & from) || line_bb(from, to) & pieces(us, KING);

Color us = sideToMove;

Square from = m.from_sq();

Square to = m.to_sq();

Piece pc = moved_piece(m);

// Use a slower but simpler function for uncommon cases

// yet we skip the legality check of MoveList<LEGAL>().

if (m.type_of() != NORMAL)

return checkers() ? MoveList<EVASIONS>(*this).contains(m)

: MoveList<NON_EVASIONS>(*this).contains(m);

// Is not a promotion, so the promotion piece must be empty

assert(m.promotion_type() - KNIGHT == NO_PIECE_TYPE);

// If the 'from' square is not occupied by a piece belonging to the side to

// move, the move is obviously not legal.

if (pc == NO_PIECE || color_of(pc) != us)

return false;

// The destination square cannot be occupied by a friendly piece

if (pieces(us) & to)

return false;

// Handle the special case of a pawn move

if (type_of(pc) == PAWN)

{

// We have already handled promotion moves, so destination cannot be on the 8th/1st rank

if ((Rank8BB | Rank1BB) & to)

return false;

// Check if it's a valid capture, single push, or double push

const bool isCapture = bool(attacks_bb<PAWN>(from, us) & pieces(~us) & to);

const bool isSinglePush = (from + pawn_push(us) == to) && empty(to);

const bool isDoublePush = (from + 2 * pawn_push(us) == to)

&& (relative_rank(us, from) == RANK_2) && empty(to)

&& empty(to - pawn_push(us));

if (!(isCapture || isSinglePush || isDoublePush))

return false;

}

else if (!(attacks_bb(type_of(pc), from, pieces()) & to))

return false;

// Evasions generator already takes care to avoid some kind of illegal moves

// and legal() relies on this. We therefore have to take care that the same

// kind of moves are filtered out here.

if (checkers())

{

if (type_of(pc) != KING)

{

// Double check? In this case, a king move is required

if (more_than_one(checkers()))

return false;

// Our move must be a blocking interposition or a capture of the checking piece

if (!(between_bb(square<KING>(us), lsb(checkers())) & to))

return false;

}

// In case of king moves under check we have to remove the king so as to catch

// invalid moves like b1a1 when opposite queen is on c1.

else if (attackers_to_exist(to, pieces() ^ from, ~us))

return false;

}

return true;

assert(m.is_ok());

assert(color_of(moved_piece(m)) == sideToMove);

Square from = m.from_sq();

Square to = m.to_sq();

// Is there a direct check?

if (check_squares(type_of(piece_on(from))) & to)

return true;

// Is there a discovered check?

if (blockers_for_king(~sideToMove) & from)

return !(line_bb(from, to) & pieces(~sideToMove, KING)) || m.type_of() == CASTLING;

switch (m.type_of())

{

case NORMAL :

return false;

case PROMOTION :

return attacks_bb(m.promotion_type(), to, pieces() ^ from) & pieces(~sideToMove, KING);

// En passant capture with check? We have already handled the case of direct

// checks and ordinary discovered check, so the only case we need to handle

// is the unusual case of a discovered check through the captured pawn.

case EN_PASSANT : {

Square capsq = make_square(file_of(to), rank_of(from));

Bitboard b = (pieces() ^ from ^ capsq) | to;

return (attacks_bb<ROOK>(square<KING>(~sideToMove), b) & pieces(sideToMove, QUEEN, ROOK))

| (attacks_bb<BISHOP>(square<KING>(~sideToMove), b)

& pieces(sideToMove, QUEEN, BISHOP));

}

default : //CASTLING

{

// Castling is encoded as 'king captures the rook'

Square rto = relative_square(sideToMove, to > from ? SQ_F1 : SQ_D1);

return check_squares(ROOK) & rto;

}

}

StateInfo& newSt,

bool givesCheck,

DirtyPiece& dp,

DirtyThreats& dts,

const TranspositionTable* tt = nullptr,

const SharedHistories* history = nullptr) {

assert(m.is_ok());

assert(&newSt != st);

Key k = st->key ^ Zobrist::side;

// Copy some fields of the old state to our new StateInfo object except the

// ones which are going to be recalculated from scratch anyway and then switch

// our state pointer to point to the new (ready to be updated) state.

std::memcpy(&newSt, st, offsetof(StateInfo, key));

newSt.previous = st;

st = &newSt;

// Increment ply counters. In particular, rule50 will be reset to zero later on

// in case of a capture or a pawn move.

++gamePly;

++st->rule50;

++st->pliesFromNull;

Color us = sideToMove;

Color them = ~us;

Square from = m.from_sq();

Square to = m.to_sq();

Piece pc = piece_on(from);

Piece captured = m.type_of() == EN_PASSANT ? make_piece(them, PAWN) : piece_on(to);

dp.pc = pc;

dp.from = from;

dp.to = to;

dp.add_sq = SQ_NONE;

dts.us = us;

dts.prevKsq = square<KING>(us);

assert(color_of(pc) == us);

assert(captured == NO_PIECE || color_of(captured) == (m.type_of() != CASTLING ? them : us));

assert(type_of(captured) != KING);

if (m.type_of() == CASTLING)

{

assert(pc == make_piece(us, KING));

assert(captured == make_piece(us, ROOK));

Square rfrom, rto;

do_castling<true>(us, from, to, rfrom, rto, &dts, &dp);

k ^= Zobrist::psq[captured][rfrom] ^ Zobrist::psq[captured][rto];

st->nonPawnKey[us] ^= Zobrist::psq[captured][rfrom] ^ Zobrist::psq[captured][rto];

captured = NO_PIECE;

}

else if (captured)

{

Square capsq = to;

// If the captured piece is a pawn, update pawn hash key, otherwise

// update non-pawn material.

if (type_of(captured) == PAWN)

{

if (m.type_of() == EN_PASSANT)

{

capsq -= pawn_push(us);

assert(pc == make_piece(us, PAWN));

assert(to == st->epSquare);

assert(relative_rank(us, to) == RANK_6);

assert(piece_on(to) == NO_PIECE);

assert(piece_on(capsq) == make_piece(them, PAWN));

// Update board and piece lists in ep case, normal captures are updated later

remove_piece(capsq, &dts);

}

st->pawnKey ^= Zobrist::psq[captured][capsq];

}

else

{

st->nonPawnMaterial[them] -= PieceValue[captured];

st->nonPawnKey[them] ^= Zobrist::psq[captured][capsq];

if (type_of(captured) <= BISHOP)

st->minorPieceKey ^= Zobrist::psq[captured][capsq];

}

dp.remove_pc = captured;

dp.remove_sq = capsq;

k ^= Zobrist::psq[captured][capsq];

st->materialKey ^=

Zobrist::psq[captured][8 + pieceCount[captured] - (m.type_of() != EN_PASSANT)];

// Reset rule 50 counter

st->rule50 = 0;

}

else

dp.remove_sq = SQ_NONE;

// Update hash key

k ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];

// Reset en passant square

if (st->epSquare != SQ_NONE)

{

k ^= Zobrist::enpassant[file_of(st->epSquare)];

st->epSquare = SQ_NONE;

}

// Update castling rights.

k ^= Zobrist::castling[st->castlingRights];

st->castlingRights &= ~(castlingRightsMask[from] | castlingRightsMask[to]);

k ^= Zobrist::castling[st->castlingRights];

// Move the piece. The tricky Chess960 castling is handled earlier

if (m.type_of() != CASTLING)

{

Piece toPc = pc;

if (m.type_of() == PROMOTION)

toPc = make_piece(us, m.promotion_type());

if (captured && m.type_of() != EN_PASSANT)

{

remove_piece(from, &dts);

swap_piece(to, toPc, &dts);

}

else if (pc == toPc)

move_piece(from, to, &dts);

else

{

remove_piece(from, &dts);

put_piece(toPc, to, &dts);

}

}

// If the moving piece is a pawn do some special extra work

if (type_of(pc) == PAWN)

{

// Check if the en passant square needs to be set. Accurate e.p. info is needed

// for correct zobrist key generation and 3-fold checking.

if ((int(to) ^ int(from)) == 16)

{

Square epSquare = to - pawn_push(us);

Bitboard pawns = attacks_bb<PAWN>(epSquare, us) & pieces(them, PAWN);

// If there are no pawns attacking the ep square, ep is not possible.

if (pawns)

{

Square ksq = square<KING>(them);

Bitboard notBlockers = ~st->previous->blockersForKing[them];

bool noDiscovery = (from & notBlockers) || file_of(from) == file_of(ksq);

// If the pawn gives discovered check, ep is never legal. Else, if at least one

// pawn was not a blocker for the enemy king or lies on the same line as the

// enemy king and en passant square, a legal capture exists.

if (noDiscovery && (pawns & (notBlockers | line_bb(epSquare, ksq))))

{

st->epSquare = epSquare;

k ^= Zobrist::enpassant[file_of(epSquare)];

}

}

}

else if (m.type_of() == PROMOTION)

{

PieceType pt = m.promotion_type();

Piece promotion = make_piece(us, pt);