git.sesse.net Git - stockfish/blob - src/bitboard.cpp

   1 /*
   2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
   4   Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
   5
   6   Stockfish is free software: you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published by
   8   the Free Software Foundation, either version 3 of the License, or
   9   (at your option) any later version.
  10
  11   Stockfish is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include <iostream>
  21
  22 #include "bitboard.h"
  23 #include "bitcount.h"
  24
  25 #if defined(IS_64BIT)
  26
  27 const uint64_t BMult[64] = {
  28   0x0440049104032280ULL, 0x1021023C82008040ULL, 0x0404040082000048ULL,
  29   0x48C4440084048090ULL, 0x2801104026490000ULL, 0x4100880442040800ULL,
  30   0x0181011002E06040ULL, 0x9101004104200E00ULL, 0x1240848848310401ULL,
  31   0x2000142828050024ULL, 0x00001004024D5000ULL, 0x0102044400800200ULL,
  32   0x8108108820112000ULL, 0xA880818210C00046ULL, 0x4008008801082000ULL,
  33   0x0060882404049400ULL, 0x0104402004240810ULL, 0x000A002084250200ULL,
  34   0x00100B0880801100ULL, 0x0004080201220101ULL, 0x0044008080A00000ULL,
  35   0x0000202200842000ULL, 0x5006004882D00808ULL, 0x0000200045080802ULL,
  36   0x0086100020200601ULL, 0xA802080A20112C02ULL, 0x0080411218080900ULL,
  37   0x000200A0880080A0ULL, 0x9A01010000104000ULL, 0x0028008003100080ULL,
  38   0x0211021004480417ULL, 0x0401004188220806ULL, 0x00825051400C2006ULL,
  39   0x00140C0210943000ULL, 0x0000242800300080ULL, 0x00C2208120080200ULL,
  40   0x2430008200002200ULL, 0x1010100112008040ULL, 0x8141050100020842ULL,
  41   0x0000822081014405ULL, 0x800C049E40400804ULL, 0x4A0404028A000820ULL,
  42   0x0022060201041200ULL, 0x0360904200840801ULL, 0x0881A08208800400ULL,
  43   0x0060202C00400420ULL, 0x1204440086061400ULL, 0x0008184042804040ULL,
  44   0x0064040315300400ULL, 0x0C01008801090A00ULL, 0x0808010401140C00ULL,
  45   0x04004830C2020040ULL, 0x0080005002020054ULL, 0x40000C14481A0490ULL,
  46   0x0010500101042048ULL, 0x1010100200424000ULL, 0x0000640901901040ULL,
  47   0x00000A0201014840ULL, 0x00840082AA011002ULL, 0x010010840084240AULL,
  48   0x0420400810420608ULL, 0x8D40230408102100ULL, 0x4A00200612222409ULL,
  49   0x0A08520292120600ULL
  50 };
  51
  52 const uint64_t RMult[64] = {
  53   0x0A8002C000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL,
  54   0x0380180080141000ULL, 0x1A00060008211044ULL, 0x410001000A0C0008ULL,
  55   0x9500060004008100ULL, 0x0100024284A20700ULL, 0x0000802140008000ULL,
  56   0x0080C01002A00840ULL, 0x0402004282011020ULL, 0x9862000820420050ULL,
  57   0x0001001448011100ULL, 0x6432800200800400ULL, 0x040100010002000CULL,
  58   0x0002800D0010C080ULL, 0x90C0008000803042ULL, 0x4010004000200041ULL,
  59   0x0003010010200040ULL, 0x0A40828028001000ULL, 0x0123010008000430ULL,
  60   0x0024008004020080ULL, 0x0060040001104802ULL, 0x00582200028400D1ULL,
  61   0x4000802080044000ULL, 0x0408208200420308ULL, 0x0610038080102000ULL,
  62   0x3601000900100020ULL, 0x0000080080040180ULL, 0x00C2020080040080ULL,
  63   0x0080084400100102ULL, 0x4022408200014401ULL, 0x0040052040800082ULL,
  64   0x0B08200280804000ULL, 0x008A80A008801000ULL, 0x4000480080801000ULL,
  65   0x0911808800801401ULL, 0x822A003002001894ULL, 0x401068091400108AULL,
  66   0x000004A10A00004CULL, 0x2000800640008024ULL, 0x1486408102020020ULL,
  67   0x000100A000D50041ULL, 0x00810050020B0020ULL, 0x0204000800808004ULL,
  68   0x00020048100A000CULL, 0x0112000831020004ULL, 0x0009000040810002ULL,
  69   0x0440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL,
  70   0x4B824A2010010100ULL, 0x04080801810C0080ULL, 0x00000400802A0080ULL,
  71   0x8224080110026400ULL, 0x40002C4104088200ULL, 0x01002100104A0282ULL,
  72   0x1208400811048021ULL, 0x3201014A40D02001ULL, 0x0005100019200501ULL,
  73   0x0101000208001005ULL, 0x0002008450080702ULL, 0x001002080301D00CULL,
  74   0x410201CE5C030092ULL
  75 };
  76
  77 const int BShift[64] = {
  78   58, 59, 59, 59, 59, 59, 59, 58, 59, 59, 59, 59, 59, 59, 59, 59,
  79   59, 59, 57, 57, 57, 57, 59, 59, 59, 59, 57, 55, 55, 57, 59, 59,
  80   59, 59, 57, 55, 55, 57, 59, 59, 59, 59, 57, 57, 57, 57, 59, 59,
  81   59, 59, 59, 59, 59, 59, 59, 59, 58, 59, 59, 59, 59, 59, 59, 58
  82 };
  83
  84 const int RShift[64] = {
  85   52, 53, 53, 53, 53, 53, 53, 52, 53, 54, 54, 54, 54, 54, 54, 53,
  86   53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
  87   53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
  88   53, 54, 54, 54, 54, 54, 54, 53, 52, 53, 53, 53, 53, 53, 53, 52
  89 };
  90
  91 #else // if !defined(IS_64BIT)
  92
  93 const uint64_t BMult[64] = {
  94   0x54142844C6A22981ULL, 0x710358A6EA25C19EULL, 0x704F746D63A4A8DCULL,
  95   0xBFED1A0B80F838C5ULL, 0x90561D5631E62110ULL, 0x2804260376E60944ULL,
  96   0x84A656409AA76871ULL, 0xF0267F64C28B6197ULL, 0x70764EBB762F0585ULL,
  97   0x92AA09E0CFE161DEULL, 0x41EE1F6BB266F60EULL, 0xDDCBF04F6039C444ULL,
  98   0x5A3FAB7BAC0D988AULL, 0xD3727877FA4EAA03ULL, 0xD988402D868DDAAEULL,
  99   0x812B291AFA075C7CULL, 0x94FAF987B685A932ULL, 0x3ED867D8470D08DBULL,
 100   0x92517660B8901DE8ULL, 0x2D97E43E058814B4ULL, 0x880A10C220B25582ULL,
 101   0xC7C6520D1F1A0477ULL, 0xDBFC7FBCD7656AA6ULL, 0x78B1B9BFB1A2B84FULL,
 102   0x2F20037F112A0BC1ULL, 0x657171EA2269A916ULL, 0xC08302B07142210EULL,
 103   0x0880A4403064080BULL, 0x3602420842208C00ULL, 0x852800DC7E0B6602ULL,
 104   0x595A3FBBAA0F03B2ULL, 0x9F01411558159D5EULL, 0x2B4A4A5F88B394F2ULL,
 105   0x4AFCBFFC292DD03AULL, 0x4A4094A3B3F10522ULL, 0xB06F00B491F30048ULL,
 106   0xD5B3820280D77004ULL, 0x8B2E01E7C8E57A75ULL, 0x2D342794E886C2E6ULL,
 107   0xC302C410CDE21461ULL, 0x111F426F1379C274ULL, 0xE0569220ABB31588ULL,
 108   0x5026D3064D453324ULL, 0xE2076040C343CD8AULL, 0x93EFD1E1738021EEULL,
 109   0xB680804BED143132ULL, 0x44E361B21986944CULL, 0x44C60170EF5C598CULL,
 110   0xF4DA475C195C9C94ULL, 0xA3AFBB5F72060B1DULL, 0xBC75F410E41C4FFCULL,
 111   0xB51C099390520922ULL, 0x902C011F8F8EC368ULL, 0x950B56B3D6F5490AULL,
 112   0x3909E0635BF202D0ULL, 0x5744F90206EC10CCULL, 0xDC59FD76317ABBC1ULL,
 113   0x881C7C67FCBFC4F6ULL, 0x47CA41E7E440D423ULL, 0xEB0C88112048D004ULL,
 114   0x51C60E04359AEF1AULL, 0x1AA1FE0E957A5554ULL, 0xDD9448DB4F5E3104ULL,
 115   0xDC01F6DCA4BEBBDCULL,
 116 };
 117
 118 const uint64_t RMult[64] = {
 119   0xD7445CDEC88002C0ULL, 0xD0A505C1F2001722ULL, 0xE065D1C896002182ULL,
 120   0x9A8C41E75A000892ULL, 0x8900B10C89002AA8ULL, 0x9B28D1C1D60005A2ULL,
 121   0x015D6C88DE002D9AULL, 0xB1DBFC802E8016A9ULL, 0x149A1042D9D60029ULL,
 122   0xB9C08050599E002FULL, 0x132208C3AF300403ULL, 0xC1000CE2E9C50070ULL,
 123   0x9D9AA13C99020012ULL, 0xB6B078DAF71E0046ULL, 0x9D880182FB6E002EULL,
 124   0x52889F467E850037ULL, 0xDA6DC008D19A8480ULL, 0x468286034F902420ULL,
 125   0x7140AC09DC54C020ULL, 0xD76FFFFA39548808ULL, 0xEA901C4141500808ULL,
 126   0xC91004093F953A02ULL, 0x02882AFA8F6BB402ULL, 0xAEBE335692442C01ULL,
 127   0x0E904A22079FB91EULL, 0x13A514851055F606ULL, 0x76C782018C8FE632ULL,
 128   0x1DC012A9D116DA06ULL, 0x3C9E0037264FFFA6ULL, 0x2036002853C6E4A2ULL,
 129   0xE3FE08500AFB47D4ULL, 0xF38AF25C86B025C2ULL, 0xC0800E2182CF9A40ULL,
 130   0x72002480D1F60673ULL, 0x2500200BAE6E9B53ULL, 0xC60018C1EEFCA252ULL,
 131   0x0600590473E3608AULL, 0x46002C4AB3FE51B2ULL, 0xA200011486BCC8D2ULL,
 132   0xB680078095784C63ULL, 0x2742002639BF11AEULL, 0xC7D60021A5BDB142ULL,
 133   0xC8C04016BB83D820ULL, 0xBD520028123B4842ULL, 0x9D1600344AC2A832ULL,
 134   0x6A808005631C8A05ULL, 0x604600A148D5389AULL, 0xE2E40103D40DEA65ULL,
 135   0x945B5A0087C62A81ULL, 0x012DC200CD82D28EULL, 0x2431C600B5F9EF76ULL,
 136   0xFB142A006A9B314AULL, 0x06870E00A1C97D62ULL, 0x2A9DB2004A2689A2ULL,
 137   0xD3594600CAF5D1A2ULL, 0xEE0E4900439344A7ULL, 0x89C4D266CA25007AULL,
 138   0x3E0013A2743F97E3ULL, 0x0180E31A0431378AULL, 0x3A9E465A4D42A512ULL,
 139   0x98D0A11A0C0D9CC2ULL, 0x8E711C1ABA19B01EULL, 0x8DCDC836DD201142ULL,
 140   0x5AC08A4735370479ULL,
 141 };
 142
 143 const int BShift[64] = {
 144   26, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 27, 27,
 145   27, 27, 25, 25, 25, 25, 27, 27, 27, 27, 25, 23, 23, 25, 27, 27,
 146   27, 27, 25, 23, 23, 25, 27, 27, 27, 27, 25, 25, 25, 25, 27, 27,
 147   27, 27, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 26
 148 };
 149
 150 const int RShift[64] = {
 151   20, 21, 21, 21, 21, 21, 21, 20, 21, 22, 22, 22, 22, 22, 22, 21,
 152   21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
 153   21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
 154   21, 22, 22, 22, 22, 22, 22, 21, 20, 21, 21, 21, 21, 21, 21, 20
 155 };
 156
 157 #endif // defined(IS_64BIT)
 158
 159 // Global bitboards definitions with static storage duration are
 160 // automatically set to zero before enter main().
 161 Bitboard RMask[64];
 162 int RAttackIndex[64];
 163 Bitboard RAttacks[0x19000];
 164
 165 Bitboard BMask[64];
 166 int BAttackIndex[64];
 167 Bitboard BAttacks[0x1480];
 168
 169 Bitboard SetMaskBB[65];
 170 Bitboard ClearMaskBB[65];
 171
 172 Bitboard SquaresByColorBB[2];
 173 Bitboard FileBB[8];
 174 Bitboard RankBB[8];
 175 Bitboard NeighboringFilesBB[8];
 176 Bitboard ThisAndNeighboringFilesBB[8];
 177 Bitboard InFrontBB[2][8];
 178 Bitboard StepAttacksBB[16][64];
 179 Bitboard BetweenBB[64][64];
 180 Bitboard SquaresInFrontMask[2][64];
 181 Bitboard PassedPawnMask[2][64];
 182 Bitboard AttackSpanMask[2][64];
 183
 184 Bitboard BishopPseudoAttacks[64];
 185 Bitboard RookPseudoAttacks[64];
 186 Bitboard QueenPseudoAttacks[64];
 187
 188 uint8_t BitCount8Bit[256];
 189
 190
 191 namespace {
 192
 193   void init_masks();
 194   void init_step_attacks();
 195   void init_pseudo_attacks();
 196   void init_between_bitboards();
 197   Bitboard index_to_bitboard(int index, Bitboard mask);
 198   Bitboard sliding_attacks(int sq, Bitboard occupied, int deltas[][2],
 199                            int fmin, int fmax, int rmin, int rmax);
 200   void init_sliding_attacks(Bitboard attacks[], int attackIndex[], Bitboard mask[],
 201                             const int shift[], const Bitboard mult[], int deltas[][2]);
 202 }
 203
 204
 205 /// print_bitboard() prints a bitboard in an easily readable format to the
 206 /// standard output. This is sometimes useful for debugging.
 207
 208 void print_bitboard(Bitboard b) {
 209
 210   for (Rank r = RANK_8; r >= RANK_1; r--)
 211   {
 212       std::cout << "+---+---+---+---+---+---+---+---+" << '\n';
 213       for (File f = FILE_A; f <= FILE_H; f++)
 214           std::cout << "| " << (bit_is_set(b, make_square(f, r)) ? 'X' : ' ') << ' ';
 215
 216       std::cout << "|\n";
 217   }
 218   std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
 219 }
 220
 221
 222 /// first_1() finds the least significant nonzero bit in a nonzero bitboard.
 223 /// pop_1st_bit() finds and clears the least significant nonzero bit in a
 224 /// nonzero bitboard.
 225
 226 #if defined(IS_64BIT) && !defined(USE_BSFQ)
 227
 228 static CACHE_LINE_ALIGNMENT
 229 const int BitTable[64] = {
 230    0,  1,  2,  7,  3, 13,  8, 19,  4, 25, 14, 28,  9, 34, 20, 40,  5, 17, 26,
 231   38, 15, 46, 29, 48, 10, 31, 35, 54, 21, 50, 41, 57, 63,  6, 12, 18, 24, 27,
 232   33, 39, 16, 37, 45, 47, 30, 53, 49, 56, 62, 11, 23, 32, 36, 44, 52, 55, 61,
 233   22, 43, 51, 60, 42, 59, 58
 234 };
 235
 236 Square first_1(Bitboard b) {
 237   return Square(BitTable[((b & -b) * 0x218a392cd3d5dbfULL) >> 58]);
 238 }
 239
 240 Square pop_1st_bit(Bitboard* b) {
 241   Bitboard bb = *b;
 242   *b &= (*b - 1);
 243   return Square(BitTable[((bb & -bb) * 0x218a392cd3d5dbfULL) >> 58]);
 244 }
 245
 246 #elif !defined(USE_BSFQ)
 247
 248 static CACHE_LINE_ALIGNMENT
 249 const int BitTable[64] = {
 250   63, 30,  3, 32, 25, 41, 22, 33, 15, 50, 42, 13, 11, 53, 19, 34, 61, 29,  2,
 251   51, 21, 43, 45, 10, 18, 47,  1, 54,  9, 57,  0, 35, 62, 31, 40,  4, 49,  5,
 252   52, 26, 60,  6, 23, 44, 46, 27, 56, 16,  7, 39, 48, 24, 59, 14, 12, 55, 38,
 253   28, 58, 20, 37, 17, 36, 8
 254 };
 255
 256 Square first_1(Bitboard b) {
 257
 258   b ^= (b - 1);
 259   uint32_t fold = int(b) ^ int(b >> 32);
 260   return Square(BitTable[(fold * 0x783a9b23) >> 26]);
 261 }
 262
 263 // Use type-punning
 264 union b_union {
 265
 266     Bitboard b;
 267     struct {
 268 #if defined (BIGENDIAN)
 269         uint32_t h;
 270         uint32_t l;
 271 #else
 272         uint32_t l;
 273         uint32_t h;
 274 #endif
 275     } dw;
 276 };
 277
 278 Square pop_1st_bit(Bitboard* bb) {
 279
 280    b_union u;
 281    Square ret;
 282
 283    u.b = *bb;
 284
 285    if (u.dw.l)
 286    {
 287        ret = Square(BitTable[((u.dw.l ^ (u.dw.l - 1)) * 0x783a9b23) >> 26]);
 288        u.dw.l &= (u.dw.l - 1);
 289        *bb = u.b;
 290        return ret;
 291    }
 292    ret = Square(BitTable[((~(u.dw.h ^ (u.dw.h - 1))) * 0x783a9b23) >> 26]);
 293    u.dw.h &= (u.dw.h - 1);
 294    *bb = u.b;
 295    return ret;
 296 }
 297
 298 #endif // !defined(USE_BSFQ)
 299
 300
 301 /// init_bitboards() initializes various bitboard arrays. It is called during
 302 /// program initialization.
 303
 304 void init_bitboards() {
 305
 306   int rookDeltas[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
 307   int bishopDeltas[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
 308
 309   init_masks();
 310   init_step_attacks();
 311   init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
 312   init_sliding_attacks(BAttacks, BAttackIndex, BMask, BShift, BMult, bishopDeltas);
 313   init_pseudo_attacks();
 314   init_between_bitboards();
 315 }
 316
 317 namespace {
 318
 319   // All functions below are used to precompute various bitboards during
 320   // program initialization.  Some of the functions may be difficult to
 321   // understand, but they all seem to work correctly, and it should never
 322   // be necessary to touch any of them.
 323
 324   void init_masks() {
 325
 326     SquaresByColorBB[DARK]  =  0xAA55AA55AA55AA55ULL;
 327     SquaresByColorBB[LIGHT] = ~SquaresByColorBB[DARK];
 328
 329     FileBB[FILE_A] = FileABB;
 330     RankBB[RANK_1] = Rank1BB;
 331
 332     for (int f = FILE_B; f <= FILE_H; f++)
 333     {
 334         FileBB[f] = FileBB[f - 1] << 1;
 335         RankBB[f] = RankBB[f - 1] << 8;
 336     }
 337
 338     for (int f = FILE_A; f <= FILE_H; f++)
 339     {
 340         NeighboringFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
 341         ThisAndNeighboringFilesBB[f] = FileBB[f] | NeighboringFilesBB[f];
 342     }
 343
 344     for (int rw = RANK_7, rb = RANK_2; rw >= RANK_1; rw--, rb++)
 345     {
 346         InFrontBB[WHITE][rw] = InFrontBB[WHITE][rw + 1] | RankBB[rw + 1];
 347         InFrontBB[BLACK][rb] = InFrontBB[BLACK][rb - 1] | RankBB[rb - 1];
 348     }
 349
 350     SetMaskBB[SQ_NONE] = EmptyBoardBB;
 351     ClearMaskBB[SQ_NONE] = ~SetMaskBB[SQ_NONE];
 352
 353     for (Square s = SQ_A1; s <= SQ_H8; s++)
 354     {
 355         SetMaskBB[s] = (1ULL << s);
 356         ClearMaskBB[s] = ~SetMaskBB[s];
 357     }
 358
 359     for (Color c = WHITE; c <= BLACK; c++)
 360         for (Square s = SQ_A1; s <= SQ_H8; s++)
 361         {
 362             SquaresInFrontMask[c][s] = in_front_bb(c, s) & file_bb(s);
 363             PassedPawnMask[c][s] = in_front_bb(c, s) & this_and_neighboring_files_bb(s);
 364             AttackSpanMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
 365         }
 366
 367     for (Bitboard b = 0; b < 256; b++)
 368         BitCount8Bit[b] = (uint8_t)count_1s<CNT32>(b);
 369   }
 370
 371   void init_step_attacks() {
 372
 373     const int step[][9] =  {
 374       {0},
 375       {7,9,0}, {17,15,10,6,-6,-10,-15,-17,0}, {0}, {0}, {0},
 376       {9,7,-7,-9,8,1,-1,-8,0}, {0}, {0},
 377       {-7,-9,0}, {17,15,10,6,-6,-10,-15,-17,0}, {0}, {0}, {0},
 378       {9,7,-7,-9,8,1,-1,-8,0}
 379     };
 380
 381     for (Square s = SQ_A1; s <= SQ_H8; s++)
 382         for (Piece pc = WP; pc <= BK; pc++)
 383             for (int k = 0; step[pc][k] != 0; k++)
 384             {
 385                 Square to = s + Square(step[pc][k]);
 386
 387                 if (square_is_ok(to) && square_distance(s, to) < 3)
 388                     set_bit(&StepAttacksBB[pc][s], to);
 389            }
 390   }
 391
 392   Bitboard sliding_attacks(int sq, Bitboard occupied, int deltas[][2],
 393                            int fmin, int fmax, int rmin, int rmax) {
 394     int dx, dy, f, r;
 395     int rk = sq / 8;
 396     int fl = sq % 8;
 397     Bitboard attacks = EmptyBoardBB;
 398
 399     for (int i = 0; i < 4; i++)
 400     {
 401         dx = deltas[i][0];
 402         dy = deltas[i][1];
 403         f = fl + dx;
 404         r = rk + dy;
 405
 406         while (   (dx == 0 || (f >= fmin && f <= fmax))
 407                && (dy == 0 || (r >= rmin && r <= rmax)))
 408         {
 409             attacks |= (1ULL << (f + r * 8));
 410
 411             if (occupied & (1ULL << (f + r * 8)))
 412                 break;
 413
 414             f += dx;
 415             r += dy;
 416         }
 417     }
 418     return attacks;
 419   }
 420
 421   Bitboard index_to_bitboard(int index, Bitboard mask) {
 422
 423     Bitboard result = EmptyBoardBB;
 424     int sq, cnt = 0;
 425
 426     while (mask)
 427     {
 428         sq = pop_1st_bit(&mask);
 429
 430         if (index & (1 << cnt++))
 431             result |= (1ULL << sq);
 432     }
 433     return result;
 434   }
 435
 436   void init_sliding_attacks(Bitboard attacks[], int attackIndex[], Bitboard mask[],
 437                             const int shift[], const Bitboard mult[], int deltas[][2]) {
 438     Bitboard b, v;
 439     int i, j, index;
 440
 441     for (i = index = 0; i < 64; i++)
 442     {
 443         attackIndex[i] = index;
 444         mask[i] = sliding_attacks(i, 0, deltas, 1, 6, 1, 6);
 445         j = 1 << ((CpuIs64Bit ? 64 : 32) - shift[i]);
 446
 447         for (int k = 0; k < j; k++)
 448         {
 449             b = index_to_bitboard(k, mask[i]);
 450             v = CpuIs64Bit ? b * mult[i] : unsigned(b * mult[i] ^ (b >> 32) * (mult[i] >> 32));
 451             attacks[index + (v >> shift[i])] = sliding_attacks(i, b, deltas, 0, 7, 0, 7);
 452         }
 453         index += j;
 454     }
 455   }
 456
 457   void init_pseudo_attacks() {
 458
 459     for (Square s = SQ_A1; s <= SQ_H8; s++)
 460     {
 461         BishopPseudoAttacks[s] = bishop_attacks_bb(s, EmptyBoardBB);
 462         RookPseudoAttacks[s]   = rook_attacks_bb(s, EmptyBoardBB);
 463         QueenPseudoAttacks[s]  = queen_attacks_bb(s, EmptyBoardBB);
 464     }
 465   }
 466
 467   void init_between_bitboards() {
 468
 469     Square s1, s2, s3, d;
 470     int f, r;
 471
 472     for (s1 = SQ_A1; s1 <= SQ_H8; s1++)
 473         for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
 474             if (bit_is_set(QueenPseudoAttacks[s1], s2))
 475             {
 476                 f = file_distance(s1, s2);
 477                 r = rank_distance(s1, s2);
 478
 479                 d = (s2 - s1) / Max(f, r);
 480
 481                 for (s3 = s1 + d; s3 != s2; s3 += d)
 482                     set_bit(&(BetweenBB[s1][s2]), s3);
 483             }
 484   }
 485
 486 }