+// Bitboard type
+typedef uint64_t Bitboard;
+
+
+////
+//// Configuration
+////
+
+//// For Linux and OSX configuration is done automatically using Makefile.
+//// To get started type "make help".
+////
+//// For windows part of the configuration is detected automatically, but
+//// some switches need to be set manually:
+////
+//// -DNDEBUG | Disable debugging mode. Use always.
+////
+//// -DNO_PREFETCH | Disable use of prefetch asm-instruction. A must if you want the
+//// | executable to run on some very old machines.
+////
+//// -DUSE_POPCNT | Add runtime support for use of popcnt asm-instruction.
+//// | Works only in 64-bit mode. For compiling requires hardware
+//// | with popcnt support. Around 4% speed-up.
+
+// Automatic detection for 64-bit under Windows
+#if defined(_WIN64)
+#define IS_64BIT
+#endif
+
+// Automatic detection for use of bsfq asm-instruction under Windows.
+// Works only in 64-bit mode. Does not work with MSVC.
+#if defined(_WIN64) && defined(__INTEL_COMPILER)
+#define USE_BSFQ
+#endif
+
+// Cache line alignment specification
+#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
+#define CACHE_LINE_ALIGNMENT __declspec(align(64))
+#else
+#define CACHE_LINE_ALIGNMENT __attribute__ ((aligned(64)))
+#endif
+
+// Define a __cpuid() function for gcc compilers, for Intel and MSVC
+// is already available as an intrinsic.
+#if defined(_MSC_VER)
+#include <intrin.h>
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+inline void __cpuid(int CPUInfo[4], int InfoType)
+{
+ int* eax = CPUInfo + 0;
+ int* ebx = CPUInfo + 1;
+ int* ecx = CPUInfo + 2;
+ int* edx = CPUInfo + 3;
+
+ *eax = InfoType;
+ *ecx = 0;
+ __asm__("cpuid" : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)
+ : "0" (*eax), "2" (*ecx));
+}
+#else
+inline void __cpuid(int CPUInfo[4], int)
+{
+ CPUInfo[0] = CPUInfo[1] = CPUInfo[2] = CPUInfo[3] = 0;
+}
+#endif
+
+
+// Templetized operators used by enum types like Depth, Piece, Square and so on.
+// We don't want to write the same inline for each different enum. Note that we
+// pass by value (to silence scaring warnings on volatiles), so you really should
+// use only enum types with these functions to avoid hidden copies.
+
+template<typename T>
+inline T operator+ (const T d1, const T d2) { return T(int(d1) + int(d2)); }
+
+template<typename T>
+inline T operator- (const T d1, const T d2) { return T(int(d1) - int(d2)); }
+
+template<typename T>
+inline T operator* (int i, const T d) { return T(i * int(d)); }
+
+template<typename T>
+inline T operator* (const T d, int i) { return T(int(d) * i); }
+
+template<typename T>
+inline T operator/ (const T d, int i) { return T(int(d) / i); }
+
+template<typename T>
+inline T operator- (const T d) { return T(-int(d)); }
+
+template<typename T>
+inline void operator++ (T& d, int) { d = T(int(d) + 1); }
+
+template<typename T>
+inline void operator-- (T& d, int) { d = T(int(d) - 1); }
+
+template<typename T>
+inline void operator+= (T& d1, const T d2) { d1 = d1 + d2; }
+
+template<typename T>
+inline void operator-= (T& d1, const T d2) { d1 = d1 - d2; }
+
+template<typename T>
+inline void operator*= (T& d, int i) { d = T(int(d) * i); }
+
+template<typename T>
+inline void operator/= (T& d, int i) { d = T(int(d) / i); }
+