diff --git a/src/.DS_Store b/src/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..dc01b496a4ed7f333a7d9953665381ebfa5bed77
Binary files /dev/null and b/src/.DS_Store differ
diff --git a/src/Makefile b/src/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..917bd5c06c7a83f9d4c48f9a531df196b0cb2d9d
--- /dev/null
+++ b/src/Makefile
@@ -0,0 +1,1009 @@
+# Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+# Copyright (C) 2004-2022 The Stockfish developers (see AUTHORS file)
+#
+# Stockfish is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Stockfish is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see .
+
+
+### ==========================================================================
+### Section 1. General Configuration
+### ==========================================================================
+
+### Establish the operating system name
+KERNEL = $(shell uname -s)
+ifeq ($(KERNEL),Linux)
+ OS = $(shell uname -o)
+endif
+
+### Target Windows OS
+ifeq ($(OS),Windows_NT)
+ ifneq ($(COMP),ndk)
+ target_windows = yes
+ endif
+else ifeq ($(COMP),mingw)
+ target_windows = yes
+ ifeq ($(WINE_PATH),)
+ WINE_PATH = $(shell which wine)
+ endif
+endif
+
+### Executable name
+ifeq ($(target_windows),yes)
+ EXE = stockfish.exe
+else
+ EXE = stockfish
+endif
+
+### Installation dir definitions
+PREFIX = /usr/local
+BINDIR = $(PREFIX)/bin
+
+### Built-in benchmark for pgo-builds
+ifeq ($(SDE_PATH),)
+ PGOBENCH = $(WINE_PATH) ./$(EXE) bench
+else
+ PGOBENCH = $(SDE_PATH) -- $(WINE_PATH) ./$(EXE) bench
+endif
+
+### Source and object files
+SRCS = benchmark.cpp bitbase.cpp bitboard.cpp endgame.cpp evaluate.cpp main.cpp \
+ material.cpp misc.cpp movegen.cpp movepick.cpp pawns.cpp position.cpp psqt.cpp \
+ search.cpp thread.cpp timeman.cpp tt.cpp uci.cpp ucioption.cpp tune.cpp syzygy/tbprobe.cpp \
+ nnue/evaluate_nnue.cpp nnue/features/half_ka_v2_hm.cpp
+
+OBJS = $(notdir $(SRCS:.cpp=.o))
+
+VPATH = syzygy:nnue:nnue/features
+
+### ==========================================================================
+### Section 2. High-level Configuration
+### ==========================================================================
+#
+# flag --- Comp switch --- Description
+# ----------------------------------------------------------------------------
+#
+# debug = yes/no --- -DNDEBUG --- Enable/Disable debug mode
+# sanitize = none/ ... (-fsanitize )
+# --- ( undefined ) --- enable undefined behavior checks
+# --- ( thread ) --- enable threading error checks
+# --- ( address ) --- enable memory access checks
+# --- ...etc... --- see compiler documentation for supported sanitizers
+# optimize = yes/no --- (-O3/-fast etc.) --- Enable/Disable optimizations
+# arch = (name) --- (-arch) --- Target architecture
+# bits = 64/32 --- -DIS_64BIT --- 64-/32-bit operating system
+# prefetch = yes/no --- -DUSE_PREFETCH --- Use prefetch asm-instruction
+# popcnt = yes/no --- -DUSE_POPCNT --- Use popcnt asm-instruction
+# pext = yes/no --- -DUSE_PEXT --- Use pext x86_64 asm-instruction
+# sse = yes/no --- -msse --- Use Intel Streaming SIMD Extensions
+# mmx = yes/no --- -mmmx --- Use Intel MMX instructions
+# sse2 = yes/no --- -msse2 --- Use Intel Streaming SIMD Extensions 2
+# ssse3 = yes/no --- -mssse3 --- Use Intel Supplemental Streaming SIMD Extensions 3
+# sse41 = yes/no --- -msse4.1 --- Use Intel Streaming SIMD Extensions 4.1
+# avx2 = yes/no --- -mavx2 --- Use Intel Advanced Vector Extensions 2
+# avxvnni = yes/no --- -mavxvnni --- Use Intel Vector Neural Network Instructions AVX
+# avx512 = yes/no --- -mavx512bw --- Use Intel Advanced Vector Extensions 512
+# vnni256 = yes/no --- -mavx512vnni --- Use Intel Vector Neural Network Instructions 256
+# vnni512 = yes/no --- -mavx512vnni --- Use Intel Vector Neural Network Instructions 512
+# neon = yes/no --- -DUSE_NEON --- Use ARM SIMD architecture
+#
+# Note that Makefile is space sensitive, so when adding new architectures
+# or modifying existing flags, you have to make sure there are no extra spaces
+# at the end of the line for flag values.
+#
+# Example of use for these flags:
+# make build ARCH=x86-64-avx512 debug=yes sanitize="address undefined"
+
+
+### 2.1. General and architecture defaults
+
+ifeq ($(ARCH),)
+ ARCH = x86-64-modern
+ help_skip_sanity = yes
+endif
+# explicitly check for the list of supported architectures (as listed with make help),
+# the user can override with `make ARCH=x86-32-vnni256 SUPPORTED_ARCH=true`
+ifeq ($(ARCH), $(filter $(ARCH), \
+ x86-64-vnni512 x86-64-vnni256 x86-64-avx512 x86-64-avxvnni x86-64-bmi2 \
+ x86-64-avx2 x86-64-sse41-popcnt x86-64-modern x86-64-ssse3 x86-64-sse3-popcnt \
+ x86-64 x86-32-sse41-popcnt x86-32-sse2 x86-32 ppc-64 ppc-32 e2k \
+ armv7 armv7-neon armv8 apple-silicon general-64 general-32 riscv64))
+ SUPPORTED_ARCH=true
+else
+ SUPPORTED_ARCH=false
+endif
+
+optimize = yes
+debug = no
+sanitize = none
+bits = 64
+prefetch = no
+popcnt = no
+pext = no
+sse = no
+mmx = no
+sse2 = no
+ssse3 = no
+sse41 = no
+avx2 = no
+avxvnni = no
+avx512 = no
+vnni256 = no
+vnni512 = no
+neon = no
+arm_version = 0
+STRIP = strip
+
+### 2.2 Architecture specific
+
+ifeq ($(findstring x86,$(ARCH)),x86)
+
+# x86-32/64
+
+ifeq ($(findstring x86-32,$(ARCH)),x86-32)
+ arch = i386
+ bits = 32
+ sse = no
+ mmx = yes
+else
+ arch = x86_64
+ sse = yes
+ sse2 = yes
+endif
+
+ifeq ($(findstring -sse,$(ARCH)),-sse)
+ sse = yes
+endif
+
+ifeq ($(findstring -popcnt,$(ARCH)),-popcnt)
+ popcnt = yes
+endif
+
+ifeq ($(findstring -mmx,$(ARCH)),-mmx)
+ mmx = yes
+endif
+
+ifeq ($(findstring -sse2,$(ARCH)),-sse2)
+ sse = yes
+ sse2 = yes
+endif
+
+ifeq ($(findstring -ssse3,$(ARCH)),-ssse3)
+ sse = yes
+ sse2 = yes
+ ssse3 = yes
+endif
+
+ifeq ($(findstring -sse41,$(ARCH)),-sse41)
+ sse = yes
+ sse2 = yes
+ ssse3 = yes
+ sse41 = yes
+endif
+
+ifeq ($(findstring -modern,$(ARCH)),-modern)
+ popcnt = yes
+ sse = yes
+ sse2 = yes
+ ssse3 = yes
+ sse41 = yes
+endif
+
+ifeq ($(findstring -avx2,$(ARCH)),-avx2)
+ popcnt = yes
+ sse = yes
+ sse2 = yes
+ ssse3 = yes
+ sse41 = yes
+ avx2 = yes
+endif
+
+ifeq ($(findstring -avxvnni,$(ARCH)),-avxvnni)
+ popcnt = yes
+ sse = yes
+ sse2 = yes
+ ssse3 = yes
+ sse41 = yes
+ avx2 = yes
+ avxvnni = yes
+ pext = yes
+endif
+
+ifeq ($(findstring -bmi2,$(ARCH)),-bmi2)
+ popcnt = yes
+ sse = yes
+ sse2 = yes
+ ssse3 = yes
+ sse41 = yes
+ avx2 = yes
+ pext = yes
+endif
+
+ifeq ($(findstring -avx512,$(ARCH)),-avx512)
+ popcnt = yes
+ sse = yes
+ sse2 = yes
+ ssse3 = yes
+ sse41 = yes
+ avx2 = yes
+ pext = yes
+ avx512 = yes
+endif
+
+ifeq ($(findstring -vnni256,$(ARCH)),-vnni256)
+ popcnt = yes
+ sse = yes
+ sse2 = yes
+ ssse3 = yes
+ sse41 = yes
+ avx2 = yes
+ pext = yes
+ vnni256 = yes
+endif
+
+ifeq ($(findstring -vnni512,$(ARCH)),-vnni512)
+ popcnt = yes
+ sse = yes
+ sse2 = yes
+ ssse3 = yes
+ sse41 = yes
+ avx2 = yes
+ pext = yes
+ avx512 = yes
+ vnni512 = yes
+endif
+
+ifeq ($(sse),yes)
+ prefetch = yes
+endif
+
+# 64-bit pext is not available on x86-32
+ifeq ($(bits),32)
+ pext = no
+endif
+
+else
+
+# all other architectures
+
+ifeq ($(ARCH),general-32)
+ arch = any
+ bits = 32
+endif
+
+ifeq ($(ARCH),general-64)
+ arch = any
+endif
+
+ifeq ($(ARCH),armv7)
+ arch = armv7
+ prefetch = yes
+ bits = 32
+ arm_version = 7
+endif
+
+ifeq ($(ARCH),armv7-neon)
+ arch = armv7
+ prefetch = yes
+ popcnt = yes
+ neon = yes
+ bits = 32
+ arm_version = 7
+endif
+
+ifeq ($(ARCH),armv8)
+ arch = armv8
+ prefetch = yes
+ popcnt = yes
+ neon = yes
+ arm_version = 8
+endif
+
+ifeq ($(ARCH),apple-silicon)
+ arch = arm64
+ prefetch = yes
+ popcnt = yes
+ neon = yes
+ arm_version = 8
+endif
+
+ifeq ($(ARCH),ppc-32)
+ arch = ppc
+ bits = 32
+endif
+
+ifeq ($(ARCH),ppc-64)
+ arch = ppc64
+ popcnt = yes
+ prefetch = yes
+endif
+
+ifeq ($(findstring e2k,$(ARCH)),e2k)
+ arch = e2k
+ mmx = yes
+ bits = 64
+ sse = yes
+ sse2 = yes
+ ssse3 = yes
+ sse41 = yes
+ popcnt = yes
+endif
+
+ifeq ($(ARCH),riscv64)
+ arch = riscv64
+endif
+endif
+
+
+### ==========================================================================
+### Section 3. Low-level Configuration
+### ==========================================================================
+
+### 3.1 Selecting compiler (default = gcc)
+ifeq ($(MAKELEVEL),0)
+ export ENV_CXXFLAGS := $(CXXFLAGS)
+ export ENV_DEPENDFLAGS := $(DEPENDFLAGS)
+ export ENV_LDFLAGS := $(LDFLAGS)
+endif
+
+CXXFLAGS = $(ENV_CXXFLAGS) -Wall -Wcast-qual -fno-exceptions -std=c++17 $(EXTRACXXFLAGS)
+DEPENDFLAGS = $(ENV_DEPENDFLAGS) -std=c++17
+LDFLAGS = $(ENV_LDFLAGS) $(EXTRALDFLAGS)
+
+ifeq ($(COMP),)
+ COMP=gcc
+endif
+
+ifeq ($(COMP),gcc)
+ comp=gcc
+ CXX=g++
+ CXXFLAGS += -pedantic -Wextra -Wshadow
+
+ ifeq ($(arch),$(filter $(arch),armv7 armv8 riscv64))
+ ifeq ($(OS),Android)
+ CXXFLAGS += -m$(bits)
+ LDFLAGS += -m$(bits)
+ endif
+ ifeq ($(ARCH),riscv64)
+ CXXFLAGS += -latomic
+ endif
+ else
+ CXXFLAGS += -m$(bits)
+ LDFLAGS += -m$(bits)
+ endif
+
+ ifeq ($(arch),$(filter $(arch),armv7))
+ LDFLAGS += -latomic
+ endif
+
+ ifneq ($(KERNEL),Darwin)
+ LDFLAGS += -Wl,--no-as-needed
+ endif
+endif
+
+ifeq ($(target_windows),yes)
+ LDFLAGS += -static
+endif
+
+ifeq ($(COMP),mingw)
+ comp=mingw
+
+ ifeq ($(bits),64)
+ ifeq ($(shell which x86_64-w64-mingw32-c++-posix 2> /dev/null),)
+ CXX=x86_64-w64-mingw32-c++
+ else
+ CXX=x86_64-w64-mingw32-c++-posix
+ endif
+ else
+ ifeq ($(shell which i686-w64-mingw32-c++-posix 2> /dev/null),)
+ CXX=i686-w64-mingw32-c++
+ else
+ CXX=i686-w64-mingw32-c++-posix
+ endif
+ endif
+ CXXFLAGS += -pedantic -Wextra -Wshadow
+endif
+
+ifeq ($(COMP),icc)
+ comp=icc
+ CXX=icpc
+ CXXFLAGS += -diag-disable 1476,10120 -Wcheck -Wabi -Wdeprecated -strict-ansi
+endif
+
+ifeq ($(COMP),clang)
+ comp=clang
+ CXX=clang++
+ ifeq ($(target_windows),yes)
+ CXX=x86_64-w64-mingw32-clang++
+ endif
+
+ CXXFLAGS += -pedantic -Wextra -Wshadow
+
+ ifeq ($(filter $(KERNEL),Darwin OpenBSD FreeBSD),)
+ ifeq ($(target_windows),)
+ ifneq ($(RTLIB),compiler-rt)
+ LDFLAGS += -latomic
+ endif
+ endif
+ endif
+
+ ifeq ($(arch),$(filter $(arch),armv7 armv8 riscv64))
+ ifeq ($(OS),Android)
+ CXXFLAGS += -m$(bits)
+ LDFLAGS += -m$(bits)
+ endif
+ ifeq ($(ARCH),riscv64)
+ CXXFLAGS += -latomic
+ endif
+ else
+ CXXFLAGS += -m$(bits)
+ LDFLAGS += -m$(bits)
+ endif
+endif
+
+ifeq ($(KERNEL),Darwin)
+ CXXFLAGS += -mmacosx-version-min=10.14
+ LDFLAGS += -mmacosx-version-min=10.14
+ ifneq ($(arch),any)
+ CXXFLAGS += -arch $(arch)
+ LDFLAGS += -arch $(arch)
+ endif
+ XCRUN = xcrun
+endif
+
+# To cross-compile for Android, NDK version r21 or later is recommended.
+# In earlier NDK versions, you'll need to pass -fno-addrsig if using GNU binutils.
+# Currently we don't know how to make PGO builds with the NDK yet.
+ifeq ($(COMP),ndk)
+ CXXFLAGS += -stdlib=libc++ -fPIE
+ comp=clang
+ ifeq ($(arch),armv7)
+ CXX=armv7a-linux-androideabi16-clang++
+ CXXFLAGS += -mthumb -march=armv7-a -mfloat-abi=softfp -mfpu=neon
+ ifneq ($(shell which arm-linux-androideabi-strip 2>/dev/null),)
+ STRIP=arm-linux-androideabi-strip
+ else
+ STRIP=llvm-strip
+ endif
+ endif
+ ifeq ($(arch),armv8)
+ CXX=aarch64-linux-android21-clang++
+ ifneq ($(shell which aarch64-linux-android-strip 2>/dev/null),)
+ STRIP=aarch64-linux-android-strip
+ else
+ STRIP=llvm-strip
+ endif
+ endif
+ LDFLAGS += -static-libstdc++ -pie -lm -latomic
+endif
+
+ifeq ($(comp),icc)
+ profile_make = icc-profile-make
+ profile_use = icc-profile-use
+else ifeq ($(comp),clang)
+ profile_make = clang-profile-make
+ profile_use = clang-profile-use
+else
+ profile_make = gcc-profile-make
+ profile_use = gcc-profile-use
+ ifeq ($(KERNEL),Darwin)
+ EXTRAPROFILEFLAGS = -fvisibility=hidden
+ endif
+endif
+
+### Travis CI script uses COMPILER to overwrite CXX
+ifdef COMPILER
+ COMPCXX=$(COMPILER)
+endif
+
+### Allow overwriting CXX from command line
+ifdef COMPCXX
+ CXX=$(COMPCXX)
+endif
+
+### Sometimes gcc is really clang
+ifeq ($(COMP),gcc)
+ gccversion = $(shell $(CXX) --version)
+ gccisclang = $(findstring clang,$(gccversion))
+ ifneq ($(gccisclang),)
+ profile_make = clang-profile-make
+ profile_use = clang-profile-use
+ endif
+endif
+
+### On mingw use Windows threads, otherwise POSIX
+ifneq ($(comp),mingw)
+ CXXFLAGS += -DUSE_PTHREADS
+ # On Android Bionic's C library comes with its own pthread implementation bundled in
+ ifneq ($(OS),Android)
+ # Haiku has pthreads in its libroot, so only link it in on other platforms
+ ifneq ($(KERNEL),Haiku)
+ ifneq ($(COMP),ndk)
+ LDFLAGS += -lpthread
+ endif
+ endif
+ endif
+endif
+
+### 3.2.1 Debugging
+ifeq ($(debug),no)
+ CXXFLAGS += -DNDEBUG
+else
+ CXXFLAGS += -g
+endif
+
+### 3.2.2 Debugging with undefined behavior sanitizers
+ifneq ($(sanitize),none)
+ CXXFLAGS += -g3 $(addprefix -fsanitize=,$(sanitize))
+ LDFLAGS += $(addprefix -fsanitize=,$(sanitize))
+endif
+
+### 3.3 Optimization
+ifeq ($(optimize),yes)
+
+ CXXFLAGS += -O3
+
+ ifeq ($(comp),gcc)
+ ifeq ($(OS), Android)
+ CXXFLAGS += -fno-gcse -mthumb -march=armv7-a -mfloat-abi=softfp
+ endif
+ endif
+
+ ifeq ($(KERNEL),Darwin)
+ ifeq ($(comp),$(filter $(comp),clang icc))
+ CXXFLAGS += -mdynamic-no-pic
+ endif
+
+ ifeq ($(comp),gcc)
+ ifneq ($(arch),arm64)
+ CXXFLAGS += -mdynamic-no-pic
+ endif
+ endif
+ endif
+
+ ifeq ($(comp),clang)
+ CXXFLAGS += -fexperimental-new-pass-manager
+ endif
+endif
+
+### 3.4 Bits
+ifeq ($(bits),64)
+ CXXFLAGS += -DIS_64BIT
+endif
+
+### 3.5 prefetch and popcount
+ifeq ($(prefetch),yes)
+ ifeq ($(sse),yes)
+ CXXFLAGS += -msse
+ endif
+else
+ CXXFLAGS += -DNO_PREFETCH
+endif
+
+ifeq ($(popcnt),yes)
+ ifeq ($(arch),$(filter $(arch),ppc64 armv7 armv8 arm64))
+ CXXFLAGS += -DUSE_POPCNT
+ else ifeq ($(comp),icc)
+ CXXFLAGS += -msse3 -DUSE_POPCNT
+ else
+ CXXFLAGS += -msse3 -mpopcnt -DUSE_POPCNT
+ endif
+endif
+
+### 3.6 SIMD architectures
+ifeq ($(avx2),yes)
+ CXXFLAGS += -DUSE_AVX2
+ ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+ CXXFLAGS += -mavx2 -mbmi
+ endif
+endif
+
+ifeq ($(avxvnni),yes)
+ CXXFLAGS += -DUSE_VNNI -DUSE_AVXVNNI
+ ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+ CXXFLAGS += -mavxvnni
+ endif
+endif
+
+ifeq ($(avx512),yes)
+ CXXFLAGS += -DUSE_AVX512
+ ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+ CXXFLAGS += -mavx512f -mavx512bw
+ endif
+endif
+
+ifeq ($(vnni256),yes)
+ CXXFLAGS += -DUSE_VNNI
+ ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+ CXXFLAGS += -mavx512f -mavx512bw -mavx512vnni -mavx512dq -mavx512vl -mprefer-vector-width=256
+ endif
+endif
+
+ifeq ($(vnni512),yes)
+ CXXFLAGS += -DUSE_VNNI
+ ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+ CXXFLAGS += -mavx512vnni -mavx512dq -mavx512vl
+ endif
+endif
+
+ifeq ($(sse41),yes)
+ CXXFLAGS += -DUSE_SSE41
+ ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+ CXXFLAGS += -msse4.1
+ endif
+endif
+
+ifeq ($(ssse3),yes)
+ CXXFLAGS += -DUSE_SSSE3
+ ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+ CXXFLAGS += -mssse3
+ endif
+endif
+
+ifeq ($(sse2),yes)
+ CXXFLAGS += -DUSE_SSE2
+ ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+ CXXFLAGS += -msse2
+ endif
+endif
+
+ifeq ($(mmx),yes)
+ CXXFLAGS += -DUSE_MMX
+ ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+ CXXFLAGS += -mmmx
+ endif
+endif
+
+ifeq ($(neon),yes)
+ CXXFLAGS += -DUSE_NEON=$(arm_version)
+ ifeq ($(KERNEL),Linux)
+ ifneq ($(COMP),ndk)
+ ifneq ($(arch),armv8)
+ CXXFLAGS += -mfpu=neon
+ endif
+ endif
+ endif
+endif
+
+### 3.7 pext
+ifeq ($(pext),yes)
+ CXXFLAGS += -DUSE_PEXT
+ ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+ CXXFLAGS += -mbmi2
+ endif
+endif
+
+### 3.7.1 Try to include git commit sha for versioning
+GIT_SHA = $(shell git rev-parse --short HEAD 2>/dev/null)
+ifneq ($(GIT_SHA), )
+ CXXFLAGS += -DGIT_SHA=\"$(GIT_SHA)\"
+endif
+
+### 3.7.2 Try to include git commit date for versioning
+GIT_DATE = $(shell git show -s --date=format:'%Y%m%d' --format=%cd HEAD 2>/dev/null)
+ifneq ($(GIT_DATE), )
+ CXXFLAGS += -DGIT_DATE=\"$(GIT_DATE)\"
+endif
+
+### 3.8 Link Time Optimization
+### This is a mix of compile and link time options because the lto link phase
+### needs access to the optimization flags.
+ifeq ($(optimize),yes)
+ifeq ($(debug), no)
+ ifeq ($(comp),clang)
+ CXXFLAGS += -flto=full
+ ifeq ($(target_windows),yes)
+ CXXFLAGS += -fuse-ld=lld
+ endif
+ LDFLAGS += $(CXXFLAGS)
+
+# GCC and CLANG use different methods for parallelizing LTO and CLANG pretends to be
+# GCC on some systems.
+ else ifeq ($(comp),gcc)
+ ifeq ($(gccisclang),)
+ CXXFLAGS += -flto -flto-partition=one
+ LDFLAGS += $(CXXFLAGS) -flto=jobserver
+ else
+ CXXFLAGS += -flto=full
+ LDFLAGS += $(CXXFLAGS)
+ endif
+
+# To use LTO and static linking on Windows,
+# the tool chain requires gcc version 10.1 or later.
+ else ifeq ($(comp),mingw)
+ CXXFLAGS += -flto -flto-partition=one
+ LDFLAGS += $(CXXFLAGS) -save-temps
+ endif
+endif
+endif
+
+### 3.9 Android 5 can only run position independent executables. Note that this
+### breaks Android 4.0 and earlier.
+ifeq ($(OS), Android)
+ CXXFLAGS += -fPIE
+ LDFLAGS += -fPIE -pie
+endif
+
+### ==========================================================================
+### Section 4. Public Targets
+### ==========================================================================
+
+
+help:
+ @echo ""
+ @echo "To compile stockfish, type: "
+ @echo ""
+ @echo "make target ARCH=arch [COMP=compiler] [COMPCXX=cxx]"
+ @echo ""
+ @echo "Supported targets:"
+ @echo ""
+ @echo "help > Display architecture details"
+ @echo "build > Standard build"
+ @echo "net > Download the default nnue net"
+ @echo "profile-build > Faster build (with profile-guided optimization)"
+ @echo "strip > Strip executable"
+ @echo "install > Install executable"
+ @echo "clean > Clean up"
+ @echo ""
+ @echo "Supported archs:"
+ @echo ""
+ @echo "x86-64-vnni512 > x86 64-bit with vnni support 512bit wide"
+ @echo "x86-64-vnni256 > x86 64-bit with vnni support 256bit wide"
+ @echo "x86-64-avx512 > x86 64-bit with avx512 support"
+ @echo "x86-64-avxvnni > x86 64-bit with avxvnni support"
+ @echo "x86-64-bmi2 > x86 64-bit with bmi2 support"
+ @echo "x86-64-avx2 > x86 64-bit with avx2 support"
+ @echo "x86-64-sse41-popcnt > x86 64-bit with sse41 and popcnt support"
+ @echo "x86-64-modern > common modern CPU, currently x86-64-sse41-popcnt"
+ @echo "x86-64-ssse3 > x86 64-bit with ssse3 support"
+ @echo "x86-64-sse3-popcnt > x86 64-bit with sse3 and popcnt support"
+ @echo "x86-64 > x86 64-bit generic (with sse2 support)"
+ @echo "x86-32-sse41-popcnt > x86 32-bit with sse41 and popcnt support"
+ @echo "x86-32-sse2 > x86 32-bit with sse2 support"
+ @echo "x86-32 > x86 32-bit generic (with mmx and sse support)"
+ @echo "ppc-64 > PPC 64-bit"
+ @echo "ppc-32 > PPC 32-bit"
+ @echo "armv7 > ARMv7 32-bit"
+ @echo "armv7-neon > ARMv7 32-bit with popcnt and neon"
+ @echo "armv8 > ARMv8 64-bit with popcnt and neon"
+ @echo "e2k > Elbrus 2000"
+ @echo "apple-silicon > Apple silicon ARM64"
+ @echo "general-64 > unspecified 64-bit"
+ @echo "general-32 > unspecified 32-bit"
+ @echo "riscv64 > RISC-V 64-bit"
+ @echo ""
+ @echo "Supported compilers:"
+ @echo ""
+ @echo "gcc > Gnu compiler (default)"
+ @echo "mingw > Gnu compiler with MinGW under Windows"
+ @echo "clang > LLVM Clang compiler"
+ @echo "icc > Intel compiler"
+ @echo "ndk > Google NDK to cross-compile for Android"
+ @echo ""
+ @echo "Simple examples. If you don't know what to do, you likely want to run: "
+ @echo ""
+ @echo "make -j build ARCH=x86-64 (A portable, slow compile for 64-bit systems)"
+ @echo "make -j build ARCH=x86-32 (A portable, slow compile for 32-bit systems)"
+ @echo ""
+ @echo "Advanced examples, for experienced users looking for performance: "
+ @echo ""
+ @echo "make help ARCH=x86-64-bmi2"
+ @echo "make -j profile-build ARCH=x86-64-bmi2 COMP=gcc COMPCXX=g++-9.0"
+ @echo "make -j build ARCH=x86-64-ssse3 COMP=clang"
+ @echo ""
+ @echo "-------------------------------"
+ifeq ($(SUPPORTED_ARCH)$(help_skip_sanity), true)
+ @echo "The selected architecture $(ARCH) will enable the following configuration: "
+ @$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
+else
+ @echo "Specify a supported architecture with the ARCH option for more details"
+ @echo ""
+endif
+
+
+.PHONY: help build profile-build strip install clean net objclean profileclean \
+ config-sanity icc-profile-use icc-profile-make gcc-profile-use gcc-profile-make \
+ clang-profile-use clang-profile-make FORCE
+
+build: net config-sanity
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
+
+profile-build: net config-sanity objclean profileclean
+ @echo ""
+ @echo "Step 1/4. Building instrumented executable ..."
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_make)
+ @echo ""
+ @echo "Step 2/4. Running benchmark for pgo-build ..."
+ $(PGOBENCH) 2>&1 | tail -n 4
+ @echo ""
+ @echo "Step 3/4. Building optimized executable ..."
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) objclean
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_use)
+ @echo ""
+ @echo "Step 4/4. Deleting profile data ..."
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) profileclean
+
+strip:
+ $(STRIP) $(EXE)
+
+install:
+ -mkdir -p -m 755 $(BINDIR)
+ -cp $(EXE) $(BINDIR)
+ $(STRIP) $(BINDIR)/$(EXE)
+
+# clean all
+clean: objclean profileclean
+ @rm -f .depend *~ core
+
+# evaluation network (nnue)
+net:
+ $(eval nnuenet := $(shell grep EvalFileDefaultName evaluate.h | grep define | sed 's/.*\(nn-[a-z0-9]\{12\}.nnue\).*/\1/'))
+ @echo "Default net: $(nnuenet)"
+ $(eval nnuedownloadurl1 := https://tests.stockfishchess.org/api/nn/$(nnuenet))
+ $(eval nnuedownloadurl2 := https://github.com/official-stockfish/networks/raw/master/$(nnuenet))
+ $(eval curl_or_wget := $(shell if hash curl 2>/dev/null; then echo "curl -skL"; elif hash wget 2>/dev/null; then echo "wget -qO-"; fi))
+ @if [ "x$(curl_or_wget)" = "x" ]; then \
+ echo "Automatic download failed: neither curl nor wget is installed. Install one of these tools or download the net manually"; exit 1; \
+ fi
+ $(eval shasum_command := $(shell if hash shasum 2>/dev/null; then echo "shasum -a 256 "; elif hash sha256sum 2>/dev/null; then echo "sha256sum "; fi))
+ @if [ "x$(shasum_command)" = "x" ]; then \
+ echo "shasum / sha256sum not found, skipping net validation"; \
+ fi
+ @for nnuedownloadurl in "$(nnuedownloadurl1)" "$(nnuedownloadurl2)"; do \
+ if test -f "$(nnuenet)"; then \
+ echo "$(nnuenet) available."; \
+ else \
+ if [ "x$(curl_or_wget)" != "x" ]; then \
+ echo "Downloading $${nnuedownloadurl}"; $(curl_or_wget) $${nnuedownloadurl} > $(nnuenet);\
+ fi; \
+ fi; \
+ if [ "x$(shasum_command)" != "x" ]; then \
+ if [ "$(nnuenet)" != "nn-"`$(shasum_command) $(nnuenet) | cut -c1-12`".nnue" ]; then \
+ echo "Removing failed download"; rm -f $(nnuenet); \
+ else \
+ echo "Network validated"; break; \
+ fi; \
+ fi; \
+ done
+ @if ! test -f "$(nnuenet)"; then \
+ echo "Failed to download $(nnuenet)."; \
+ fi
+
+# clean binaries and objects
+objclean:
+ @rm -f stockfish stockfish.exe *.o ./syzygy/*.o ./nnue/*.o ./nnue/features/*.o
+
+# clean auxiliary profiling files
+profileclean:
+ @rm -rf profdir
+ @rm -f bench.txt *.gcda *.gcno ./syzygy/*.gcda ./nnue/*.gcda ./nnue/features/*.gcda *.s
+ @rm -f stockfish.profdata *.profraw
+ @rm -f stockfish.*args*
+ @rm -f stockfish.*lt*
+ @rm -f stockfish.res
+ @rm -f ./-lstdc++.res
+
+default:
+ help
+
+### ==========================================================================
+### Section 5. Private Targets
+### ==========================================================================
+
+all: $(EXE) .depend
+
+config-sanity: net
+ @echo ""
+ @echo "Config:"
+ @echo "debug: '$(debug)'"
+ @echo "sanitize: '$(sanitize)'"
+ @echo "optimize: '$(optimize)'"
+ @echo "arch: '$(arch)'"
+ @echo "bits: '$(bits)'"
+ @echo "kernel: '$(KERNEL)'"
+ @echo "os: '$(OS)'"
+ @echo "prefetch: '$(prefetch)'"
+ @echo "popcnt: '$(popcnt)'"
+ @echo "pext: '$(pext)'"
+ @echo "sse: '$(sse)'"
+ @echo "mmx: '$(mmx)'"
+ @echo "sse2: '$(sse2)'"
+ @echo "ssse3: '$(ssse3)'"
+ @echo "sse41: '$(sse41)'"
+ @echo "avx2: '$(avx2)'"
+ @echo "avxvnni: '$(avxvnni)'"
+ @echo "avx512: '$(avx512)'"
+ @echo "vnni256: '$(vnni256)'"
+ @echo "vnni512: '$(vnni512)'"
+ @echo "neon: '$(neon)'"
+ @echo "arm_version: '$(arm_version)'"
+ @echo ""
+ @echo "Flags:"
+ @echo "CXX: $(CXX)"
+ @echo "CXXFLAGS: $(CXXFLAGS)"
+ @echo "LDFLAGS: $(LDFLAGS)"
+ @echo ""
+ @echo "Testing config sanity. If this fails, try 'make help' ..."
+ @echo ""
+ @test "$(debug)" = "yes" || test "$(debug)" = "no"
+ @test "$(optimize)" = "yes" || test "$(optimize)" = "no"
+ @test "$(SUPPORTED_ARCH)" = "true"
+ @test "$(arch)" = "any" || test "$(arch)" = "x86_64" || test "$(arch)" = "i386" || \
+ test "$(arch)" = "ppc64" || test "$(arch)" = "ppc" || test "$(arch)" = "e2k" || \
+ test "$(arch)" = "armv7" || test "$(arch)" = "armv8" || test "$(arch)" = "arm64" || test "$(arch)" = "riscv64"
+ @test "$(bits)" = "32" || test "$(bits)" = "64"
+ @test "$(prefetch)" = "yes" || test "$(prefetch)" = "no"
+ @test "$(popcnt)" = "yes" || test "$(popcnt)" = "no"
+ @test "$(pext)" = "yes" || test "$(pext)" = "no"
+ @test "$(sse)" = "yes" || test "$(sse)" = "no"
+ @test "$(mmx)" = "yes" || test "$(mmx)" = "no"
+ @test "$(sse2)" = "yes" || test "$(sse2)" = "no"
+ @test "$(ssse3)" = "yes" || test "$(ssse3)" = "no"
+ @test "$(sse41)" = "yes" || test "$(sse41)" = "no"
+ @test "$(avx2)" = "yes" || test "$(avx2)" = "no"
+ @test "$(avx512)" = "yes" || test "$(avx512)" = "no"
+ @test "$(vnni256)" = "yes" || test "$(vnni256)" = "no"
+ @test "$(vnni512)" = "yes" || test "$(vnni512)" = "no"
+ @test "$(neon)" = "yes" || test "$(neon)" = "no"
+ @test "$(comp)" = "gcc" || test "$(comp)" = "icc" || test "$(comp)" = "mingw" || test "$(comp)" = "clang" \
+ || test "$(comp)" = "armv7a-linux-androideabi16-clang" || test "$(comp)" = "aarch64-linux-android21-clang"
+
+$(EXE): $(OBJS)
+ +$(CXX) -o $@ $(OBJS) $(LDFLAGS)
+
+# Force recompilation to ensure version info is up-to-date
+misc.o: FORCE
+FORCE:
+
+clang-profile-make:
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+ EXTRACXXFLAGS='-fprofile-instr-generate ' \
+ EXTRALDFLAGS=' -fprofile-instr-generate' \
+ all
+
+clang-profile-use:
+ $(XCRUN) llvm-profdata merge -output=stockfish.profdata *.profraw
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+ EXTRACXXFLAGS='-fprofile-instr-use=stockfish.profdata' \
+ EXTRALDFLAGS='-fprofile-use ' \
+ all
+
+gcc-profile-make:
+ @mkdir -p profdir
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+ EXTRACXXFLAGS='-fprofile-generate=profdir' \
+ EXTRACXXFLAGS+=$(EXTRAPROFILEFLAGS) \
+ EXTRALDFLAGS='-lgcov' \
+ all
+
+gcc-profile-use:
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+ EXTRACXXFLAGS='-fprofile-use=profdir -fno-peel-loops -fno-tracer' \
+ EXTRACXXFLAGS+=$(EXTRAPROFILEFLAGS) \
+ EXTRALDFLAGS='-lgcov' \
+ all
+
+icc-profile-make:
+ @mkdir -p profdir
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+ EXTRACXXFLAGS='-prof-gen=srcpos -prof_dir ./profdir' \
+ all
+
+icc-profile-use:
+ $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+ EXTRACXXFLAGS='-prof_use -prof_dir ./profdir' \
+ all
+
+.depend: $(SRCS)
+ -@$(CXX) $(DEPENDFLAGS) -MM $(SRCS) > $@ 2> /dev/null
+
+-include .depend
diff --git a/src/benchmark.cpp b/src/benchmark.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e1c025adb9afc7d955d9b763154b2002b27e3394
--- /dev/null
+++ b/src/benchmark.cpp
@@ -0,0 +1,175 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2022 The Stockfish developers (see AUTHORS file)
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#include
+#include
+#include
+#include
+
+#include "position.h"
+
+using namespace std;
+
+namespace {
+
+const vector Defaults = {
+ "setoption name UCI_Chess960 value false",
+ "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
+ "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 10",
+ "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 11",
+ "4rrk1/pp1n3p/3q2pQ/2p1pb2/2PP4/2P3N1/P2B2PP/4RRK1 b - - 7 19",
+ "rq3rk1/ppp2ppp/1bnpb3/3N2B1/3NP3/7P/PPPQ1PP1/2KR3R w - - 7 14 moves d4e6",
+ "r1bq1r1k/1pp1n1pp/1p1p4/4p2Q/4Pp2/1BNP4/PPP2PPP/3R1RK1 w - - 2 14 moves g2g4",
+ "r3r1k1/2p2ppp/p1p1bn2/8/1q2P3/2NPQN2/PPP3PP/R4RK1 b - - 2 15",
+ "r1bbk1nr/pp3p1p/2n5/1N4p1/2Np1B2/8/PPP2PPP/2KR1B1R w kq - 0 13",
+ "r1bq1rk1/ppp1nppp/4n3/3p3Q/3P4/1BP1B3/PP1N2PP/R4RK1 w - - 1 16",
+ "4r1k1/r1q2ppp/ppp2n2/4P3/5Rb1/1N1BQ3/PPP3PP/R5K1 w - - 1 17",
+ "2rqkb1r/ppp2p2/2npb1p1/1N1Nn2p/2P1PP2/8/PP2B1PP/R1BQK2R b KQ - 0 11",
+ "r1bq1r1k/b1p1npp1/p2p3p/1p6/3PP3/1B2NN2/PP3PPP/R2Q1RK1 w - - 1 16",
+ "3r1rk1/p5pp/bpp1pp2/8/q1PP1P2/b3P3/P2NQRPP/1R2B1K1 b - - 6 22",
+ "r1q2rk1/2p1bppp/2Pp4/p6b/Q1PNp3/4B3/PP1R1PPP/2K4R w - - 2 18",
+ "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b - - 3 22",
+ "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26",
+ "6k1/6p1/6Pp/ppp5/3pn2P/1P3K2/1PP2P2/3N4 b - - 0 1",
+ "3b4/5kp1/1p1p1p1p/pP1PpP1P/P1P1P3/3KN3/8/8 w - - 0 1",
+ "2K5/p7/7P/5pR1/8/5k2/r7/8 w - - 0 1 moves g5g6 f3e3 g6g5 e3f3",
+ "8/6pk/1p6/8/PP3p1p/5P2/4KP1q/3Q4 w - - 0 1",
+ "7k/3p2pp/4q3/8/4Q3/5Kp1/P6b/8 w - - 0 1",
+ "8/2p5/8/2kPKp1p/2p4P/2P5/3P4/8 w - - 0 1",
+ "8/1p3pp1/7p/5P1P/2k3P1/8/2K2P2/8 w - - 0 1",
+ "8/pp2r1k1/2p1p3/3pP2p/1P1P1P1P/P5KR/8/8 w - - 0 1",
+ "8/3p4/p1bk3p/Pp6/1Kp1PpPp/2P2P1P/2P5/5B2 b - - 0 1",
+ "5k2/7R/4P2p/5K2/p1r2P1p/8/8/8 b - - 0 1",
+ "6k1/6p1/P6p/r1N5/5p2/7P/1b3PP1/4R1K1 w - - 0 1",
+ "1r3k2/4q3/2Pp3b/3Bp3/2Q2p2/1p1P2P1/1P2KP2/3N4 w - - 0 1",
+ "6k1/4pp1p/3p2p1/P1pPb3/R7/1r2P1PP/3B1P2/6K1 w - - 0 1",
+ "8/3p3B/5p2/5P2/p7/PP5b/k7/6K1 w - - 0 1",
+ "5rk1/q6p/2p3bR/1pPp1rP1/1P1Pp3/P3B1Q1/1K3P2/R7 w - - 93 90",
+ "4rrk1/1p1nq3/p7/2p1P1pp/3P2bp/3Q1Bn1/PPPB4/1K2R1NR w - - 40 21",
+ "r3k2r/3nnpbp/q2pp1p1/p7/Pp1PPPP1/4BNN1/1P5P/R2Q1RK1 w kq - 0 16",
+ "3Qb1k1/1r2ppb1/pN1n2q1/Pp1Pp1Pr/4P2p/4BP2/4B1R1/1R5K b - - 11 40",
+ "4k3/3q1r2/1N2r1b1/3ppN2/2nPP3/1B1R2n1/2R1Q3/3K4 w - - 5 1",
+
+ // 5-man positions
+ "8/8/8/8/5kp1/P7/8/1K1N4 w - - 0 1", // Kc2 - mate
+ "8/8/8/5N2/8/p7/8/2NK3k w - - 0 1", // Na2 - mate
+ "8/3k4/8/8/8/4B3/4KB2/2B5 w - - 0 1", // draw
+
+ // 6-man positions
+ "8/8/1P6/5pr1/8/4R3/7k/2K5 w - - 0 1", // Re5 - mate
+ "8/2p4P/8/kr6/6R1/8/8/1K6 w - - 0 1", // Ka2 - mate
+ "8/8/3P3k/8/1p6/8/1P6/1K3n2 b - - 0 1", // Nd2 - draw
+
+ // 7-man positions
+ "8/R7/2q5/8/6k1/8/1P5p/K6R w - - 0 124", // Draw
+
+ // Mate and stalemate positions
+ "6k1/3b3r/1p1p4/p1n2p2/1PPNpP1q/P3Q1p1/1R1RB1P1/5K2 b - - 0 1",
+ "r2r1n2/pp2bk2/2p1p2p/3q4/3PN1QP/2P3R1/P4PP1/5RK1 w - - 0 1",
+ "8/8/8/8/8/6k1/6p1/6K1 w - -",
+ "7k/7P/6K1/8/3B4/8/8/8 b - -",
+
+ // Chess 960
+ "setoption name UCI_Chess960 value true",
+ "bbqnnrkr/pppppppp/8/8/8/8/PPPPPPPP/BBQNNRKR w HFhf - 0 1 moves g2g3 d7d5 d2d4 c8h3 c1g5 e8d6 g5e7 f7f6",
+ "nqbnrkrb/pppppppp/8/8/8/8/PPPPPPPP/NQBNRKRB w KQkq - 0 1",
+ "setoption name UCI_Chess960 value false"
+};
+
+} // namespace
+
+namespace Stockfish {
+
+/// setup_bench() builds a list of UCI commands to be run by bench. There
+/// are five parameters: TT size in MB, number of search threads that
+/// should be used, the limit value spent for each position, a file name
+/// where to look for positions in FEN format, the type of the limit:
+/// depth, perft, nodes and movetime (in millisecs), and evaluation type
+/// mixed (default), classical, NNUE.
+///
+/// bench -> search default positions up to depth 13
+/// bench 64 1 15 -> search default positions up to depth 15 (TT = 64MB)
+/// bench 64 4 5000 current movetime -> search current position with 4 threads for 5 sec
+/// bench 64 1 100000 default nodes -> search default positions for 100K nodes each
+/// bench 16 1 5 default perft -> run a perft 5 on default positions
+
+vector setup_bench(const Position& current, istream& is) {
+
+ vector fens, list;
+ string go, token;
+
+ // Assign default values to missing arguments
+ string ttSize = (is >> token) ? token : "16";
+ string threads = (is >> token) ? token : "1";
+ string limit = (is >> token) ? token : "13";
+ string fenFile = (is >> token) ? token : "default";
+ string limitType = (is >> token) ? token : "depth";
+ string evalType = (is >> token) ? token : "mixed";
+
+ go = limitType == "eval" ? "eval" : "go " + limitType + " " + limit;
+
+ if (fenFile == "default")
+ fens = Defaults;
+
+ else if (fenFile == "current")
+ fens.push_back(current.fen());
+
+ else
+ {
+ string fen;
+ ifstream file(fenFile);
+
+ if (!file.is_open())
+ {
+ cerr << "Unable to open file " << fenFile << endl;
+ exit(EXIT_FAILURE);
+ }
+
+ while (getline(file, fen))
+ if (!fen.empty())
+ fens.push_back(fen);
+
+ file.close();
+ }
+
+ list.emplace_back("setoption name Threads value " + threads);
+ list.emplace_back("setoption name Hash value " + ttSize);
+ list.emplace_back("ucinewgame");
+
+ size_t posCounter = 0;
+
+ for (const string& fen : fens)
+ if (fen.find("setoption") != string::npos)
+ list.emplace_back(fen);
+ else
+ {
+ if (evalType == "classical" || (evalType == "mixed" && posCounter % 2 == 0))
+ list.emplace_back("setoption name Use NNUE value false");
+ else if (evalType == "NNUE" || (evalType == "mixed" && posCounter % 2 != 0))
+ list.emplace_back("setoption name Use NNUE value true");
+ list.emplace_back("position fen " + fen);
+ list.emplace_back(go);
+ ++posCounter;
+ }
+
+ list.emplace_back("setoption name Use NNUE value true");
+
+ return list;
+}
+
+} // namespace Stockfish
diff --git a/src/bitbase.cpp b/src/bitbase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..84300baf92abb0dc0519ff4659081f1319190eff
--- /dev/null
+++ b/src/bitbase.cpp
@@ -0,0 +1,172 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2022 The Stockfish developers (see AUTHORS file)
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#include
+#include
+#include
+
+#include "bitboard.h"
+#include "types.h"
+
+namespace Stockfish {
+
+namespace {
+
+ // There are 24 possible pawn squares: files A to D and ranks from 2 to 7.
+ // Positions with the pawn on files E to H will be mirrored before probing.
+ constexpr unsigned MAX_INDEX = 2*24*64*64; // stm * psq * wksq * bksq = 196608
+
+ std::bitset KPKBitbase;
+
+ // A KPK bitbase index is an integer in [0, IndexMax] range
+ //
+ // Information is mapped in a way that minimizes the number of iterations:
+ //
+ // bit 0- 5: white king square (from SQ_A1 to SQ_H8)
+ // bit 6-11: black king square (from SQ_A1 to SQ_H8)
+ // bit 12: side to move (WHITE or BLACK)
+ // bit 13-14: white pawn file (from FILE_A to FILE_D)
+ // bit 15-17: white pawn RANK_7 - rank (from RANK_7 - RANK_7 to RANK_7 - RANK_2)
+ unsigned index(Color stm, Square bksq, Square wksq, Square psq) {
+ return int(wksq) | (bksq << 6) | (stm << 12) | (file_of(psq) << 13) | ((RANK_7 - rank_of(psq)) << 15);
+ }
+
+ enum Result {
+ INVALID = 0,
+ UNKNOWN = 1,
+ DRAW = 2,
+ WIN = 4
+ };
+
+ Result& operator|=(Result& r, Result v) { return r = Result(r | v); }
+
+ struct KPKPosition {
+ KPKPosition() = default;
+ explicit KPKPosition(unsigned idx);
+ operator Result() const { return result; }
+ Result classify(const std::vector& db);
+
+ Color stm;
+ Square ksq[COLOR_NB], psq;
+ Result result;
+ };
+
+} // namespace
+
+bool Bitbases::probe(Square wksq, Square wpsq, Square bksq, Color stm) {
+
+ assert(file_of(wpsq) <= FILE_D);
+
+ return KPKBitbase[index(stm, bksq, wksq, wpsq)];
+}
+
+
+void Bitbases::init() {
+
+ std::vector db(MAX_INDEX);
+ unsigned idx, repeat = 1;
+
+ // Initialize db with known win / draw positions
+ for (idx = 0; idx < MAX_INDEX; ++idx)
+ db[idx] = KPKPosition(idx);
+
+ // Iterate through the positions until none of the unknown positions can be
+ // changed to either wins or draws (15 cycles needed).
+ while (repeat)
+ for (repeat = idx = 0; idx < MAX_INDEX; ++idx)
+ repeat |= (db[idx] == UNKNOWN && db[idx].classify(db) != UNKNOWN);
+
+ // Fill the bitbase with the decisive results
+ for (idx = 0; idx < MAX_INDEX; ++idx)
+ if (db[idx] == WIN)
+ KPKBitbase.set(idx);
+}
+
+namespace {
+
+ KPKPosition::KPKPosition(unsigned idx) {
+
+ ksq[WHITE] = Square((idx >> 0) & 0x3F);
+ ksq[BLACK] = Square((idx >> 6) & 0x3F);
+ stm = Color ((idx >> 12) & 0x01);
+ psq = make_square(File((idx >> 13) & 0x3), Rank(RANK_7 - ((idx >> 15) & 0x7)));
+
+ // Invalid if two pieces are on the same square or if a king can be captured
+ if ( distance(ksq[WHITE], ksq[BLACK]) <= 1
+ || ksq[WHITE] == psq
+ || ksq[BLACK] == psq
+ || (stm == WHITE && (pawn_attacks_bb(WHITE, psq) & ksq[BLACK])))
+ result = INVALID;
+
+ // Win if the pawn can be promoted without getting captured
+ else if ( stm == WHITE
+ && rank_of(psq) == RANK_7
+ && ksq[WHITE] != psq + NORTH
+ && ( distance(ksq[BLACK], psq + NORTH) > 1
+ || (distance(ksq[WHITE], psq + NORTH) == 1)))
+ result = WIN;
+
+ // Draw if it is stalemate or the black king can capture the pawn
+ else if ( stm == BLACK
+ && ( !(attacks_bb(ksq[BLACK]) & ~(attacks_bb(ksq[WHITE]) | pawn_attacks_bb(WHITE, psq)))
+ || (attacks_bb(ksq[BLACK]) & ~attacks_bb(ksq[WHITE]) & psq)))
+ result = DRAW;
+
+ // Position will be classified later
+ else
+ result = UNKNOWN;
+ }
+
+ Result KPKPosition::classify(const std::vector& db) {
+
+ // White to move: If one move leads to a position classified as WIN, the result
+ // of the current position is WIN. If all moves lead to positions classified
+ // as DRAW, the current position is classified as DRAW, otherwise the current
+ // position is classified as UNKNOWN.
+ //
+ // Black to move: If one move leads to a position classified as DRAW, the result
+ // of the current position is DRAW. If all moves lead to positions classified
+ // as WIN, the position is classified as WIN, otherwise the current position is
+ // classified as UNKNOWN.
+ const Result Good = (stm == WHITE ? WIN : DRAW);
+ const Result Bad = (stm == WHITE ? DRAW : WIN);
+
+ Result r = INVALID;
+ Bitboard b = attacks_bb(ksq[stm]);
+
+ while (b)
+ r |= stm == WHITE ? db[index(BLACK, ksq[BLACK], pop_lsb(b), psq)]
+ : db[index(WHITE, pop_lsb(b), ksq[WHITE], psq)];
+
+ if (stm == WHITE)
+ {
+ if (rank_of(psq) < RANK_7) // Single push
+ r |= db[index(BLACK, ksq[BLACK], ksq[WHITE], psq + NORTH)];
+
+ if ( rank_of(psq) == RANK_2 // Double push
+ && psq + NORTH != ksq[WHITE]
+ && psq + NORTH != ksq[BLACK])
+ r |= db[index(BLACK, ksq[BLACK], ksq[WHITE], psq + NORTH + NORTH)];
+ }
+
+ return result = r & Good ? Good : r & UNKNOWN ? UNKNOWN : Bad;
+ }
+
+} // namespace
+
+} // namespace Stockfish
diff --git a/src/bitboard.cpp b/src/bitboard.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fd0ba235cb471f70853b76723564cb69c4f17bea
--- /dev/null
+++ b/src/bitboard.cpp
@@ -0,0 +1,222 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2022 The Stockfish developers (see AUTHORS file)
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#include
+#include
+
+#include "bitboard.h"
+#include "misc.h"
+
+namespace Stockfish {
+
+uint8_t PopCnt16[1 << 16];
+uint8_t SquareDistance[SQUARE_NB][SQUARE_NB];
+
+Bitboard SquareBB[SQUARE_NB];
+Bitboard LineBB[SQUARE_NB][SQUARE_NB];
+Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
+Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
+Bitboard PawnAttacks[COLOR_NB][SQUARE_NB];
+
+Magic RookMagics[SQUARE_NB];
+Magic BishopMagics[SQUARE_NB];
+
+namespace {
+
+ Bitboard RookTable[0x19000]; // To store rook attacks
+ Bitboard BishopTable[0x1480]; // To store bishop attacks
+
+ void init_magics(PieceType pt, Bitboard table[], Magic magics[]);
+
+}
+
+/// safe_destination() returns the bitboard of target square for the given step
+/// from the given square. If the step is off the board, returns empty bitboard.
+
+inline Bitboard safe_destination(Square s, int step) {
+ Square to = Square(s + step);
+ return is_ok(to) && distance(s, to) <= 2 ? square_bb(to) : Bitboard(0);
+}
+
+
+/// Bitboards::pretty() returns an ASCII representation of a bitboard suitable
+/// to be printed to standard output. Useful for debugging.
+
+std::string Bitboards::pretty(Bitboard b) {
+
+ std::string s = "+---+---+---+---+---+---+---+---+\n";
+
+ for (Rank r = RANK_8; r >= RANK_1; --r)
+ {
+ for (File f = FILE_A; f <= FILE_H; ++f)
+ s += b & make_square(f, r) ? "| X " : "| ";
+
+ s += "| " + std::to_string(1 + r) + "\n+---+---+---+---+---+---+---+---+\n";
+ }
+ s += " a b c d e f g h\n";
+
+ return s;
+}
+
+
+/// Bitboards::init() initializes various bitboard tables. It is called at
+/// startup and relies on global objects to be already zero-initialized.
+
+void Bitboards::init() {
+
+ for (unsigned i = 0; i < (1 << 16); ++i)
+ PopCnt16[i] = uint8_t(std::bitset<16>(i).count());
+
+ for (Square s = SQ_A1; s <= SQ_H8; ++s)
+ SquareBB[s] = (1ULL << s);
+
+ for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
+ for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2)
+ SquareDistance[s1][s2] = std::max(distance(s1, s2), distance(s1, s2));
+
+ init_magics(ROOK, RookTable, RookMagics);
+ init_magics(BISHOP, BishopTable, BishopMagics);
+
+ for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
+ {
+ PawnAttacks[WHITE][s1] = pawn_attacks_bb(square_bb(s1));
+ PawnAttacks[BLACK][s1] = pawn_attacks_bb(square_bb(s1));
+
+ for (int step : {-9, -8, -7, -1, 1, 7, 8, 9} )
+ PseudoAttacks[KING][s1] |= safe_destination(s1, step);
+
+ for (int step : {-17, -15, -10, -6, 6, 10, 15, 17} )
+ PseudoAttacks[KNIGHT][s1] |= safe_destination(s1, step);
+
+ PseudoAttacks[QUEEN][s1] = PseudoAttacks[BISHOP][s1] = attacks_bb(s1, 0);
+ PseudoAttacks[QUEEN][s1] |= PseudoAttacks[ ROOK][s1] = attacks_bb< ROOK>(s1, 0);
+
+ for (PieceType pt : { BISHOP, ROOK })
+ for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2)
+ {
+ if (PseudoAttacks[pt][s1] & s2)
+ {
+ LineBB[s1][s2] = (attacks_bb(pt, s1, 0) & attacks_bb(pt, s2, 0)) | s1 | s2;
+ BetweenBB[s1][s2] = (attacks_bb(pt, s1, square_bb(s2)) & attacks_bb(pt, s2, square_bb(s1)));
+ }
+ BetweenBB[s1][s2] |= s2;
+ }
+ }
+}
+
+namespace {
+
+ Bitboard sliding_attack(PieceType pt, Square sq, Bitboard occupied) {
+
+ Bitboard attacks = 0;
+ Direction RookDirections[4] = {NORTH, SOUTH, EAST, WEST};
+ Direction BishopDirections[4] = {NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST};
+
+ for (Direction d : (pt == ROOK ? RookDirections : BishopDirections))
+ {
+ Square s = sq;
+ while (safe_destination(s, d) && !(occupied & s))
+ attacks |= (s += d);
+ }
+
+ return attacks;
+ }
+
+
+ // init_magics() computes all rook and bishop attacks at startup. Magic
+ // bitboards are used to look up attacks of sliding pieces. As a reference see
+ // www.chessprogramming.org/Magic_Bitboards. In particular, here we use the so
+ // called "fancy" approach.
+
+ void init_magics(PieceType pt, Bitboard table[], Magic magics[]) {
+
+ // Optimal PRNG seeds to pick the correct magics in the shortest time
+ int seeds[][RANK_NB] = { { 8977, 44560, 54343, 38998, 5731, 95205, 104912, 17020 },
+ { 728, 10316, 55013, 32803, 12281, 15100, 16645, 255 } };
+
+ Bitboard occupancy[4096], reference[4096], edges, b;
+ int epoch[4096] = {}, cnt = 0, size = 0;
+
+ for (Square s = SQ_A1; s <= SQ_H8; ++s)
+ {
+ // Board edges are not considered in the relevant occupancies
+ edges = ((Rank1BB | Rank8BB) & ~rank_bb(s)) | ((FileABB | FileHBB) & ~file_bb(s));
+
+ // Given a square 's', the mask is the bitboard of sliding attacks from
+ // 's' computed on an empty board. The index must be big enough to contain
+ // all the attacks for each possible subset of the mask and so is 2 power
+ // the number of 1s of the mask. Hence we deduce the size of the shift to
+ // apply to the 64 or 32 bits word to get the index.
+ Magic& m = magics[s];
+ m.mask = sliding_attack(pt, s, 0) & ~edges;
+ m.shift = (Is64Bit ? 64 : 32) - popcount(m.mask);
+
+ // Set the offset for the attacks table of the square. We have individual
+ // table sizes for each square with "Fancy Magic Bitboards".
+ m.attacks = s == SQ_A1 ? table : magics[s - 1].attacks + size;
+
+ // Use Carry-Rippler trick to enumerate all subsets of masks[s] and
+ // store the corresponding sliding attack bitboard in reference[].
+ b = size = 0;
+ do {
+ occupancy[size] = b;
+ reference[size] = sliding_attack(pt, s, b);
+
+ if (HasPext)
+ m.attacks[pext(b, m.mask)] = reference[size];
+
+ size++;
+ b = (b - m.mask) & m.mask;
+ } while (b);
+
+ if (HasPext)
+ continue;
+
+ PRNG rng(seeds[Is64Bit][rank_of(s)]);
+
+ // Find a magic for square 's' picking up an (almost) random number
+ // until we find the one that passes the verification test.
+ for (int i = 0; i < size; )
+ {
+ for (m.magic = 0; popcount((m.magic * m.mask) >> 56) < 6; )
+ m.magic = rng.sparse_rand();
+
+ // A good magic must map every possible occupancy to an index that
+ // looks up the correct sliding attack in the attacks[s] database.
+ // Note that we build up the database for square 's' as a side
+ // effect of verifying the magic. Keep track of the attempt count
+ // and save it in epoch[], little speed-up trick to avoid resetting
+ // m.attacks[] after every failed attempt.
+ for (++cnt, i = 0; i < size; ++i)
+ {
+ unsigned idx = m.index(occupancy[i]);
+
+ if (epoch[idx] < cnt)
+ {
+ epoch[idx] = cnt;
+ m.attacks[idx] = reference[i];
+ }
+ else if (m.attacks[idx] != reference[i])
+ break;
+ }
+ }
+ }
+ }
+}
+
+} // namespace Stockfish
diff --git a/src/bitboard.h b/src/bitboard.h
new file mode 100644
index 0000000000000000000000000000000000000000..2b6e2a6920c646486c1ccbe942e980396f571fc3
--- /dev/null
+++ b/src/bitboard.h
@@ -0,0 +1,451 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2022 The Stockfish developers (see AUTHORS file)
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#ifndef BITBOARD_H_INCLUDED
+#define BITBOARD_H_INCLUDED
+
+#include
+
+#include "types.h"
+
+namespace Stockfish {
+
+namespace Bitbases {
+
+void init();
+bool probe(Square wksq, Square wpsq, Square bksq, Color us);
+
+} // namespace Stockfish::Bitbases
+
+namespace Bitboards {
+
+void init();
+std::string pretty(Bitboard b);
+
+} // namespace Stockfish::Bitboards
+
+constexpr Bitboard AllSquares = ~Bitboard(0);
+constexpr Bitboard DarkSquares = 0xAA55AA55AA55AA55ULL;
+
+constexpr Bitboard FileABB = 0x0101010101010101ULL;
+constexpr Bitboard FileBBB = FileABB << 1;
+constexpr Bitboard FileCBB = FileABB << 2;
+constexpr Bitboard FileDBB = FileABB << 3;
+constexpr Bitboard FileEBB = FileABB << 4;
+constexpr Bitboard FileFBB = FileABB << 5;
+constexpr Bitboard FileGBB = FileABB << 6;
+constexpr Bitboard FileHBB = FileABB << 7;
+
+constexpr Bitboard Rank1BB = 0xFF;
+constexpr Bitboard Rank2BB = Rank1BB << (8 * 1);
+constexpr Bitboard Rank3BB = Rank1BB << (8 * 2);
+constexpr Bitboard Rank4BB = Rank1BB << (8 * 3);
+constexpr Bitboard Rank5BB = Rank1BB << (8 * 4);
+constexpr Bitboard Rank6BB = Rank1BB << (8 * 5);
+constexpr Bitboard Rank7BB = Rank1BB << (8 * 6);
+constexpr Bitboard Rank8BB = Rank1BB << (8 * 7);
+
+constexpr Bitboard QueenSide = FileABB | FileBBB | FileCBB | FileDBB;
+constexpr Bitboard CenterFiles = FileCBB | FileDBB | FileEBB | FileFBB;
+constexpr Bitboard KingSide = FileEBB | FileFBB | FileGBB | FileHBB;
+constexpr Bitboard Center = (FileDBB | FileEBB) & (Rank4BB | Rank5BB);
+
+constexpr Bitboard KingFlank[FILE_NB] = {
+ QueenSide ^ FileDBB, QueenSide, QueenSide,
+ CenterFiles, CenterFiles,
+ KingSide, KingSide, KingSide ^ FileEBB
+};
+
+extern uint8_t PopCnt16[1 << 16];
+extern uint8_t SquareDistance[SQUARE_NB][SQUARE_NB];
+
+extern Bitboard SquareBB[SQUARE_NB];
+extern Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
+extern Bitboard LineBB[SQUARE_NB][SQUARE_NB];
+extern Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
+extern Bitboard PawnAttacks[COLOR_NB][SQUARE_NB];
+
+
+/// Magic holds all magic bitboards relevant data for a single square
+struct Magic {
+ Bitboard mask;
+ Bitboard magic;
+ Bitboard* attacks;
+ unsigned shift;
+
+ // Compute the attack's index using the 'magic bitboards' approach
+ unsigned index(Bitboard occupied) const {
+
+ if (HasPext)
+ return unsigned(pext(occupied, mask));
+
+ if (Is64Bit)
+ return unsigned(((occupied & mask) * magic) >> shift);
+
+ unsigned lo = unsigned(occupied) & unsigned(mask);
+ unsigned hi = unsigned(occupied >> 32) & unsigned(mask >> 32);
+ return (lo * unsigned(magic) ^ hi * unsigned(magic >> 32)) >> shift;
+ }
+};
+
+extern Magic RookMagics[SQUARE_NB];
+extern Magic BishopMagics[SQUARE_NB];
+
+inline Bitboard square_bb(Square s) {
+ assert(is_ok(s));
+ return SquareBB[s];
+}
+
+
+/// Overloads of bitwise operators between a Bitboard and a Square for testing
+/// whether a given bit is set in a bitboard, and for setting and clearing bits.
+
+inline Bitboard operator&( Bitboard b, Square s) { return b & square_bb(s); }
+inline Bitboard operator|( Bitboard b, Square s) { return b | square_bb(s); }
+inline Bitboard operator^( Bitboard b, Square s) { return b ^ square_bb(s); }
+inline Bitboard& operator|=(Bitboard& b, Square s) { return b |= square_bb(s); }
+inline Bitboard& operator^=(Bitboard& b, Square s) { return b ^= square_bb(s); }
+
+inline Bitboard operator&(Square s, Bitboard b) { return b & s; }
+inline Bitboard operator|(Square s, Bitboard b) { return b | s; }
+inline Bitboard operator^(Square s, Bitboard b) { return b ^ s; }
+
+inline Bitboard operator|(Square s1, Square s2) { return square_bb(s1) | s2; }
+
+constexpr bool more_than_one(Bitboard b) {
+ return b & (b - 1);
+}
+
+
+constexpr bool opposite_colors(Square s1, Square s2) {
+ return (s1 + rank_of(s1) + s2 + rank_of(s2)) & 1;
+}
+
+
+/// rank_bb() and file_bb() return a bitboard representing all the squares on
+/// the given file or rank.
+
+constexpr Bitboard rank_bb(Rank r) {
+ return Rank1BB << (8 * r);
+}
+
+constexpr Bitboard rank_bb(Square s) {
+ return rank_bb(rank_of(s));
+}
+
+constexpr Bitboard file_bb(File f) {
+ return FileABB << f;
+}
+
+constexpr Bitboard file_bb(Square s) {
+ return file_bb(file_of(s));
+}
+
+
+/// shift() moves a bitboard one or two steps as specified by the direction D
+
+template
+constexpr Bitboard shift(Bitboard b) {
+ return D == NORTH ? b << 8 : D == SOUTH ? b >> 8
+ : D == NORTH+NORTH? b <<16 : D == SOUTH+SOUTH? b >>16
+ : D == EAST ? (b & ~FileHBB) << 1 : D == WEST ? (b & ~FileABB) >> 1
+ : D == NORTH_EAST ? (b & ~FileHBB) << 9 : D == NORTH_WEST ? (b & ~FileABB) << 7
+ : D == SOUTH_EAST ? (b & ~FileHBB) >> 7 : D == SOUTH_WEST ? (b & ~FileABB) >> 9
+ : 0;
+}
+
+
+/// pawn_attacks_bb() returns the squares attacked by pawns of the given color
+/// from the squares in the given bitboard.
+
+template
+constexpr Bitboard pawn_attacks_bb(Bitboard b) {
+ return C == WHITE ? shift(b) | shift(b)
+ : shift(b) | shift(b);
+}
+
+inline Bitboard pawn_attacks_bb(Color c, Square s) {
+
+ assert(is_ok(s));
+ return PawnAttacks[c][s];
+}
+
+
+/// pawn_double_attacks_bb() returns the squares doubly attacked by pawns of the
+/// given color from the squares in the given bitboard.
+
+template
+constexpr Bitboard pawn_double_attacks_bb(Bitboard b) {
+ return C == WHITE ? shift(b) & shift(b)
+ : shift(b) & shift(b);
+}
+
+
+/// adjacent_files_bb() returns a bitboard representing all the squares on the
+/// adjacent files of a given square.
+
+constexpr Bitboard adjacent_files_bb(Square s) {
+ return shift(file_bb(s)) | shift(file_bb(s));
+}
+
+
+/// line_bb() returns a bitboard representing an entire line (from board edge
+/// to board edge) that intersects the two given squares. If the given squares
+/// are not on a same file/rank/diagonal, the function returns 0. For instance,
+/// line_bb(SQ_C4, SQ_F7) will return a bitboard with the A2-G8 diagonal.
+
+inline Bitboard line_bb(Square s1, Square s2) {
+
+ assert(is_ok(s1) && is_ok(s2));
+
+ return LineBB[s1][s2];
+}
+
+
+/// between_bb(s1, s2) returns a bitboard representing the squares in the semi-open
+/// segment between the squares s1 and s2 (excluding s1 but including s2). If the
+/// given squares are not on a same file/rank/diagonal, it returns s2. For instance,
+/// between_bb(SQ_C4, SQ_F7) will return a bitboard with squares D5, E6 and F7, but
+/// between_bb(SQ_E6, SQ_F8) will return a bitboard with the square F8. This trick
+/// allows to generate non-king evasion moves faster: the defending piece must either
+/// interpose itself to cover the check or capture the checking piece.
+
+inline Bitboard between_bb(Square s1, Square s2) {
+
+ assert(is_ok(s1) && is_ok(s2));
+
+ return BetweenBB[s1][s2];
+}
+
+
+/// forward_ranks_bb() returns a bitboard representing the squares on the ranks in
+/// front of the given one, from the point of view of the given color. For instance,
+/// forward_ranks_bb(BLACK, SQ_D3) will return the 16 squares on ranks 1 and 2.
+
+constexpr Bitboard forward_ranks_bb(Color c, Square s) {
+ return c == WHITE ? ~Rank1BB << 8 * relative_rank(WHITE, s)
+ : ~Rank8BB >> 8 * relative_rank(BLACK, s);
+}
+
+
+/// forward_file_bb() returns a bitboard representing all the squares along the
+/// line in front of the given one, from the point of view of the given color.
+
+constexpr Bitboard forward_file_bb(Color c, Square s) {
+ return forward_ranks_bb(c, s) & file_bb(s);
+}
+
+
+/// pawn_attack_span() returns a bitboard representing all the squares that can
+/// be attacked by a pawn of the given color when it moves along its file, starting
+/// from the given square.
+
+constexpr Bitboard pawn_attack_span(Color c, Square s) {
+ return forward_ranks_bb(c, s) & adjacent_files_bb(s);
+}
+
+
+/// passed_pawn_span() returns a bitboard which can be used to test if a pawn of
+/// the given color and on the given square is a passed pawn.
+
+constexpr Bitboard passed_pawn_span(Color c, Square s) {
+ return pawn_attack_span(c, s) | forward_file_bb(c, s);
+}
+
+
+/// aligned() returns true if the squares s1, s2 and s3 are aligned either on a
+/// straight or on a diagonal line.
+
+inline bool aligned(Square s1, Square s2, Square s3) {
+ return line_bb(s1, s2) & s3;
+}
+
+
+/// distance() functions return the distance between x and y, defined as the
+/// number of steps for a king in x to reach y.
+
+template inline int distance(Square x, Square y);
+template<> inline int distance(Square x, Square y) { return std::abs(file_of(x) - file_of(y)); }
+template<> inline int distance(Square x, Square y) { return std::abs(rank_of(x) - rank_of(y)); }
+template<> inline int distance(Square x, Square y) { return SquareDistance[x][y]; }
+
+inline int edge_distance(File f) { return std::min(f, File(FILE_H - f)); }
+inline int edge_distance(Rank r) { return std::min(r, Rank(RANK_8 - r)); }
+
+
+/// attacks_bb(Square) returns the pseudo attacks of the give piece type
+/// assuming an empty board.
+
+template
+inline Bitboard attacks_bb(Square s) {
+
+ assert((Pt != PAWN) && (is_ok(s)));
+
+ return PseudoAttacks[Pt][s];
+}
+
+
+/// attacks_bb(Square, Bitboard) returns the attacks by the given piece
+/// assuming the board is occupied according to the passed Bitboard.
+/// Sliding piece attacks do not continue passed an occupied square.
+
+template
+inline Bitboard attacks_bb(Square s, Bitboard occupied) {
+
+ assert((Pt != PAWN) && (is_ok(s)));
+
+ switch (Pt)
+ {
+ case BISHOP: return BishopMagics[s].attacks[BishopMagics[s].index(occupied)];
+ case ROOK : return RookMagics[s].attacks[ RookMagics[s].index(occupied)];
+ case QUEEN : return attacks_bb(s, occupied) | attacks_bb(s, occupied);
+ default : return PseudoAttacks[Pt][s];
+ }
+}
+
+inline Bitboard attacks_bb(PieceType pt, Square s, Bitboard occupied) {
+
+ assert((pt != PAWN) && (is_ok(s)));
+
+ switch (pt)
+ {
+ case BISHOP: return attacks_bb(s, occupied);
+ case ROOK : return attacks_bb< ROOK>(s, occupied);
+ case QUEEN : return attacks_bb(s, occupied) | attacks_bb(s, occupied);
+ default : return PseudoAttacks[pt][s];
+ }
+}
+
+
+/// popcount() counts the number of non-zero bits in a bitboard
+
+inline int popcount(Bitboard b) {
+
+#ifndef USE_POPCNT
+
+ union { Bitboard bb; uint16_t u[4]; } v = { b };
+ return PopCnt16[v.u[0]] + PopCnt16[v.u[1]] + PopCnt16[v.u[2]] + PopCnt16[v.u[3]];
+
+#elif defined(_MSC_VER) || defined(__INTEL_COMPILER)
+
+ return (int)_mm_popcnt_u64(b);
+
+#else // Assumed gcc or compatible compiler
+
+ return __builtin_popcountll(b);
+
+#endif
+}
+
+
+/// lsb() and msb() return the least/most significant bit in a non-zero bitboard
+
+#if defined(__GNUC__) // GCC, Clang, ICC
+
+inline Square lsb(Bitboard b) {
+ assert(b);
+ return Square(__builtin_ctzll(b));
+}
+
+inline Square msb(Bitboard b) {
+ assert(b);
+ return Square(63 ^ __builtin_clzll(b));
+}
+
+#elif defined(_MSC_VER) // MSVC
+
+#ifdef _WIN64 // MSVC, WIN64
+
+inline Square lsb(Bitboard b) {
+ assert(b);
+ unsigned long idx;
+ _BitScanForward64(&idx, b);
+ return (Square) idx;
+}
+
+inline Square msb(Bitboard b) {
+ assert(b);
+ unsigned long idx;
+ _BitScanReverse64(&idx, b);
+ return (Square) idx;
+}
+
+#else // MSVC, WIN32
+
+inline Square lsb(Bitboard b) {
+ assert(b);
+ unsigned long idx;
+
+ if (b & 0xffffffff) {
+ _BitScanForward(&idx, int32_t(b));
+ return Square(idx);
+ } else {
+ _BitScanForward(&idx, int32_t(b >> 32));
+ return Square(idx + 32);
+ }
+}
+
+inline Square msb(Bitboard b) {
+ assert(b);
+ unsigned long idx;
+
+ if (b >> 32) {
+ _BitScanReverse(&idx, int32_t(b >> 32));
+ return Square(idx + 32);
+ } else {
+ _BitScanReverse(&idx, int32_t(b));
+ return Square(idx);
+ }
+}
+
+#endif
+
+#else // Compiler is neither GCC nor MSVC compatible
+
+#error "Compiler not supported."
+
+#endif
+
+/// least_significant_square_bb() returns the bitboard of the least significant
+/// square of a non-zero bitboard. It is equivalent to square_bb(lsb(bb)).
+
+inline Bitboard least_significant_square_bb(Bitboard b) {
+ assert(b);
+ return b & -b;
+}
+
+/// pop_lsb() finds and clears the least significant bit in a non-zero bitboard
+
+inline Square pop_lsb(Bitboard& b) {
+ assert(b);
+ const Square s = lsb(b);
+ b &= b - 1;
+ return s;
+}
+
+
+/// frontmost_sq() returns the most advanced square for the given color,
+/// requires a non-zero bitboard.
+inline Square frontmost_sq(Color c, Bitboard b) {
+ assert(b);
+ return c == WHITE ? msb(b) : lsb(b);
+}
+
+} // namespace Stockfish
+
+#endif // #ifndef BITBOARD_H_INCLUDED
diff --git a/src/endgame.cpp b/src/endgame.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e773e7a91199353881648890490c58a54b5134ea
--- /dev/null
+++ b/src/endgame.cpp
@@ -0,0 +1,747 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2022 The Stockfish developers (see AUTHORS file)
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#include
+
+#include "bitboard.h"
+#include "endgame.h"
+#include "movegen.h"
+
+namespace Stockfish {
+
+namespace {
+
+ // Used to drive the king towards the edge of the board
+ // in KX vs K and KQ vs KR endgames.
+ // Values range from 27 (center squares) to 90 (in the corners)
+ inline int push_to_edge(Square s) {
+ int rd = edge_distance(rank_of(s)), fd = edge_distance(file_of(s));
+ return 90 - (7 * fd * fd / 2 + 7 * rd * rd / 2);
+ }
+
+ // Used to drive the king towards A1H8 corners in KBN vs K endgames.
+ // Values range from 0 on A8H1 diagonal to 7 in A1H8 corners
+ inline int push_to_corner(Square s) {
+ return abs(7 - rank_of(s) - file_of(s));
+ }
+
+ // Drive a piece close to or away from another piece
+ inline int push_close(Square s1, Square s2) { return 140 - 20 * distance(s1, s2); }
+ inline int push_away(Square s1, Square s2) { return 120 - push_close(s1, s2); }
+
+#ifndef NDEBUG
+ bool verify_material(const Position& pos, Color c, Value npm, int pawnsCnt) {
+ return pos.non_pawn_material(c) == npm && pos.count(c) == pawnsCnt;
+ }
+#endif
+
+ // Map the square as if strongSide is white and strongSide's only pawn
+ // is on the left half of the board.
+ Square normalize(const Position& pos, Color strongSide, Square sq) {
+
+ assert(pos.count(strongSide) == 1);
+
+ if (file_of(pos.square(strongSide)) >= FILE_E)
+ sq = flip_file(sq);
+
+ return strongSide == WHITE ? sq : flip_rank(sq);
+ }
+
+} // namespace
+
+
+namespace Endgames {
+
+ std::pair, Map> maps;
+
+ void init() {
+
+ add("KPK");
+ add("KNNK");
+ add("KBNK");
+ add("KRKP");
+ add("KRKB");
+ add("KRKN");
+ add("KQKP");
+ add("KQKR");
+ add("KNNKP");
+
+ add("KRPKR");
+ add("KRPKB");
+ add("KBPKB");
+ add("KBPKN");
+ add("KBPPKB");
+ add("KRPPKRP");
+ }
+}
+
+
+/// Mate with KX vs K. This function is used to evaluate positions with
+/// king and plenty of material vs a lone king. It simply gives the
+/// attacking side a bonus for driving the defending king towards the edge
+/// of the board, and for keeping the distance between the two kings small.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
+ assert(!pos.checkers()); // Eval is never called when in check
+
+ // Stalemate detection with lone king
+ if (pos.side_to_move() == weakSide && !MoveList(pos).size())
+ return VALUE_DRAW;
+
+ Square strongKing = pos.square(strongSide);
+ Square weakKing = pos.square(weakSide);
+
+ Value result = pos.non_pawn_material(strongSide)
+ + pos.count(strongSide) * PawnValueEg
+ + push_to_edge(weakKing)
+ + push_close(strongKing, weakKing);
+
+ if ( pos.count(strongSide)
+ || pos.count(strongSide)
+ ||(pos.count(strongSide) && pos.count(strongSide))
+ || ( (pos.pieces(strongSide, BISHOP) & ~DarkSquares)
+ && (pos.pieces(strongSide, BISHOP) & DarkSquares)))
+ result = std::min(result + VALUE_KNOWN_WIN, VALUE_TB_WIN_IN_MAX_PLY - 1);
+
+ return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// Mate with KBN vs K. This is similar to KX vs K, but we have to drive the
+/// defending king towards a corner square that our bishop attacks.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, KnightValueMg + BishopValueMg, 0));
+ assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
+
+ Square strongKing = pos.square(strongSide);
+ Square strongBishop = pos.square(strongSide);
+ Square weakKing = pos.square(weakSide);
+
+ // If our bishop does not attack A1/H8, we flip the enemy king square
+ // to drive to opposite corners (A8/H1).
+
+ Value result = (VALUE_KNOWN_WIN + 3520)
+ + push_close(strongKing, weakKing)
+ + 420 * push_to_corner(opposite_colors(strongBishop, SQ_A1) ? flip_file(weakKing) : weakKing);
+
+ assert(abs(result) < VALUE_TB_WIN_IN_MAX_PLY);
+ return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KP vs K. This endgame is evaluated with the help of a bitbase
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, VALUE_ZERO, 1));
+ assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
+
+ // Assume strongSide is white and the pawn is on files A-D
+ Square strongKing = normalize(pos, strongSide, pos.square(strongSide));
+ Square strongPawn = normalize(pos, strongSide, pos.square(strongSide));
+ Square weakKing = normalize(pos, strongSide, pos.square(weakSide));
+
+ Color us = strongSide == pos.side_to_move() ? WHITE : BLACK;
+
+ if (!Bitbases::probe(strongKing, strongPawn, weakKing, us))
+ return VALUE_DRAW;
+
+ Value result = VALUE_KNOWN_WIN + PawnValueEg + Value(rank_of(strongPawn));
+
+ return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KR vs KP. This is a somewhat tricky endgame to evaluate precisely without
+/// a bitbase. The function below returns drawish scores when the pawn is
+/// far advanced with support of the king, while the attacking king is far
+/// away.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, RookValueMg, 0));
+ assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
+
+ Square strongKing = pos.square(strongSide);
+ Square weakKing = pos.square(weakSide);
+ Square strongRook = pos.square(strongSide);
+ Square weakPawn = pos.square(weakSide);
+ Square queeningSquare = make_square(file_of(weakPawn), relative_rank(weakSide, RANK_8));
+ Value result;
+
+ // If the stronger side's king is in front of the pawn, it's a win
+ if (forward_file_bb(strongSide, strongKing) & weakPawn)
+ result = RookValueEg - distance(strongKing, weakPawn);
+
+ // If the weaker side's king is too far from the pawn and the rook,
+ // it's a win.
+ else if ( distance(weakKing, weakPawn) >= 3 + (pos.side_to_move() == weakSide)
+ && distance(weakKing, strongRook) >= 3)
+ result = RookValueEg - distance(strongKing, weakPawn);
+
+ // If the pawn is far advanced and supported by the defending king,
+ // the position is drawish
+ else if ( relative_rank(strongSide, weakKing) <= RANK_3
+ && distance(weakKing, weakPawn) == 1
+ && relative_rank(strongSide, strongKing) >= RANK_4
+ && distance(strongKing, weakPawn) > 2 + (pos.side_to_move() == strongSide))
+ result = Value(80) - 8 * distance(strongKing, weakPawn);
+
+ else
+ result = Value(200) - 8 * ( distance(strongKing, weakPawn + pawn_push(weakSide))
+ - distance(weakKing, weakPawn + pawn_push(weakSide))
+ - distance(weakPawn, queeningSquare));
+
+ return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KR vs KB. This is very simple, and always returns drawish scores. The
+/// score is slightly bigger when the defending king is close to the edge.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, RookValueMg, 0));
+ assert(verify_material(pos, weakSide, BishopValueMg, 0));
+
+ Value result = Value(push_to_edge(pos.square(weakSide)));
+ return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KR vs KN. The attacking side has slightly better winning chances than
+/// in KR vs KB, particularly if the king and the knight are far apart.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, RookValueMg, 0));
+ assert(verify_material(pos, weakSide, KnightValueMg, 0));
+
+ Square weakKing = pos.square(weakSide);
+ Square weakKnight = pos.square(weakSide);
+ Value result = Value(push_to_edge(weakKing) + push_away(weakKing, weakKnight));
+ return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KQ vs KP. In general, this is a win for the stronger side, but there are a
+/// few important exceptions. A pawn on 7th rank and on the A,C,F or H files
+/// with a king positioned next to it can be a draw, so in that case, we only
+/// use the distance between the kings.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, QueenValueMg, 0));
+ assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
+
+ Square strongKing = pos.square(strongSide);
+ Square weakKing = pos.square(weakSide);
+ Square weakPawn = pos.square(weakSide);
+
+ Value result = Value(push_close(strongKing, weakKing));
+
+ if ( relative_rank(weakSide, weakPawn) != RANK_7
+ || distance(weakKing, weakPawn) != 1
+ || ((FileBBB | FileDBB | FileEBB | FileGBB) & weakPawn))
+ result += QueenValueEg - PawnValueEg;
+
+ return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KQ vs KR. This is almost identical to KX vs K: we give the attacking
+/// king a bonus for having the kings close together, and for forcing the
+/// defending king towards the edge. If we also take care to avoid null move for
+/// the defending side in the search, this is usually sufficient to win KQ vs KR.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, QueenValueMg, 0));
+ assert(verify_material(pos, weakSide, RookValueMg, 0));
+
+ Square strongKing = pos.square(strongSide);
+ Square weakKing = pos.square(weakSide);
+
+ Value result = QueenValueEg
+ - RookValueEg
+ + push_to_edge(weakKing)
+ + push_close(strongKing, weakKing);
+
+ return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KNN vs KP. Very drawish, but there are some mate opportunities if we can
+/// press the weakSide King to a corner before the pawn advances too much.
+template<>
+Value Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, 2 * KnightValueMg, 0));
+ assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
+
+ Square weakKing = pos.square(weakSide);
+ Square weakPawn = pos.square(weakSide);
+
+ Value result = PawnValueEg
+ + 2 * push_to_edge(weakKing)
+ - 10 * relative_rank(weakSide, weakPawn);
+
+ return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// Some cases of trivial draws
+template<> Value Endgame::operator()(const Position&) const { return VALUE_DRAW; }
+
+
+/// KB and one or more pawns vs K. It checks for draws with rook pawns and
+/// a bishop of the wrong color. If such a draw is detected, SCALE_FACTOR_DRAW
+/// is returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling
+/// will be used.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongSide) == BishopValueMg);
+ assert(pos.count(strongSide) >= 1);
+
+ // No assertions about the material of weakSide, because we want draws to
+ // be detected even when the weaker side has some pawns.
+
+ Bitboard strongPawns = pos.pieces(strongSide, PAWN);
+ Bitboard allPawns = pos.pieces(PAWN);
+
+ Square strongBishop = pos.square(strongSide);
+ Square weakKing = pos.square(weakSide);
+ Square strongKing = pos.square(strongSide);
+
+ // All strongSide pawns are on a single rook file?
+ if (!(strongPawns & ~FileABB) || !(strongPawns & ~FileHBB))
+ {
+ Square queeningSquare = relative_square(strongSide, make_square(file_of(lsb(strongPawns)), RANK_8));
+
+ if ( opposite_colors(queeningSquare, strongBishop)
+ && distance(queeningSquare, weakKing) <= 1)
+ return SCALE_FACTOR_DRAW;
+ }
+
+ // If all the pawns are on the same B or G file, then it's potentially a draw
+ if ((!(allPawns & ~FileBBB) || !(allPawns & ~FileGBB))
+ && pos.non_pawn_material(weakSide) == 0
+ && pos.count(weakSide) >= 1)
+ {
+ // Get the least advanced weakSide pawn
+ Square weakPawn = frontmost_sq(strongSide, pos.pieces(weakSide, PAWN));
+
+ // There's potential for a draw if our pawn is blocked on the 7th rank,
+ // the bishop cannot attack it or they only have one pawn left.
+ if ( relative_rank(strongSide, weakPawn) == RANK_7
+ && (strongPawns & (weakPawn + pawn_push(weakSide)))
+ && (opposite_colors(strongBishop, weakPawn) || !more_than_one(strongPawns)))
+ {
+ int strongKingDist = distance(weakPawn, strongKing);
+ int weakKingDist = distance(weakPawn, weakKing);
+
+ // It's a draw if the weak king is on its back two ranks, within 2
+ // squares of the blocking pawn and the strong king is not
+ // closer. (I think this rule only fails in practically
+ // unreachable positions such as 5k1K/6p1/6P1/8/8/3B4/8/8 w
+ // and positions where qsearch will immediately correct the
+ // problem such as 8/4k1p1/6P1/1K6/3B4/8/8/8 w).
+ if ( relative_rank(strongSide, weakKing) >= RANK_7
+ && weakKingDist <= 2
+ && weakKingDist <= strongKingDist)
+ return SCALE_FACTOR_DRAW;
+ }
+ }
+
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// KQ vs KR and one or more pawns. It tests for fortress draws with a rook on
+/// the third rank defended by a pawn.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, QueenValueMg, 0));
+ assert(pos.count(weakSide) == 1);
+ assert(pos.count(weakSide) >= 1);
+
+ Square strongKing = pos.square(strongSide);
+ Square weakKing = pos.square(weakSide);
+ Square weakRook = pos.square(weakSide);
+
+ if ( relative_rank(weakSide, weakKing) <= RANK_2
+ && relative_rank(weakSide, strongKing) >= RANK_4
+ && relative_rank(weakSide, weakRook) == RANK_3
+ && ( pos.pieces(weakSide, PAWN)
+ & attacks_bb(weakKing)
+ & pawn_attacks_bb(strongSide, weakRook)))
+ return SCALE_FACTOR_DRAW;
+
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// KRP vs KR. This function knows a handful of the most important classes of
+/// drawn positions, but is far from perfect. It would probably be a good idea
+/// to add more knowledge in the future.
+///
+/// It would also be nice to rewrite the actual code for this function,
+/// which is mostly copied from Glaurung 1.x, and isn't very pretty.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, RookValueMg, 1));
+ assert(verify_material(pos, weakSide, RookValueMg, 0));
+
+ // Assume strongSide is white and the pawn is on files A-D
+ Square strongKing = normalize(pos, strongSide, pos.square(strongSide));
+ Square strongRook = normalize(pos, strongSide, pos.square(strongSide));
+ Square strongPawn = normalize(pos, strongSide, pos.square(strongSide));
+ Square weakKing = normalize(pos, strongSide, pos.square(weakSide));
+ Square weakRook = normalize(pos, strongSide, pos.square(weakSide));
+
+ File pawnFile = file_of(strongPawn);
+ Rank pawnRank = rank_of(strongPawn);
+ Square queeningSquare = make_square(pawnFile, RANK_8);
+ int tempo = (pos.side_to_move() == strongSide);
+
+ // If the pawn is not too far advanced and the defending king defends the
+ // queening square, use the third-rank defence.
+ if ( pawnRank <= RANK_5
+ && distance(weakKing, queeningSquare) <= 1
+ && strongKing <= SQ_H5
+ && (rank_of(weakRook) == RANK_6 || (pawnRank <= RANK_3 && rank_of(strongRook) != RANK_6)))
+ return SCALE_FACTOR_DRAW;
+
+ // The defending side saves a draw by checking from behind in case the pawn
+ // has advanced to the 6th rank with the king behind.
+ if ( pawnRank == RANK_6
+ && distance(weakKing, queeningSquare) <= 1
+ && rank_of(strongKing) + tempo <= RANK_6
+ && (rank_of(weakRook) == RANK_1 || (!tempo && distance(weakRook, strongPawn) >= 3)))
+ return SCALE_FACTOR_DRAW;
+
+ if ( pawnRank >= RANK_6
+ && weakKing == queeningSquare
+ && rank_of(weakRook) == RANK_1
+ && (!tempo || distance(strongKing, strongPawn) >= 2))
+ return SCALE_FACTOR_DRAW;
+
+ // White pawn on a7 and rook on a8 is a draw if black's king is on g7 or h7
+ // and the black rook is behind the pawn.
+ if ( strongPawn == SQ_A7
+ && strongRook == SQ_A8
+ && (weakKing == SQ_H7 || weakKing == SQ_G7)
+ && file_of(weakRook) == FILE_A
+ && (rank_of(weakRook) <= RANK_3 || file_of(strongKing) >= FILE_D || rank_of(strongKing) <= RANK_5))
+ return SCALE_FACTOR_DRAW;
+
+ // If the defending king blocks the pawn and the attacking king is too far
+ // away, it's a draw.
+ if ( pawnRank <= RANK_5
+ && weakKing == strongPawn + NORTH
+ && distance(strongKing, strongPawn) - tempo >= 2
+ && distance(strongKing, weakRook) - tempo >= 2)
+ return SCALE_FACTOR_DRAW;
+
+ // Pawn on the 7th rank supported by the rook from behind usually wins if the
+ // attacking king is closer to the queening square than the defending king,
+ // and the defending king cannot gain tempi by threatening the attacking rook.
+ if ( pawnRank == RANK_7
+ && pawnFile != FILE_A
+ && file_of(strongRook) == pawnFile
+ && strongRook != queeningSquare
+ && (distance(strongKing, queeningSquare) < distance(weakKing, queeningSquare) - 2 + tempo)
+ && (distance(strongKing, queeningSquare) < distance(weakKing, strongRook) + tempo))
+ return ScaleFactor(SCALE_FACTOR_MAX - 2 * distance(strongKing, queeningSquare));
+
+ // Similar to the above, but with the pawn further back
+ if ( pawnFile != FILE_A
+ && file_of(strongRook) == pawnFile
+ && strongRook < strongPawn
+ && (distance(strongKing, queeningSquare) < distance(weakKing, queeningSquare) - 2 + tempo)
+ && (distance(strongKing, strongPawn + NORTH) < distance(weakKing, strongPawn + NORTH) - 2 + tempo)
+ && ( distance(weakKing, strongRook) + tempo >= 3
+ || ( distance(strongKing, queeningSquare) < distance(weakKing, strongRook) + tempo
+ && (distance(strongKing, strongPawn + NORTH) < distance(weakKing, strongPawn) + tempo))))
+ return ScaleFactor( SCALE_FACTOR_MAX
+ - 8 * distance(strongPawn, queeningSquare)
+ - 2 * distance(strongKing, queeningSquare));
+
+ // If the pawn is not far advanced and the defending king is somewhere in
+ // the pawn's path, it's probably a draw.
+ if (pawnRank <= RANK_4 && weakKing > strongPawn)
+ {
+ if (file_of(weakKing) == file_of(strongPawn))
+ return ScaleFactor(10);
+ if ( distance(weakKing, strongPawn) == 1
+ && distance(strongKing, weakKing) > 2)
+ return ScaleFactor(24 - 2 * distance(strongKing, weakKing));
+ }
+ return SCALE_FACTOR_NONE;
+}
+
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, RookValueMg, 1));
+ assert(verify_material(pos, weakSide, BishopValueMg, 0));
+
+ // Test for a rook pawn
+ if (pos.pieces(PAWN) & (FileABB | FileHBB))
+ {
+ Square weakKing = pos.square(weakSide);
+ Square weakBishop = pos.square(weakSide);
+ Square strongKing = pos.square(strongSide);
+ Square strongPawn = pos.square(strongSide);
+ Rank pawnRank = relative_rank(strongSide, strongPawn);
+ Direction push = pawn_push(strongSide);
+
+ // If the pawn is on the 5th rank and the pawn (currently) is on
+ // the same color square as the bishop then there is a chance of
+ // a fortress. Depending on the king position give a moderate
+ // reduction or a stronger one if the defending king is near the
+ // corner but not trapped there.
+ if (pawnRank == RANK_5 && !opposite_colors(weakBishop, strongPawn))
+ {
+ int d = distance(strongPawn + 3 * push, weakKing);
+
+ if (d <= 2 && !(d == 0 && weakKing == strongKing + 2 * push))
+ return ScaleFactor(24);
+ else
+ return ScaleFactor(48);
+ }
+
+ // When the pawn has moved to the 6th rank we can be fairly sure
+ // it's drawn if the bishop attacks the square in front of the
+ // pawn from a reasonable distance and the defending king is near
+ // the corner
+ if ( pawnRank == RANK_6
+ && distance(strongPawn + 2 * push, weakKing) <= 1
+ && (attacks_bb(weakBishop) & (strongPawn + push))
+ && distance(weakBishop, strongPawn) >= 2)
+ return ScaleFactor(8);
+ }
+
+ return SCALE_FACTOR_NONE;
+}
+
+/// KRPP vs KRP. There is just a single rule: if the stronger side has no passed
+/// pawns and the defending king is actively placed, the position is drawish.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, RookValueMg, 2));
+ assert(verify_material(pos, weakSide, RookValueMg, 1));
+
+ Square strongPawn1 = lsb(pos.pieces(strongSide, PAWN));
+ Square strongPawn2 = msb(pos.pieces(strongSide, PAWN));
+ Square weakKing = pos.square(weakSide);
+
+ // Does the stronger side have a passed pawn?
+ if (pos.pawn_passed(strongSide, strongPawn1) || pos.pawn_passed(strongSide, strongPawn2))
+ return SCALE_FACTOR_NONE;
+
+ Rank pawnRank = std::max(relative_rank(strongSide, strongPawn1), relative_rank(strongSide, strongPawn2));
+
+ if ( distance(weakKing, strongPawn1) <= 1
+ && distance(weakKing, strongPawn2) <= 1
+ && relative_rank(strongSide, weakKing) > pawnRank)
+ {
+ assert(pawnRank > RANK_1 && pawnRank < RANK_7);
+ return ScaleFactor(7 * pawnRank);
+ }
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// K and two or more pawns vs K. There is just a single rule here: if all pawns
+/// are on the same rook file and are blocked by the defending king, it's a draw.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(pos.non_pawn_material(strongSide) == VALUE_ZERO);
+ assert(pos.count(strongSide) >= 2);
+ assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
+
+ Square weakKing = pos.square(weakSide);
+ Bitboard strongPawns = pos.pieces(strongSide, PAWN);
+
+ // If all pawns are ahead of the king on a single rook file, it's a draw.
+ if ( !(strongPawns & ~(FileABB | FileHBB))
+ && !(strongPawns & ~passed_pawn_span(weakSide, weakKing)))
+ return SCALE_FACTOR_DRAW;
+
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// KBP vs KB. There are two rules: if the defending king is somewhere along the
+/// path of the pawn, and the square of the king is not of the same color as the
+/// stronger side's bishop, it's a draw. If the two bishops have opposite color,
+/// it's almost always a draw.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, BishopValueMg, 1));
+ assert(verify_material(pos, weakSide, BishopValueMg, 0));
+
+ Square strongPawn = pos.square(strongSide);
+ Square strongBishop = pos.square(strongSide);
+ Square weakBishop = pos.square(weakSide);
+ Square weakKing = pos.square(weakSide);
+
+ // Case 1: Defending king blocks the pawn, and cannot be driven away
+ if ( (forward_file_bb(strongSide, strongPawn) & weakKing)
+ && ( opposite_colors(weakKing, strongBishop)
+ || relative_rank(strongSide, weakKing) <= RANK_6))
+ return SCALE_FACTOR_DRAW;
+
+ // Case 2: Opposite colored bishops
+ if (opposite_colors(strongBishop, weakBishop))
+ return SCALE_FACTOR_DRAW;
+
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// KBPP vs KB. It detects a few basic draws with opposite-colored bishops
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, BishopValueMg, 2));
+ assert(verify_material(pos, weakSide, BishopValueMg, 0));
+
+ Square strongBishop = pos.square(strongSide);
+ Square weakBishop = pos.square(weakSide);
+
+ if (!opposite_colors(strongBishop, weakBishop))
+ return SCALE_FACTOR_NONE;
+
+ Square weakKing = pos.square(weakSide);
+ Square strongPawn1 = lsb(pos.pieces(strongSide, PAWN));
+ Square strongPawn2 = msb(pos.pieces(strongSide, PAWN));
+ Square blockSq1, blockSq2;
+
+ if (relative_rank(strongSide, strongPawn1) > relative_rank(strongSide, strongPawn2))
+ {
+ blockSq1 = strongPawn1 + pawn_push(strongSide);
+ blockSq2 = make_square(file_of(strongPawn2), rank_of(strongPawn1));
+ }
+ else
+ {
+ blockSq1 = strongPawn2 + pawn_push(strongSide);
+ blockSq2 = make_square(file_of(strongPawn1), rank_of(strongPawn2));
+ }
+
+ switch (distance(strongPawn1, strongPawn2))
+ {
+ case 0:
+ // Both pawns are on the same file. It's an easy draw if the defender firmly
+ // controls some square in the frontmost pawn's path.
+ if ( file_of(weakKing) == file_of(blockSq1)
+ && relative_rank(strongSide, weakKing) >= relative_rank(strongSide, blockSq1)
+ && opposite_colors(weakKing, strongBishop))
+ return SCALE_FACTOR_DRAW;
+ else
+ return SCALE_FACTOR_NONE;
+
+ case 1:
+ // Pawns on adjacent files. It's a draw if the defender firmly controls the
+ // square in front of the frontmost pawn's path, and the square diagonally
+ // behind this square on the file of the other pawn.
+ if ( weakKing == blockSq1
+ && opposite_colors(weakKing, strongBishop)
+ && ( weakBishop == blockSq2
+ || (attacks_bb(blockSq2, pos.pieces()) & pos.pieces(weakSide, BISHOP))
+ || distance(strongPawn1, strongPawn2) >= 2))
+ return SCALE_FACTOR_DRAW;
+
+ else if ( weakKing == blockSq2
+ && opposite_colors(weakKing, strongBishop)
+ && ( weakBishop == blockSq1
+ || (attacks_bb(blockSq1, pos.pieces()) & pos.pieces(weakSide, BISHOP))))
+ return SCALE_FACTOR_DRAW;
+ else
+ return SCALE_FACTOR_NONE;
+
+ default:
+ // The pawns are not on the same file or adjacent files. No scaling.
+ return SCALE_FACTOR_NONE;
+ }
+}
+
+
+/// KBP vs KN. There is a single rule: if the defending king is somewhere along
+/// the path of the pawn, and the square of the king is not of the same color as
+/// the stronger side's bishop, it's a draw.
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, BishopValueMg, 1));
+ assert(verify_material(pos, weakSide, KnightValueMg, 0));
+
+ Square strongPawn = pos.square(strongSide);
+ Square strongBishop = pos.square(strongSide);
+ Square weakKing = pos.square(weakSide);
+
+ if ( file_of(weakKing) == file_of(strongPawn)
+ && relative_rank(strongSide, strongPawn) < relative_rank(strongSide, weakKing)
+ && ( opposite_colors(weakKing, strongBishop)
+ || relative_rank(strongSide, weakKing) <= RANK_6))
+ return SCALE_FACTOR_DRAW;
+
+ return SCALE_FACTOR_NONE;
+}
+
+
+/// KP vs KP. This is done by removing the weakest side's pawn and probing the
+/// KP vs K bitbase: if the weakest side has a draw without the pawn, it probably
+/// has at least a draw with the pawn as well. The exception is when the stronger
+/// side's pawn is far advanced and not on a rook file; in this case it is often
+/// possible to win (e.g. 8/4k3/3p4/3P4/6K1/8/8/8 w - - 0 1).
+template<>
+ScaleFactor Endgame::operator()(const Position& pos) const {
+
+ assert(verify_material(pos, strongSide, VALUE_ZERO, 1));
+ assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
+
+ // Assume strongSide is white and the pawn is on files A-D
+ Square strongKing = normalize(pos, strongSide, pos.square(strongSide));
+ Square weakKing = normalize(pos, strongSide, pos.square(weakSide));
+ Square strongPawn = normalize(pos, strongSide, pos.square(strongSide));
+
+ Color us = strongSide == pos.side_to_move() ? WHITE : BLACK;
+
+ // If the pawn has advanced to the fifth rank or further, and is not a
+ // rook pawn, it's too dangerous to assume that it's at least a draw.
+ if (rank_of(strongPawn) >= RANK_5 && file_of(strongPawn) != FILE_A)
+ return SCALE_FACTOR_NONE;
+
+ // Probe the KPK bitbase with the weakest side's pawn removed. If it's a draw,
+ // it's probably at least a draw even with the pawn.
+ return Bitbases::probe(strongKing, strongPawn, weakKing, us) ? SCALE_FACTOR_NONE : SCALE_FACTOR_DRAW;
+}
+
+} // namespace Stockfish
diff --git a/src/endgame.h b/src/endgame.h
new file mode 100644
index 0000000000000000000000000000000000000000..e79f696fa3a091dd8009d78a433228c429300acc
--- /dev/null
+++ b/src/endgame.h
@@ -0,0 +1,126 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2022 The Stockfish developers (see AUTHORS file)
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#ifndef ENDGAME_H_INCLUDED
+#define ENDGAME_H_INCLUDED
+
+#include
+#include
+#include
+#include
+#include
+
+#include "position.h"
+#include "types.h"
+
+namespace Stockfish {
+
+/// EndgameCode lists all supported endgame functions by corresponding codes
+
+enum EndgameCode {
+
+ EVALUATION_FUNCTIONS,
+ KNNK, // KNN vs K
+ KNNKP, // KNN vs KP
+ KXK, // Generic "mate lone king" eval
+ KBNK, // KBN vs K
+ KPK, // KP vs K
+ KRKP, // KR vs KP
+ KRKB, // KR vs KB
+ KRKN, // KR vs KN
+ KQKP, // KQ vs KP
+ KQKR, // KQ vs KR
+
+ SCALING_FUNCTIONS,
+ KBPsK, // KB and pawns vs K
+ KQKRPs, // KQ vs KR and pawns
+ KRPKR, // KRP vs KR
+ KRPKB, // KRP vs KB
+ KRPPKRP, // KRPP vs KRP
+ KPsK, // K and pawns vs K
+ KBPKB, // KBP vs KB
+ KBPPKB, // KBPP vs KB
+ KBPKN, // KBP vs KN
+ KPKP // KP vs KP
+};
+
+
+/// Endgame functions can be of two types depending on whether they return a
+/// Value or a ScaleFactor.
+
+template using
+eg_type = typename std::conditional<(E < SCALING_FUNCTIONS), Value, ScaleFactor>::type;
+
+
+/// Base and derived functors for endgame evaluation and scaling functions
+
+template
+struct EndgameBase {
+
+ explicit EndgameBase(Color c) : strongSide(c), weakSide(~c) {}
+ virtual ~EndgameBase() = default;
+ virtual T operator()(const Position&) const = 0;
+
+ const Color strongSide, weakSide;
+};
+
+
+template>
+struct Endgame : public EndgameBase {
+
+ explicit Endgame(Color c) : EndgameBase(c) {}
+ T operator()(const Position&) const override;
+};
+
+
+/// The Endgames namespace handles the pointers to endgame evaluation and scaling
+/// base objects in two std::map. We use polymorphism to invoke the actual
+/// endgame function by calling its virtual operator().
+
+namespace Endgames {
+
+ template using Ptr = std::unique_ptr>;
+ template using Map = std::unordered_map>;
+
+ extern std::pair, Map> maps;
+
+ void init();
+
+ template
+ Map& map() {
+ return std::get::value>(maps);
+ }
+
+ template>
+ void add(const std::string& code) {
+
+ StateInfo st;
+ map()[Position().set(code, WHITE, &st).material_key()] = Ptr(new Endgame(WHITE));
+ map()[Position().set(code, BLACK, &st).material_key()] = Ptr(new Endgame(BLACK));
+ }
+
+ template
+ const EndgameBase* probe(Key key) {
+ auto it = map().find(key);
+ return it != map().end() ? it->second.get() : nullptr;
+ }
+}
+
+} // namespace Stockfish
+
+#endif // #ifndef ENDGAME_H_INCLUDED
diff --git a/src/evaluate.cpp b/src/evaluate.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..87412b81b0b141392ebbc7d700a560303e85d20c
--- /dev/null
+++ b/src/evaluate.cpp
@@ -0,0 +1,1171 @@
+/*
+ Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+ Copyright (C) 2004-2022 The Stockfish developers (see AUTHORS file)
+
+ Stockfish is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Stockfish is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+*/
+
+#include
+#include
+#include
+#include // For std::memset
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "bitboard.h"
+#include "evaluate.h"
+#include "material.h"
+#include "misc.h"
+#include "pawns.h"
+#include "thread.h"
+#include "timeman.h"
+#include "uci.h"
+#include "incbin/incbin.h"
+
+
+// Macro to embed the default efficiently updatable neural network (NNUE) file
+// data in the engine binary (using incbin.h, by Dale Weiler).
+// This macro invocation will declare the following three variables
+// const unsigned char gEmbeddedNNUEData[]; // a pointer to the embedded data
+// const unsigned char *const gEmbeddedNNUEEnd; // a marker to the end
+// const unsigned int gEmbeddedNNUESize; // the size of the embedded file
+// Note that this does not work in Microsoft Visual Studio.
+#if !defined(_MSC_VER) && !defined(NNUE_EMBEDDING_OFF)
+ INCBIN(EmbeddedNNUE, EvalFileDefaultName);
+#else
+ const unsigned char gEmbeddedNNUEData[1] = {0x0};
+ const unsigned char *const gEmbeddedNNUEEnd = &gEmbeddedNNUEData[1];
+ const unsigned int gEmbeddedNNUESize = 1;
+#endif
+
+
+using namespace std;
+
+namespace Stockfish {
+
+namespace Eval {
+
+ bool useNNUE;
+ string currentEvalFileName = "None";
+
+ /// NNUE::init() tries to load a NNUE network at startup time, or when the engine
+ /// receives a UCI command "setoption name EvalFile value nn-[a-z0-9]{12}.nnue"
+ /// The name of the NNUE network is always retrieved from the EvalFile option.
+ /// We search the given network in three locations: internally (the default
+ /// network may be embedded in the binary), in the active working directory and
+ /// in the engine directory. Distro packagers may define the DEFAULT_NNUE_DIRECTORY
+ /// variable to have the engine search in a special directory in their distro.
+
+ void NNUE::init() {
+
+ useNNUE = Options["Use NNUE"];
+ if (!useNNUE)
+ return;
+
+ string eval_file = string(Options["EvalFile"]);
+ if (eval_file.empty())
+ eval_file = EvalFileDefaultName;
+
+ #if defined(DEFAULT_NNUE_DIRECTORY)
+ #define stringify2(x) #x
+ #define stringify(x) stringify2(x)
+ vector dirs = { "" , "" , CommandLine::binaryDirectory , stringify(DEFAULT_NNUE_DIRECTORY) };
+ #else
+ vector dirs = { "" , "" , CommandLine::binaryDirectory };
+ #endif
+
+ for (string directory : dirs)
+ if (currentEvalFileName != eval_file)
+ {
+ if (directory != "")
+ {
+ ifstream stream(directory + eval_file, ios::binary);
+ if (load_eval(eval_file, stream))
+ currentEvalFileName = eval_file;
+ }
+
+ if (directory == "" && eval_file == EvalFileDefaultName)
+ {
+ // C++ way to prepare a buffer for a memory stream
+ class MemoryBuffer : public basic_streambuf {
+ public: MemoryBuffer(char* p, size_t n) { setg(p, p, p + n); setp(p, p + n); }
+ };
+
+ MemoryBuffer buffer(const_cast(reinterpret_cast(gEmbeddedNNUEData)),
+ size_t(gEmbeddedNNUESize));
+ (void) gEmbeddedNNUEEnd; // Silence warning on unused variable
+
+ istream stream(&buffer);
+ if (load_eval(eval_file, stream))
+ currentEvalFileName = eval_file;
+ }
+ }
+ }
+
+ /// NNUE::verify() verifies that the last net used was loaded successfully
+ void NNUE::verify() {
+
+ string eval_file = string(Options["EvalFile"]);
+ if (eval_file.empty())
+ eval_file = EvalFileDefaultName;
+
+ if (useNNUE && currentEvalFileName != eval_file)
+ {
+
+ string msg1 = "If the UCI option \"Use NNUE\" is set to true, network evaluation parameters compatible with the engine must be available.";
+ string msg2 = "The option is set to true, but the network file " + eval_file + " was not loaded successfully.";
+ string msg3 = "The UCI option EvalFile might need to specify the full path, including the directory name, to the network file.";
+ string msg4 = "The default net can be downloaded from: https://tests.stockfishchess.org/api/nn/" + std::string(EvalFileDefaultName);
+ string msg5 = "The engine will be terminated now.";
+
+ sync_cout << "info string ERROR: " << msg1 << sync_endl;
+ sync_cout << "info string ERROR: " << msg2 << sync_endl;
+ sync_cout << "info string ERROR: " << msg3 << sync_endl;
+ sync_cout << "info string ERROR: " << msg4 << sync_endl;
+ sync_cout << "info string ERROR: " << msg5 << sync_endl;
+
+ exit(EXIT_FAILURE);
+ }
+
+ if (useNNUE)
+ sync_cout << "info string NNUE evaluation using " << eval_file << " enabled" << sync_endl;
+ else
+ sync_cout << "info string classical evaluation enabled" << sync_endl;
+ }
+}
+
+namespace Trace {
+
+ enum Tracing { NO_TRACE, TRACE };
+
+ enum Term { // The first 8 entries are reserved for PieceType
+ MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, WINNABLE, TOTAL, TERM_NB
+ };
+
+ Score scores[TERM_NB][COLOR_NB];
+
+ double to_cp(Value v) { return double(v) / UCI::NormalizeToPawnValue; }
+
+ void add(int idx, Color c, Score s) {
+ scores[idx][c] = s;
+ }
+
+ void add(int idx, Score w, Score b = SCORE_ZERO) {
+ scores[idx][WHITE] = w;
+ scores[idx][BLACK] = b;
+ }
+
+ std::ostream& operator<<(std::ostream& os, Score s) {
+ os << std::setw(5) << to_cp(mg_value(s)) << " "
+ << std::setw(5) << to_cp(eg_value(s));
+ return os;
+ }
+
+ std::ostream& operator<<(std::ostream& os, Term t) {
+
+ if (t == MATERIAL || t == IMBALANCE || t == WINNABLE || t == TOTAL)
+ os << " ---- ----" << " | " << " ---- ----";
+ else
+ os << scores[t][WHITE] << " | " << scores[t][BLACK];
+
+ os << " | " << scores[t][WHITE] - scores[t][BLACK] << " |\n";
+ return os;
+ }
+}
+
+using namespace Trace;
+
+namespace {
+
+ // Threshold for lazy and space evaluation
+ constexpr Value LazyThreshold1 = Value(3631);
+ constexpr Value LazyThreshold2 = Value(2084);
+ constexpr Value SpaceThreshold = Value(11551);
+
+ // KingAttackWeights[PieceType] contains king attack weights by piece type
+ constexpr int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 76, 46, 45, 14 };
+
+ // SafeCheck[PieceType][single/multiple] contains safe check bonus by piece type,
+ // higher if multiple safe checks are possible for that piece type.
+ constexpr int SafeCheck[][2] = {
+ {}, {}, {805, 1292}, {650, 984}, {1071, 1886}, {730, 1128}
+ };
+
+#define S(mg, eg) make_score(mg, eg)
+
+ // MobilityBonus[PieceType-2][attacked] contains bonuses for middle and end game,
+ // indexed by piece type and number of attacked squares in the mobility area.
+ constexpr Score MobilityBonus[][32] = {
+ { S(-62,-79), S(-53,-57), S(-12,-31), S( -3,-17), S( 3, 7), S( 12, 13), // Knight
+ S( 21, 16), S( 28, 21), S( 37, 26) },
+ { S(-47,-59), S(-20,-25), S( 14, -8), S( 29, 12), S( 39, 21), S( 53, 40), // Bishop
+ S( 53, 56), S( 60, 58), S( 62, 65), S( 69, 72), S( 78, 78), S( 83, 87),
+ S( 91, 88), S( 96, 98) },
+ { S(-60,-82), S(-24,-15), S( 0, 17) ,S( 3, 43), S( 4, 72), S( 14,100), // Rook
+ S( 20,102), S( 30,122), S( 41,133), S(41 ,139), S( 41,153), S( 45,160),
+ S( 57,165), S( 58,170), S( 67,175) },
+ { S(-29,-49), S(-16,-29), S( -8, -8), S( -8, 17), S( 18, 39), S( 25, 54), // Queen
+ S( 23, 59), S( 37, 73), S( 41, 76), S( 54, 95), S( 65, 95) ,S( 68,101),
+ S( 69,124), S( 70,128), S( 70,132), S( 70,133) ,S( 71,136), S( 72,140),
+ S( 74,147), S( 76,149), S( 90,153), S(104,169), S(105,171), S(106,171),
+ S(112,178), S(114,185), S(114,187), S(119,221) }
+ };
+
+ // BishopPawns[distance from edge] contains a file-dependent penalty for pawns on
+ // squares of the same color as our bishop.
+ constexpr Score BishopPawns[int(FILE_NB) / 2] = {
+ S(3, 8), S(3, 9), S(2, 7), S(3, 7)
+ };
+
+ // KingProtector[knight/bishop] contains penalty for each distance unit to own king
+ constexpr Score KingProtector[] = { S(9, 9), S(7, 9) };
+
+ // Outpost[knight/bishop] contains bonuses for each knight or bishop occupying a
+ // pawn protected square on rank 4 to 6 which is also safe from a pawn attack.
+ constexpr Score Outpost[] = { S(54, 34), S(31, 25) };
+
+ // PassedRank[Rank] contains a bonus according to the rank of a passed pawn
+ constexpr Score PassedRank[RANK_NB] = {
+ S(0, 0), S(2, 38), S(15, 36), S(22, 50), S(64, 81), S(166, 184), S(284, 269)
+ };
+
+ constexpr Score RookOnClosedFile = S(10, 5);
+ constexpr Score RookOnOpenFile[] = { S(18, 8), S(49, 26) };
+
+ // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to
+ // which piece type attacks which one. Attacks on lesser pieces which are
+ // pawn-defended are not considered.
+ constexpr Score ThreatByMinor[PIECE_TYPE_NB] = {
+ S(0, 0), S(6, 37), S(64, 50), S(82, 57), S(103, 130), S(81, 163)
+ };
+
+ constexpr Score ThreatByRook[PIECE_TYPE_NB] = {
+ S(0, 0), S(3, 44), S(36, 71), S(44, 59), S(0, 39), S(60, 39)
+ };
+
+ constexpr Value CorneredBishop = Value(50);
+
+ // Assorted bonuses and penalties
+ constexpr Score UncontestedOutpost = S( 0, 10);
+ constexpr Score BishopOnKingRing = S( 24, 0);
+ constexpr Score BishopXRayPawns = S( 4, 5);
+ constexpr Score FlankAttacks = S( 8, 0);
+ constexpr Score Hanging = S( 72, 40);
+ constexpr Score KnightOnQueen = S( 16, 11);
+ constexpr Score LongDiagonalBishop = S( 45, 0);
+ constexpr Score MinorBehindPawn = S( 18, 3);
+ constexpr Score PassedFile = S( 13, 8);
+ constexpr Score PawnlessFlank = S( 19, 97);
+ constexpr Score ReachableOutpost = S( 33, 19);
+ constexpr Score RestrictedPiece = S( 6, 7);
+ constexpr Score RookOnKingRing = S( 16, 0);
+ constexpr Score SliderOnQueen = S( 62, 21);
+ constexpr Score ThreatByKing = S( 24, 87);
+ constexpr Score ThreatByPawnPush = S( 48, 39);
+ constexpr Score ThreatBySafePawn = S(167, 99);
+ constexpr Score TrappedRook = S( 55, 13);
+ constexpr Score WeakQueenProtection = S( 14, 0);
+ constexpr Score WeakQueen = S( 57, 19);
+
+
+#undef S
+
+ // Evaluation class computes and stores attacks tables and other working data
+ template
+ class Evaluation {
+
+ public:
+ Evaluation() = delete;
+ explicit Evaluation(const Position& p) : pos(p) {}
+ Evaluation& operator=(const Evaluation&) = delete;
+ Value value();
+
+ private:
+ template void initialize();
+ template Score pieces();
+ template Score king() const;
+ template Score threats() const;
+ template Score passed() const;
+ template Score space() const;
+ Value winnable(Score score) const;
+
+ const Position& pos;
+ Material::Entry* me;
+ Pawns::Entry* pe;
+ Bitboard mobilityArea[COLOR_NB];
+ Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO };
+
+ // attackedBy[color][piece type] is a bitboard representing all squares
+ // attacked by a given color and piece type. Special "piece types" which
+ // is also calculated is ALL_PIECES.
+ Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB];
+
+ // attackedBy2[color] are the squares attacked by at least 2 units of a given
+ // color, including x-rays. But diagonal x-rays through pawns are not computed.
+ Bitboard attackedBy2[COLOR_NB];
+
+ // kingRing[color] are the squares adjacent to the king plus some other
+ // very near squares, depending on king position.
+ Bitboard kingRing[COLOR_NB];
+
+ // kingAttackersCount[color] is the number of pieces of the given color
+ // which attack a square in the kingRing of the enemy king.
+ int kingAttackersCount[COLOR_NB];
+
+ // kingAttackersWeight[color] is the sum of the "weights" of the pieces of
+ // the given color which attack a square in the kingRing of the enemy king.
+ // The weights of the individual piece types are given by the elements in
+ // the KingAttackWeights array.
+ int kingAttackersWeight[COLOR_NB];
+
+ // kingAttacksCount[color] is the number of attacks by the given color to
+ // squares directly adjacent to the enemy king. Pieces which attack more
+ // than one square are counted multiple times. For instance, if there is
+ // a white knight on g5 and black's king is on g8, this white knight adds 2
+ // to kingAttacksCount[WHITE].
+ int kingAttacksCount[COLOR_NB];
+ };
+
+
+ // Evaluation::initialize() computes king and pawn attacks, and the king ring
+ // bitboard for a given color. This is done at the beginning of the evaluation.
+
+ template template
+ void Evaluation::initialize() {
+
+ constexpr Color Them = ~Us;
+ constexpr Direction Up = pawn_push(Us);
+ constexpr Direction Down = -Up;
+ constexpr Bitboard LowRanks = (Us == WHITE ? Rank2BB | Rank3BB : Rank7BB | Rank6BB);
+
+ const Square ksq = pos.square(Us);
+
+ Bitboard dblAttackByPawn = pawn_double_attacks_bb(pos.pieces(Us, PAWN));
+
+ // Find our pawns that are blocked or on the first two ranks
+ Bitboard b = pos.pieces(Us, PAWN) & (shift(pos.pieces()) | LowRanks);
+
+ // Squares occupied by those pawns, by our king or queen, by blockers to attacks on our king
+ // or controlled by enemy pawns are excluded from the mobility area.
+ mobilityArea[Us] = ~(b | pos.pieces(Us, KING, QUEEN) | pos.blockers_for_king(Us) | pe->pawn_attacks(Them));
+
+ // Initialize attackedBy[] for king and pawns
+ attackedBy[Us][KING] = attacks_bb(ksq);
+ attackedBy[Us][PAWN] = pe->pawn_attacks(Us);
+ attackedBy[Us][ALL_PIECES] = attackedBy[Us][KING] | attackedBy[Us][PAWN];
+ attackedBy2[Us] = dblAttackByPawn | (attackedBy[Us][KING] & attackedBy[Us][PAWN]);
+
+ // Init our king safety tables
+ Square s = make_square(std::clamp(file_of(ksq), FILE_B, FILE_G),
+ std::clamp(rank_of(ksq), RANK_2, RANK_7));
+ kingRing[Us] = attacks_bb(s) | s;
+
+ kingAttackersCount[Them] = popcount(kingRing[Us] & pe->pawn_attacks(Them));
+ kingAttacksCount[Them] = kingAttackersWeight[Them] = 0;
+
+ // Remove from kingRing[] the squares defended by two pawns
+ kingRing[Us] &= ~dblAttackByPawn;
+ }
+
+
+ // Evaluation::pieces() scores pieces of a given color and type
+
+ template template
+ Score Evaluation::pieces() {
+
+ constexpr Color Them = ~Us;
+ constexpr Direction Down = -pawn_push(Us);
+ constexpr Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB
+ : Rank5BB | Rank4BB | Rank3BB);
+ Bitboard b1 = pos.pieces(Us, Pt);
+ Bitboard b, bb;
+ Score score = SCORE_ZERO;
+
+ attackedBy[Us][Pt] = 0;
+
+ while (b1)
+ {
+ Square s = pop_lsb(b1);
+
+ // Find attacked squares, including x-ray attacks for bishops and rooks
+ b = Pt == BISHOP ? attacks_bb(s, pos.pieces() ^ pos.pieces(QUEEN))
+ : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(QUEEN) ^ pos.pieces(Us, ROOK))
+ : attacks_bb(s, pos.pieces());
+
+ if (pos.blockers_for_king(Us) & s)
+ b &= line_bb(pos.square(Us), s);
+
+ attackedBy2[Us] |= attackedBy[Us][ALL_PIECES] & b;
+ attackedBy[Us][Pt] |= b;
+ attackedBy[Us][ALL_PIECES] |= b;
+
+ if (b & kingRing[Them])
+ {
+ kingAttackersCount[Us]++;
+ kingAttackersWeight[Us] += KingAttackWeights[Pt];
+ kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
+ }
+
+ else if (Pt == ROOK && (file_bb(s) & kingRing[Them]))
+ score += RookOnKingRing;
+
+ else if (Pt == BISHOP && (attacks_bb(s, pos.pieces(PAWN)) & kingRing[Them]))
+ score += BishopOnKingRing;
+
+ int mob = popcount(b & mobilityArea[Us]);
+ mobility[Us] += MobilityBonus[Pt - 2][mob];
+
+ if (Pt == BISHOP || Pt == KNIGHT)
+ {
+ // Bonus if the piece is on an outpost square or can reach one
+ // Bonus for knights (UncontestedOutpost) if few relevant targets
+ bb = OutpostRanks & (attackedBy[Us][PAWN] | shift(pos.pieces(PAWN)))
+ & ~pe->pawn_attacks_span(Them);
+ Bitboard targets = pos.pieces(Them) & ~pos.pieces(PAWN);
+
+ if ( Pt == KNIGHT
+ && bb & s & ~CenterFiles // on a side outpost
+ && !(b & targets) // no relevant attacks
+ && (!more_than_one(targets & (s & QueenSide ? QueenSide : KingSide))))
+ score += UncontestedOutpost * popcount(pos.pieces(PAWN) & (s & QueenSide ? QueenSide : KingSide));
+ else if (bb & s)
+ score += Outpost[Pt == BISHOP];
+ else if (Pt == KNIGHT && bb & b & ~pos.pieces(Us))
+ score += ReachableOutpost;
+
+ // Bonus for a knight or bishop shielded by pawn
+ if (shift(pos.pieces(PAWN)) & s)
+ score += MinorBehindPawn;
+
+ // Penalty if the piece is far from the king
+ score -= KingProtector[Pt == BISHOP] * distance(pos.square(Us), s);
+
+ if constexpr (Pt == BISHOP)
+ {
+ // Penalty according to the number of our pawns on the same color square as the
+ // bishop, bigger when the center files are blocked with pawns and smaller
+ // when the bishop is outside the pawn chain.
+ Bitboard blocked = pos.pieces(Us, PAWN) & shift(pos.pieces());
+
+ score -= BishopPawns[edge_distance(file_of(s))] * pos.pawns_on_same_color_squares(Us, s)
+ * (!(attackedBy[Us][PAWN] & s) + popcount(blocked & CenterFiles));
+
+ // Penalty for all enemy pawns x-rayed
+ score -= BishopXRayPawns * popcount(attacks_bb(s) & pos.pieces(Them, PAWN));
+
+ // Bonus for bishop on a long diagonal which can "see" both center squares
+ if (more_than_one(attacks_bb(s, pos.pieces(PAWN)) & Center))
+ score += LongDiagonalBishop;
+
+ // An important Chess960 pattern: a cornered bishop blocked by a friendly
+ // pawn diagonally in front of it is a very serious problem, especially
+ // when that pawn is also blocked.
+ if ( pos.is_chess960()
+ && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
+ {
+ Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
+ if (pos.piece_on(s + d) == make_piece(Us, PAWN))
+ score -= !pos.empty(s + d + pawn_push(Us)) ? 4 * make_score(CorneredBishop, CorneredBishop)
+ : 3 * make_score(CorneredBishop, CorneredBishop);
+ }
+ }
+ }
+
+ if constexpr (Pt == ROOK)
+ {
+ // Bonuses for rook on a (semi-)open or closed file
+ if (pos.is_on_semiopen_file(Us, s))
+ {
+ score += RookOnOpenFile[pos.is_on_semiopen_file(Them, s)];
+ }
+ else
+ {
+ // If our pawn on this file is blocked, increase penalty
+ if ( pos.pieces(Us, PAWN)
+ & shift(pos.pieces())
+ & file_bb(s))
+ {
+ score -= RookOnClosedFile;
+ }
+
+ // Penalty when trapped by the king, even more if the king cannot castle
+ if (mob <= 3)
+ {
+ File kf = file_of(pos.square(Us));
+ if ((kf < FILE_E) == (file_of(s) < kf))
+ score -= TrappedRook * (1 + !pos.castling_rights(Us));
+ }
+ }
+ }
+
+ if constexpr (Pt == QUEEN)
+ {
+ // Penalty if any relative pin or discovered attack against the queen
+ Bitboard queenPinners;
+ if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, queenPinners))
+ score -= WeakQueen;
+ }
+ }
+ if constexpr (T)
+ Trace::add(Pt, Us, score);
+
+ return score;
+ }
+
+
+ // Evaluation::king() assigns bonuses and penalties to a king of a given color
+
+ template template
+ Score Evaluation::king() const {
+
+ constexpr Color Them = ~Us;
+ constexpr Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB
+ : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB);
+
+ Bitboard weak, b1, b2, b3, safe, unsafeChecks = 0;
+ Bitboard rookChecks, queenChecks, bishopChecks, knightChecks;
+ int kingDanger = 0;
+ const Square ksq = pos.square(Us);
+
+ // Init the score with king shelter and enemy pawns storm
+ Score score = pe->king_safety(pos);
+
+ // Attacked squares defended at most once by our queen or king
+ weak = attackedBy[Them][ALL_PIECES]
+ & ~attackedBy2[Us]
+ & (~attackedBy[Us][ALL_PIECES] | attackedBy[Us][KING] | attackedBy[Us][QUEEN]);
+
+ // Analyse the safe enemy's checks which are possible on next move
+ safe = ~pos.pieces(Them);
+ safe &= ~attackedBy[Us][ALL_PIECES] | (weak & attackedBy2[Them]);
+
+ b1 = attacks_bb(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
+ b2 = attacks_bb