Upload 109 files

Fairy-Stockfish-master/.gitattributes

@@ -0,0 +1 @@
+README.md merge=ours

Fairy-Stockfish-master/.github/FUNDING.yml

@@ -0,0 +1,2 @@
+# These are supported funding model platforms
+github: ianfab

Fairy-Stockfish-master/.github/dependabot.yml

@@ -0,0 +1,13 @@
+# Keep GitHub Actions up to date with GitHub's Dependabot...
+# https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot
+# https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#package-ecosystem
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    groups:
+      github-actions:
+        patterns:
+          - "*"  # Group all Actions updates into a single larger pull request
+    schedule:
+      interval: weekly

Fairy-Stockfish-master/.github/workflows/fairy.yml

@@ -0,0 +1,93 @@
+name: fairy
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+jobs:
+  fairy:
+    name: ${{ matrix.config.name }}
+    runs-on: ${{ matrix.config.os }}
+    env:
+      COMPILER: ${{ matrix.config.compiler }}
+      COMP: ${{ matrix.config.comp }}
+      CXXFLAGS: "-Werror"
+    strategy:
+      matrix:
+        config:
+          - {
+              name: "Ubuntu 24.04 GCC",
+              os: ubuntu-24.04,
+              compiler: g++,
+              comp: gcc,
+              run_expensive_tests: true
+            }
+          - {
+              name: "Ubuntu 24.04 Clang",
+              os: ubuntu-24.04,
+              compiler: clang++,
+              comp: clang,
+              run_expensive_tests: false
+            }
+
+    defaults:
+      run:
+        working-directory: src
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Download required packages
+        run: |
+          sudo apt update
+          sudo apt install expect valgrind g++-multilib
+
+      - name: Download the used network from the fishtest framework
+        run: |
+          make net
+
+      - name: Test NNUE
+        run: |
+          make clean
+          make -j2 ARCH=x86-64 nnue=yes debug=yes build
+          ./stockfish bench
+
+      - name: Test NNUE largeboards
+        run: |
+          make clean
+          make -j2 ARCH=x86-64 largeboards=yes nnue=yes debug=yes build
+          ./stockfish bench
+
+      - name: Build all variants
+        run: |
+          make clean
+          make -j2 ARCH=x86-64 largeboards=yes all=yes debug=yes build
+
+      - name: Test protocols
+        run: |
+          ../tests/protocol.sh
+
+      - name: Test variants.ini
+        run: |
+          ! ./stockfish check variants.ini 2>&1 >/dev/null | grep -v "Parsing variant"
+
+      - name: Test variant perft
+        run: |
+          ../tests/perft.sh all
+
+      - name: Test variant bench
+        run: |
+          ./stockfish bench xiangqi
+          ./stockfish bench shogi
+          ./stockfish bench capablanca
+          ./stockfish bench sittuyin
+
+      - name: Test 32bit largeboards
+        run: |
+          if [[ "$COMP" == "gcc" ]]; then export EXTRACXXFLAGS=-Wno-class-memaccess; fi
+          make clean
+          make -j2 ARCH=x86-32 largeboards=yes build
+          ../tests/perft.sh largeboard

Fairy-Stockfish-master/.github/workflows/ffishjs.yml

@@ -0,0 +1,90 @@
+name: ffishjs
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+env:
+  EM_VERSION: 1.39.16
+  EM_CACHE_FOLDER: 'emsdk-cache'
+
+jobs:
+  test:
+    runs-on: ubuntu-24.04
+
+    strategy:
+      matrix:
+        node-version: [12.x]
+
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup cache
+        id: cache-system-libraries
+        uses: actions/cache@v5
+        with:
+          path: ${{env.EM_CACHE_FOLDER}}
+          key: emsdk-${{env.EM_VERSION}}-${{ runner.os }}
+      - uses: mymindstorm/setup-emsdk@v16
+        with:
+          version: ${{env.EM_VERSION}}
+          actions-cache-folder: ${{env.EM_CACHE_FOLDER}}
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v6
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Build ffishjs
+        working-directory: src
+        run: make -f Makefile_js build debug=yes
+      - name: Install dependencies
+        working-directory: tests/js
+        run: npm install
+      - name: Run unit tests
+        working-directory: tests/js
+        run: npm test
+
+  build:
+    runs-on: ubuntu-24.04
+    needs: [test]    #Building process must start after successful testing process
+
+    strategy:
+      matrix:
+        node-version: [12.x]
+
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup cache
+        id: cache-system-libraries
+        uses: actions/cache@v5
+        with:
+          path: ${{env.EM_CACHE_FOLDER}}
+          key: emsdk-${{env.EM_VERSION}}-${{ runner.os }}
+      - uses: mymindstorm/setup-emsdk@v16
+        with:
+          version: ${{env.EM_VERSION}}
+          actions-cache-folder: ${{env.EM_CACHE_FOLDER}}
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v6
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Build ffish.js ES6/ES2015 module
+        working-directory: src
+        run: rm -f ../tests/js/ffish.js & rm -f ../tests/js/ffish.wasm & make -f Makefile_js build es6=yes
+      - name: Upload ffish.js ES6/ES2015 module ZIP archive
+        uses: actions/upload-artifact@v7
+        with:
+          name: ffishjs-es6
+          path: tests/js/*
+          if-no-files-found: error
+          compression-level: 9
+      - name: Build ffish.js standard module
+        working-directory: src
+        run: rm -f ../tests/js/ffish.js & rm -f ../tests/js/ffish.wasm & make -f Makefile_js build
+      - name: Upload ffish.js standard module ZIP archive
+        uses: actions/upload-artifact@v7
+        with:
+          name: ffishjs-standard
+          path: tests/js/*
+          if-no-files-found: error
+          compression-level: 9

Fairy-Stockfish-master/.github/workflows/release.yml

@@ -0,0 +1,116 @@
+name: Release
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  windows:
+    strategy:
+      matrix:
+        arch: ["x86-64-bmi2", "x86-64-modern", "x86-64"]
+    runs-on: windows-2022
+
+    steps:
+      - uses: al-cheb/configure-pagefile-action@v1.5	
+        with:	
+            minimum-size: 16GB
+            maximum-size: 16GB
+            disk-root: "C:"
+
+      - uses: actions/checkout@v6
+
+      - name: make
+        run: cd src && make clean && make -j build COMP=mingw ARCH=${{ matrix.arch }} EXE=fairy-stockfish_${{ matrix.arch }}.exe && strip fairy-stockfish_${{ matrix.arch }}.exe
+
+      - name: make largeboards
+        run: cd src && make clean && make -j build COMP=mingw ARCH=${{ matrix.arch }} EXE=fairy-stockfish-largeboards_${{ matrix.arch }}.exe largeboards=yes && strip fairy-stockfish-largeboards_${{ matrix.arch }}.exe
+
+      - name: make all
+        if: ${{ matrix.arch == 'x86-64' }}
+        run: cd src && make clean && make -j build COMP=mingw ARCH=${{ matrix.arch }} EXE=fairy-stockfish-all_${{ matrix.arch }}.exe largeboards=yes all=yes && strip fairy-stockfish-all_${{ matrix.arch }}.exe
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: fairy-stockfish-windows-${{ matrix.arch }}
+          path: src/fairy-stockfish*.exe
+          if-no-files-found: error
+          compression-level: 9
+
+  linux:
+    strategy:
+      matrix:
+        arch: ["x86-64-bmi2", "x86-64-modern", "x86-64"]
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: make
+        run: cd src && make clean && make -j build COMP=gcc ARCH=${{ matrix.arch }} EXE=fairy-stockfish_${{ matrix.arch }} && strip fairy-stockfish_${{ matrix.arch }}
+
+      - name: make largeboards
+        run: cd src && make clean && make -j build COMP=gcc ARCH=${{ matrix.arch }} EXE=fairy-stockfish-largeboards_${{ matrix.arch }} largeboards=yes && strip fairy-stockfish-largeboards_${{ matrix.arch }}
+
+      - name: make all
+        if: ${{ matrix.arch == 'x86-64' }}
+        run: cd src && make clean && make -j build COMP=gcc ARCH=${{ matrix.arch }} EXE=fairy-stockfish-all_${{ matrix.arch }} largeboards=yes all=yes && strip fairy-stockfish-all_${{ matrix.arch }}
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: fairy-stockfish-linux-${{ matrix.arch }}
+          path: src/fairy-stockfish*
+          if-no-files-found: error
+          compression-level: 9
+
+  macos:
+    strategy:
+      matrix:
+        arch: ["x86-64"]
+    runs-on: macos-15-intel
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: make
+        run: cd src && make clean && make -j build COMP=clang ARCH=${{ matrix.arch }} EXE=fairy-stockfish_${{ matrix.arch }} && strip fairy-stockfish_${{ matrix.arch }}
+
+      - name: make largeboards
+        run: cd src && make clean && make -j build COMP=clang ARCH=${{ matrix.arch }} EXE=fairy-stockfish-largeboards_${{ matrix.arch }} largeboards=yes && strip fairy-stockfish-largeboards_${{ matrix.arch }}
+
+      - name: make all
+        run: cd src && make clean && make -j build COMP=clang ARCH=${{ matrix.arch }} EXE=fairy-stockfish-all_${{ matrix.arch }} largeboards=yes all=yes && strip fairy-stockfish-all_${{ matrix.arch }}
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: fairy-stockfish-macos-${{ matrix.arch }}
+          path: src/fairy-stockfish*
+          if-no-files-found: error
+          compression-level: 9
+
+  macos-m1:
+    strategy:
+      matrix:
+        arch: ["apple-silicon"]
+    runs-on: macos-14
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: make
+        run: cd src && make clean && make -j build COMP=clang ARCH=${{ matrix.arch }} EXE=fairy-stockfish_${{ matrix.arch }} && strip fairy-stockfish_${{ matrix.arch }}
+
+      - name: make largeboards
+        run: cd src && make clean && make -j build COMP=clang ARCH=${{ matrix.arch }} EXE=fairy-stockfish-largeboards_${{ matrix.arch }} largeboards=yes && strip fairy-stockfish-largeboards_${{ matrix.arch }}
+
+      - name: make all
+        run: cd src && make clean && make -j build COMP=clang ARCH=${{ matrix.arch }} EXE=fairy-stockfish-all_${{ matrix.arch }} largeboards=yes all=yes && strip fairy-stockfish-all_${{ matrix.arch }}
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: fairy-stockfish-macos-m1-${{ matrix.arch }}
+          path: src/fairy-stockfish*
+          if-no-files-found: error
+          compression-level: 9

Fairy-Stockfish-master/.github/workflows/stockfish.yml

@@ -0,0 +1,213 @@
+name: Stockfish
+on:
+  push:
+    branches:
+      - master
+      - tools
+      - github_ci
+  pull_request:
+    branches:
+      - master
+      - tools
+jobs:
+  Stockfish:
+    name: ${{ matrix.config.name }}
+    runs-on: ${{ matrix.config.os }}
+    env:
+      COMPILER: ${{ matrix.config.compiler }}
+      COMP: ${{ matrix.config.comp }}
+      CXXFLAGS: "-Werror"
+    strategy:
+      matrix:
+        config:
+          - {
+              name: "Ubuntu 24.04 GCC",
+              os: ubuntu-24.04,
+              compiler: g++,
+              comp: gcc,
+              run_expensive_tests: true
+            }
+          - {
+              name: "Ubuntu 24.04 Clang",
+              os: ubuntu-24.04,
+              compiler: clang++,
+              comp: clang,
+              run_expensive_tests: false
+            }
+
+    defaults:
+      run:
+        working-directory: src
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Download required packages
+        run: |
+          sudo apt update
+          sudo apt install expect valgrind g++-multilib llvm
+
+      - name: Download the used network from the fishtest framework
+        run: |
+          make net
+
+      - name: Extract the bench number from the commit history
+        run: |
+          git log HEAD | grep "\b[Bb]ench[ :]\+[0-9]\{7\}" | head -n 1 | sed "s/[^0-9]*\([0-9]*\).*/\1/g" > git_sig
+          [ -s git_sig ] && echo "benchref=$(cat git_sig)" >> $GITHUB_ENV && echo "Reference bench:" $(cat git_sig) || echo "No bench found"
+
+      - name: Check compiler
+        run: |
+          $COMPILER -v
+
+      - name: Test help target
+        run: |
+          make help
+
+      # x86-32 tests
+
+      - name: Test debug x86-32 build
+        run: |
+          export CXXFLAGS="-Werror -D_GLIBCXX_DEBUG"
+          make clean
+          make -j2 ARCH=x86-32 optimize=no debug=yes build
+          ../tests/signature.sh $benchref
+
+      - name: Test debug x86-32 profile build (Optimization on, All features)
+        run: |
+          export CXXFLAGS=""
+          make clean
+          make -j2 ARCH=x86-32 optimize=yes all=yes largeboards=yes debug=yes profile-build
+
+      - name: Test x86-32 build
+        run: |
+          make clean
+          make -j2 ARCH=x86-32 build
+          ../tests/signature.sh $benchref
+
+      - name: Test x86-32-sse41-popcnt build
+        run: |
+          make clean
+          make -j2 ARCH=x86-32-sse41-popcnt build
+          ../tests/signature.sh $benchref
+
+      - name: Test x86-32-sse2 build
+        run: |
+          make clean
+          make -j2 ARCH=x86-32-sse2 build
+          ../tests/signature.sh $benchref
+
+      - name: Test general-32 build
+        run: |
+          make clean
+          make -j2 ARCH=general-32 build
+          ../tests/signature.sh $benchref
+
+      # x86-64 tests
+
+      - name: Test debug x86-64-modern build
+        run: |
+          export CXXFLAGS="-Werror -D_GLIBCXX_DEBUG"
+          make clean
+          make -j2 ARCH=x86-64-modern optimize=no debug=yes build
+          ../tests/signature.sh $benchref
+
+      - name: Test debug x86-64-modern profile build (Optimization on, All features)
+        run: |
+          export CXXFLAGS=""
+          make clean
+          make -j2 ARCH=x86-64-modern optimize=yes all=yes largeboards=yes debug=yes profile-build
+
+      - name: Test x86-64-modern build
+        run: |
+          make clean
+          make -j2 ARCH=x86-64-modern build
+          ../tests/signature.sh $benchref
+
+      - name: Test x86-64-ssse3 build
+        run: |
+          make clean
+          make -j2 ARCH=x86-64-ssse3 build
+          ../tests/signature.sh $benchref
+
+      - name: Test x86-64-sse3-popcnt build
+        run: |
+          make clean
+          make -j2 ARCH=x86-64-sse3-popcnt build
+          ../tests/signature.sh $benchref
+
+      - name: Test x86-64 build
+        run: |
+          make clean
+          make -j2 ARCH=x86-64 build
+          ../tests/signature.sh $benchref
+
+      - name: Test general-64 build
+        run: |
+          make clean
+          make -j2 ARCH=general-64 build
+          ../tests/signature.sh $benchref
+
+      # x86-64 with newer extensions tests
+
+      - name: Compile x86-64-avx2 build
+        run: |
+          make clean
+          make -j2 ARCH=x86-64-avx2 build
+
+      - name: Compile x86-64-bmi2 build
+        run: |
+          make clean
+          make -j2 ARCH=x86-64-bmi2 build
+
+      - name: Compile x86-64-avx512 build
+        run: |
+          make clean
+          make -j2 ARCH=x86-64-avx512 build
+
+      - name: Compile x86-64-vnni512 build
+        run: |
+          make clean
+          make -j2 ARCH=x86-64-vnni512 build
+
+      - name: Compile x86-64-vnni256 build
+        run: |
+          make clean
+          make -j2 ARCH=x86-64-vnni256 build
+
+      # Other tests
+
+      - name: Check perft and search reproducibility
+        run: |
+          make clean
+          make -j2 ARCH=x86-64-modern build
+          ../tests/perft.sh
+          ../tests/reprosearch.sh
+
+      # Sanitizers
+
+      - name: Run under valgrind
+        if: ${{ matrix.config.run_expensive_tests }}
+        run: |
+          export CXXFLAGS="-O1 -fno-inline"
+          make clean
+          make -j2 ARCH=x86-64-modern debug=yes optimize=no build > /dev/null
+          ../tests/instrumented.sh --valgrind
+          ../tests/instrumented.sh --valgrind-thread
+
+      - name: Run with UB sanitizer
+        if: ${{ matrix.config.run_expensive_tests }}
+        run: |
+          export CXXFLAGS="-O1 -fno-inline"
+          make clean
+          make -j2 ARCH=x86-64-modern sanitize=undefined optimize=no debug=yes build > /dev/null
+          ../tests/instrumented.sh --sanitizer-undefined
+
+      - name: Run with thread sanitizer
+        if: ${{ matrix.config.run_expensive_tests }}
+        run: |
+          export CXXFLAGS="-O1 -fno-inline"
+          make clean
+          make -j2 ARCH=x86-64-modern sanitize=thread optimize=no debug=yes build > /dev/null
+          ../tests/instrumented.sh --sanitizer-thread

Fairy-Stockfish-master/.github/workflows/wheels.yml

@@ -0,0 +1,57 @@
+name: Wheels
+
+on: 
+    push:
+      branches:
+        - master
+    pull_request:
+      branches:
+        - master
+
+jobs:
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-24.04, windows-2022, macos-14]
+
+    steps:
+      - uses: actions/checkout@v6
+
+      # Used to host cibuildwheel
+      - uses: actions/setup-python@v6
+
+      - name: Install cibuildwheel
+        run: python -m pip install cibuildwheel==3.4.0
+
+      - name: Build wheels
+        run: python -m cibuildwheel --output-dir wheelhouse
+        # to supply options, put them in 'env', like:
+        env:
+          MACOSX_DEPLOYMENT_TARGET: "10.14"
+          CIBW_ARCHS_MACOS: "x86_64 arm64"
+          CIBW_SKIP: "pp* *-win32 *-manylinux_i686 *-musllinux_* cp36-* cp37-* cp38"
+          CIBW_TEST_COMMAND: python {project}/test.py
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: dist-wheel-${{ matrix.os }}
+          path: ./wheelhouse/*.whl
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.9'
+
+      - name: Build sdist
+        run: python setup.py sdist
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: dist-source
+          path: dist/*.tar.gz

Fairy-Stockfish-master/.gitignore

@@ -0,0 +1,43 @@
+# Ignore binaries in src/ that have no extension
+/src/*
+!/src/*.*
+!/src/*/
+
+# Files from build
+**/*.o
+**/*.s
+src/.depend
+
+# Built binary
+src/stockfish*
+src/-lstdc++.res
+
+# Neural network for the NNUE evaluation
+**/*.nnue
+
+
+# Build/test artifacts
+*.exe
+tests/syzygy
+
+# ffishjs
+tests/js/node_modules
+ffish.js
+*.wasm
+
+# pyffish
+venv
+*.so
+pyffish.egg-info
+__pycache__
+*.pyc
+
+# test artifacts
+tests/*.exp
+src/*.log
+src/*.epd
+src/*.txt
+
+# IDEs
+.vscode
+.idea

Fairy-Stockfish-master/AGENTS.md

@@ -0,0 +1,158 @@
+# Fairy-Stockfish Development Guide
+
+## Repository Overview
+
+**Fairy-Stockfish** is a chess variant engine derived from Stockfish, designed to support numerous chess variants and protocols. Written primarily in C++17, it includes Python and JavaScript bindings for library use.
+
+**Repository Statistics:**
+- **Languages:** C++17 (primary), Python, JavaScript, Shell scripts
+- **Architecture:** Multi-protocol chess engine (UCI, UCCI, USI, XBoard/CECP)
+- **Target Platforms:** Windows, Linux, macOS, Android, WebAssembly
+- **Supported Variants:** 90+ chess variants including regional, historical, and modern variants
+
+## Build System & Requirements
+
+### Prerequisites
+- **Compiler:** GCC, Clang, or MSVC with C++17 support
+- **Build Tool:** GNU Make (required for C++ engine)
+- **Python:** 3.7+ (for Python bindings)
+- **Node.js:** (for JavaScript bindings)
+- **Additional Tools:** expect utility (for testing)
+
+### Core Build Process
+
+Note: Run engine and test commands from the `src/` directory unless specified otherwise.
+
+#### Basic Build Commands
+```bash
+# Standard release build (recommended for most users)
+make -j2 ARCH=x86-64 build
+
+# Debug build (for development)
+make -j2 ARCH=x86-64 debug=yes build
+
+# All variants including ones with large boards (up to 12x10) and large branching factor (all)
+make -j2 ARCH=x86-64 largeboards=yes all=yes build
+```
+
+### Python Bindings (pyffish)
+```bash
+# Build Python bindings (from repository root)
+python3 setup.py install
+
+# Alternative: Install from PyPI
+pip install pyffish
+```
+
+### JavaScript Bindings (ffish.js)
+Also see the `tests/js/README.md`.
+```bash
+cd src/
+
+# Build JavaScript bindings (requires emscripten)
+make -f Makefile_js build
+
+# Alternative: Install from npm
+npm install ffish
+```
+
+## Testing & Validation
+
+All test commands below assume the current directory is `src/`.
+
+### Core Engine Tests
+```bash
+# Basic functionality test
+./stockfish bench
+
+# Variant-specific benchmarks
+./stockfish bench xiangqi
+./stockfish bench shogi
+./stockfish bench capablanca
+
+# Validate variants configuration
+./stockfish check variants.ini
+```
+
+### Comprehensive Test Suite
+```bash
+# Protocol compliance tests
+../tests/protocol.sh
+
+# Move generation validation
+../tests/perft.sh all
+../tests/perft.sh chess      # Chess only
+../tests/perft.sh largeboard # Large board variants only
+
+# Regression testing
+../tests/regression.sh
+
+# Reproducible search test
+../tests/reprosearch.sh
+
+# Build signature verification  
+../tests/signature.sh
+```
+
+
+## Project Architecture
+
+### Directory Structure
+```
+src/                  # Core C++ engine source
+tests/                # Test scripts and data
+.github/workflows/    # CI/CD configurations
+```
+
+### Configuration Files
+- **`src/variants.ini`**: Defines examples for configuration of chess variants
+- **`setup.py`**: Python package build configuration
+- **`tests/js/package.json`**: JavaScript bindings configuration
+
+### Key Source Files in `src/`
+- **`variant.h`**: Variant rule properties
+- **`variant.cpp`**: Variant-specific game rules
+- **`variant.ini`**: Variant rule configuration examples and documentation of variant properties
+- **`position.h`**: Position representation
+- **`position.cpp`**: Board logic
+- **`movegen.cpp`**: Move generation logic
+- **`parser.cpp`**: Variant rule configuration parsing
+- **`piece.cpp`**: Piece type definitions and behavior
+- **`pyffish.cpp`**: Python bindings
+- **`ffishjs.cpp`**: JavaScript bindings
+
+## Continuous Integration
+
+### GitHub Actions Workflows
+- **`fairy.yml`**: Core engine testing (perft, protocols, variants)
+- **`stockfish.yml`**: Standard Stockfish compatibility tests
+- **`release.yml`**: Binary releases for multiple platforms
+- **`wheels.yml`**: Python package builds
+- **`ffishjs.yml`**: JavaScript binding builds
+
+## Common Development Patterns
+
+### Making Engine Changes
+1. **Always test basic functionality:** `./stockfish bench` after changes
+2. **Validate variant compatibility:** `./stockfish check variants.ini`  
+3. **Run relevant tests:** `../tests/perft.sh all` for move generation changes
+
+### Adding New Configurable Variants
+1. **Edit `src/variants.ini`**: Add variant configuration
+2. **Test parsing:** `./stockfish check variants.ini`
+
+### Relevant websites for researching chess variant rules
+- [Chess Variants on Wikipedia](https://en.wikipedia.org/wiki/List_of_chess_variants)
+- [Chess Variants Wiki](https://www.chessvariants.com/)
+- [Variant Chess on BoardGameGeek](https://boardgamegeek.com/boardgamefamily/4024/traditional-games-chess)
+- [PyChess Variants](https://www.pychess.org/variants)
+- [Ludii](https://ludii.games/library.php)
+- [Lichess.org Variants](https://lichess.org/variant)
+- [Greenchess](https://greenchess.net/variants.php)
+- [Chess Variants on Chess.com](https://www.chess.com/variants)
+
+### Development Best Practices
+* Make sure to only stage and commit changes that were changed as part of the task, do not simply add all changes.
+* Keep changes minimal and focused on the task at hand.
+* After applying changes make sure that all places related to the task have been identified.
+* Stay consistent with the existing code style and conventions.

Fairy-Stockfish-master/AUTHORS

@@ -0,0 +1,231 @@
+# Fairy-Stockfish authors
+
+# Main author
+Fabian Fichter (ianfab)
+
+# Contributors in alphabetical order
+alwey
+Belzedar94
+cloudfish
+CouchTomato87
+dpldgr
+Fulmene
+gbtami
+gnunicode
+johndoknjas
+kz04px
+majormink
+mtaktikos
+QueensGambit
+RainRat
+rkb97
+romstad
+Snowmoondaphne
+SriMethan
+thearst3rd
+TheYoBots
+tttak
+yjf2002ghty
+yoav-rozin
+ydirson
+
+
+
+# List of authors for Stockfish, as of June 14, 2021
+
+# Founders of the Stockfish project and fishtest infrastructure
+Tord Romstad (romstad)
+Marco Costalba (mcostalba)
+Joona Kiiski (zamar)
+Gary Linscott (glinscott)
+
+# Authors and inventors of NNUE, training, NNUE port
+Yu Nasu (ynasu87)
+Motohiro Isozaki (yaneurao)
+Hisayori Noda (nodchip)
+
+# all other authors of the code in alphabetical order
+Aditya (absimaldata)
+Adrian Petrescu (apetresc)
+Ajith Chandy Jose (ajithcj)
+Alain Savard (Rocky640)
+Alayan Feh (Alayan-stk-2)
+Alexander Kure
+Alexander Pagel (Lolligerhans)
+Alfredo Menezes (lonfom169)
+Ali AlZhrani (Cooffe)
+Andrew Grant (AndyGrant)
+Andrey Neporada (nepal)
+Andy Duplain
+Antoine Champion (antoinechampion)
+Aram Tumanian (atumanian)
+Arjun Temurnikar
+Artem Solopiy (EntityFX)
+Auguste Pop
+Balint Pfliegel
+Ben Koshy (BKSpurgeon)
+Bill Henry (VoyagerOne)
+Bojun Guo (noobpwnftw, Nooby)
+braich
+Brian Sheppard (SapphireBrand, briansheppard-toast)
+Bruno de Melo Costa (BM123499)
+Bryan Cross (crossbr)
+candirufish
+Chess13234
+Chris Cain (ceebo)
+Dale Weiler (graphitemaster)
+Dan Schmidt (dfannius)
+Daniel Axtens (daxtens)
+Daniel Dugovic (ddugovic)
+Dariusz Orzechowski (dorzechowski)
+David Zar
+Daylen Yang (daylen)
+Deshawn Mohan-Smith (GoldenRare)
+Dieter Dobbelaere (ddobbelaere)
+DiscanX
+Dominik Schlösser (domschl)
+double-beep
+Douglas Matos Gomes (dsmsgms)
+Eduardo Cáceres (eduherminio)
+Eelco de Groot (KingDefender)
+Elvin Liu (solarlight2)
+erbsenzaehler
+Ernesto Gatti
+Linmiao Xu (linrock)
+Fabian Beuke (madnight)
+Fabian Fichter (ianfab)
+Fanael Linithien (Fanael)
+fanon
+Fauzi Akram Dabat (FauziAkram)
+Felix Wittmann
+gamander
+Gary Heckman (gheckman)
+George Sobala (gsobala)
+gguliash
+Gian-Carlo Pascutto (gcp)
+Gontran Lemaire (gonlem)
+Goodkov Vasiliy Aleksandrovich (goodkov)
+Gregor Cramer
+GuardianRM
+Günther Demetz (pb00067, pb00068)
+Guy Vreuls (gvreuls)
+Henri Wiechers
+Hiraoka Takuya (HiraokaTakuya)
+homoSapiensSapiens
+Hongzhi Cheng
+Ivan Ivec (IIvec)
+Jacques B. (Timshel)
+Jan Ondruš (hxim)
+Jared Kish (Kurtbusch)
+Jarrod Torriero (DU-jdto)
+Jean Gauthier (OuaisBla)
+Jean-Francois Romang (jromang)
+Jekaa
+Jerry Donald Watson (jerrydonaldwatson)
+jjoshua2
+Jonathan Calovski (Mysseno)
+Jonathan Buladas Dumale (SFisGOD)
+Joost VandeVondele (vondele)
+Jörg Oster (joergoster)
+Joseph Ellis (jhellis3)
+Joseph R. Prostko
+Julian Willemer (NightlyKing)
+jundery
+Justin Blanchard (UncombedCoconut)
+Kelly Wilson
+Ken Takusagawa
+kinderchocolate
+Kiran Panditrao (Krgp)
+Kojirion
+Krystian Kuzniarek (kuzkry)
+Leonardo Ljubičić (ICCF World Champion)
+Leonid Pechenik (lp--)
+Linus Arver (listx)
+loco-loco
+Lub van den Berg (ElbertoOne)
+Luca Brivio (lucabrivio)
+Lucas Braesch (lucasart)
+Lyudmil Antonov (lantonov)
+Maciej Żenczykowski (zenczykowski)
+Malcolm Campbell (xoto10)
+Mark Tenzer (31m059)
+marotear
+Matt Ginsberg (mattginsberg)
+Matthew Lai (matthewlai)
+Matthew Sullivan (Matt14916)
+Maxim Molchanov (Maxim)
+Michael An (man)
+Michael Byrne (MichaelB7)
+Michael Chaly (Vizvezdenec)
+Michael Stembera (mstembera)
+Michael Whiteley (protonspring)
+Michel Van den Bergh (vdbergh)
+Miguel Lahoz (miguel-l)
+Mikael Bäckman (mbootsector)
+Mira
+Miroslav Fontán (Hexik)
+Moez Jellouli (MJZ1977)
+Mohammed Li (tthsqe12)
+Nathan Rugg (nmrugg)
+Nick Pelling (nickpelling)
+Nicklas Persson (NicklasPersson)
+Niklas Fiekas (niklasf)
+Nikolay Kostov (NikolayIT)
+Nguyen Pham (nguyenpham)
+Norman Schmidt (FireFather)
+notruck
+Ondrej Mosnáček (WOnder93)
+Oskar Werkelin Ahlin
+Pablo Vazquez
+Panthee
+Pascal Romaret
+Pasquale Pigazzini (ppigazzini)
+Patrick Jansen (mibere)
+pellanda
+Peter Zsifkovits (CoffeeOne)
+Praveen Kumar Tummala (praveentml)
+Rahul Dsilva (silversolver1)
+Ralph Stößer (Ralph Stoesser)
+Raminder Singh
+renouve
+Reuven Peleg
+Richard Lloyd
+Rodrigo Exterckötter Tjäder
+Ron Britvich (Britvich)
+Ronald de Man (syzygy1, syzygy)
+rqs
+Ryan Schmitt
+Ryan Takker
+Sami Kiminki (skiminki)
+Sebastian Buchwald (UniQP)
+Sergei Antonov (saproj)
+Sergei Ivanov (svivanov72)
+Sergio Vieri (sergiovieri)
+sf-x
+Shane Booth (shane31)
+Shawn Varghese (xXH4CKST3RXx)
+Siad Daboul (Topologist)
+Stefan Geschwentner (locutus2)
+Stefano Cardanobile (Stefano80)
+Steinar Gunderson (sesse)
+Stéphane Nicolet (snicolet)
+Prokop Randáček (ProkopRandacek)
+Thanar2
+thaspel
+theo77186
+Tom Truscott
+Tom Vijlbrief (tomtor)
+Tomasz Sobczyk (Sopel97)
+Torsten Franz (torfranz, tfranzer)
+Tracey Emery (basepr1me)
+tttak
+Unai Corzo (unaiic)
+Uri Blass (uriblass)
+Vince Negri (cuddlestmonkey)
+zz4032
+
+
+# Additionally, we acknowledge the authors and maintainers of fishtest,
+# an amazing and essential framework for the development of Stockfish!
+#
+# https://github.com/glinscott/fishtest/blob/master/AUTHORS

Fairy-Stockfish-master/Copying.txt

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program 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.
+
+    This program 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 <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

Fairy-Stockfish-master/MANIFEST.in

@@ -0,0 +1,2 @@
+include AUTHORS Copying.txt Readme.md test.py
+recursive-include src *.h *.cpp

Fairy-Stockfish-master/README.md

@@ -0,0 +1,126 @@
+# Fairy-Stockfish
+
+## Overview
+
+[![Build Status](https://github.com/fairy-stockfish/Fairy-Stockfish/actions/workflows/release.yml/badge.svg?branch=master)](https://github.com/fairy-stockfish/Fairy-Stockfish/actions?query=workflow%3ARelease)
+[![Build Status](https://github.com/fairy-stockfish/Fairy-Stockfish/actions/workflows/fairy.yml/badge.svg?branch=master)](https://github.com/fairy-stockfish/Fairy-Stockfish/actions?query=workflow%3Afairy)
+[![Build Status](https://ci.appveyor.com/api/projects/status/github/fairy-stockfish/Fairy-Stockfish?branch=master&svg=true)](https://ci.appveyor.com/project/ianfab/Fairy-Stockfish/branch/master)
+[![PyPI version](https://badge.fury.io/py/pyffish.svg)](https://badge.fury.io/py/pyffish)
+[![NPM version](https://img.shields.io/npm/v/ffish.svg?sanitize=true)](https://www.npmjs.com/package/ffish)
+
+Fairy-Stockfish is a chess variant engine derived from [Stockfish](https://github.com/official-stockfish/Stockfish/) designed for the support of fairy chess variants and easy extensibility with more games. It can play various regional, historical, and modern chess variants as well as [games with user-defined rules](https://github.com/fairy-stockfish/Fairy-Stockfish/wiki/Variant-configuration). For [compatibility with graphical user interfaces](https://github.com/fairy-stockfish/Fairy-Stockfish/wiki/Graphical-user-interfaces) it supports the UCI, UCCI, USI, UCI-cyclone, and CECP/XBoard protocols.
+
+The goal of the project is to create an engine supporting a large variety of chess-like games, equipped with the powerful search of Stockfish. Despite its generality the [playing strength](https://github.com/fairy-stockfish/Fairy-Stockfish/wiki/Playing-strength) is on a very high level in almost all supported variants. Due to its multi-protocol support Fairy-Stockfish works with almost any chess variant GUI.
+
+## Installation
+You can download the [Windows executable](https://github.com/fairy-stockfish/Fairy-Stockfish/releases/latest/download/fairy-stockfish-largeboard_x86-64.exe) or [Linux binary](https://github.com/fairy-stockfish/Fairy-Stockfish/releases/latest/download/fairy-stockfish-largeboard_x86-64) from the [latest release](https://github.com/fairy-stockfish/Fairy-Stockfish/releases/latest) or [compile the program from source](https://github.com/fairy-stockfish/Fairy-Stockfish#compiling-stockfish-yourself-from-the-sources). The program comes without a graphical user interface, so you perhaps want to use it together with a [compatible GUI](https://github.com/fairy-stockfish/Fairy-Stockfish/wiki/Graphical-user-interfaces), or [play against it online](https://github.com/fairy-stockfish/Fairy-Stockfish/wiki/Online) at [pychess](https://www.pychess.org/), [lishogi](https://lishogi.org/@/Fairy-Stockfish), or [lichess](https://lichess.org/@/Fairy-Stockfish). Read more about [how to use](https://github.com/fairy-stockfish/Fairy-Stockfish/wiki/Usage) Fairy-Stockfish in the wiki.
+
+If you want to preview the functionality of Fairy-Stockfish before downloading, you can try it out on the [Fairy-Stockfish playground](https://fairyground.vercel.app/) in the browser.
+
+Optional NNUE evaluation parameter files to improve playing strength for many variants are in the [list of NNUE networks](https://fairy-stockfish.github.io/nnue/#current-best-nnue-networks).
+For the regional variants Xiangqi, Janggi, and Makruk [dedicated releases with built-in NNUE networks](https://github.com/fairy-stockfish/Fairy-Stockfish-NNUE) are available. See the [wiki](https://github.com/fairy-stockfish/Fairy-Stockfish/wiki/NNUE) for more details on NNUE.
+
+## Contributing
+
+If you like this project, please support its development via [patreon](https://www.patreon.com/ianfab), [paypal](https://paypal.me/FairyStockfish), or [github](https://github.com/sponsors/ianfab), or by [contributing to the code](https://github.com/fairy-stockfish/Fairy-Stockfish/wiki/Contributing) or documentation. An [introduction to the code base](https://github.com/fairy-stockfish/Fairy-Stockfish/wiki/Understanding-the-code) can be found in the wiki.
+
+## Supported games
+
+The games currently supported besides chess are listed below. Fairy-Stockfish can also play user-defined variants loaded via a variant configuration file, see the file [`src/variants.ini`](https://github.com/ianfab/Fairy-Stockfish/blob/master/src/variants.ini) and the [wiki](https://github.com/fairy-stockfish/Fairy-Stockfish/wiki/Variant-configuration).
+
+### Regional and historical games
+- [Xiangqi](https://en.wikipedia.org/wiki/Xiangqi), [Manchu](https://en.wikipedia.org/wiki/Manchu_chess), [Minixiangqi](https://www.pychess.org/variants/minixiangqi), [Supply chess](https://en.wikipedia.org/wiki/Xiangqi#Variations)
+- [Shogi](https://en.wikipedia.org/wiki/Shogi), [Shogi variants](https://github.com/fairy-stockfish/Fairy-Stockfish#shogi-variants)
+- [Janggi](https://en.wikipedia.org/wiki/Janggi)
+- [Makruk](https://en.wikipedia.org/wiki/Makruk), [ASEAN](http://hgm.nubati.net/rules/ASEAN.html), Makpong, Ai-Wok
+- [Ouk Chatrang](https://en.wikipedia.org/wiki/Makruk#Cambodian_chess), [Kar Ouk](https://en.wikipedia.org/wiki/Makruk#Cambodian_chess)
+- [Sittuyin](https://en.wikipedia.org/wiki/Sittuyin)
+- [Shatar](https://en.wikipedia.org/wiki/Shatar), [Jeson Mor](https://en.wikipedia.org/wiki/Jeson_Mor)
+- [Shatranj](https://en.wikipedia.org/wiki/Shatranj), [Courier](https://en.wikipedia.org/wiki/Courier_chess)
+- [Raazuvaa](https://www.reddit.com/r/chess/comments/sj7y3n/raazuvaa_the_chess_of_the_maldives)
+
+### Chess variants
+- [Capablanca](https://en.wikipedia.org/wiki/Capablanca_Chess), [Janus](https://en.wikipedia.org/wiki/Janus_Chess), [Modern](https://en.wikipedia.org/wiki/Modern_Chess_(chess_variant)), [Chancellor](https://en.wikipedia.org/wiki/Chancellor_Chess), [Embassy](https://en.wikipedia.org/wiki/Embassy_Chess), [Gothic](https://www.chessvariants.com/large.dir/gothicchess.html), [Capablanca random chess](https://en.wikipedia.org/wiki/Capablanca_Random_Chess)
+- [Grand](https://en.wikipedia.org/wiki/Grand_Chess), [Shako](https://www.chessvariants.com/large.dir/shako.html), [Centaur](https://www.chessvariants.com/large.dir/contest/royalcourt.html), [Tencubed](https://www.chessvariants.com/contests/10/tencubedchess.html), [Opulent](https://www.chessvariants.com/rules/opulent-chess)
+- [Chess960](https://en.wikipedia.org/wiki/Chess960), [Placement/Pre-Chess](https://www.chessvariants.com/link/placement-chess)
+- [Crazyhouse](https://en.wikipedia.org/wiki/Crazyhouse), [Loop](https://en.wikipedia.org/wiki/Crazyhouse#Variations), [Chessgi](https://en.wikipedia.org/wiki/Crazyhouse#Variations), [Pocket Knight](http://www.chessvariants.com/other.dir/pocket.html), Capablanca-Crazyhouse
+- [Bughouse](https://en.wikipedia.org/wiki/Bughouse_chess), [Koedem](http://schachclub-oetigheim.de/wp-content/uploads/2016/04/Koedem-rules.pdf)
+- [Seirawan](https://en.wikipedia.org/wiki/Seirawan_chess), Seirawan-Crazyhouse, [Dragon Chess](https://www.edami.com/dragonchess/)
+- [Amazon](https://www.chessvariants.com/diffmove.dir/amazone.html), [Chigorin](https://www.chessvariants.com/diffsetup.dir/chigorin.html), [Almost chess](https://en.wikipedia.org/wiki/Almost_Chess)
+- [Hoppel-Poppel](http://www.chessvariants.com/diffmove.dir/hoppel-poppel.html), New Zealand
+- [Antichess](https://lichess.org/variant/antichess), [Giveaway](http://www.chessvariants.com/diffobjective.dir/giveaway.old.html), [Suicide](https://www.freechess.org/Help/HelpFiles/suicide_chess.html), [Losers](https://www.chessclub.com/help/Wild17), [Codrus](http://www.binnewirtz.com/Schlagschach1.htm)
+- [Extinction](https://en.wikipedia.org/wiki/Extinction_chess), [Kinglet](https://en.wikipedia.org/wiki/V._R._Parton#Kinglet_chess), Three Kings, [Coregal](https://www.chessvariants.com/winning.dir/coregal.html)
+- [King of the Hill](https://en.wikipedia.org/wiki/King_of_the_Hill_(chess)), [Racing Kings](https://en.wikipedia.org/wiki/V._R._Parton#Racing_Kings)
+- [Three-check](https://en.wikipedia.org/wiki/Three-check_chess), Five-check
+- [Los Alamos](https://en.wikipedia.org/wiki/Los_Alamos_chess), [Gardner's Minichess](https://en.wikipedia.org/wiki/Minichess#5%C3%975_chess)
+- [Atomic](https://en.wikipedia.org/wiki/Atomic_chess)
+- [Horde](https://en.wikipedia.org/wiki/Dunsany%27s_Chess#Horde_Chess), [Maharajah and the Sepoys](https://en.wikipedia.org/wiki/Maharajah_and_the_Sepoys)
+- [Knightmate](https://www.chessvariants.com/diffobjective.dir/knightmate.html), [Nightrider](https://en.wikipedia.org/wiki/Nightrider_(chess)), [Grasshopper](https://en.wikipedia.org/wiki/Grasshopper_chess)
+- [Duck chess](https://duckchess.com/), [Omicron](http://www.eglebbk.dds.nl/program/chess-omicron.html), [Gustav III](https://www.chessvariants.com/play/gustav-iiis-chess)
+- [Berolina Chess](https://en.wikipedia.org/wiki/Berolina_pawn#Berolina_chess), [Pawn-Sideways](https://arxiv.org/abs/2009.04374), [Pawn-Back](https://arxiv.org/abs/2009.04374), [Torpedo](https://arxiv.org/abs/2009.04374), [Legan Chess](https://en.wikipedia.org/wiki/Legan_chess)
+- [Spartan Chess](https://www.chessvariants.com/rules/spartan-chess)
+- [Wolf Chess](https://en.wikipedia.org/wiki/Wolf_chess)
+- [Troitzky Chess](https://www.chessvariants.com/play/troitzky-chess)
+
+### Shogi variants
+- [Minishogi](https://en.wikipedia.org/wiki/Minishogi), [EuroShogi](https://en.wikipedia.org/wiki/EuroShogi), [Judkins shogi](https://en.wikipedia.org/wiki/Judkins_shogi)
+- [Kyoto shogi](https://en.wikipedia.org/wiki/Kyoto_shogi), [Microshogi](https://en.wikipedia.org/wiki/Micro_shogi)
+- [Dobutsu shogi](https://en.wikipedia.org/wiki/Dōbutsu_shōgi), [Goro goro shogi](https://en.wikipedia.org/wiki/D%C5%8Dbutsu_sh%C5%8Dgi#Variation)
+- [Tori shogi](https://en.wikipedia.org/wiki/Tori_shogi)
+- [Yari shogi](https://en.wikipedia.org/wiki/Yari_shogi)
+- [Okisaki shogi](https://en.wikipedia.org/wiki/Okisaki_shogi)
+- [Sho shogi](https://en.wikipedia.org/wiki/Sho_shogi)
+
+### Related games
+- [Amazons](https://en.wikipedia.org/wiki/Game_of_the_Amazons)
+- [Ataxx](https://en.wikipedia.org/wiki/Ataxx)
+- [Breakthrough](https://en.wikipedia.org/wiki/Breakthrough_(board_game))
+- [Clobber](https://en.wikipedia.org/wiki/Clobber)
+- [Cfour](https://en.wikipedia.org/wiki/Connect_Four), [Tic-tac-toe](https://en.wikipedia.org/wiki/Tic-tac-toe)
+- [Five Field Kono](https://en.wikipedia.org/wiki/Five_Field_Kono)
+- [Flipersi](https://en.wikipedia.org/wiki/Reversi), [Flipello](https://en.wikipedia.org/wiki/Reversi#Othello)
+- [Fox and Hounds](https://boardgamegeek.com/boardgame/148180/fox-and-hounds)
+- [Isolation](https://boardgamegeek.com/boardgame/1875/isolation)
+- [Joust](https://www.chessvariants.com/programs.dir/joust.html)
+- [Snailtrail](https://boardgamegeek.com/boardgame/37135/snailtrail)
+
+
+## Help
+
+See the [Fairy-Stockfish Wiki](https://github.com/fairy-stockfish/Fairy-Stockfish/wiki) for more info, or if the required information is not available, open an [issue](https://github.com/fairy-stockfish/Fairy-Stockfish/issues) or join our [discord server](https://discord.gg/FYUGgmCFB4).
+
+## Bindings
+
+Besides the C++ engine, this project also includes bindings for other programming languages in order to be able to use it as a library for chess variants. They support move, SAN, and FEN generation, as well as checking of game end conditions for all variants supported by Fairy-Stockfish. Since the bindings are using the C++ code, they are very performant compared to libraries directly written in the respective target language.
+
+### Python
+
+The python binding [pyffish](https://pypi.org/project/pyffish/) contributed by [@gbtami](https://github.com/gbtami) is implemented in [pyffish.cpp](https://github.com/fairy-stockfish/Fairy-Stockfish/blob/master/src/pyffish.cpp). It is e.g. used in the backend for the [pychess server](https://github.com/gbtami/pychess-variants).
+
+### Javascript
+
+The javascript binding [ffish.js](https://www.npmjs.com/package/ffish) contributed by [@QueensGambit](https://github.com/QueensGambit) is implemented in [ffishjs.cpp](https://github.com/fairy-stockfish/Fairy-Stockfish/blob/master/src/ffishjs.cpp). The compilation/binding to javascript is done using emscripten, see the [readme](https://github.com/fairy-stockfish/Fairy-Stockfish/tree/master/tests/js).
+
+## Ports
+
+### WebAssembly
+
+For in-browser use a [port of Fairy-Stockfish to WebAssembly](https://github.com/fairy-stockfish/fairy-stockfish.wasm) is available at [npm](https://www.npmjs.com/package/fairy-stockfish-nnue.wasm). It is e.g. used for local analysis on [pychess.org](https://www.pychess.org/analysis/chess). Also see the [Fairy-Stockfish WASM demo](https://github.com/ianfab/fairy-stockfish-nnue-wasm-demo) available at https://fairy-stockfish-nnue-wasm.vercel.app/.
+
+## Terms of use
+
+Fairy-Stockfish is free, and distributed under the **GNU General Public License version 3**
+(GPL v3). Essentially, this means you are free to do almost exactly
+what you want with the program, including distributing it among your
+friends, making it available for download from your website, selling
+it (either by itself or as part of some bigger software package), or
+using it as the starting point for a software project of your own.
+
+The only real limitation is that whenever you distribute Fairy-Stockfish in
+some way, you MUST always include the full source code, or a pointer
+to where the source code can be found, to generate the exact binary
+you are distributing. If you make any changes to the source code,
+these changes must also be made available under the GPL.
+
+For full details, read the copy of the GPL v3 found in the file named
+[*Copying.txt*](https://github.com/fairy-stockfish/Fairy-Stockfish/blob/master/Copying.txt).

Fairy-Stockfish-master/Top CPU Contributors.txt

@@ -0,0 +1,205 @@
+Contributors to Fishtest with >10,000 CPU hours, as of Jun 29, 2021.
+Thank you!
+
+Username                 CPU Hours       Games played
+-----------------------------------------------------
+noobpwnftw                27649494         1834734733
+mlang                      1426107           89454622
+dew                        1380910           82831648
+mibere                      703840           46867607
+grandphish2                 692707           41737913
+tvijlbrief                  669642           42371594
+JojoM                       597778           35297180
+TueRens                     519226           31823562
+cw                          458421           30307421
+fastgm                      439667           25950040
+gvreuls                     436599           28177460
+crunchy                     427035           27344275
+CSU_Dynasty                 374765           25106278
+Fisherman                   326901           21822979
+ctoks                       325477           21767943
+velislav                    295343           18844324
+linrock                     292789           10624427
+bcross                      278584           19488961
+okrout                      262818           13803272
+pemo                        245982           11376085
+glinscott                   217799           13780820
+leszek                      212346           12959025
+nordlandia                  211692           13484886
+bking_US                    198894           11876016
+drabel                      196463           13450602
+robal                       195473           12375650
+mgrabiak                    187226           12016564
+Dantist                     183202           10990484
+Thanar                      179852           12365359
+vdv                         175274            9889046
+spams                       157128           10319326
+marrco                      150295            9402141
+sqrt2                       147963            9724586
+mhoram                      141278            8901241
+CoffeeOne                   137100            5024116
+vdbergh                     137041            8926915
+malala                      136182            8002293
+xoto                        133702            9156676
+davar                       122092            7960001
+dsmith                      122059            7570238
+Data                        113305            8220352
+BrunoBanani                 112960            7436849
+MaZePallas                  102823            6633619
+sterni1971                  100532            5880772
+ElbertoOne                   99028            7023771
+brabos                       92118            6186135
+oz                           92100            6486640
+psk                          89957            5984901
+amicic                       89156            5392305
+sunu                         88851            6028873
+Vizvezdenec                  83761            5344740
+0x3C33                       82614            5271253
+BRAVONE                      81239            5054681
+racerschmacer                80899            5759262
+cuistot                      80300            4606144
+nssy                         76497            5259388
+teddybaer                    75125            5407666
+Pking_cda                    73776            5293873
+jromang                      72192            5057715
+solarlight                   70517            5028306
+dv8silencer                  70287            3883992
+Bobo1239                     68515            4652287
+manap                        66273            4121774
+skiminki                     65088            4023328
+tinker                       64333            4268790
+sschnee                      60767            3500800
+qurashee                     57344            3168264
+robnjr                       57262            4053117
+Freja                        56938            3733019
+ttruscott                    56010            3680085
+rkl                          55132            4164467
+renouve                      53811            3501516
+finfish                      51360            3370515
+eva42                        51272            3599691
+rap                          49985            3219146
+pb00067                      49727            3298270
+ronaldjerum                  47654            3240695
+bigpen0r                     47653            3335327
+eastorwest                   47585            3221629
+biffhero                     46564            3111352
+VoyagerOne                   45476            3452465
+yurikvelo                    44834            3034550
+speedycpu                    43842            3003273
+jbwiebe                      43305            2805433
+Spprtr                       42279            2680153
+DesolatedDodo                42007            2447516
+Antihistamine                41788            2761312
+mhunt                        41735            2691355
+homyur                       39893            2850481
+gri                          39871            2515779
+Fifis                        38776            2529121
+oryx                         38724            2966648
+SC                           37290            2731014
+csnodgrass                   36207            2688994
+jmdana                       36157            2210661
+strelock                     34716            2074055
+rpngn                        33951            2057395
+Garf                         33922            2751802
+EthanOConnor                 33370            2090311
+slakovv                      32915            2021889
+manapbk                      30987            1810399
+Prcuvu                       30377            2170122
+anst                         30301            2190091
+jkiiski                      30136            1904470
+hyperbolic.tom               29840            2017394
+Pyafue                       29650            1902349
+Wolfgang                     29260            1658936
+zeryl                        28156            1579911
+OuaisBla                     27636            1578800
+DMBK                         27051            1999456
+chriswk                      26902            1868317
+achambord                    26582            1767323
+Patrick_G                    26276            1801617
+yorkman                      26193            1992080
+SFTUser                      25182            1675689
+nabildanial                  24942            1519409
+Sharaf_DG                    24765            1786697
+ncfish1                      24411            1520927
+rodneyc                      24227            1409514
+agg177                       23890            1395014
+JanErik                      23408            1703875
+Isidor                       23388            1680691
+Norabor                      23164            1591830
+cisco2015                    22897            1762669
+Zirie                        22542            1472937
+team-oh                      22272            1636708
+MazeOfGalious                21978            1629593
+sg4032                       21947            1643265
+ianh2105                     21725            1632562
+xor12                        21628            1680365
+dex                          21612            1467203
+nesoneg                      21494            1463031
+sphinx                       21211            1384728
+jjoshua2                     21001            1423089
+horst.prack                  20878            1465656
+Ente                         20865            1477066
+0xB00B1ES                    20590            1208666
+j3corre                      20405             941444
+Adrian.Schmidt123            20316            1281436
+wei                          19973            1745989
+MaxKlaxxMiner                19850            1009176
+rstoesser                    19569            1293588
+gopeto                       19491            1174952
+eudhan                       19274            1283717
+jundery                      18445            1115855
+megaman7de                   18377            1067540
+iisiraider                   18247            1101015
+ville                        17883            1384026
+chris                        17698            1487385
+purplefishies                17595            1092533
+dju                          17353             978595
+DragonLord                   17014            1162790
+IgorLeMasson                 16064            1147232
+ako027ako                    15671            1173203
+chuckstablers                15289             891576
+Nikolay.IT                   15154            1068349
+Andrew Grant                 15114             895539
+OssumOpossum                 14857            1007129
+Karby                        14808             867120
+enedene                      14476             905279
+bpfliegel                    14298             884523
+mpx86                        14019             759568
+jpulman                      13982             870599
+crocogoat                    13803            1117422
+joster                       13794             950160
+Nesa92                       13786            1114691
+Hjax                         13535             915487
+jsys14                       13459             785000
+Dark_wizzie                  13422            1007152
+mabichito                    12903             749391
+thijsk                       12886             722107
+AdrianSA                     12860             804972
+Flopzee                      12698             894821
+fatmurphy                    12547             853210
+Rudolphous                   12520             832340
+scuzzi                       12511             845761
+SapphireBrand                12416             969604
+modolief                     12386             896470
+Machariel                    12335             810784
+pgontarz                     12151             848794
+stocky                       11954             699440
+mschmidt                     11941             803401
+Maxim                        11543             836024
+infinity                     11470             727027
+torbjo                       11395             729145
+Thomas A. Anderson           11372             732094
+savage84                     11358             670860
+d64                          11263             789184
+MooTheCow                    11237             720174
+snicolet                     11106             869170
+ali-al-zhrani                11086             767926
+AndreasKrug                  10875             887457
+pirt                         10806             836519
+basepi                       10637             744851
+michaelrpg                   10508             739039
+dzjp                         10343             732529
+aga                          10302             622975
+ols                          10259             570669
+lbraesch                     10252             647825
+FormazChar                   10059             757283

Fairy-Stockfish-master/appveyor.yml

@@ -0,0 +1,91 @@
+version: 1.0.{build}
+clone_depth: 50
+
+branches:
+  only:
+    - master
+    - merge
+    - appveyor
+
+# Operating system (build VM template)
+os: Visual Studio 2019
+
+# Build platform, i.e. x86, x64, AnyCPU. This setting is optional.
+platform:
+  - x86
+  - x64
+
+# build Configuration, i.e. Debug, Release, etc.
+configuration:
+  - Debug
+  - Release
+
+matrix:
+  # The build fail immediately once one of the job fails
+  fast_finish: true
+
+# Scripts that are called at very beginning, before repo cloning
+init:
+  - cmake --version
+  - msbuild /version
+
+before_build:
+  - ps: |
+      # Get sources
+      $src = get-childitem -Path *.cpp -Recurse -Exclude pyffish.cpp,ffishjs.cpp | select -ExpandProperty FullName
+      $src = $src -join ' '
+      $src = $src.Replace("\", "/")
+
+      # Build CMakeLists.txt
+      $t = 'cmake_minimum_required(VERSION 3.17)',
+           'project(Stockfish)',
+           'set(CMAKE_CXX_STANDARD 17)',
+           'set(CMAKE_CXX_STANDARD_REQUIRED ON)',
+           'set (CMAKE_CXX_EXTENSIONS OFF)',
+           'set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/src)',
+           'set(source_files', $src, ')',
+           'add_compile_definitions(NNUE_EMBEDDING_OFF)',
+           'add_executable(stockfish ${source_files})'
+
+      # Write CMakeLists.txt without BOM
+      $MyPath = (Get-Item -Path "." -Verbose).FullName + '\CMakeLists.txt'
+      $Utf8NoBomEncoding = New-Object System.Text.UTF8Encoding $False
+      [System.IO.File]::WriteAllLines($MyPath, $t, $Utf8NoBomEncoding)
+
+      # Obtain bench reference from git log
+      $b = git log HEAD | sls "\b[Bb]ench[ :]+[0-9]{7}" | select -first 1
+      $bench = $b -match '\D+(\d+)' | % { $matches[1] }
+      Write-Host "Reference bench:" $bench
+      $g = "Visual Studio 16 2019"
+      If (${env:PLATFORM} -eq 'x64') { $a = "x64" }
+      If (${env:PLATFORM} -eq 'x86') { $a = "Win32" }
+      cmake -G "${g}" -A ${a} .
+      Write-Host "Generated files for: " $g $a
+
+build_script:
+  - cmake --build . --config %CONFIGURATION% -- /verbosity:minimal
+  - ps: |
+      # Download default NNUE net from fishtest
+      $nnuenet = Get-Content -Path src\evaluate.h | Select-String -CaseSensitive -Pattern "EvalFileDefaultName" | Select-String -CaseSensitive -Pattern "nn-[a-z0-9]{12}.nnue"
+      $dummy = $nnuenet -match "(?<nnuenet>nn-[a-z0-9]{12}.nnue)"
+      $nnuenet = $Matches.nnuenet
+      Write-Host "Default net:" $nnuenet
+      $nnuedownloadurl = "https://github.com/official-stockfish/networks/raw/master/$nnuenet"
+      $nnuefilepath = "src\${env:CONFIGURATION}\$nnuenet"
+      if (Test-Path -Path $nnuefilepath) {
+            Write-Host "Already available."
+      } else {
+            Write-Host "Downloading $nnuedownloadurl to $nnuefilepath"
+            Invoke-WebRequest -Uri $nnuedownloadurl -OutFile $nnuefilepath
+      }
+
+before_test:
+  - cd src/%CONFIGURATION%
+  - stockfish bench 2> out.txt >NUL
+  - ps: |
+      # Verify bench number
+      $s = (gc "./out.txt" | out-string)
+      $r = ($s -match 'Nodes searched \D+(\d+)' | % { $matches[1] })
+      Write-Host "Engine bench:" $r
+      Write-Host "Reference bench:" $bench
+      If ($r -ne $bench) { exit 1 }

Fairy-Stockfish-master/pyffish.pyi

@@ -0,0 +1,39 @@
+from typing import Any
+
+FEN_OK: int
+NOTATION_DEFAULT: int
+NOTATION_JANGGI: int
+NOTATION_LAN: int
+NOTATION_SAN: int
+NOTATION_SHOGI_HODGES: int
+NOTATION_SHOGI_HODGES_NUMBER: int
+NOTATION_SHOGI_HOSKING: int
+NOTATION_THAI_LAN: int
+NOTATION_THAI_SAN: int
+NOTATION_XIANGQI_WXF: int
+VALUE_DRAW: int
+VALUE_MATE: int
+
+class error(Exception): ...
+
+def version() -> tuple[int, int, int]: ...
+def info() -> str: ...
+def variants() -> list[str]: ...
+def set_option(name: str, value: Any) -> None: ...
+def load_variant_config(config: str) -> None: ...
+def start_fen(variant: str) -> str: ...
+def two_boards(variant: str) -> bool: ...
+def captures_to_hand(variant: str) -> bool: ...
+def get_san(variant: str, fen: str, move: str, chess960: bool = False, notation: int = NOTATION_DEFAULT) -> str: ...
+def get_san_moves(variant: str, fen: str, movelist: list[str], chess960: bool = False, notation: int = NOTATION_DEFAULT) -> list[str]: ...
+def legal_moves(variant: str, fen: str, movelist: list[str], chess960: bool = False) -> list[str]: ...
+def get_fen(variant: str, fen: str, movelist: list[str], chess960: bool = False, sfen: bool = False, show_promoted: bool = False, count_started: int = 0) -> str: ...
+def gives_check(variant: str, fen: str, movelist: list[str], chess960: bool = False) -> bool: ...
+def is_capture(variant: str, fen: str, movelist: list[str], move: str, chess960: bool = False) -> bool: ...
+def piece_to_partner(variant: str, fen: str, movelist: list[str], chess960: bool = False) -> str: ...
+def game_result(variant: str, fen: str, movelist: list[str], chess960: bool = False) -> int: ...
+def is_immediate_game_end(variant: str, fen: str, movelist: list[str], chess960: bool = False) -> tuple[bool, int]: ...
+def is_optional_game_end(variant: str, fen: str, movelist: list[str], chess960: bool = False, count_started: int = 0) -> tuple[bool, int]: ...
+def has_insufficient_material(variant: str, fen: str, movelist: list[str], chess960: bool = False) -> tuple[bool, bool]: ...
+def validate_fen(fen: str, variant: str, chess960: bool = False) -> int: ...
+def get_fog_fen(fen: str, variant: str, chess960: bool = False) -> str: ...

Fairy-Stockfish-master/setup.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+from setuptools import setup, Extension
+from glob import glob
+import platform
+import io
+import os
+
+
+if platform.python_compiler().startswith("MSC"):
+    args = ["/std:c++17"]
+else:
+    args = ["-std=c++17", "-flto", "-Wno-date-time"]
+
+args.extend(["-DLARGEBOARDS", "-DALLVARS", "-DPRECOMPUTED_MAGICS", "-DNNUE_EMBEDDING_OFF"])
+
+if "64bit" in platform.architecture():
+    args.append("-DIS_64BIT")
+
+CLASSIFIERS = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+with io.open("README.md", "r", encoding="utf8") as fh:
+    long_description = fh.read().strip()
+
+sources = glob("src/*.cpp") + glob("src/syzygy/*.cpp") + glob("src/nnue/*.cpp") + glob("src/nnue/features/*.cpp")
+headers = glob("src/*.h") + glob("src/syzygy/*.h") + glob("src/nnue/*.h") + glob("src/nnue/features/*.h")
+ffish_source_file = os.path.normcase("src/ffishjs.cpp")
+try:
+    sources.remove(ffish_source_file)
+except ValueError:
+    print(f"ffish_source_file {ffish_source_file} was not found in sources {sources}.")
+
+pyffish_module = Extension(
+    "pyffish",
+    sources=sources,
+    depends=headers,
+    extra_compile_args=args)
+
+setup(name="pyffish", version="0.0.89",
+      description="Fairy-Stockfish Python wrapper",
+      long_description=long_description,
+      long_description_content_type="text/markdown",
+      author="Bajusz Tamás",
+      author_email="gbtami@gmail.com",
+      license="GPL3",
+      classifiers=CLASSIFIERS,
+      url="https://github.com/gbtami/Fairy-Stockfish",
+      python_requires=">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*",
+      ext_modules=[pyffish_module],
+      data_files=[("", ["pyffish.pyi"])]
+      )

Fairy-Stockfish-master/src/Makefile

@@ -0,0 +1,982 @@
+# 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 <http://www.gnu.org/licenses/>.
+
+
+### ==========================================================================
+### Section 1. General Configuration
+### ==========================================================================
+
+### Executable name
+ifeq ($(COMP),mingw)
+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 = ./$(EXE) bench
+else
+	PGOBENCH = $(SDE_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.cpp \
+	partner.cpp parser.cpp piece.cpp variant.cpp xboard.cpp \
+	nnue/features/half_ka_v2_variants.cpp
+
+OBJS = $(notdir $(SRCS:.cpp=.o))
+
+VPATH = syzygy:nnue:nnue/features
+
+### Establish the operating system name
+KERNEL = $(shell uname -s)
+ifeq ($(KERNEL),Linux)
+	OS = $(shell uname -o)
+endif
+
+### ==========================================================================
+### Section 2. High-level Configuration
+### ==========================================================================
+#
+# flag                --- Comp switch      --- Description
+# ----------------------------------------------------------------------------
+#
+# debug = yes/no      --- -DNDEBUG         --- Enable/Disable debug mode
+# sanitize = none/<sanitizer> ... (-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
+# 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=on sanitize="address undefined"
+
+
+### 2.1. General and architecture defaults
+largeboards = no
+all = no
+precomputedmagics = yes
+nnue = no
+load_net = $(if $(filter $(nnue),yes),net)
+
+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-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))
+   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
+avx512 = no
+vnni256 = no
+vnni512 = no
+neon = no
+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 = yes
+	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 -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
+endif
+
+ifeq ($(ARCH),armv7-neon)
+	arch = armv7
+	prefetch = yes
+	popcnt = yes
+	neon = yes
+	bits = 32
+endif
+
+ifeq ($(ARCH),armv8)
+	arch = armv8
+	prefetch = yes
+	popcnt = yes
+	neon = yes
+endif
+
+ifeq ($(ARCH),apple-silicon)
+	arch = arm64
+	prefetch = yes
+	popcnt = yes
+	neon = yes
+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
+
+endif
+
+# Disable precomputed magics when 64-bit PEXT is available
+ifeq ($(pext),yes)
+	precomputedmagics = no
+endif
+
+### ==========================================================================
+### Section 3. Low-level Configuration
+### ==========================================================================
+
+### 3.1 Selecting compiler (default = gcc)
+CXXFLAGS += -Wall -Wcast-qual -fno-exceptions -std=c++17 $(EXTRACXXFLAGS)
+DEPENDFLAGS += -std=c++17
+LDFLAGS += $(EXTRALDFLAGS)
+
+# Ignore warning due to missing profile information from unused NNUE features
+CXXFLAGS += -Wno-profile-instr-out-of-date
+
+# Compile version with support for large board variants
+# Use precomputed magics by default if pext is not available
+ifneq ($(largeboards),no)
+	CXXFLAGS += -DLARGEBOARDS
+	ifeq ($(precomputedmagics),yes)
+		CXXFLAGS += -DPRECOMPUTED_MAGICS
+	endif
+endif
+
+# Embed and enable NNUE
+ifeq ($(nnue),no)
+	CXXFLAGS += -DNNUE_EMBEDDING_OFF
+endif
+
+# Enable all variants, even heavyweight ones like duck and amazons
+ifneq ($(all),no)
+	CXXFLAGS += -DALLVARS
+endif
+
+ifeq ($(COMP),)
+	COMP=gcc
+endif
+
+ifeq ($(COMP),gcc)
+	comp=gcc
+	CXX=g++
+	CXXFLAGS += -Wextra -Wshadow
+	ifeq ($(largeboards),no)
+		CXXFLAGS += -pedantic
+	endif
+
+	ifeq ($(arch),$(filter $(arch),armv7 armv8))
+		ifeq ($(OS),Android)
+			CXXFLAGS += -m$(bits)
+			LDFLAGS += -m$(bits)
+		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 ($(COMP),mingw)
+	comp=mingw
+
+	ifeq ($(KERNEL),Linux)
+		ifeq ($(bits),64)
+			ifeq ($(shell which x86_64-w64-mingw32-c++-posix),)
+				CXX=x86_64-w64-mingw32-c++
+			else
+				CXX=x86_64-w64-mingw32-c++-posix
+			endif
+		else
+			ifeq ($(shell which i686-w64-mingw32-c++-posix),)
+				CXX=i686-w64-mingw32-c++
+			else
+				CXX=i686-w64-mingw32-c++-posix
+			endif
+		endif
+	else
+		CXX=g++
+	endif
+
+	CXXFLAGS += -Wextra -Wshadow
+	LDFLAGS += -static
+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++
+	CXXFLAGS += -pedantic -Wextra -Wshadow
+
+	ifneq ($(KERNEL),Darwin)
+	ifneq ($(KERNEL),OpenBSD)
+	ifneq ($(KERNEL),FreeBSD)
+		LDFLAGS += -latomic
+	endif
+	endif
+	endif
+
+	ifeq ($(arch),$(filter $(arch),armv7 armv8))
+		ifeq ($(OS),Android)
+			CXXFLAGS += -m$(bits)
+			LDFLAGS += -m$(bits)
+		endif
+	else
+		CXXFLAGS += -m$(bits)
+		LDFLAGS += -m$(bits)
+	endif
+endif
+
+ifeq ($(KERNEL),Darwin)
+	CXXFLAGS += -arch $(arch) -mmacosx-version-min=10.14
+	LDFLAGS += -arch $(arch) -mmacosx-version-min=10.14
+	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
+		STRIP=arm-linux-androideabi-strip
+	endif
+	ifeq ($(arch),armv8)
+		CXX=aarch64-linux-android21-clang++
+		STRIP=aarch64-linux-android-strip
+	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
+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 -fno-strict-aliasing
+
+	ifeq ($(comp),gcc)
+		ifeq ($(OS), Android)
+			CXXFLAGS += -fno-gcse -mthumb -march=armv7-a -mfloat-abi=softfp
+		endif
+	endif
+
+	ifeq ($(comp),$(filter $(comp),gcc clang icc))
+		ifeq ($(KERNEL),Darwin)
+			CXXFLAGS += -mdynamic-no-pic
+		endif
+	endif
+
+	ifeq ($(comp),clang)
+		clangmajorversion = $(shell $(CXX) -dumpversion 2>/dev/null | cut -f1 -d.)
+		ifeq ($(shell expr $(clangmajorversion) \< 16),1)
+			CXXFLAGS += -fexperimental-new-pass-manager
+		endif
+	endif
+endif
+
+### 3.4 Bits
+ifeq ($(bits),64)
+	CXXFLAGS += -DIS_64BIT
+endif
+
+### 3.5 prefetch
+ifeq ($(prefetch),yes)
+	ifeq ($(sse),yes)
+		CXXFLAGS += -msse
+	endif
+else
+	CXXFLAGS += -DNO_PREFETCH
+endif
+
+### 3.6 popcnt
+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
+
+ifeq ($(avx2),yes)
+	CXXFLAGS += -DUSE_AVX2
+	ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+		CXXFLAGS += -mavx2 -mbmi
+	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
+	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.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
+		ifneq ($(findstring MINGW,$(KERNEL)),)
+			CXXFLAGS += -fuse-ld=lld
+		else ifneq ($(findstring MSYS,$(KERNEL)),)
+			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
+		LDFLAGS += $(CXXFLAGS) -flto=jobserver
+		ifneq ($(findstring MINGW,$(KERNEL)),)
+			LDFLAGS += -save-temps
+		else ifneq ($(findstring MSYS,$(KERNEL)),)
+			LDFLAGS += -save-temps
+		endif
+	else
+		CXXFLAGS += -flto
+		LDFLAGS += $(CXXFLAGS)
+	endif
+
+# To use LTO and static linking on windows, the tool chain requires a recent gcc:
+# gcc version 10.1 in msys2 or TDM-GCC version 9.2 are known to work, older might not.
+# So, only enable it for a cross from Linux by default.
+	else ifeq ($(comp),mingw)
+	ifeq ($(KERNEL),Linux)
+	ifneq ($(arch),i386)
+		CXXFLAGS += -flto
+		LDFLAGS += $(CXXFLAGS) -flto=jobserver
+	endif
+	endif
+	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-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 ""
+	@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 ""
+	@echo "-------------------------------"
+	@echo "Embed and enable NNUE by default: "
+	@echo ""
+	@echo "make build ARCH=x86-64 nnue=yes"
+	@echo ""
+	@echo "-------------------------------"
+	@echo "Version for large boards: "
+	@echo ""
+	@echo "make build ARCH=x86-64 COMP=gcc largeboards=yes"
+	@echo ""
+	@echo "Include all variants (adds Game of the Amazons): "
+	@echo ""
+	@echo "make build ARCH=x86-64 largeboards=yes all=yes"
+	@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
+
+build: $(load_net) config-sanity
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
+
+profile-build: $(load_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) > /dev/null
+	@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 $(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.exe.lto_wrapper_args
+	@rm -f stockfish.exe.ltrans.out
+	@rm -f ./-lstdc++.res
+
+default:
+	help
+
+### ==========================================================================
+### Section 5. Private Targets
+### ==========================================================================
+
+all: $(EXE) .depend
+
+config-sanity: $(load_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 "avx512: '$(avx512)'"
+	@echo "vnni256: '$(vnni256)'"
+	@echo "vnni512: '$(vnni512)'"
+	@echo "neon: '$(neon)'"
+	@echo ""
+	@echo "Fairy-Stockfish specific:"
+	@echo "largeboards: '$(largeboards)'"
+	@echo "all: '$(all)'"
+	@echo "precomputedmagics: '$(precomputedmagics)'"
+	@echo "nnue: '$(nnue)'"
+	@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 "$(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)
+
+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' \
+	EXTRALDFLAGS='-lgcov' \
+	all
+
+gcc-profile-use:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+	EXTRACXXFLAGS='-fprofile-use=profdir -fno-peel-loops -fno-tracer' \
+	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:
+	-@$(CXX) $(DEPENDFLAGS) -MM $(SRCS) > $@ 2> /dev/null
+
+-include .depend

Fairy-Stockfish-master/src/Makefile_js

@@ -0,0 +1,95 @@
+# ffish.js, a JavaScript chess variant library derived from Fairy-Stockfish
+# Copyright (C) 2022 Fabian Fichter, Johannes Czech
+#
+# ffish.js 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.
+#
+# ffish.js 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 <http://www.gnu.org/licenses/>.
+
+EXE = ../tests/js/ffish.js
+
+SRCS = ffishjs.cpp benchmark.cpp bitbase.cpp bitboard.cpp endgame.cpp evaluate.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.cpp \
+	partner.cpp parser.cpp piece.cpp variant.cpp xboard.cpp \
+	nnue/features/half_ka_v2_variants.cpp
+
+CXX=emcc
+CXXFLAGS += --bind -DNNUE_EMBEDDING_OFF -DNO_THREADS -std=c++17 -Wall
+
+largeboards = yes
+all = yes
+optimize = yes
+debug = no
+
+### Debugging
+ifeq ($(debug),no)
+	CXXFLAGS += -DNDEBUG -s ASSERTIONS=0 -s SAFE_HEAP=0
+else
+	CXXFLAGS += -g -s ASSERTIONS=1 -s SAFE_HEAP=1
+endif
+
+### Optimization
+ifeq ($(optimize),yes)
+	CXXFLAGS += -O3
+endif
+
+# Compile version with support for large board variants
+# Use precomputed magics by default
+ifneq ($(largeboards),no)
+	CXXFLAGS += -DLARGEBOARDS -DPRECOMPUTED_MAGICS -s TOTAL_MEMORY=32MB -s ALLOW_MEMORY_GROWTH=1 -s WASM_MEM_MAX=1GB
+endif
+
+# Enable all variants, even heavyweight ones like duck and amazons
+ifneq ($(all),no)
+	CXXFLAGS += -DALLVARS
+endif
+
+### Compile as ES6/ES2015 module
+ifeq ($(es6),yes)
+	CXXFLAGS += -s ENVIRONMENT='web,worker' -s EXPORT_ES6=1 -s MODULARIZE=1 -s USE_ES6_IMPORT_META=0
+endif
+
+.PHONY: help objclean clean build deps test serve
+
+help:
+	@echo ""
+	@echo "To compile ffishjs, type: "
+	@echo ""
+	@echo "make -f Makefile_js build"
+	@echo ""
+	@echo "Supported targets:"
+	@echo ""
+	@echo "help                    > Display this help"
+	@echo "build                   > Standard build"
+	@echo "clean                   > Clean up"
+	@echo "deps                    > Install runtime dependencies using npm"
+	@echo "test                    > Run tests"
+	@echo "serve                   > Run example server"
+	@echo ""
+
+objclean:
+	@rm -f $(EXE)
+
+clean: objclean
+
+build:
+	$(CXX) $(CXXFLAGS) $(SRCS) -o $(EXE)
+
+deps:
+	cd ../tests/js && npm install
+
+test: deps
+	cd ../tests/js && npm test
+
+serve: deps
+	cd ../tests/js && node index.js

Fairy-Stockfish-master/src/apiutil.h

@@ -0,0 +1,1165 @@
+/*
+  Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish
+  Copyright (C) 2018-2022 Fabian Fichter
+
+  Fairy-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.
+
+  Fairy-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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef APIUTIL_H_INCLUDED
+#define APIUTIL_H_INCLUDED
+
+#include <array>
+#include <vector>
+#include <string>
+#include <sstream>
+#include <cctype>
+#include <iostream>
+#include <math.h>
+
+#include "types.h"
+#include "position.h"
+#include "variant.h"
+
+namespace Stockfish {
+
+enum Notation {
+    NOTATION_DEFAULT,
+    // https://en.wikipedia.org/wiki/Algebraic_notation_(chess)
+    NOTATION_SAN,
+    NOTATION_LAN,
+    // https://en.wikipedia.org/wiki/Shogi_notation#Western_notation
+    NOTATION_SHOGI_HOSKING, // Examples: P76, S’34
+    NOTATION_SHOGI_HODGES, // Examples: P-7f, S*3d
+    NOTATION_SHOGI_HODGES_NUMBER, // Examples: P-76, S*34
+    // http://www.janggi.pl/janggi-notation/
+    NOTATION_JANGGI,
+    // https://en.wikipedia.org/wiki/Xiangqi#Notation
+    NOTATION_XIANGQI_WXF,
+    // https://web.archive.org/web/20180817205956/http://bgsthai.com/2018/05/07/lawofthaichessc/
+    NOTATION_THAI_SAN,
+    NOTATION_THAI_LAN,
+};
+
+inline Notation default_notation(const Variant* v) {
+    if (v->variantTemplate == "shogi")
+        return NOTATION_SHOGI_HODGES_NUMBER;
+    return NOTATION_SAN;
+}
+
+enum Termination {
+    ONGOING,
+    CHECKMATE,
+    STALEMATE,
+    INSUFFICIENT_MATERIAL,
+    N_MOVE_RULE,
+    N_FOLD_REPETITION,
+    VARIANT_END,
+};
+
+const std::array<std::string, 12> THAI_FILES = {"ก", "ข", "ค", "ง", "จ", "ฉ", "ช", "ญ", "ต", "ถ", "ธ", "น"};
+const std::array<std::string, 12> THAI_RANKS = {"๑", "๒", "๓", "๔", "๕", "๖", "๗", "๘", "๙", "๑๐", "๑๑", "๑๒"};
+
+namespace SAN {
+
+enum Disambiguation {
+    NO_DISAMBIGUATION,
+    FILE_DISAMBIGUATION,
+    RANK_DISAMBIGUATION,
+    SQUARE_DISAMBIGUATION,
+};
+
+inline bool is_shogi(Notation n) {
+    return n == NOTATION_SHOGI_HOSKING || n == NOTATION_SHOGI_HODGES || n == NOTATION_SHOGI_HODGES_NUMBER;
+}
+
+inline bool is_thai(Notation n) {
+    return n == NOTATION_THAI_SAN || n == NOTATION_THAI_LAN;
+}
+
+// is there more than one file with a pair of pieces?
+inline bool multi_tandem(Bitboard b) {
+    int tandems = 0;
+    for (File f = FILE_A; f <= FILE_MAX; ++f)
+        if (more_than_one(b & file_bb(f)))
+            tandems++;
+    return tandems >= 2;
+}
+
+inline std::string piece_to_thai_char(Piece pc, bool promoted) {
+    switch(type_of(pc)) {
+        case KING:
+            return "ข";
+        case KHON:
+            return "ค";
+        case FERS:
+            return promoted ? "ง" : "ม็";
+        case KNIGHT:
+            return "ม";
+        case ROOK:
+            return "ร";
+        case PAWN:
+            return "บ";
+        case AIWOK:
+            return "ว";
+        default:
+            return "X";
+    }
+}
+
+inline std::string piece(const Position& pos, Move m, Notation n) {
+    Color us = pos.side_to_move();
+    Square from = from_sq(m);
+    Piece pc = pos.moved_piece(m);
+    PieceType pt = type_of(pc);
+    // Quiet pawn moves
+    if ((n == NOTATION_SAN || n == NOTATION_LAN || n == NOTATION_THAI_SAN) && type_of(pc) == PAWN && type_of(m) != DROP)
+        return "";
+    // Tandem pawns
+    else if (n == NOTATION_XIANGQI_WXF && popcount(pos.pieces(us, pt) & file_bb(from)) >= 3 - multi_tandem(pos.pieces(us, pt)))
+        return std::to_string(popcount(forward_file_bb(us, from) & pos.pieces(us, pt)) + 1);
+    // Moves of promoted pieces
+    else if (is_shogi(n) && type_of(m) != DROP && pos.unpromoted_piece_on(from))
+        return "+" + std::string(1, toupper(pos.piece_to_char()[pos.unpromoted_piece_on(from)]));
+    // Promoted drops
+    else if (is_shogi(n) && type_of(m) == DROP && dropped_piece_type(m) != in_hand_piece_type(m))
+        return "+" + std::string(1, toupper(pos.piece_to_char()[in_hand_piece_type(m)]));
+    else if (is_thai(n))
+        return piece_to_thai_char(pc, pos.is_promoted(from));
+    else if (pos.piece_to_char_synonyms()[pc] != ' ')
+        return std::string(1, toupper(pos.piece_to_char_synonyms()[pc]));
+    else
+        return std::string(1, toupper(pos.piece_to_char()[pc]));
+}
+
+inline std::string file(const Position& pos, Square s, Notation n) {
+    switch (n)
+    {
+    case NOTATION_SHOGI_HOSKING:
+    case NOTATION_SHOGI_HODGES:
+    case NOTATION_SHOGI_HODGES_NUMBER:
+        return std::to_string(pos.max_file() - file_of(s) + 1);
+    case NOTATION_JANGGI:
+        return std::to_string(file_of(s) + 1);
+    case NOTATION_XIANGQI_WXF:
+        return std::to_string((pos.side_to_move() == WHITE ? pos.max_file() - file_of(s) : file_of(s)) + 1);
+    case NOTATION_THAI_SAN:
+    case NOTATION_THAI_LAN:
+        return THAI_FILES[file_of(s)];
+    default:
+        return std::string(1, char('a' + file_of(s)));
+    }
+}
+
+inline std::string rank(const Position& pos, Square s, Notation n) {
+    switch (n)
+    {
+    case NOTATION_SHOGI_HOSKING:
+    case NOTATION_SHOGI_HODGES_NUMBER:
+        return std::to_string(pos.max_rank() - rank_of(s) + 1);
+    case NOTATION_SHOGI_HODGES:
+        return std::string(1, char('a' + pos.max_rank() - rank_of(s)));
+    case NOTATION_JANGGI:
+        return std::to_string((pos.max_rank() - rank_of(s) + 1) % 10);
+    case NOTATION_XIANGQI_WXF:
+    {
+        if (pos.empty(s))
+            // Handle piece drops
+            return std::to_string(relative_rank(pos.side_to_move(), s, pos.max_rank()) + 1);
+        else if (pos.pieces(pos.side_to_move(), type_of(pos.piece_on(s))) & forward_file_bb(pos.side_to_move(), s))
+            return "-";
+        else
+            return "+";
+    }
+    case NOTATION_THAI_SAN:
+    case NOTATION_THAI_LAN:
+        return THAI_RANKS[rank_of(s)];
+    default:
+        return std::to_string(rank_of(s) + 1);
+    }
+}
+
+inline std::string square(const Position& pos, Square s, Notation n) {
+    switch (n)
+    {
+    case NOTATION_JANGGI:
+        return rank(pos, s, n) + file(pos, s, n);
+    default:
+        return file(pos, s, n) + rank(pos, s, n);
+    }
+}
+
+inline Disambiguation disambiguation_level(const Position& pos, Move m, Notation n) {
+    // Drops never need disambiguation
+    if (type_of(m) == DROP)
+        return NO_DISAMBIGUATION;
+
+    // NOTATION_LAN and Janggi always use disambiguation
+    if (n == NOTATION_LAN || n == NOTATION_THAI_LAN || n == NOTATION_JANGGI)
+        return SQUARE_DISAMBIGUATION;
+
+    Color us = pos.side_to_move();
+    Square from = from_sq(m);
+    Square to = to_sq(m);
+    Piece pc = pos.moved_piece(m);
+    PieceType pt = type_of(pc);
+
+    // Xiangqi uses either file disambiguation or +/- if two pieces on file
+    if (n == NOTATION_XIANGQI_WXF)
+    {
+        // Disambiguate by rank (+/-) if target square of other piece is valid
+        if (popcount(pos.pieces(us, pt) & file_bb(from)) == 2 && !multi_tandem(pos.pieces(us, pt)))
+        {
+            Square otherFrom = lsb((pos.pieces(us, pt) & file_bb(from)) ^ from);
+            Square otherTo = otherFrom + Direction(to) - Direction(from);
+            if (is_ok(otherTo) && (pos.board_bb(us, pt) & otherTo))
+                return RANK_DISAMBIGUATION;
+        }
+        return FILE_DISAMBIGUATION;
+    }
+
+    // Pawn captures always use disambiguation
+    if ((n == NOTATION_SAN || n == NOTATION_THAI_SAN) && pt == PAWN)
+    {
+        if (pos.capture(m))
+            return FILE_DISAMBIGUATION;
+        if (type_of(m) == PROMOTION && from != to && pos.sittuyin_promotion())
+            return SQUARE_DISAMBIGUATION;
+    }
+
+    // A disambiguation occurs if we have more than one piece of type 'pt'
+    // that can reach 'to' with a legal move.
+    Bitboard b = pos.pieces(us, pt) ^ from;
+    Bitboard others = 0;
+
+    while (b)
+    {
+        Square s = pop_lsb(b);
+        // Construct a potential move with identical special move flags
+        // and only a different "from" square.
+        Move testMove = Move(m ^ make_move(from, to) ^ make_move(s, to));
+        if (      pos.pseudo_legal(testMove)
+               && pos.legal(testMove)
+               && !(is_shogi(n) && pos.unpromoted_piece_on(s) != pos.unpromoted_piece_on(from)))
+            others |= s;
+    }
+
+    if (!others)
+        return NO_DISAMBIGUATION;
+    else if (is_shogi(n))
+        return SQUARE_DISAMBIGUATION;
+    else if (!(others & file_bb(from)))
+        return FILE_DISAMBIGUATION;
+    else if (!(others & rank_bb(from)))
+        return RANK_DISAMBIGUATION;
+    else
+        return SQUARE_DISAMBIGUATION;
+}
+
+inline std::string disambiguation(const Position& pos, Square s, Notation n, Disambiguation d) {
+    switch (d)
+    {
+    case FILE_DISAMBIGUATION:
+        return file(pos, s, n);
+    case RANK_DISAMBIGUATION:
+        return rank(pos, s, n);
+    case SQUARE_DISAMBIGUATION:
+        return square(pos, s, n);
+    default:
+        assert(d == NO_DISAMBIGUATION);
+        return "";
+    }
+}
+
+inline const std::string move_to_san(Position& pos, Move m, Notation n) {
+    std::string san = "";
+    Color us = pos.side_to_move();
+    Square from = from_sq(m);
+    Square to = to_sq(m);
+
+    if (type_of(m) == CASTLING)
+    {
+        san = to > from ? "O-O" : "O-O-O";
+
+        if (is_gating(m))
+        {
+            san += std::string("/") + (char)toupper(pos.piece_to_char()[make_piece(us, gating_type(m))]);
+            san += square(pos, gating_square(m), n);
+        }
+    }
+    else
+    {
+        // Piece
+        san += piece(pos, m, n);
+
+        if (n == NOTATION_THAI_LAN)
+            san += " ";
+
+        // Origin square, disambiguation
+        Disambiguation d = disambiguation_level(pos, m, n);
+        san += disambiguation(pos, from, n, d);
+
+        // Separator/Operator
+        if (type_of(m) == DROP)
+            san += n == NOTATION_SHOGI_HOSKING ? '\'' : is_shogi(n) ? '*' : '@';
+        else if (n == NOTATION_XIANGQI_WXF)
+        {
+            if (rank_of(from) == rank_of(to))
+                san += '=';
+            else if (relative_rank(us, to, pos.max_rank()) > relative_rank(us, from, pos.max_rank()))
+                san += '+';
+            else
+                san += '-';
+        }
+        else if (pos.capture(m))
+            san += 'x';
+        else if (n == NOTATION_LAN || n == NOTATION_THAI_LAN || (is_shogi(n) && (n != NOTATION_SHOGI_HOSKING || d == SQUARE_DISAMBIGUATION)) || n == NOTATION_JANGGI || (n == NOTATION_THAI_SAN && type_of(pos.moved_piece(m)) != PAWN))
+            san += '-';
+
+        // Destination square
+        if (n == NOTATION_XIANGQI_WXF && type_of(m) != DROP)
+            san += file_of(to) == file_of(from) ? std::to_string(std::abs(rank_of(to) - rank_of(from))) : file(pos, to, n);
+        else
+            san += square(pos, to, n);
+
+        // Suffix
+        if (type_of(m) == PROMOTION)
+            san += std::string("=") + (char)toupper(pos.piece_to_char()[make_piece(us, promotion_type(m))]);
+        else if (type_of(m) == PIECE_PROMOTION)
+            san += is_shogi(n) ? std::string("+") : std::string("=") + (char)toupper(pos.piece_to_char()[make_piece(us, pos.promoted_piece_type(type_of(pos.moved_piece(m))))]);
+        else if (type_of(m) == PIECE_DEMOTION)
+            san += is_shogi(n) ? std::string("-") : std::string("=") + std::string(1, toupper(pos.piece_to_char()[pos.unpromoted_piece_on(from)]));
+        else if (type_of(m) == NORMAL && is_shogi(n) && pos.pseudo_legal(make<PIECE_PROMOTION>(from, to)))
+            san += std::string("=");
+        if (is_gating(m))
+            san += std::string("/") + (char)toupper(pos.piece_to_char()[make_piece(us, gating_type(m))]);
+    }
+
+    // Wall square
+    if (pos.walling())
+        san += "," + square(pos, gating_square(m), n);
+
+    // Check and checkmate
+    if (pos.gives_check(m) && !is_shogi(n) && n != NOTATION_XIANGQI_WXF)
+    {
+        StateInfo st;
+        pos.do_move(m, st);
+        san += MoveList<LEGAL>(pos).size() ? "+" : "#";
+        pos.undo_move(m);
+    }
+
+    return san;
+}
+
+} // namespace SAN
+
+inline bool has_insufficient_material(Color c, const Position& pos) {
+
+    // Other win rules
+    if (   pos.captures_to_hand()
+        || pos.count_in_hand(c, ALL_PIECES)
+        || (pos.extinction_value() != VALUE_NONE && !pos.extinction_pseudo_royal())
+        || (pos.variant()->nFoldRule && pos.variant()->nFoldValue != VALUE_DRAW)
+        || (pos.flag_region(c) && pos.count(c, pos.flag_piece(c))))
+        return false;
+
+    // Precalculate if any promotion pawn types have pieces
+    bool hasPromotingPawn = false;
+    for (PieceSet pawnTypes = pos.promotion_pawn_types(c); pawnTypes; )
+    {
+        PieceType pawnType = pop_lsb(pawnTypes);
+        if (pos.count(c, pawnType) > 0)
+        {
+            hasPromotingPawn = true;
+            break;
+        }
+    }
+
+    // Determine checkmating potential of present pieces
+    constexpr PieceSet MAJOR_PIECES = piece_set(ROOK) | QUEEN | ARCHBISHOP | CHANCELLOR
+                                     | SILVER | GOLD | COMMONER | CENTAUR | AMAZON | BERS;
+    constexpr PieceSet COLORBOUND_PIECES = piece_set(BISHOP) | FERS | FERS_ALFIL | ALFIL | ELEPHANT;
+    Bitboard restricted = pos.pieces(KING);
+    Bitboard colorbound = 0;
+    for (PieceSet ps = pos.piece_types(); ps;)
+    {
+        PieceType pt = pop_lsb(ps);
+
+        // Constrained pieces
+        if (pt == KING || !(pos.board_bb(c, pt) & pos.board_bb(~c, KING)) || (pos.extinction_pseudo_royal() && pos.blast_on_capture() && (pos.extinction_piece_types() & pt)))
+            restricted |= pos.pieces(c, pt);
+
+        // If piece is a major piece or a custom piece we consider it sufficient for mate.
+        // To avoid false positives, we assume any custom piece has mating potential.
+        else if ((MAJOR_PIECES & pt) || is_custom(pt))
+        {
+            // Check if piece is already on the board
+            if (pos.count(c, pt) > 0)
+                return false;
+
+            // Check if any pawn can promote to this piece type
+            if (hasPromotingPawn && (pos.promotion_piece_types(c) & pt))
+                return false;
+        }
+
+        // Collect color-bound pieces
+        else if (COLORBOUND_PIECES & pt)
+            colorbound |= pos.pieces(pt);
+    }
+
+    Bitboard unbound = pos.pieces() ^ restricted ^ colorbound;
+
+    // Color-bound pieces
+    if ((colorbound & pos.pieces(c)) && (((DarkSquares & colorbound) && (~DarkSquares & colorbound)) || unbound || pos.stalemate_value() != VALUE_DRAW || pos.check_counting() || pos.makpong()))
+        return false;
+
+    // Unbound pieces require one helper piece of either color
+    if ((pos.pieces(c) & unbound) && (popcount(pos.pieces() ^ restricted) >= 2 || pos.stalemate_value() != VALUE_DRAW || pos.check_counting() || pos.makpong()))
+        return false;
+
+    // Non-draw stalemate with lone custom king
+    if (   pos.stalemate_value() != VALUE_DRAW && pos.king_type() != KING
+        && pos.pieces(c, KING) && (pos.board_bb(c, KING) & pos.board_bb(~c, KING)))
+        return false;
+
+    return true;
+}
+
+inline Bitboard checked(const Position& pos) {
+    return (pos.checkers() ? square_bb(pos.square<KING>(pos.side_to_move())) : Bitboard(0))
+        | (pos.extinction_pseudo_royal() ? pos.checked_pseudo_royals(pos.side_to_move()) : Bitboard(0));
+}
+
+namespace FEN {
+
+enum FenValidation : int {
+    FEN_INVALID_COUNTING_RULE = -14,
+    FEN_INVALID_CHECK_COUNT = -13,
+    FEN_INVALID_PROMOTED_PIECE = -12,
+    FEN_INVALID_NB_PARTS = -11,
+    FEN_INVALID_CHAR = -10,
+    FEN_TOUCHING_KINGS = -9,
+    FEN_INVALID_BOARD_GEOMETRY = -8,
+    FEN_INVALID_POCKET_INFO = -7,
+    FEN_INVALID_SIDE_TO_MOVE = -6,
+    FEN_INVALID_CASTLING_INFO = -5,
+    FEN_INVALID_EN_PASSANT_SQ = -4,
+    FEN_INVALID_NUMBER_OF_KINGS = -3,
+    FEN_INVALID_HALF_MOVE_COUNTER = -2,
+    FEN_INVALID_MOVE_COUNTER = -1,
+    FEN_EMPTY = 0,
+    FEN_OK = 1
+};
+enum Validation : int {
+    NOK,
+    OK
+};
+
+struct CharSquare {
+    int rowIdx;
+    int fileIdx;
+    CharSquare() : rowIdx(-1), fileIdx(-1) {}
+    CharSquare(int row, int file) : rowIdx(row), fileIdx(file) {}
+};
+
+inline bool operator==(const CharSquare& s1, const CharSquare& s2) {
+    return s1.rowIdx == s2.rowIdx && s1.fileIdx == s2.fileIdx;
+}
+
+inline bool operator!=(const CharSquare& s1, const CharSquare& s2) {
+    return !(s1 == s2);
+}
+
+inline int non_root_euclidian_distance(const CharSquare& s1, const CharSquare& s2) {
+    return pow(s1.rowIdx - s2.rowIdx, 2) + pow(s1.fileIdx - s2.fileIdx, 2);
+}
+
+class CharBoard {
+private:
+    int nbRanks;
+    int nbFiles;
+    std::vector<char> board;  // fill an array where the pieces are for later geometry checks
+public:
+    CharBoard(int ranks, int files) : nbRanks(ranks), nbFiles(files) {
+        assert(nbFiles > 0 && nbRanks > 0);
+        board = std::vector<char>(nbRanks * nbFiles, ' ');
+    }
+    void set_piece(int rankIdx, int fileIdx, char c) {
+        board[rankIdx * nbFiles + fileIdx] = c;
+    }
+    char get_piece(int rowIdx, int fileIdx) const {
+        return board[rowIdx * nbFiles + fileIdx];
+    }
+    int get_nb_ranks() const {
+        return nbRanks;
+    }
+    int get_nb_files() const {
+        return nbFiles;
+    }
+    /// Returns the square of a given character
+    CharSquare get_square_for_piece(char piece) const {
+        CharSquare s;
+        for (int r = 0; r < nbRanks; ++r)
+        {
+            for (int c = 0; c < nbFiles; ++c)
+            {
+                if (get_piece(r, c) == piece)
+                {
+                    s.rowIdx = r;
+                    s.fileIdx = c;
+                    return s;
+                }
+            }
+        }
+        return s;
+    }
+    /// Returns all square positions for a given piece
+    std::vector<CharSquare> get_squares_for_pieces(Color color, PieceSet ps, const std::string& pieceChars) const {
+        std::vector<CharSquare> squares;
+        size_t pcIdx;
+        for (int r = 0; r < nbRanks; ++r)
+            for (int c = 0; c < nbFiles; ++c)
+                if ((pcIdx = pieceChars.find(get_piece(r, c))) != std::string::npos && (ps & type_of(Piece(pcIdx))) && color_of(Piece(pcIdx)) == color)
+                    squares.emplace_back(CharSquare(r, c));
+        return squares;
+    }
+    friend std::ostream& operator<<(std::ostream& os, const CharBoard& board);
+};
+
+inline std::ostream& operator<<(std::ostream& os, const CharBoard& board) {
+    for (int r = 0; r < board.nbRanks; ++r)
+    {
+        for (int c = 0; c < board.nbFiles; ++c)
+            os << "[" << board.get_piece(r, c) << "] ";
+        os << std::endl;
+    }
+    return os;
+}
+
+inline bool contains(const std::string& str, char c) {
+    return str.find(c) != std::string::npos;
+}
+
+inline bool in_any(const std::vector<std::string>& vec, char c) {
+    for (std::string str : vec)
+        if (contains(str, c))
+            return true;
+    return false;
+}
+
+inline Validation check_for_valid_characters(const std::string& firstFenPart, const std::string& validSpecialCharactersFirstField, const Variant* v) {
+    for (char c : firstFenPart)
+    {
+        if (!isdigit(c) && !in_any({v->pieceToChar, v->pieceToCharSynonyms, validSpecialCharactersFirstField}, c))
+        {
+            std::cerr << "Invalid piece character: '" << c << "'." << std::endl;
+            return NOK;
+        }
+    }
+    return OK;
+}
+
+inline Validation check_promoted_pieces(const std::string& firstFenPart, const Variant* v) {
+    // Only check promoted pieces if the variant supports shogi-style promotions
+    if (!v || !v->shogiStylePromotions)
+        return OK;
+    
+    for (size_t i = 0; i < firstFenPart.length() - 1; ++i) {
+        // Look for promoted pieces ('+' followed by piece character)
+        if (firstFenPart[i] == '+') {
+            char pieceChar = firstFenPart[i + 1];
+            
+            // Skip if next character is not a piece character or is a special character
+            if (isdigit(pieceChar) || pieceChar == '/' || pieceChar == ' ' || pieceChar == '[')
+                continue;
+                
+            // Find the piece type corresponding to this character
+            size_t idx = v->pieceToChar.find(pieceChar);
+            if (idx == std::string::npos) {
+                // Try synonyms
+                idx = v->pieceToCharSynonyms.find(pieceChar);
+                if (idx == std::string::npos)
+                    continue; // Character validation will catch this
+            }
+            
+            // Ensure idx is within valid range for piece types
+            if (idx >= PIECE_TYPE_NB)
+                continue;
+                
+            // Get the piece type directly from the index
+            PieceType pt = PieceType(idx);
+            
+            // Check if this piece type has a promoted form
+            if (pt != NO_PIECE_TYPE && pt < PIECE_TYPE_NB && v->promotedPieceType[pt] == NO_PIECE_TYPE) {
+                std::cerr << "Invalid promoted piece: '+' followed by '" << pieceChar 
+                         << "'. This piece cannot be promoted in variant." << std::endl;
+                return NOK;
+            }
+        }
+    }
+    return OK;
+}
+
+inline std::vector<std::string> get_fen_parts(const std::string& fullFen, char delim) {
+    std::vector<std::string> fenParts;
+    std::string curPart;
+    std::stringstream ss(fullFen);
+    while (std::getline(ss, curPart, delim))
+        fenParts.emplace_back(curPart);
+    return fenParts;
+}
+
+/// fills the character board according to a given FEN string
+inline Validation fill_char_board(CharBoard& board, const std::string& fenBoard, const std::string& validSpecialCharactersFirstField, const Variant* v) {
+    int rankIdx = 0;
+    int fileIdx = 0;
+
+    char prevChar = '?';
+    for (char c : fenBoard)
+    {
+        if (c == ' ' || c == '[')
+            break;
+        if (c == '*')
+            ++fileIdx;
+        else if (isdigit(c))
+        {
+            fileIdx += c - '0';
+            // if we have multiple digits attached we can add multiples of 9 to compute the resulting number (e.g. -> 21 = 2 + 2 * 9 + 1)
+            if (isdigit(prevChar))
+                fileIdx += 9 * (prevChar - '0');
+        }
+        else if (c == '/')
+        {
+            ++rankIdx;
+            if (fileIdx != board.get_nb_files())
+            {
+                std::cerr << "curRankWidth != nbFiles: " << fileIdx << " != " << board.get_nb_files() << std::endl;
+                return NOK;
+            }
+            if (rankIdx == board.get_nb_ranks())
+                break;
+            fileIdx = 0;
+        }
+        else if (!contains(validSpecialCharactersFirstField, c))
+        {  // normal piece
+            if (fileIdx == board.get_nb_files())
+            {
+                std::cerr << "File index: " << fileIdx << " for piece '" << c << "' exceeds maximum of allowed number of files: " << board.get_nb_files() << "." << std::endl;
+                return NOK;
+            }
+            board.set_piece(v->maxRank-rankIdx, fileIdx, c);  // we mirror the rank index because the black pieces are given first in the FEN
+            ++fileIdx;
+        }
+        prevChar = c;
+    }
+
+    if (v->pieceDrops)
+    { // pockets can either be defined by [] or /
+        if (rankIdx+1 != board.get_nb_ranks() && rankIdx != board.get_nb_ranks())
+        {
+            std::cerr << "Invalid number of ranks. Expected: " << board.get_nb_ranks() << " Actual: " << rankIdx+1 << std::endl;
+            return NOK;
+        }
+    }
+    else
+    {
+        if (rankIdx+1 != board.get_nb_ranks())
+        {
+            std::cerr << "Invalid number of ranks. Expected: " << board.get_nb_ranks() << " Actual: " << rankIdx+1 << std::endl;
+            return NOK;
+        }
+    }
+    return OK;
+}
+
+inline Validation check_touching_kings(const CharBoard& board, const std::array<CharSquare, 2>& kingPositions) {
+    if (non_root_euclidian_distance(kingPositions[WHITE], kingPositions[BLACK]) <= 2)
+    {
+        std::cerr << "King pieces are next to each other." << std::endl;
+        std::cerr << board << std::endl;
+        return NOK;
+    }
+    return OK;
+}
+
+inline Validation fill_castling_info_splitted(const std::string& castlingInfo, std::array<std::string, 2>& castlingInfoSplitted) {
+    for (char c : castlingInfo)
+    {
+        if (c != '-')
+        {
+            if (!isalpha(c))
+            {
+                std::cerr << "Invalid castling specification: '" << c << "'." << std::endl;
+                return NOK;
+            }
+            else if (isupper(c))
+                castlingInfoSplitted[WHITE] += tolower(c);
+            else
+                castlingInfoSplitted[BLACK] += c;
+        }
+    }
+    return OK;
+}
+
+inline std::string color_to_string(Color c) {
+    switch (c)
+    {
+    case WHITE:
+        return "WHITE";
+    case BLACK:
+        return "BLACK";
+    case COLOR_NB:
+        return "COLOR_NB";
+    default:
+        return "INVALID_COLOR";
+    }
+}
+
+inline std::string castling_rights_to_string(CastlingRights castlingRights) {
+    switch (castlingRights)
+    {
+    case KING_SIDE:
+        return "KING_SIDE";
+    case QUEEN_SIDE:
+        return "QUEENS_SIDE";
+    case WHITE_OO:
+        return "WHITE_OO";
+    case WHITE_OOO:
+        return "WHITE_OOO";
+    case BLACK_OO:
+        return "BLACK_OO";
+    case BLACK_OOO:
+        return "BLACK_OOO";
+    case WHITE_CASTLING:
+        return "WHITE_CASTLING";
+    case BLACK_CASTLING:
+        return "BLACK_CASTLING";
+    case ANY_CASTLING:
+        return "ANY_CASTLING";
+    case CASTLING_RIGHT_NB:
+        return "CASTLING_RIGHT_NB";
+    default:
+        return "INVALID_CASTLING_RIGHTS";
+    }
+}
+
+inline Validation check_castling_rank(const std::array<std::string, 2>& castlingInfoSplitted, const CharBoard& board,
+                            const std::array<CharSquare, 2>& kingPositions, const Variant* v) {
+
+    for (Color c : {WHITE, BLACK})
+    {
+        const Rank castlingRank = relative_rank(c, v->castlingRank, v->maxRank);
+        for (char castlingFlag : castlingInfoSplitted[c])
+        {
+            if (tolower(castlingFlag) == 'k' || tolower(castlingFlag) == 'q')
+            {
+                if (kingPositions[c].rowIdx != castlingRank)
+                {
+                    std::cerr << "The " << color_to_string(c) << " king must be on rank " << castlingRank << " if castling is enabled for " << color_to_string(c) << "." << std::endl;
+                    return NOK;
+                }
+                bool kingside = tolower(castlingFlag) == 'k';
+                bool castlingRook = false;
+                size_t pcIdx;
+                for (int f = kingside ? board.get_nb_files() - 1 : 0; f != kingPositions[c].fileIdx; kingside ? f-- : f++)
+                    if (   (pcIdx = v->pieceToChar.find(board.get_piece(castlingRank, f))) != std::string::npos
+                        && (v->castlingRookPieces[c] & type_of(Piece(pcIdx)))
+                        && color_of(Piece(pcIdx)) == c)
+                    {
+                        castlingRook = true;
+                        break;
+                    }
+                if (!castlingRook)
+                {
+                    std::cerr << "No castling rook for flag " << castlingFlag << std::endl;
+                    return NOK;
+                }
+            }
+            else if (board.get_piece(castlingRank, tolower(castlingFlag) - 'a') == ' ')
+            {
+                std::cerr << "No gating piece for flag " << castlingFlag << std::endl;
+                return NOK;
+            }
+        }
+    }
+    return OK;
+}
+
+inline Validation check_standard_castling(std::array<std::string, 2>& castlingInfoSplitted, const CharBoard& board,
+                             const std::array<CharSquare, 2>& kingPositions, const std::array<CharSquare, 2>& kingPositionsStart,
+                             const std::array<std::vector<CharSquare>, 2>& rookPositionsStart, const Variant* v) {
+
+    for (Color c : {WHITE, BLACK})
+    {
+        if (castlingInfoSplitted[c].size() == 0)
+            continue;
+        if (kingPositions[c] != kingPositionsStart[c])
+        {
+            std::cerr << "The " << color_to_string(c) << " KING has moved. Castling is no longer valid for " << color_to_string(c) << "." << std::endl;
+            return NOK;
+        }
+
+        for (CastlingRights castling: {KING_SIDE, QUEEN_SIDE})
+        {
+            CharSquare rookStartingSquare = castling == QUEEN_SIDE ? rookPositionsStart[c][0] : rookPositionsStart[c][1];
+            char targetChar = castling == QUEEN_SIDE ? 'q' : 'k';
+            size_t pcIdx;
+            if (castlingInfoSplitted[c].find(targetChar) != std::string::npos)
+            {
+                if (   (pcIdx = v->pieceToChar.find(board.get_piece(rookStartingSquare.rowIdx, rookStartingSquare.fileIdx))) == std::string::npos
+                    || !(v->castlingRookPieces[c] & type_of(Piece(pcIdx)))
+                    || color_of(Piece(pcIdx)) != c)
+                {
+                    std::cerr << "The " << color_to_string(c) << " ROOK on the "<<  castling_rights_to_string(castling) << " has moved. "
+                              << castling_rights_to_string(castling) << " castling is no longer valid for " << color_to_string(c) << "." << std::endl;
+                    return NOK;
+                }
+            }
+
+        }
+    }
+    return OK;
+}
+
+inline Validation check_pocket_info(const std::string& fenBoard, int nbRanks, const Variant* v, std::string& pocket) {
+
+    char stopChar;
+    int offset = 0;
+    if (std::count(fenBoard.begin(), fenBoard.end(), '/') == nbRanks)
+    {
+        // look for last '/'
+        stopChar = '/';
+    }
+    else if (std::count(fenBoard.begin(), fenBoard.end(), '[') == 1)
+    {
+        // pocket is defined as [ and ]
+        stopChar = '[';
+        offset = 1;
+        if (*(fenBoard.end()-1) != ']')
+        {
+            std::cerr << "Pocket specification does not end with ']'." << std::endl;
+            return NOK;
+        }
+    }
+    else
+        // allow to skip pocket
+        return OK;
+
+    // look for last '/'
+    for (auto it = fenBoard.rbegin()+offset; it != fenBoard.rend(); ++it)
+    {
+        const char c = *it;
+        if (c == stopChar)
+            return OK;
+        if (c != '-')
+        {
+            if (!in_any({v->pieceToChar, v->pieceToCharSynonyms}, c))
+            {
+                std::cerr << "Invalid pocket piece: '" << c << "'." << std::endl;
+                return NOK;
+            }
+            else
+                pocket += c;
+        }
+    }
+    std::cerr << "Pocket piece closing character '" << stopChar << "' was not found." << std::endl;
+    return NOK;
+}
+
+inline int piece_count(const std::string& fenBoard, Color c, PieceType pt, const Variant* v) {
+    return std::count(fenBoard.begin(), fenBoard.end(), v->pieceToChar[make_piece(c, pt)]);
+}
+
+inline Validation check_number_of_kings(const std::string& fenBoard, const std::string& startFenBoard, const Variant* v) {
+    int nbWhiteKings = piece_count(fenBoard, WHITE, KING, v);
+    int nbBlackKings = piece_count(fenBoard, BLACK, KING, v);
+    int nbWhiteKingsStart = piece_count(startFenBoard, WHITE, KING, v);
+    int nbBlackKingsStart = piece_count(startFenBoard, BLACK, KING, v);
+
+    if (nbWhiteKings > 1)
+    {
+        std::cerr << "Invalid number of white kings. Maximum: 1. Given: " << nbWhiteKings << std::endl;
+        return NOK;
+    }
+    if (nbBlackKings > 1)
+    {
+        std::cerr << "Invalid number of black kings. Maximum: 1. Given: " << nbBlackKings << std::endl;
+        return NOK;
+    }
+    if (nbWhiteKings != nbWhiteKingsStart)
+    {
+        std::cerr << "Invalid number of white kings. Expected: " << nbWhiteKingsStart << ". Given: " << nbWhiteKings << std::endl;
+        return NOK;
+    }
+    if (nbBlackKings != nbBlackKingsStart)
+    {
+        std::cerr << "Invalid number of black kings. Expected: " << nbBlackKingsStart << ". Given: " << nbBlackKings << std::endl;
+        return NOK;
+    }
+    return OK;
+}
+
+
+inline Validation check_en_passant_square(const std::string& enPassantInfo) {
+    if (enPassantInfo.size() != 1 || enPassantInfo[0] != '-')
+    {
+        if (enPassantInfo.size() != 2)
+        {
+            std::cerr << "Invalid en-passant square '" << enPassantInfo << "'. Expects 2 characters. Actual: " << enPassantInfo.size() << " character(s)." << std::endl;
+            return NOK;
+        }
+        if (!isalpha(enPassantInfo[0]))
+        {
+            std::cerr << "Invalid en-passant square '" << enPassantInfo << "'. Expects 1st character to be a letter." << std::endl;
+            return NOK;
+        }
+        if (!isdigit(enPassantInfo[1]))
+        {
+            std::cerr << "Invalid en-passant square '" << enPassantInfo << "'. Expects 2nd character to be a digit." << std::endl;
+            return NOK;
+        }
+    }
+    return OK;
+}
+
+
+inline Validation check_check_count(const std::string& checkCountInfo) {
+    if (checkCountInfo.size() != 3)
+    {
+        std::cerr << "Invalid check count '" << checkCountInfo << "'. Expects 3 characters. Actual: " << checkCountInfo.size() << " character(s)." << std::endl;
+        return NOK;
+    }
+    if (!isdigit(checkCountInfo[0]))
+    {
+        std::cerr << "Invalid check count '" << checkCountInfo << "'. Expects 1st character to be a digit." << std::endl;
+        return NOK;
+    }
+    if (!isdigit(checkCountInfo[2])) {
+        std::cerr << "Invalid check count '" << checkCountInfo << "'. Expects 3rd character to be a digit." << std::endl;
+        return NOK;
+    }
+    return OK;
+}
+
+inline Validation check_lichess_check_count(const std::string& checkCountInfo) {
+    if (checkCountInfo.size() != 4)
+    {
+        std::cerr << "Invalid check count '" << checkCountInfo << "'. Expects 4 characters. Actual: " << checkCountInfo.size() << " character(s)." << std::endl;
+        return NOK;
+    }
+    if (!isdigit(checkCountInfo[1]) || checkCountInfo[1] - '0' > 3)
+    {
+        std::cerr << "Invalid check count '" << checkCountInfo << "'. Expects 2nd character to be a digit up to 3." << std::endl;
+        return NOK;
+    }
+    if (!isdigit(checkCountInfo[3]) || checkCountInfo[3] - '0' > 3) {
+        std::cerr << "Invalid check count '" << checkCountInfo << "'. Expects 4th character to be a digit up to 3." << std::endl;
+        return NOK;
+    }
+    return OK;
+}
+
+inline Validation check_digit_field(const std::string& field) {
+    if (field.size() == 1 && field[0] == '-')
+        return OK;
+    for (char c : field)
+        if (!isdigit(c))
+            return NOK;
+    return OK;
+}
+
+inline std::string get_valid_special_chars(const Variant* v) {
+    std::string validSpecialCharactersFirstField = "/*";
+    // Whether or not '-', '+', '~', '[', ']' are valid depends on the variant being played.
+    if (v->shogiStylePromotions)
+        validSpecialCharactersFirstField += '+';
+    if (v->promotionPieceTypes[WHITE] || v->promotionPieceTypes[BLACK])
+        validSpecialCharactersFirstField += '~';
+    if (!v->freeDrops && (v->pieceDrops || v->seirawanGating))
+        validSpecialCharactersFirstField += "[-]";
+    return validSpecialCharactersFirstField;
+}
+
+inline FenValidation validate_fen(const std::string& fen, const Variant* v, bool chess960 = false) {
+
+    const std::string validSpecialCharactersFirstField = get_valid_special_chars(v);
+    // 0) Layout
+    // check for empty fen
+    if (fen.empty())
+    {
+        std::cerr << "Fen is empty." << std::endl;
+        return FEN_EMPTY;
+    }
+
+    std::vector<std::string> fenParts = get_fen_parts(fen, ' ');
+    std::vector<std::string> startFenParts = get_fen_parts(v->startFen, ' ');
+
+    // check for number of parts
+    const unsigned int maxNumberFenParts = 6 + v->checkCounting;
+    if (fenParts.size() < 1 || fenParts.size() > maxNumberFenParts)
+    {
+        std::cerr << "Invalid number of fen parts. Expected: >= 1 and <= " << maxNumberFenParts
+                  << " Actual: " << fenParts.size() << std::endl;
+        return FEN_INVALID_NB_PARTS;
+    }
+
+    // 1) Part
+    // check for valid characters
+    if (check_for_valid_characters(fenParts[0], validSpecialCharactersFirstField, v) == NOK)
+        return FEN_INVALID_CHAR;
+
+    // check for valid promoted pieces
+    if (check_promoted_pieces(fenParts[0], v) == NOK)
+        return FEN_INVALID_PROMOTED_PIECE;
+
+    // check for number of ranks
+    const int nbRanks = v->maxRank + 1;
+    // check for number of files
+    const int nbFiles = v->maxFile + 1;
+    CharBoard board(nbRanks, nbFiles);  // create a 2D character board for later geometry checks
+
+    if (fill_char_board(board, fenParts[0], validSpecialCharactersFirstField, v) == NOK)
+        return FEN_INVALID_BOARD_GEOMETRY;
+
+    // check for pocket
+    std::string pocket = "";
+    if (v->pieceDrops || v->seirawanGating)
+    {
+        if (check_pocket_info(fenParts[0], nbRanks, v, pocket) == NOK)
+            return FEN_INVALID_POCKET_INFO;
+    }
+
+    // check for number of kings
+    if (v->pieceTypes & KING)
+    {
+        // we have a royal king in this variant,
+        // ensure that each side has exactly as many kings as in the starting position
+        // (variants like giveaway use the COMMONER piece type instead)
+        if (check_number_of_kings(fenParts[0], startFenParts[0], v) == NOK)
+            return FEN_INVALID_NUMBER_OF_KINGS;
+
+        // check for touching kings if there are exactly two royal kings on the board (excluding pocket)
+        if (   v->kingType == KING
+            && piece_count(fenParts[0], WHITE, KING, v) - piece_count(pocket, WHITE, KING, v) == 1
+            && piece_count(fenParts[0], BLACK, KING, v) - piece_count(pocket, BLACK, KING, v) == 1)
+        {
+            std::array<CharSquare, 2> kingPositions;
+            kingPositions[WHITE] = board.get_square_for_piece(v->pieceToChar[make_piece(WHITE, KING)]);
+            kingPositions[BLACK] = board.get_square_for_piece(v->pieceToChar[make_piece(BLACK, KING)]);
+            if (check_touching_kings(board, kingPositions) == NOK)
+                return FEN_TOUCHING_KINGS;
+        }
+    }
+
+    // 2) Part
+    // check side to move char
+    if (fenParts.size() >= 2 && fenParts[1][0] != 'w' && fenParts[1][0] != 'b')
+    {
+        std::cerr << "Invalid side to move specification: '" << fenParts[1][0] << "'." << std::endl;
+        return FEN_INVALID_SIDE_TO_MOVE;
+    }
+
+    // Castling and en passant can be skipped
+    bool skipCastlingAndEp = fenParts.size() >= 4 && fenParts.size() <= 5 && isdigit(fenParts[2][0]);
+
+    // 3) Part
+    // check castling rights
+    if (fenParts.size() >= 3 && !skipCastlingAndEp && v->castling)
+    {
+        std::array<std::string, 2> castlingInfoSplitted;
+        if (fill_castling_info_splitted(fenParts[2], castlingInfoSplitted) == NOK)
+            return FEN_INVALID_CASTLING_INFO;
+
+        if (castlingInfoSplitted[WHITE].size() != 0 || castlingInfoSplitted[BLACK].size() != 0)
+        {
+            std::array<CharSquare, 2> kingPositions;
+            kingPositions[WHITE] = board.get_square_for_piece(toupper(v->pieceToChar[v->castlingKingPiece[WHITE]]));
+            kingPositions[BLACK] = board.get_square_for_piece(tolower(v->pieceToChar[v->castlingKingPiece[BLACK]]));
+
+            CharBoard startBoard(board.get_nb_ranks(), board.get_nb_files());
+            fill_char_board(startBoard, v->startFen, validSpecialCharactersFirstField, v);
+
+            // Check pieces present on castling rank against castling/gating rights
+            if (check_castling_rank(castlingInfoSplitted, board, kingPositions, v) == NOK)
+                return FEN_INVALID_CASTLING_INFO;
+
+            // only check exact squares if starting position of castling pieces is known
+            if (!v->chess960 && !v->castlingDroppedPiece && !chess960)
+            {
+                std::array<CharSquare, 2> kingPositionsStart;
+                kingPositionsStart[WHITE] = startBoard.get_square_for_piece(v->pieceToChar[make_piece(WHITE, v->castlingKingPiece[WHITE])]);
+                kingPositionsStart[BLACK] = startBoard.get_square_for_piece(v->pieceToChar[make_piece(BLACK, v->castlingKingPiece[BLACK])]);
+                std::array<std::vector<CharSquare>, 2> rookPositionsStart;
+                rookPositionsStart[WHITE] = startBoard.get_squares_for_pieces(WHITE, v->castlingRookPieces[WHITE], v->pieceToChar);
+                rookPositionsStart[BLACK] = startBoard.get_squares_for_pieces(BLACK, v->castlingRookPieces[BLACK], v->pieceToChar);
+
+                if (check_standard_castling(castlingInfoSplitted, board, kingPositions, kingPositionsStart, rookPositionsStart, v) == NOK)
+                    return FEN_INVALID_CASTLING_INFO;
+            }
+        }
+    }
+
+    // 4) Part
+    // check en-passant square
+    if (fenParts.size() >= 4 && !skipCastlingAndEp)
+    {
+        if (v->doubleStep && (v->pieceTypes & PAWN))
+        {
+            if (check_en_passant_square(fenParts[3]) == NOK)
+                return FEN_INVALID_EN_PASSANT_SQ;
+        }
+        else if (v->countingRule && !check_digit_field(fenParts[3]))
+            return FEN_INVALID_COUNTING_RULE;
+    }
+
+    // 5) Part
+    // check check count
+    unsigned int optionalInbetweenFields = 2 * !skipCastlingAndEp;
+    unsigned int optionalTrailingFields = 0;
+    if (fenParts.size() >= 3 + optionalInbetweenFields && v->checkCounting && fenParts.size() % 2)
+    {
+        if (check_check_count(fenParts[2 + optionalInbetweenFields]) == NOK)
+        {
+            // allow valid lichess style check as alternative
+            if (fenParts.size() < 5 + optionalInbetweenFields || check_lichess_check_count(fenParts[fenParts.size() - 1]) == NOK)
+                return FEN_INVALID_CHECK_COUNT;
+            else
+                optionalTrailingFields++;
+        }
+        else
+            optionalInbetweenFields++;
+    }
+
+    // 6) Part
+    // check half move counter
+    if (fenParts.size() >= 3 + optionalInbetweenFields && !check_digit_field(fenParts[fenParts.size() - 2 - optionalTrailingFields]))
+    {
+        std::cerr << "Invalid half move counter: '" << fenParts[fenParts.size()-2] << "'." << std::endl;
+        return FEN_INVALID_HALF_MOVE_COUNTER;
+    }
+
+    // 7) Part
+    // check move counter
+    if (fenParts.size() >= 4 + optionalInbetweenFields && !check_digit_field(fenParts[fenParts.size() - 1 - optionalTrailingFields]))
+    {
+        std::cerr << "Invalid move counter: '" << fenParts[fenParts.size()-1] << "'." << std::endl;
+        return FEN_INVALID_MOVE_COUNTER;
+    }
+
+    return FEN_OK;
+}
+} // namespace FEN
+
+} // namespace Stockfish
+
+#endif // #ifndef APIUTIL_H_INCLUDED

Fairy-Stockfish-master/src/benchmark.cpp

@@ -0,0 +1,195 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <fstream>
+#include <iostream>
+#include <istream>
+#include <vector>
+
+#include "position.h"
+#include "uci.h"
+
+using namespace std;
+
+namespace {
+
+const vector<string> 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",
+  "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<string> setup_bench(const Position& current, istream& is) {
+
+  vector<string> fens, list;
+  string go, token, varname;
+
+  streampos args = is.tellg();
+  // Check whether the next token is a variant name
+  if ((is >> token) && variants.find(token) != variants.end())
+  {
+      args = is.tellg();
+      varname = token;
+  }
+  else
+  {
+      is.seekg(args);
+      varname = string(Options["UCI_Variant"]);
+  }
+  const Variant* variant = variants.find(varname)->second;
+
+  // 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")
+  {
+      if (varname != "chess")
+          fens.push_back(variant->startFen);
+      else
+          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("setoption name UCI_Variant value " + varname);
+  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

Fairy-Stockfish-master/src/bitbase.cpp

@@ -0,0 +1,177 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <cassert>
+#include <vector>
+#include <bitset>
+
+#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<MAX_INDEX> 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<KPKPosition>& 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() {
+
+#ifdef LARGEBOARDS
+    // Bitbases are not working for large-board version
+    return;
+#endif
+
+  std::vector<KPKPosition> 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<KING>(ksq[BLACK]) & ~(attacks_bb<KING>(ksq[WHITE]) | pawn_attacks_bb(WHITE, psq)))
+                 || (attacks_bb<KING>(ksq[BLACK]) & ~attacks_bb<KING>(ksq[WHITE]) & psq)))
+        result = DRAW;
+
+    // Position will be classified later
+    else
+        result = UNKNOWN;
+  }
+
+  Result KPKPosition::classify(const std::vector<KPKPosition>& 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<KING>(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

Fairy-Stockfish-master/src/bitboard.cpp

@@ -0,0 +1,501 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <algorithm>
+#include <bitset>
+
+#include "bitboard.h"
+#include "magic.h"
+#include "misc.h"
+#include "piece.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[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+Bitboard PseudoMoves[2][COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+Bitboard LeaperAttacks[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+Bitboard LeaperMoves[2][COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+Bitboard BoardSizeBB[FILE_NB][RANK_NB];
+RiderType AttackRiderTypes[PIECE_TYPE_NB];
+RiderType MoveRiderTypes[2][PIECE_TYPE_NB];
+
+Magic RookMagicsH[SQUARE_NB];
+Magic RookMagicsV[SQUARE_NB];
+Magic BishopMagics[SQUARE_NB];
+Magic CannonMagicsH[SQUARE_NB];
+Magic CannonMagicsV[SQUARE_NB];
+Magic LameDabbabaMagics[SQUARE_NB];
+Magic HorseMagics[SQUARE_NB];
+Magic ElephantMagics[SQUARE_NB];
+Magic JanggiElephantMagics[SQUARE_NB];
+Magic CannonDiagMagics[SQUARE_NB];
+Magic NightriderMagics[SQUARE_NB];
+Magic GrasshopperMagicsH[SQUARE_NB];
+Magic GrasshopperMagicsV[SQUARE_NB];
+Magic GrasshopperMagicsD[SQUARE_NB];
+
+Magic* magics[] = {BishopMagics, RookMagicsH, RookMagicsV, CannonMagicsH, CannonMagicsV,
+                   LameDabbabaMagics, HorseMagics, ElephantMagics, JanggiElephantMagics, CannonDiagMagics, NightriderMagics,
+                   GrasshopperMagicsH, GrasshopperMagicsV, GrasshopperMagicsD};
+
+namespace {
+
+// Some magics need to be split in order to reduce memory consumption.
+// Otherwise on a 12x10 board they can be >100 MB.
+#ifdef LARGEBOARDS
+  Bitboard RookTableH[0x11800];  // To store horizontal rook attacks
+  Bitboard RookTableV[0x4800];  // To store vertical rook attacks
+  Bitboard BishopTable[0x33C00]; // To store bishop attacks
+  Bitboard CannonTableH[0x11800];  // To store horizontal cannon attacks
+  Bitboard CannonTableV[0x4800];  // To store vertical cannon attacks
+  Bitboard LameDabbabaTable[0x500];  // To store lame dabbaba attacks
+  Bitboard HorseTable[0x500];  // To store horse attacks
+  Bitboard ElephantTable[0x400];  // To store elephant attacks
+  Bitboard JanggiElephantTable[0x1C000];  // To store janggi elephant attacks
+  Bitboard CannonDiagTable[0x33C00]; // To store diagonal cannon attacks
+  Bitboard NightriderTable[0x70200]; // To store nightrider attacks
+  Bitboard GrasshopperTableH[0x11800];  // To store horizontal grasshopper attacks
+  Bitboard GrasshopperTableV[0x4800];  // To store vertical grasshopper attacks
+  Bitboard GrasshopperTableD[0x33C00]; // To store diagonal grasshopper attacks
+#else
+  Bitboard RookTableH[0xA00];  // To store horizontal rook attacks
+  Bitboard RookTableV[0xA00];  // To store vertical rook attacks
+  Bitboard BishopTable[0x1480]; // To store bishop attacks
+  Bitboard CannonTableH[0xA00];  // To store horizontal cannon attacks
+  Bitboard CannonTableV[0xA00];  // To store vertical cannon attacks
+  Bitboard LameDabbabaTable[0x240];  // To store lame dabbaba attacks
+  Bitboard HorseTable[0x240];  // To store horse attacks
+  Bitboard ElephantTable[0x1A0];  // To store elephant attacks
+  Bitboard JanggiElephantTable[0x5C00];  // To store janggi elephant attacks
+  Bitboard CannonDiagTable[0x1480]; // To store diagonal cannon attacks
+  Bitboard NightriderTable[0x1840]; // To store nightrider attacks
+  Bitboard GrasshopperTableH[0xA00];  // To store horizontal grasshopper attacks
+  Bitboard GrasshopperTableV[0xA00];  // To store vertical grasshopper attacks
+  Bitboard GrasshopperTableD[0x1480]; // To store diagonal grasshopper attacks
+#endif
+
+  // Rider directions
+  const std::map<Direction, int> RookDirectionsV { {NORTH, 0}, {SOUTH, 0}};
+  const std::map<Direction, int> RookDirectionsH { {EAST, 0}, {WEST, 0} };
+  const std::map<Direction, int> BishopDirections { {NORTH_EAST, 0}, {SOUTH_EAST, 0}, {SOUTH_WEST, 0}, {NORTH_WEST, 0} };
+  const std::map<Direction, int> LameDabbabaDirections { {2 * NORTH, 0}, {2 * EAST, 0}, {2 * SOUTH, 0}, {2 * WEST, 0} };
+  const std::map<Direction, int> HorseDirections { {2 * SOUTH + WEST, 0}, {2 * SOUTH + EAST, 0}, {SOUTH + 2 * WEST, 0}, {SOUTH + 2 * EAST, 0},
+                                                   {NORTH + 2 * WEST, 0}, {NORTH + 2 * EAST, 0}, {2 * NORTH + WEST, 0}, {2 * NORTH + EAST, 0} };
+  const std::map<Direction, int> ElephantDirections { {2 * NORTH_EAST, 0}, {2 * SOUTH_EAST, 0}, {2 * SOUTH_WEST, 0}, {2 * NORTH_WEST, 0} };
+  const std::map<Direction, int> JanggiElephantDirections { {NORTH + 2 * NORTH_EAST, 0}, {EAST  + 2 * NORTH_EAST, 0},
+                                                            {EAST  + 2 * SOUTH_EAST, 0}, {SOUTH + 2 * SOUTH_EAST, 0},
+                                                            {SOUTH + 2 * SOUTH_WEST, 0}, {WEST  + 2 * SOUTH_WEST, 0},
+                                                            {WEST  + 2 * NORTH_WEST, 0}, {NORTH + 2 * NORTH_WEST, 0} };
+  const std::map<Direction, int> GrasshopperDirectionsV { {NORTH, 1}, {SOUTH, 1}};
+  const std::map<Direction, int> GrasshopperDirectionsH { {EAST, 1}, {WEST, 1} };
+  const std::map<Direction, int> GrasshopperDirectionsD { {NORTH_EAST, 1}, {SOUTH_EAST, 1}, {SOUTH_WEST, 1}, {NORTH_WEST, 1} };
+
+  enum MovementType { RIDER, HOPPER, LAME_LEAPER, HOPPER_RANGE };
+
+  template <MovementType MT>
+#ifdef PRECOMPUTED_MAGICS
+  void init_magics(Bitboard table[], Magic magics[], std::map<Direction, int> directions, const Bitboard magicsInit[]);
+#else
+  void init_magics(Bitboard table[], Magic magics[], std::map<Direction, int> directions);
+#endif
+
+  template <MovementType MT>
+  Bitboard sliding_attack(std::map<Direction, int> directions, Square sq, Bitboard occupied, Color c = WHITE) {
+    assert(MT != LAME_LEAPER);
+
+    Bitboard attack = 0;
+
+    for (auto const& [d, limit] : directions)
+    {
+        int count = 0;
+        bool hurdle = false;
+        for (Square s = sq + (c == WHITE ? d : -d);
+             is_ok(s) && distance(s, s - (c == WHITE ? d : -d)) <= 2;
+             s += (c == WHITE ? d : -d))
+        {
+            if (MT != HOPPER || hurdle)
+            {
+                attack |= s;
+                // For hoppers we consider limit == 1 as a grasshopper,
+                // but limit > 1 as a limited distance hopper
+                if (limit && !(MT == HOPPER_RANGE && limit == 1) && ++count >= limit)
+                    break;
+            }
+
+            if (occupied & s)
+            {
+                if (MT == HOPPER && !hurdle)
+                    hurdle = true;
+                else
+                    break;
+            }
+        }
+    }
+
+    return attack;
+  }
+
+  Bitboard lame_leaper_path(Direction d, Square s) {
+    Direction dr = d > 0 ? NORTH : SOUTH;
+    Direction df = (std::abs(d % NORTH) < NORTH / 2 ? d % NORTH : -(d % NORTH)) < 0 ? WEST : EAST;
+    Square to = s + d;
+    Bitboard b = 0;
+    if (!is_ok(to) || distance(s, to) >= 4)
+        return b;
+    while (s != to)
+    {
+        int diff = std::abs(file_of(to) - file_of(s)) - std::abs(rank_of(to) - rank_of(s));
+        if (diff > 0)
+            s += df;
+        else if (diff < 0)
+            s += dr;
+        else
+            s += df + dr;
+
+        if (s != to)
+            b |= s;
+    }
+    return b;
+  }
+
+  Bitboard lame_leaper_path(std::map<Direction, int> directions, Square s) {
+    Bitboard b = 0;
+    for (const auto& i : directions)
+        b |= lame_leaper_path(i.first, s);
+    return b;
+  }
+
+  Bitboard lame_leaper_attack(std::map<Direction, int> directions, Square s, Bitboard occupied) {
+    Bitboard b = 0;
+    for (const auto& i : directions)
+    {
+        Square to = s + i.first;
+        if (is_ok(to) && distance(s, to) < 4 && !(lame_leaper_path(i.first, s) & occupied))
+            b |= to;
+    }
+    return b;
+  }
+
+}
+
+/// 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) <= 3 ? 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_MAX; r >= RANK_1; --r)
+  {
+      for (File f = FILE_A; f <= FILE_MAX; ++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   i   j   k   l\n";
+
+  return s;
+}
+
+/// Bitboards::init_pieces() initializes piece move/attack bitboards and rider types
+
+void Bitboards::init_pieces() {
+
+  for (PieceType pt = PAWN; pt <= KING; ++pt)
+  {
+      const PieceInfo* pi = pieceMap.find(pt)->second;
+
+      // Detect rider types
+      for (auto modality : {MODALITY_QUIET, MODALITY_CAPTURE})
+      {
+          for (bool initial : {false, true})
+          {
+              // We do not support initial captures
+              if (modality == MODALITY_CAPTURE && initial)
+                  continue;
+              auto& riderTypes = modality == MODALITY_CAPTURE ? AttackRiderTypes[pt] : MoveRiderTypes[initial][pt];
+              riderTypes = NO_RIDER;
+              for (auto const& [d, limit] : pi->steps[initial][modality])
+              {
+                  if (limit && LameDabbabaDirections.find(d) != LameDabbabaDirections.end())
+                      riderTypes |= RIDER_LAME_DABBABA;
+                  if (limit && HorseDirections.find(d) != HorseDirections.end())
+                      riderTypes |= RIDER_HORSE;
+                  if (limit && ElephantDirections.find(d) != ElephantDirections.end())
+                      riderTypes |= RIDER_ELEPHANT;
+                  if (limit && JanggiElephantDirections.find(d) != JanggiElephantDirections.end())
+                      riderTypes |= RIDER_JANGGI_ELEPHANT;
+              }
+              for (auto const& [d, limit] : pi->slider[initial][modality])
+              {
+                  if (BishopDirections.find(d) != BishopDirections.end())
+                      riderTypes |= RIDER_BISHOP;
+                  if (RookDirectionsH.find(d) != RookDirectionsH.end())
+                      riderTypes |= RIDER_ROOK_H;
+                  if (RookDirectionsV.find(d) != RookDirectionsV.end())
+                      riderTypes |= RIDER_ROOK_V;
+                  if (HorseDirections.find(d) != HorseDirections.end())
+                      riderTypes |= RIDER_NIGHTRIDER;
+              }
+              for (auto const& [d, limit] : pi->hopper[initial][modality])
+              {
+                  if (RookDirectionsH.find(d) != RookDirectionsH.end())
+                      riderTypes |= limit == 1 ? RIDER_GRASSHOPPER_H : RIDER_CANNON_H;
+                  if (RookDirectionsV.find(d) != RookDirectionsV.end())
+                      riderTypes |= limit == 1 ? RIDER_GRASSHOPPER_V : RIDER_CANNON_V;
+                  if (BishopDirections.find(d) != BishopDirections.end())
+                      riderTypes |= limit == 1 ? RIDER_GRASSHOPPER_D : RIDER_CANNON_DIAG;
+              }
+          }
+      }
+
+      // Initialize move/attack bitboards
+      for (Color c : { WHITE, BLACK })
+      {
+          for (Square s = SQ_A1; s <= SQ_MAX; ++s)
+          {
+              for (auto modality : {MODALITY_QUIET, MODALITY_CAPTURE})
+              {
+                  for (bool initial : {false, true})
+                  {
+                      // We do not support initial captures
+                      if (modality == MODALITY_CAPTURE && initial)
+                          continue;
+                      auto& pseudo = modality == MODALITY_CAPTURE ? PseudoAttacks[c][pt][s] : PseudoMoves[initial][c][pt][s];
+                      auto& leaper = modality == MODALITY_CAPTURE ? LeaperAttacks[c][pt][s] : LeaperMoves[initial][c][pt][s];
+                      pseudo = 0;
+                      leaper = 0;
+                      for (auto const& [d, limit] : pi->steps[initial][modality])
+                      {
+                          pseudo |= safe_destination(s, c == WHITE ? d : -d);
+                          if (!limit)
+                              leaper |= safe_destination(s, c == WHITE ? d : -d);
+                      }
+                      pseudo |= sliding_attack<RIDER>(pi->slider[initial][modality], s, 0, c);
+                      pseudo |= sliding_attack<HOPPER_RANGE>(pi->hopper[initial][modality], s, 0, c);
+                  }
+              }
+          }
+      }
+  }
+}
+
+
+/// 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_MAX; ++s)
+      SquareBB[s] = make_bitboard(s);
+
+  for (File f = FILE_A; f <= FILE_MAX; ++f)
+      for (Rank r = RANK_1; r <= RANK_MAX; ++r)
+          BoardSizeBB[f][r] = forward_file_bb(BLACK, make_square(f, r)) | SquareBB[make_square(f, r)] | (f > FILE_A ? BoardSizeBB[f - 1][r] : Bitboard(0));
+
+  for (Square s1 = SQ_A1; s1 <= SQ_MAX; ++s1)
+      for (Square s2 = SQ_A1; s2 <= SQ_MAX; ++s2)
+              SquareDistance[s1][s2] = std::max(distance<File>(s1, s2), distance<Rank>(s1, s2));
+
+#ifdef PRECOMPUTED_MAGICS
+  init_magics<RIDER>(RookTableH, RookMagicsH, RookDirectionsH, RookMagicHInit);
+  init_magics<RIDER>(RookTableV, RookMagicsV, RookDirectionsV, RookMagicVInit);
+  init_magics<RIDER>(BishopTable, BishopMagics, BishopDirections, BishopMagicInit);
+  init_magics<HOPPER>(CannonTableH, CannonMagicsH, RookDirectionsH, CannonMagicHInit);
+  init_magics<HOPPER>(CannonTableV, CannonMagicsV, RookDirectionsV, CannonMagicVInit);
+  init_magics<LAME_LEAPER>(LameDabbabaTable, LameDabbabaMagics, LameDabbabaDirections, LameDabbabaMagicInit);
+  init_magics<LAME_LEAPER>(HorseTable, HorseMagics, HorseDirections, HorseMagicInit);
+  init_magics<LAME_LEAPER>(ElephantTable, ElephantMagics, ElephantDirections, ElephantMagicInit);
+  init_magics<LAME_LEAPER>(JanggiElephantTable, JanggiElephantMagics, JanggiElephantDirections, JanggiElephantMagicInit);
+  init_magics<HOPPER>(CannonDiagTable, CannonDiagMagics, BishopDirections, CannonDiagMagicInit);
+  init_magics<RIDER>(NightriderTable, NightriderMagics, HorseDirections, NightriderMagicInit);
+  init_magics<HOPPER>(GrasshopperTableH, GrasshopperMagicsH, GrasshopperDirectionsH, GrasshopperMagicHInit);
+  init_magics<HOPPER>(GrasshopperTableV, GrasshopperMagicsV, GrasshopperDirectionsV, GrasshopperMagicVInit);
+  init_magics<HOPPER>(GrasshopperTableD, GrasshopperMagicsD, GrasshopperDirectionsD, GrasshopperMagicDInit);
+#else
+  init_magics<RIDER>(RookTableH, RookMagicsH, RookDirectionsH);
+  init_magics<RIDER>(RookTableV, RookMagicsV, RookDirectionsV);
+  init_magics<RIDER>(BishopTable, BishopMagics, BishopDirections);
+  init_magics<HOPPER>(CannonTableH, CannonMagicsH, RookDirectionsH);
+  init_magics<HOPPER>(CannonTableV, CannonMagicsV, RookDirectionsV);
+  init_magics<LAME_LEAPER>(LameDabbabaTable, LameDabbabaMagics, LameDabbabaDirections);
+  init_magics<LAME_LEAPER>(HorseTable, HorseMagics, HorseDirections);
+  init_magics<LAME_LEAPER>(ElephantTable, ElephantMagics, ElephantDirections);
+  init_magics<LAME_LEAPER>(JanggiElephantTable, JanggiElephantMagics, JanggiElephantDirections);
+  init_magics<HOPPER>(CannonDiagTable, CannonDiagMagics, BishopDirections);
+  init_magics<RIDER>(NightriderTable, NightriderMagics, HorseDirections);
+  init_magics<HOPPER>(GrasshopperTableH, GrasshopperMagicsH, GrasshopperDirectionsH);
+  init_magics<HOPPER>(GrasshopperTableV, GrasshopperMagicsV, GrasshopperDirectionsV);
+  init_magics<HOPPER>(GrasshopperTableD, GrasshopperMagicsD, GrasshopperDirectionsD);
+#endif
+
+  init_pieces();
+
+  for (Square s1 = SQ_A1; s1 <= SQ_MAX; ++s1)
+  {
+      for (PieceType pt : { BISHOP, ROOK })
+          for (Square s2 = SQ_A1; s2 <= SQ_MAX; ++s2)
+          {
+              if (PseudoAttacks[WHITE][pt][s1] & s2)
+              {
+                  LineBB[s1][s2]    = (attacks_bb(WHITE, pt, s1, 0) & attacks_bb(WHITE, pt, s2, 0)) | s1 | s2;
+                  BetweenBB[s1][s2] = (attacks_bb(WHITE, pt, s1, square_bb(s2)) & attacks_bb(WHITE, pt, s2, square_bb(s1)));
+              }
+              BetweenBB[s1][s2] |= s2;
+          }
+  }
+}
+
+namespace {
+
+  // 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.
+
+  template <MovementType MT>
+#ifdef PRECOMPUTED_MAGICS
+  void init_magics(Bitboard table[], Magic magics[], std::map<Direction, int> directions, const Bitboard magicsInit[]) {
+#else
+  void init_magics(Bitboard table[], Magic magics[], std::map<Direction, int> directions) {
+#endif
+
+    // Optimal PRNG seeds to pick the correct magics in the shortest time
+#ifndef PRECOMPUTED_MAGICS
+#ifdef LARGEBOARDS
+    int seeds[][RANK_NB] = { { 734, 10316, 55013, 32803, 12281, 15100,  16645, 255, 346, 89123 },
+                             { 734, 10316, 55013, 32803, 12281, 15100,  16645, 255, 346, 89123 } };
+#else
+    int seeds[][RANK_NB] = { { 8977, 44560, 54343, 38998,  5731, 95205, 104912, 17020 },
+                             {  728, 10316, 55013, 32803, 12281, 15100,  16645,   255 } };
+#endif
+#endif
+
+    Bitboard* occupancy = new Bitboard[1 << (FILE_NB + RANK_NB - 4)];
+    Bitboard* reference = new Bitboard[1 << (FILE_NB + RANK_NB - 4)];
+    Bitboard edges, b;
+    int* epoch = new int[1 << (FILE_NB + RANK_NB - 4)]();
+    int cnt = 0, size = 0;
+
+    for (Square s = SQ_A1; s <= SQ_MAX; ++s)
+    {
+        // Board edges are not considered in the relevant occupancies
+        edges = ((Rank1BB | rank_bb(RANK_MAX)) & ~rank_bb(s)) | ((FileABB | file_bb(FILE_MAX)) & ~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];
+        // The mask for hoppers is unlimited distance, even if the hopper is limited distance (e.g., grasshopper)
+        m.mask  = (MT == LAME_LEAPER ? lame_leaper_path(directions, s) : sliding_attack<MT == HOPPER ? HOPPER_RANGE : MT>(directions, s, 0)) & ~edges;
+#ifdef LARGEBOARDS
+        m.shift = 128 - popcount(m.mask);
+#else
+        m.shift = (Is64Bit ? 64 : 32) - popcount(m.mask);
+#endif
+
+        // 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] = MT == LAME_LEAPER ? lame_leaper_attack(directions, s, b) : sliding_attack<MT>(directions, s, b);
+
+            if (HasPext)
+                m.attacks[pext(b, m.mask)] = reference[size];
+
+            size++;
+            b = (b - m.mask) & m.mask;
+        } while (b);
+
+        if (HasPext)
+            continue;
+
+#ifndef PRECOMPUTED_MAGICS
+        PRNG rng(seeds[Is64Bit][rank_of(s)]);
+#endif
+
+        // 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) >> (SQUARE_NB - FILE_NB)) < FILE_NB - 2; )
+            {
+#ifdef LARGEBOARDS
+#ifdef PRECOMPUTED_MAGICS
+                m.magic = magicsInit[s];
+#else
+                m.magic = (rng.sparse_rand<Bitboard>() << 64) ^ rng.sparse_rand<Bitboard>();
+#endif
+#else
+                m.magic = rng.sparse_rand<Bitboard>();
+#endif
+            }
+
+            // 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;
+            }
+        }
+    }
+
+    delete[] occupancy;
+    delete[] reference;
+    delete[] epoch;
+  }
+}
+
+} // namespace Stockfish

Fairy-Stockfish-master/src/bitboard.h

@@ -0,0 +1,787 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef BITBOARD_H_INCLUDED
+#define BITBOARD_H_INCLUDED
+
+#include <string>
+
+#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_pieces();
+void init();
+std::string pretty(Bitboard b);
+
+} // namespace Stockfish::Bitboards
+
+#ifdef LARGEBOARDS
+constexpr Bitboard AllSquares = ((~Bitboard(0)) >> 8);
+#else
+constexpr Bitboard AllSquares = ~Bitboard(0);
+#endif
+#ifdef LARGEBOARDS
+constexpr Bitboard DarkSquares = (Bitboard(0xAAA555AAA555AAULL) << 64) ^ Bitboard(0xA555AAA555AAA555ULL);
+#else
+constexpr Bitboard DarkSquares = 0xAA55AA55AA55AA55ULL;
+#endif
+
+#ifdef LARGEBOARDS
+constexpr Bitboard FileABB = (Bitboard(0x00100100100100ULL) << 64) ^ Bitboard(0x1001001001001001ULL);
+#else
+constexpr Bitboard FileABB = 0x0101010101010101ULL;
+#endif
+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;
+#ifdef LARGEBOARDS
+constexpr Bitboard FileIBB = FileABB << 8;
+constexpr Bitboard FileJBB = FileABB << 9;
+constexpr Bitboard FileKBB = FileABB << 10;
+constexpr Bitboard FileLBB = FileABB << 11;
+#endif
+
+
+#ifdef LARGEBOARDS
+constexpr Bitboard Rank1BB = 0xFFF;
+#else
+constexpr Bitboard Rank1BB = 0xFF;
+#endif
+constexpr Bitboard Rank2BB = Rank1BB << (FILE_NB * 1);
+constexpr Bitboard Rank3BB = Rank1BB << (FILE_NB * 2);
+constexpr Bitboard Rank4BB = Rank1BB << (FILE_NB * 3);
+constexpr Bitboard Rank5BB = Rank1BB << (FILE_NB * 4);
+constexpr Bitboard Rank6BB = Rank1BB << (FILE_NB * 5);
+constexpr Bitboard Rank7BB = Rank1BB << (FILE_NB * 6);
+constexpr Bitboard Rank8BB = Rank1BB << (FILE_NB * 7);
+#ifdef LARGEBOARDS
+constexpr Bitboard Rank9BB = Rank1BB << (FILE_NB * 8);
+constexpr Bitboard Rank10BB = Rank1BB << (FILE_NB * 9);
+#endif
+
+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[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+extern Bitboard PseudoMoves[2][COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+extern Bitboard LeaperAttacks[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+extern Bitboard LeaperMoves[2][COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+extern Bitboard SquareBB[SQUARE_NB];
+extern Bitboard BoardSizeBB[FILE_NB][RANK_NB];
+extern RiderType AttackRiderTypes[PIECE_TYPE_NB];
+extern RiderType MoveRiderTypes[2][PIECE_TYPE_NB];
+
+#ifdef LARGEBOARDS
+int popcount(Bitboard b); // required for 128 bit pext
+#endif
+
+/// 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));
+
+#ifdef LARGEBOARDS
+    return unsigned(((occupied & mask) * magic) >> shift);
+#else
+    if (Is64Bit)
+        return unsigned(((occupied & mask) * magic) >> shift);
+#endif
+
+    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 RookMagicsH[SQUARE_NB];
+extern Magic RookMagicsV[SQUARE_NB];
+extern Magic BishopMagics[SQUARE_NB];
+extern Magic CannonMagicsH[SQUARE_NB];
+extern Magic CannonMagicsV[SQUARE_NB];
+extern Magic LameDabbabaMagics[SQUARE_NB];
+extern Magic HorseMagics[SQUARE_NB];
+extern Magic ElephantMagics[SQUARE_NB];
+extern Magic JanggiElephantMagics[SQUARE_NB];
+extern Magic CannonDiagMagics[SQUARE_NB];
+extern Magic NightriderMagics[SQUARE_NB];
+extern Magic GrasshopperMagicsH[SQUARE_NB];
+extern Magic GrasshopperMagicsV[SQUARE_NB];
+extern Magic GrasshopperMagicsD[SQUARE_NB];
+
+extern Magic* magics[];
+
+constexpr Bitboard make_bitboard() { return 0; }
+
+template<typename ...Squares>
+constexpr Bitboard make_bitboard(Square s, Squares... squares) {
+  return (Bitboard(1) << s) | make_bitboard(squares...);
+}
+
+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-( 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);
+}
+
+
+inline Bitboard undo_move_board(Bitboard b, Move m) {
+  return (from_sq(m) != SQ_NONE && (b & to_sq(m))) ? (b ^ to_sq(m)) | from_sq(m) : b;
+}
+
+/// board_size_bb() returns a bitboard representing all the squares
+/// on a board with given size.
+
+inline Bitboard board_size_bb(File f, Rank r) {
+  return BoardSizeBB[f][r];
+}
+
+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 << (FILE_NB * 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<Direction D>
+constexpr Bitboard shift(Bitboard b) {
+  return  D == NORTH      ?  b                       << NORTH      : D == SOUTH      ?  b             >> NORTH
+        : D == NORTH+NORTH?  b                       <<(2 * NORTH) : D == SOUTH+SOUTH?  b             >> (2 * NORTH)
+        : D == EAST       ? (b & ~file_bb(FILE_MAX)) << EAST       : D == WEST       ? (b & ~FileABB) >> EAST
+        : D == NORTH_EAST ? (b & ~file_bb(FILE_MAX)) << NORTH_EAST : D == NORTH_WEST ? (b & ~FileABB) << NORTH_WEST
+        : D == SOUTH_EAST ? (b & ~file_bb(FILE_MAX)) >> NORTH_WEST : D == SOUTH_WEST ? (b & ~FileABB) >> NORTH_EAST
+        : Bitboard(0);
+}
+
+
+/// shift() moves a bitboard one step along direction D (mainly for pawns)
+
+constexpr Bitboard shift(Direction D, Bitboard b) {
+  return  D == NORTH      ?  b                       << NORTH      : D == SOUTH      ?  b             >> NORTH
+        : D == NORTH+NORTH?  b                       <<(2 * NORTH) : D == SOUTH+SOUTH?  b             >> (2 * NORTH)
+        : D == EAST       ? (b & ~file_bb(FILE_MAX)) << EAST       : D == WEST       ? (b & ~FileABB) >> EAST
+        : D == NORTH_EAST ? (b & ~file_bb(FILE_MAX)) << NORTH_EAST : D == NORTH_WEST ? (b & ~FileABB) << NORTH_WEST
+        : D == SOUTH_EAST ? (b & ~file_bb(FILE_MAX)) >> NORTH_WEST : D == SOUTH_WEST ? (b & ~FileABB) >> NORTH_EAST
+        : Bitboard(0);
+}
+
+
+/// pawn_attacks_bb() returns the squares attacked by pawns of the given color
+/// from the squares in the given bitboard.
+
+template<Color C>
+constexpr Bitboard pawn_attacks_bb(Bitboard b) {
+  return C == WHITE ? shift<NORTH_WEST>(b) | shift<NORTH_EAST>(b)
+                    : shift<SOUTH_WEST>(b) | shift<SOUTH_EAST>(b);
+}
+
+inline Bitboard pawn_attacks_bb(Color c, Square s) {
+
+  assert(is_ok(s));
+  return PseudoAttacks[c][PAWN][s];
+}
+
+
+/// pawn_double_attacks_bb() returns the squares doubly attacked by pawns of the
+/// given color from the squares in the given bitboard.
+
+template<Color C>
+constexpr Bitboard pawn_double_attacks_bb(Bitboard b) {
+  return C == WHITE ? shift<NORTH_WEST>(b) & shift<NORTH_EAST>(b)
+                    : shift<SOUTH_WEST>(b) & shift<SOUTH_EAST>(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<EAST>(file_bb(s)) | shift<WEST>(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];
+}
+
+inline Bitboard between_bb(Square s1, Square s2, PieceType pt) {
+  if (pt == HORSE)
+      return PseudoAttacks[WHITE][WAZIR][s2] & PseudoAttacks[WHITE][FERS][s1];
+  else if (pt == JANGGI_ELEPHANT)
+      return  (PseudoAttacks[WHITE][WAZIR][s2] & PseudoAttacks[WHITE][ALFIL][s1])
+            | (PseudoAttacks[WHITE][KNIGHT][s2] & PseudoAttacks[WHITE][FERS][s1]);
+  else
+      return between_bb(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 ? (AllSquares ^ Rank1BB) << FILE_NB * relative_rank(WHITE, s, RANK_MAX)
+                    : (AllSquares ^ rank_bb(RANK_MAX)) >> FILE_NB * relative_rank(BLACK, s, RANK_MAX);
+}
+
+constexpr Bitboard forward_ranks_bb(Color c, Rank r) {
+  return c == WHITE ? (AllSquares ^ Rank1BB) << FILE_NB * (r - RANK_1)
+                    : (AllSquares ^ rank_bb(RANK_MAX)) >> FILE_NB * (RANK_MAX - r);
+}
+
+
+/// zone_bb() returns a bitboard representing the squares on all the ranks
+/// in front of and on the given relative rank, from the point of view of the given color.
+/// For instance, zone_bb(BLACK, RANK_7) will return the 16 squares on ranks 1 and 2.
+
+inline Bitboard zone_bb(Color c, Rank r, Rank maxRank) {
+  return forward_ranks_bb(c, relative_rank(c, r, maxRank)) | rank_bb(relative_rank(c, r, maxRank));
+}
+
+
+/// 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<typename T1 = Square> inline int distance(Square x, Square y);
+template<> inline int distance<File>(Square x, Square y) { return std::abs(file_of(x) - file_of(y)); }
+template<> inline int distance<Rank>(Square x, Square y) { return std::abs(rank_of(x) - rank_of(y)); }
+template<> inline int distance<Square>(Square x, Square y) { return SquareDistance[x][y]; }
+
+inline int edge_distance(File f, File maxFile = FILE_H) { return std::min(f, File(maxFile - f)); }
+inline int edge_distance(Rank r, Rank maxRank = RANK_8) { return std::min(r, Rank(maxRank - r)); }
+
+
+template<RiderType R>
+inline Bitboard rider_attacks_bb(Square s, Bitboard occupied) {
+
+  static_assert(R != NO_RIDER && !(R & (R - 1))); // exactly one bit
+  const Magic& m =  R == RIDER_ROOK_H ? RookMagicsH[s]
+                  : R == RIDER_ROOK_V ? RookMagicsV[s]
+                  : R == RIDER_CANNON_H ? CannonMagicsH[s]
+                  : R == RIDER_CANNON_V ? CannonMagicsV[s]
+                  : R == RIDER_LAME_DABBABA ? LameDabbabaMagics[s]
+                  : R == RIDER_HORSE ? HorseMagics[s]
+                  : R == RIDER_ELEPHANT ? ElephantMagics[s]
+                  : R == RIDER_JANGGI_ELEPHANT ? JanggiElephantMagics[s]
+                  : R == RIDER_CANNON_DIAG ? CannonDiagMagics[s]
+                  : R == RIDER_NIGHTRIDER ? NightriderMagics[s]
+                  : R == RIDER_GRASSHOPPER_H ? GrasshopperMagicsH[s]
+                  : R == RIDER_GRASSHOPPER_V ? GrasshopperMagicsV[s]
+                  : R == RIDER_GRASSHOPPER_D ? GrasshopperMagicsD[s]
+                  : BishopMagics[s];
+  return m.attacks[m.index(occupied)];
+}
+
+inline Square lsb(Bitboard b);
+
+inline Bitboard rider_attacks_bb(RiderType R, Square s, Bitboard occupied) {
+
+  assert(R != NO_RIDER && !(R & (R - 1))); // exactly one bit
+  const Magic& m = magics[lsb(R)][s]; // re-use Bitboard lsb for riders
+  return m.attacks[m.index(occupied)];
+}
+
+
+/// attacks_bb(Square) returns the pseudo attacks of the give piece type
+/// assuming an empty board.
+
+template<PieceType Pt>
+inline Bitboard attacks_bb(Square s) {
+
+  assert((Pt != PAWN) && (is_ok(s)));
+
+  return PseudoAttacks[WHITE][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<PieceType Pt>
+inline Bitboard attacks_bb(Square s, Bitboard occupied) {
+
+  assert((Pt != PAWN) && (is_ok(s)));
+
+  switch (Pt)
+  {
+  case BISHOP: return rider_attacks_bb<RIDER_BISHOP>(s, occupied);
+  case ROOK  : return rider_attacks_bb<RIDER_ROOK_H>(s, occupied) | rider_attacks_bb<RIDER_ROOK_V>(s, occupied);
+  case QUEEN : return attacks_bb<BISHOP>(s, occupied) | attacks_bb<ROOK>(s, occupied);
+  default    : return PseudoAttacks[WHITE][Pt][s];
+  }
+}
+
+/// pop_rider() finds and clears a rider in a (hybrid) rider type
+
+inline RiderType pop_rider(RiderType* r) {
+  assert(*r);
+  const RiderType r2 = *r & ~(*r - 1);
+  *r &= *r - 1;
+  return r2;
+}
+
+inline Bitboard attacks_bb(Color c, PieceType pt, Square s, Bitboard occupied) {
+  Bitboard b = LeaperAttacks[c][pt][s];
+  RiderType r = AttackRiderTypes[pt];
+  while (r)
+      b |= rider_attacks_bb(pop_rider(&r), s, occupied);
+  return b & PseudoAttacks[c][pt][s];
+}
+
+
+template <bool Initial=false>
+inline Bitboard moves_bb(Color c, PieceType pt, Square s, Bitboard occupied) {
+  Bitboard b = LeaperMoves[Initial][c][pt][s];
+  RiderType r = MoveRiderTypes[Initial][pt];
+  while (r)
+      b |= rider_attacks_bb(pop_rider(&r), s, occupied);
+  return b & PseudoMoves[Initial][c][pt][s];
+}
+
+
+/// popcount() counts the number of non-zero bits in a bitboard
+
+inline int popcount(Bitboard b) {
+
+#ifndef USE_POPCNT
+
+#ifdef LARGEBOARDS
+  union { Bitboard bb; uint16_t u[8]; } v = { b };
+  return  PopCnt16[v.u[0]] + PopCnt16[v.u[1]] + PopCnt16[v.u[2]] + PopCnt16[v.u[3]]
+        + PopCnt16[v.u[4]] + PopCnt16[v.u[5]] + PopCnt16[v.u[6]] + PopCnt16[v.u[7]];
+#else
+  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]];
+#endif
+
+#elif defined(_MSC_VER) || defined(__INTEL_COMPILER)
+
+#ifdef LARGEBOARDS
+  return (int)_mm_popcnt_u64(uint64_t(b >> 64)) + (int)_mm_popcnt_u64(uint64_t(b));
+#else
+  return (int)_mm_popcnt_u64(b);
+#endif
+
+#else // Assumed gcc or compatible compiler
+
+#ifdef LARGEBOARDS
+  return __builtin_popcountll(b >> 64) + __builtin_popcountll(b);
+#else
+  return __builtin_popcountll(b);
+#endif
+
+#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);
+#ifdef LARGEBOARDS
+  if (!(b << 64))
+      return Square(__builtin_ctzll(b >> 64) + 64);
+#endif
+  return Square(__builtin_ctzll(b));
+}
+
+inline Square msb(Bitboard b) {
+  assert(b);
+#ifdef LARGEBOARDS
+  if (b >> 64)
+      return Square(int(SQUARE_BIT_MASK) ^ __builtin_clzll(b >> 64));
+  return Square(int(SQUARE_BIT_MASK) ^ (__builtin_clzll(b) + 64));
+#else
+  return Square(int(SQUARE_BIT_MASK) ^ __builtin_clzll(b));
+#endif
+}
+
+#elif defined(_MSC_VER)  // MSVC
+
+#ifdef _WIN64  // MSVC, WIN64
+
+inline Square lsb(Bitboard b) {
+  assert(b);
+  unsigned long idx;
+#ifdef LARGEBOARDS
+  if (uint64_t(b))
+  {
+      _BitScanForward64(&idx, uint64_t(b));
+      return Square(idx);
+  }
+  else
+  {
+      _BitScanForward64(&idx, uint64_t(b >> 64));
+      return Square(idx + 64);
+  }
+#else
+  _BitScanForward64(&idx, b);
+  return (Square) idx;
+#endif
+}
+
+inline Square msb(Bitboard b) {
+  assert(b);
+  unsigned long idx;
+#ifdef LARGEBOARDS
+  if (b >> 64)
+  {
+      _BitScanReverse64(&idx, uint64_t(b >> 64));
+      return Square(idx + 64);
+  }
+  else
+  {
+      _BitScanReverse64(&idx, uint64_t(b));
+      return Square(idx);
+  }
+#else
+  _BitScanReverse64(&idx, b);
+  return (Square) idx;
+#endif
+}
+
+#else  // MSVC, WIN32
+
+inline Square lsb(Bitboard b) {
+  assert(b);
+  unsigned long idx;
+
+#ifdef LARGEBOARDS
+  if (b << 96) {
+      _BitScanForward(&idx, uint32_t(b));
+      return Square(idx);
+  } else if (b << 64) {
+      _BitScanForward(&idx, uint32_t(b >> 32));
+      return Square(idx + 32);
+  } else if (b << 32) {
+      _BitScanForward(&idx, uint32_t(b >> 64));
+      return Square(idx + 64);
+  } else {
+      _BitScanForward(&idx, uint32_t(b >> 96));
+      return Square(idx + 96);
+  }
+#else
+  if (b & 0xffffffff) {
+      _BitScanForward(&idx, uint32_t(b));
+      return Square(idx);
+  } else {
+      _BitScanForward(&idx, uint32_t(b >> 32));
+      return Square(idx + 32);
+  }
+#endif
+}
+
+inline Square msb(Bitboard b) {
+  assert(b);
+  unsigned long idx;
+
+#ifdef LARGEBOARDS
+  if (b >> 96) {
+      _BitScanReverse(&idx, uint32_t(b >> 96));
+      return Square(idx + 96);
+  } else if (b >> 64) {
+      _BitScanReverse(&idx, uint32_t(b >> 64));
+      return Square(idx + 64);
+  } else
+#endif
+  if (b >> 32) {
+      _BitScanReverse(&idx, uint32_t(b >> 32));
+      return Square(idx + 32);
+  } else {
+      _BitScanReverse(&idx, uint32_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);
+}
+
+
+/// popcount() counts the number of non-zero bits in a piece set
+
+inline int popcount(PieceSet ps) {
+
+#ifndef USE_POPCNT
+
+  union { uint64_t bb; uint16_t u[4]; } v = { (uint64_t)ps };
+  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(ps);
+
+#else // Assumed gcc or compatible compiler
+
+  return __builtin_popcountll(ps);
+
+#endif
+}
+
+/// lsb() and msb() return the least/most significant bit in a non-zero piece set
+
+#if defined(__GNUC__)  // GCC, Clang, ICC
+
+inline PieceType lsb(PieceSet ps) {
+  assert(ps);
+  return PieceType(__builtin_ctzll(ps));
+}
+
+inline PieceType msb(PieceSet ps) {
+  assert(ps);
+  return PieceType((PIECE_TYPE_NB - 1) ^ __builtin_clzll(ps));
+}
+
+#elif defined(_MSC_VER)  // MSVC
+
+#ifdef _WIN64  // MSVC, WIN64
+
+inline PieceType lsb(PieceSet ps) {
+  assert(ps);
+  unsigned long idx;
+  _BitScanForward64(&idx, ps);
+  return (PieceType) idx;
+}
+
+inline PieceType msb(PieceSet ps) {
+  assert(ps);
+  unsigned long idx;
+  _BitScanReverse64(&idx, ps);
+  return (PieceType) idx;
+}
+
+#else  // MSVC, WIN32
+
+inline PieceType lsb(PieceSet ps) {
+  assert(ps);
+  unsigned long idx;
+
+  if (ps & 0xffffffff) {
+      _BitScanForward(&idx, uint32_t(ps));
+      return PieceType(idx);
+  } else {
+      _BitScanForward(&idx, uint32_t(ps >> 32));
+      return PieceType(idx + 32);
+  }
+}
+
+inline PieceType msb(PieceSet ps) {
+  assert(ps);
+  unsigned long idx;
+  if (ps >> 32) {
+      _BitScanReverse(&idx, uint32_t(ps >> 32));
+      return PieceType(idx + 32);
+  } else {
+      _BitScanReverse(&idx, uint32_t(ps));
+      return PieceType(idx);
+  }
+}
+
+#endif
+
+#else  // Compiler is neither GCC nor MSVC compatible
+
+#error "Compiler not supported."
+
+#endif
+
+/// pop_lsb() and pop_msb() find and clear the least/most significant bit in a non-zero piece set
+
+inline PieceType pop_lsb(PieceSet& ps) {
+  assert(ps);
+  const PieceType pt = lsb(ps);
+  ps &= PieceSet(ps - 1);
+  return pt;
+}
+
+inline PieceType pop_msb(PieceSet& ps) {
+  assert(ps);
+  const PieceType pt = msb(ps);
+  ps &= ~piece_set(pt);
+  return pt;
+}
+
+} // namespace Stockfish
+
+#endif // #ifndef BITBOARD_H_INCLUDED

Fairy-Stockfish-master/src/endgame.cpp

@@ -0,0 +1,1321 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <cassert>
+
+#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, const Position& pos) {
+      int rd = edge_distance(rank_of(s), pos.max_rank()), fd = edge_distance(file_of(s), pos.max_file());
+      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, const Position& pos) {
+      return abs((pos.max_file() + pos.max_rank()) / 2 - rank_of(s) - file_of(s));
+  }
+
+  // Used to drive the king towards the edge of the board in KSF vs K.
+  inline int push_to_opposing_edge(Square s, const Position& pos) {
+      int rd = rank_of(s), fd = edge_distance(file_of(s), pos.max_file());
+      return 20 - (7 * fd * fd / 2 - 7 * rd * rd / 4);
+  }
+
+  // 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<PAWN>(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<PAWN>(strongSide) == 1);
+
+    if (file_of(pos.square<PAWN>(strongSide)) > pos.max_file() / 2)
+        sq = flip_file(sq, pos.max_file());
+
+    return strongSide == WHITE ? sq : flip_rank(sq, pos.max_rank());
+  }
+
+} // namespace
+
+
+namespace Endgames {
+
+  std::pair<Map<Value>, Map<ScaleFactor>> maps;
+
+  void init() {
+
+    add<KPK>("KPK");
+    add<KNNK>("KNNK");
+    add<KBNK>("KBNK");
+    add<KRKP>("KRKP");
+    add<KRKB>("KRKB");
+    add<KRKN>("KRKN");
+    add<KQKP>("KQKP");
+    add<KQKR>("KQKR");
+    add<KNNKP>("KNNKP");
+
+    // Fairy piece endgames
+    add<KNSK>("KNSK");
+    add<KNFK>("KNFK");
+    add<KNSFKR>("KNSFKR");
+    add<KSFK>("KSFK");
+    add<KSFKF>("KSFKF");
+    add<KRKS>("KRKS");
+    add<KCKR>("KCKR");
+    add<KAKR>("KAKR");
+
+    // Anti
+    add<RK, EG_EVAL_ANTI>("RvM");
+    add<KN, EG_EVAL_ANTI>("MvN");
+    add<NN, EG_EVAL_ANTI>("NvN");
+
+    // Atomic
+    add<KPK, EG_EVAL_ATOMIC>("MPvM");
+    add<KNK, EG_EVAL_ATOMIC>("MNvM");
+    add<KBK, EG_EVAL_ATOMIC>("MBvM");
+    add<KRK, EG_EVAL_ATOMIC>("MRvM");
+    add<KQK, EG_EVAL_ATOMIC>("MQvM");
+    add<KNNK, EG_EVAL_ATOMIC>("MNNvM");
+
+    // Duck
+    add<KBK, EG_EVAL_DUCK>("MBvM");
+    add<KNK, EG_EVAL_DUCK>("MNvM");
+    add<KPK, EG_EVAL_DUCK>("MPvM");
+
+    // Racing kings
+    add<KQK, EG_EVAL_RK>("KQK");
+    add<KRK, EG_EVAL_RK>("KRK");
+    add<KK, EG_EVAL_RK>("KK");
+
+    add<KRPKB>("KRPKB");
+    add<KBPKB>("KBPKB");
+    add<KBPKN>("KBPKN");
+    add<KBPPKB>("KBPPKB");
+    add<KRPPKRP>("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<KXK>::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<LEGAL>(pos).size())
+      return VALUE_DRAW;
+
+  Square strongKing = pos.square<KING>(strongSide);
+  Square weakKing   = pos.square<KING>(weakSide);
+
+  Value result =  pos.non_pawn_material(strongSide)
+                + pos.count<PAWN>(strongSide) * PawnValueEg
+                + push_to_edge(weakKing, pos)
+                + push_close(strongKing, weakKing);
+
+  if (   pos.count<QUEEN>(strongSide)
+      || pos.count<ROOK>(strongSide)
+      ||(pos.count<BISHOP>(strongSide) && pos.count<KNIGHT>(strongSide))
+      || (   (pos.pieces(strongSide, BISHOP) & ~DarkSquares)
+          && (pos.pieces(strongSide, BISHOP) &  DarkSquares))
+      || pos.count<SILVER>(strongSide) >= 2
+      ||(pos.count<SILVER>(strongSide) && pos.count<KNIGHT>(strongSide))
+      ||(pos.count<SILVER>(strongSide) && pos.count<FERS>(strongSide))
+      ||(pos.count<KNIGHT>(strongSide) && pos.count<FERS>(strongSide) >= 2)
+      ||(pos.count<FERS>(strongSide) >= 3
+          && ( DarkSquares & pos.pieces(strongSide, FERS))
+          && (~DarkSquares & pos.pieces(strongSide, FERS))))
+      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<KBNK>::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<KING>(strongSide);
+  Square strongBishop = pos.square<BISHOP>(strongSide);
+  Square weakKing     = pos.square<KING>(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, pos.max_file()) : weakKing, pos);
+
+  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<KPK>::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<KING>(strongSide));
+  Square strongPawn = normalize(pos, strongSide, pos.square<PAWN>(strongSide));
+  Square weakKing   = normalize(pos, strongSide, pos.square<KING>(weakSide));
+
+  Color us = strongSide == pos.side_to_move() ? WHITE : BLACK;
+
+  // Non-standard promotion, evaluation unclear
+  if (   pos.promotion_zone(us) != rank_bb(relative_rank(us, RANK_8, pos.max_rank()))
+      || RANK_MAX != RANK_8
+      || !(pos.promotion_piece_types(us) & QUEEN))
+  {
+      Value result = PawnValueEg + Value(rank_of(strongPawn));
+      return strongSide == pos.side_to_move() ? result : -result;
+  }
+
+  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<KRKP>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, RookValueMg, 0));
+  assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
+
+  Square strongKing = pos.square<KING>(strongSide);
+  Square weakKing   = pos.square<KING>(weakSide);
+  Square strongRook = pos.square<ROOK>(strongSide);
+  Square weakPawn   = pos.square<PAWN>(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<KRKB>::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<KING>(weakSide), pos));
+  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<KRKN>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, RookValueMg, 0));
+  assert(verify_material(pos, weakSide, KnightValueMg, 0));
+
+  Square weakKing   = pos.square<KING>(weakSide);
+  Square weakKnight = pos.square<KNIGHT>(weakSide);
+  Value result = Value(push_to_edge(weakKing, pos) + 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<KQKP>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, QueenValueMg, 0));
+  assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
+
+  Square strongKing = pos.square<KING>(strongSide);
+  Square weakKing   = pos.square<KING>(weakSide);
+  Square weakPawn   = pos.square<PAWN>(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<KQKR>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, QueenValueMg, 0));
+  assert(verify_material(pos, weakSide, RookValueMg, 0));
+
+  Square strongKing = pos.square<KING>(strongSide);
+  Square weakKing   = pos.square<KING>(weakSide);
+
+  Value result =  QueenValueEg
+                - RookValueEg
+                + push_to_edge(weakKing, pos)
+                + push_close(strongKing, weakKing);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KC vs KR. Drawish, but good winning chances if king and rook are close.
+template<>
+Value Endgame<KCKR>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, ChancellorValueMg, 0));
+  assert(verify_material(pos, weakSide, RookValueMg, 0));
+
+  Square strongKing = pos.square<KING>(strongSide);
+  Square weakKing = pos.square<KING>(weakSide);
+  Square weakRook = pos.square<ROOK>(weakSide);
+
+  Value result =  Value(push_to_edge(weakKing, pos))
+                + push_close(strongKing, weakKing)
+                + push_close(weakRook, weakKing);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KA vs KR. Very drawish.
+template<>
+Value Endgame<KAKR>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, ArchbishopValueMg, 0));
+  assert(verify_material(pos, weakSide, RookValueMg, 0));
+
+  Square strongKing = pos.square<KING>(strongSide);
+  Square weakKing = pos.square<KING>(weakSide);
+
+  Value result =  Value(push_to_edge(weakKing, pos))
+                + 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<KNNKP>::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<KING>(weakSide);
+  Square weakPawn = pos.square<PAWN>(weakSide);
+
+  Value result =      PawnValueEg
+               +  2 * push_to_edge(weakKing, pos)
+               - 10 * relative_rank(weakSide, weakPawn);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// Some cases of trivial draws
+template<> Value Endgame<KNNK>::operator()(const Position&) const { return VALUE_DRAW; }
+
+
+/// KFsPs vs K.
+template<>
+Value Endgame<KFsPsK>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
+
+  Square winnerKSq = pos.square<KING>(strongSide);
+  Square loserKSq = pos.square<KING>(weakSide);
+
+  Value result =  pos.non_pawn_material(strongSide)
+                + pos.count<PAWN>(strongSide) * PawnValueEg
+                + push_to_edge(loserKSq, pos)
+                + push_close(winnerKSq, loserKSq);
+
+  if (   pos.count<FERS>(strongSide) >= 3
+      && ( DarkSquares & pos.pieces(strongSide, FERS))
+      && (~DarkSquares & pos.pieces(strongSide, FERS)))
+      result = std::min(result + VALUE_KNOWN_WIN, VALUE_TB_WIN_IN_MAX_PLY - 1);
+  else if (pos.count<FERS>(strongSide) + pos.count<PAWN>(strongSide) < 3)
+      return VALUE_DRAW;
+  else
+  {
+      bool dark  =  DarkSquares & pos.pieces(strongSide, FERS);
+      bool light = ~DarkSquares & pos.pieces(strongSide, FERS);
+
+      // Determine the color of ferzes from promoting pawns
+      Bitboard b = pos.pieces(strongSide, PAWN);
+      while (b && (!dark || !light))
+      {
+          Square s = pos.promotion_square(strongSide, pop_lsb(b));
+          if (s != SQ_NONE)
+          {
+              if (DarkSquares & s)
+                  dark = true;
+              else
+                  light = true;
+          }
+      }
+      if (!dark || !light)
+          return VALUE_DRAW; // we can not checkmate with same colored ferzes
+  }
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// Mate with KNS vs K.
+template<>
+Value Endgame<KNSK>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, KnightValueMg + SilverValueMg, 0));
+  assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
+
+  Square winnerKSq = pos.square<KING>(strongSide);
+  Square loserKSq = pos.square<KING>(weakSide);
+
+  Value result =  VALUE_KNOWN_WIN
+                + push_close(winnerKSq, loserKSq)
+                + push_to_opposing_edge(relative_square(strongSide, loserKSq, pos.max_rank()), pos);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KNF vs K. Can only be won if the weaker side's king
+/// is close to a corner of the same color as the fers.
+template<>
+Value Endgame<KNFK>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, KnightValueMg + FersValueMg, 0));
+  assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
+
+  Square winnerKSq = pos.square<KING>(strongSide);
+  Square loserKSq = pos.square<KING>(weakSide);
+  Square fersSq = pos.square<FERS>(strongSide);
+
+  // tries to drive toward corners A1 or H8. If we have a
+  // fers that cannot reach the above squares, we flip the kings in order
+  // to drive the enemy toward corners A8 or H1.
+  if (opposite_colors(fersSq, SQ_A1))
+  {
+      winnerKSq = relative_square(BLACK, winnerKSq, pos.max_rank());
+      loserKSq  = relative_square(BLACK, loserKSq, pos.max_rank());
+  }
+
+  Value result =  Value(push_close(winnerKSq, loserKSq))
+                + 50 * push_to_corner(loserKSq, pos);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KNSFKR vs K.
+template<>
+Value Endgame<KNSFKR>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, KnightValueMg + SilverValueMg + FersValueMg, 0));
+  assert(verify_material(pos, weakSide, RookValueMg, 0));
+
+  Square winnerKSq = pos.square<KING>(strongSide);
+  Square loserKSq = pos.square<KING>(weakSide);
+
+  Value result =  KnightValueEg + SilverValueEg + FersValueEg - RookValueEg
+                + push_close(winnerKSq, loserKSq)
+                + push_to_opposing_edge(relative_square(strongSide, loserKSq, pos.max_rank()), pos);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// Mate with KSF vs K.
+template<>
+Value Endgame<KSFK>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, SilverValueMg + FersValueMg, 0));
+  assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
+
+  Square winnerKSq = pos.square<KING>(strongSide);
+  Square loserKSq = pos.square<KING>(weakSide);
+
+  Value result =  VALUE_KNOWN_WIN
+                + push_close(winnerKSq, loserKSq)
+                + push_to_opposing_edge(relative_square(strongSide, loserKSq, pos.max_rank()), pos);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// Mate with KSF vs KF.
+template<>
+Value Endgame<KSFKF>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, SilverValueMg + FersValueMg, 0));
+  assert(verify_material(pos, weakSide, FersValueMg, 0));
+
+  Square winnerKSq = pos.square<KING>(strongSide);
+  Square loserKSq = pos.square<KING>(weakSide);
+  Square fersSq = pos.square<FERS>(weakSide);
+
+  Value result =  SilverValueEg
+                + push_close(winnerKSq, loserKSq)
+                + push_away(fersSq, loserKSq)
+                + push_to_opposing_edge(relative_square(strongSide, loserKSq, pos.max_rank()), pos);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// KR vs KS
+template<>
+Value Endgame<KRKS>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, RookValueMg, 0));
+  assert(verify_material(pos, weakSide, SilverValueMg, 0));
+
+  Square winnerKSq = pos.square<KING>(strongSide);
+  Square loserKSq = pos.square<KING>(weakSide);
+
+  Value result =  RookValueEg
+                - SilverValueEg
+                + push_to_edge(loserKSq, pos)
+                + push_close(winnerKSq, loserKSq);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// 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<KBPsK>::operator()(const Position& pos) const {
+
+  assert(pos.non_pawn_material(strongSide) == BishopValueMg);
+  assert(pos.count<PAWN>(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<BISHOP>(strongSide);
+  Square weakKing = pos.square<KING>(weakSide);
+  Square strongKing = pos.square<KING>(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<PAWN>(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<KQKRPs>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, QueenValueMg, 0));
+  assert(pos.count<ROOK>(weakSide) == 1);
+  assert(pos.count<PAWN>(weakSide) >= 1);
+
+  Square strongKing = pos.square<KING>(strongSide);
+  Square weakKing   = pos.square<KING>(weakSide);
+  Square weakRook   = pos.square<ROOK>(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<KING>(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<KRPKR>::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<KING>(strongSide));
+  Square strongRook = normalize(pos, strongSide, pos.square<ROOK>(strongSide));
+  Square strongPawn = normalize(pos, strongSide, pos.square<PAWN>(strongSide));
+  Square weakKing = normalize(pos, strongSide, pos.square<KING>(weakSide));
+  Square weakRook = normalize(pos, strongSide, pos.square<ROOK>(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<File>(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<File>(weakKing, strongPawn) == 1
+          && distance(strongKing, weakKing) > 2)
+          return ScaleFactor(24 - 2 * distance(strongKing, weakKing));
+  }
+  return SCALE_FACTOR_NONE;
+}
+
+template<>
+ScaleFactor Endgame<KRPKB>::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<KING>(weakSide);
+      Square weakBishop = pos.square<BISHOP>(weakSide);
+      Square strongKing = pos.square<KING>(strongSide);
+      Square strongPawn = pos.square<PAWN>(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<BISHOP>(weakBishop) & (strongPawn + push))
+          && distance<File>(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<KRPPKRP>::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<KING>(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<File>(weakKing, strongPawn1) <= 1
+      && distance<File>(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<KPsK>::operator()(const Position& pos) const {
+
+  assert(pos.non_pawn_material(strongSide) == VALUE_ZERO);
+  assert(pos.count<PAWN>(strongSide) >= 2);
+  assert(verify_material(pos, weakSide, VALUE_ZERO, 0));
+
+  Square weakKing = pos.square<KING>(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<KBPKB>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, BishopValueMg, 1));
+  assert(verify_material(pos, weakSide,   BishopValueMg, 0));
+
+  Square strongPawn = pos.square<PAWN>(strongSide);
+  Square strongBishop = pos.square<BISHOP>(strongSide);
+  Square weakBishop = pos.square<BISHOP>(weakSide);
+  Square weakKing = pos.square<KING>(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<KBPPKB>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, BishopValueMg, 2));
+  assert(verify_material(pos, weakSide,   BishopValueMg, 0));
+
+  Square strongBishop = pos.square<BISHOP>(strongSide);
+  Square weakBishop   = pos.square<BISHOP>(weakSide);
+
+  if (!opposite_colors(strongBishop, weakBishop))
+      return SCALE_FACTOR_NONE;
+
+  Square weakKing = pos.square<KING>(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<File>(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<BISHOP>(blockSq2, pos.pieces()) & pos.pieces(weakSide, BISHOP))
+            || distance<Rank>(strongPawn1, strongPawn2) >= 2))
+        return SCALE_FACTOR_DRAW;
+
+    else if (   weakKing == blockSq2
+             && opposite_colors(weakKing, strongBishop)
+             && (   weakBishop == blockSq1
+                 || (attacks_bb<BISHOP>(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<KBPKN>::operator()(const Position& pos) const {
+
+  assert(verify_material(pos, strongSide, BishopValueMg, 1));
+  assert(verify_material(pos, weakSide, KnightValueMg, 0));
+
+  Square strongPawn = pos.square<PAWN>(strongSide);
+  Square strongBishop = pos.square<BISHOP>(strongSide);
+  Square weakKing = pos.square<KING>(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<KPKP>::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<KING>(strongSide));
+  Square weakKing   = normalize(pos, strongSide, pos.square<KING>(weakSide));
+  Square strongPawn = normalize(pos, strongSide, pos.square<PAWN>(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.
+  if (   pos.promotion_zone(us) != rank_bb(relative_rank(us, RANK_8, pos.max_rank()))
+      || RANK_MAX != RANK_8
+      || !(pos.promotion_piece_types(us) & QUEEN))
+      return SCALE_FACTOR_NONE;
+
+  return Bitbases::probe(strongKing, strongPawn, weakKing, us) ? SCALE_FACTOR_NONE : SCALE_FACTOR_DRAW;
+}
+
+
+/// Endgame evals for special variants
+/// R vs K. The rook side always wins if there is no immediate forced capture.
+template<>
+Value Endgame<RK, EG_EVAL_ANTI>::operator()(const Position& pos) const {
+
+  assert(pos.endgame_eval() == EG_EVAL_ANTI);
+
+  Square RSq = pos.square<ROOK>(strongSide);
+  Square KSq = pos.square<COMMONER>(weakSide);
+
+  Value result = Value(push_to_edge(KSq, pos)) + push_close(RSq, KSq);
+
+  int dist_min = std::min(distance<Rank>(RSq, KSq), distance<File>(RSq, KSq));
+  int dist_max = std::max(distance<Rank>(RSq, KSq), distance<File>(RSq, KSq));
+
+  if (dist_min == 0)
+      result += strongSide == pos.side_to_move() || dist_max > 1 ? -VALUE_KNOWN_WIN : VALUE_KNOWN_WIN;
+  else if (dist_min == 1)
+      result += weakSide == pos.side_to_move() && dist_max > 1 ? -VALUE_KNOWN_WIN : VALUE_KNOWN_WIN;
+  else
+      result += VALUE_KNOWN_WIN;
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// K vs N. The king usually wins, but there are a few exceptions.
+template<>
+Value Endgame<KN, EG_EVAL_ANTI>::operator()(const Position& pos) const {
+
+  assert(pos.endgame_eval() == EG_EVAL_ANTI);
+
+  Square KSq = pos.square<COMMONER>(strongSide);
+  Square NSq = pos.square<KNIGHT>(weakSide);
+  Bitboard kingAttacks = attacks_bb<KING>(KSq) & pos.board_bb();
+  Bitboard knightAttacks = attacks_bb<KNIGHT>(NSq) & pos.board_bb();
+  bool strongSideToMove = pos.side_to_move() == strongSide;
+
+  // Loss in 1 play
+  if (strongSideToMove ? kingAttacks & NSq : knightAttacks & KSq)
+      return VALUE_TB_LOSS_IN_MAX_PLY + 1;
+  // Win in 2 ply
+  if (kingAttacks & knightAttacks)
+      return VALUE_TB_WIN_IN_MAX_PLY - 2;
+  // Loss in 3 ply
+  if (strongSideToMove ? knightAttacks & KSq : kingAttacks & NSq)
+      return VALUE_TB_LOSS_IN_MAX_PLY + 3;
+
+  Value result = Value(push_to_edge(NSq, pos)) - push_to_edge(KSq, pos);
+  // The king usually wins, but scenarios with king on the edge are more complicated
+  if (!(KSq & (FileABB | FileHBB | Rank1BB | Rank8BB)))
+      result += VALUE_KNOWN_WIN;
+
+  return strongSideToMove ? result : -result;
+}
+
+/// N vs N. The side to move always wins/loses if the knights are on
+/// same/opposite colored squares.
+template<>
+Value Endgame<NN, EG_EVAL_ANTI>::operator()(const Position& pos) const {
+
+  assert(pos.endgame_eval() == EG_EVAL_ANTI);
+
+  Square N1Sq = pos.square<KNIGHT>(pos.side_to_move());
+  Square N2Sq = pos.square<KNIGHT>(~pos.side_to_move());
+
+  Value result = VALUE_KNOWN_WIN + push_close(N1Sq, N2Sq);
+
+  return !opposite_colors(N1Sq, N2Sq) ? result : -result;
+}
+
+
+template<>
+Value Endgame<KXK, EG_EVAL_ATOMIC>::operator()(const Position& pos) const {
+
+  assert(pos.endgame_eval() == EG_EVAL_ATOMIC);
+
+  // Stalemate/checkmate detection with lone king
+  if (pos.side_to_move() == weakSide && !MoveList<LEGAL>(pos).size())
+      return std::min(pos.stalemate_value(), VALUE_MATE_IN_MAX_PLY - 1);
+
+  Square winnerKSq = pos.square<COMMONER>(strongSide);
+  Square loserKSq = pos.square<COMMONER>(weakSide);
+
+  Value result =  pos.non_pawn_material(strongSide)
+                + pos.count<PAWN>(strongSide) * PawnValueEg
+                + push_to_edge(loserKSq, pos)
+                + push_away(winnerKSq, loserKSq);
+
+  // We need at least a major and a minor, or three minors to force checkmate
+  if (  ((pos.count<QUEEN>(strongSide) || pos.count<ROOK>(strongSide)) && pos.count<ALL_PIECES>(strongSide) >= 3)
+      || (pos.count<BISHOP>(strongSide) + pos.count<KNIGHT>(strongSide) >= 3
+         && (pos.count<KNIGHT>(strongSide) >= 2 || ((pos.pieces(strongSide, BISHOP) & DarkSquares)
+                                                    && (pos.pieces(strongSide, BISHOP) & ~DarkSquares)))))
+      result = std::min(result + VALUE_KNOWN_WIN, VALUE_MATE_IN_MAX_PLY - 1);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+template<>
+Value Endgame<KPK, EG_EVAL_ATOMIC>::operator()(const Position& pos) const {
+
+  assert(pos.endgame_eval() == EG_EVAL_ATOMIC);
+
+  Square winnerKSq = pos.square<COMMONER>(strongSide);
+  Square loserKSq = pos.square<COMMONER>(weakSide);
+
+  int dist = distance(winnerKSq, loserKSq);
+  // Draw in case of adjacent kings
+  if (dist <= (strongSide == pos.side_to_move() ? 1 : 2))
+      return VALUE_DRAW;
+
+  Value result = PawnValueEg
+                + 20 * relative_rank(strongSide, pos.square<PAWN>(strongSide), pos.max_rank()) - 20
+                + push_away(winnerKSq, loserKSq);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+template<> Value Endgame<KNK, EG_EVAL_ATOMIC>::operator()(const Position&) const { return VALUE_DRAW; }
+
+template<> Value Endgame<KBK, EG_EVAL_ATOMIC>::operator()(const Position&) const { return VALUE_DRAW; }
+
+template<> Value Endgame<KRK, EG_EVAL_ATOMIC>::operator()(const Position&) const { return VALUE_DRAW; }
+
+template<>
+Value Endgame<KQK, EG_EVAL_ATOMIC>::operator()(const Position& pos) const {
+
+  assert(pos.endgame_eval() == EG_EVAL_ATOMIC);
+
+  // Stalemate/checkmate detection with lone king
+  if (pos.side_to_move() == weakSide && !MoveList<LEGAL>(pos).size())
+      return std::min(pos.stalemate_value(), VALUE_MATE_IN_MAX_PLY - 1);
+
+  Square winnerKSq = pos.square<COMMONER>(strongSide);
+  Square loserKSq = pos.square<COMMONER>(weakSide);
+
+  int dist = distance(winnerKSq, loserKSq);
+  // Draw in case of adjacent kings
+  if (dist ==  1)
+      return VALUE_DRAW;
+  // If the weaker side is to move and there is a way to connect kings, it is a draw
+  if (   pos.side_to_move() == weakSide
+      && (attacks_bb<KING>(winnerKSq) & attacks_bb<KING>(loserKSq) & ~pos.pieces()))
+      return VALUE_DRAW;
+
+  Value result =  Value(push_to_edge(loserKSq, pos))
+                + push_away(winnerKSq, loserKSq);
+
+  if (dist >= (strongSide == pos.side_to_move() ? 3 : 4))
+      result += VALUE_KNOWN_WIN;
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+template<> Value Endgame<KNNK, EG_EVAL_ATOMIC>::operator()(const Position&) const { return VALUE_DRAW; }
+
+
+/// Self-mate with KX vs KX.
+template<>
+Value Endgame<KXKX, EG_EVAL_MISERE>::operator()(const Position& pos) const {
+
+  assert(!pos.checkers()); // Eval is never called when in check
+
+  // Stalemate detection with lone king
+  if (pos.side_to_move() == weakSide && !MoveList<LEGAL>(pos).size())
+      return VALUE_DRAW;
+
+  Square strongKing = pos.square<KING>(strongSide);
+  Square weakKing   = pos.square<KING>(weakSide);
+
+  Value result =  pos.non_pawn_material(strongSide) * int(VALUE_KNOWN_WIN) / int(VALUE_KNOWN_WIN + pos.non_pawn_material(strongSide))
+                - pos.non_pawn_material(weakSide)
+                + pos.count<PAWN>(weakSide) * PawnValueEg
+                + push_to_opposing_edge(relative_square(weakSide, strongKing, pos.max_rank()), pos) * 2
+                + push_close(strongKing, weakKing) * 2;
+
+  for (Bitboard b = pos.pieces(PAWN); b;)
+  {
+      Square s = pop_lsb(b);
+      result += (push_close(strongKing, s) + push_close(weakKing, s)) / 2;
+  }
+
+  if (!pos.count<PAWN>(weakSide))
+      result = VALUE_DRAW;
+  else if (pos.count<PAWN>(weakSide) == 1)
+      result = result / 2;
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// 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<KXK, EG_EVAL_DUCK>::operator()(const Position& pos) const {
+
+  Square strongKing = pos.square<COMMONER>(strongSide);
+  Square weakKing   = pos.square<COMMONER>(weakSide);
+
+  Value result =  pos.non_pawn_material(strongSide)
+                + pos.count<PAWN>(strongSide) * PawnValueEg
+                + push_to_edge(weakKing, pos)
+                + push_close(strongKing, weakKing);
+
+  result = std::min(result + VALUE_KNOWN_WIN, VALUE_TB_WIN_IN_MAX_PLY - 1);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// Drawish, but king should stay away from the edge
+template<>
+Value Endgame<KNK, EG_EVAL_DUCK>::operator()(const Position& pos) const {
+
+  Square strongKing = pos.square<COMMONER>(strongSide);
+  Square weakKing   = pos.square<COMMONER>(weakSide);
+
+  Value result =  Value(push_to_edge(weakKing, pos))
+                + push_close(strongKing, weakKing);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// Drawish, but king should stay away from the edge
+template<>
+Value Endgame<KBK, EG_EVAL_DUCK>::operator()(const Position& pos) const {
+
+  Square strongKing = pos.square<COMMONER>(strongSide);
+  Square weakKing   = pos.square<COMMONER>(weakSide);
+
+  Value result =  Value(push_to_edge(weakKing, pos))
+                + push_close(strongKing, weakKing);
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+
+/// Winning as long as pawn is safe
+template<>
+Value Endgame<KPK, EG_EVAL_DUCK>::operator()(const Position& pos) const {
+
+  Square strongKing = pos.square<COMMONER>(strongSide);
+  Square weakKing   = pos.square<COMMONER>(weakSide);
+  Square strongPawn = pos.square<PAWN>(strongSide);
+
+  Value result =  PawnValueEg + 50 * relative_rank(strongSide, strongPawn, pos.max_rank())
+                + push_to_edge(weakKing, pos)
+                + push_close(strongKing, weakKing)
+                + push_close(strongKing, strongPawn) / 2
+                + push_away(weakKing, strongPawn) / 2;
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+/// Winning as long as last rank can be blocked
+template<>
+Value Endgame<KQK, EG_EVAL_RK>::operator()(const Position& pos) const {
+
+  Square strongKing  = pos.square<KING>(strongSide);
+  Square weakKing    = pos.square<KING>(weakSide);
+  Square strongQueen = pos.square<QUEEN>(strongSide);
+
+  Value result;
+
+  if (   rank_of(weakKing) < rank_of(strongQueen)
+      || rank_of(weakKing) + (weakSide == pos.side_to_move()) < RANK_7
+      || (Rank8BB & attacks_bb<QUEEN>(strongQueen, pos.pieces()) & ~(attacks_bb<QUEEN>(weakKing) | attacks_bb<SHOGI_KNIGHT>(weakKing))))
+      result = VALUE_KNOWN_WIN + 100 * rank_of(strongKing);
+  else
+      result = -VALUE_KNOWN_WIN;
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+/// Winning as long as last rank can be blocked
+template<>
+Value Endgame<KRK, EG_EVAL_RK>::operator()(const Position& pos) const {
+
+  Square strongKing = pos.square<KING>(strongSide);
+  Square weakKing   = pos.square<KING>(weakSide);
+  Square strongRook = pos.square<ROOK>(strongSide);
+
+  Value result;
+
+  if (   rank_of(weakKing) < rank_of(strongRook)
+      || rank_of(weakKing) + (weakSide == pos.side_to_move()) < RANK_7
+      || (Rank8BB & attacks_bb<ROOK>(strongRook, pos.pieces()) & ~(attacks_bb<QUEEN>(weakKing) | attacks_bb<SHOGI_KNIGHT>(weakKing))))
+      result = VALUE_KNOWN_WIN + 100 * rank_of(strongKing);
+  else
+      result = -VALUE_KNOWN_WIN;
+
+  return strongSide == pos.side_to_move() ? result : -result;
+}
+
+/// KvK. Pure race
+template<>
+Value Endgame<KK, EG_EVAL_RK>::operator()(const Position& pos) const {
+
+  Square whiteKing = pos.square<KING>(WHITE);
+  Square blackKing = pos.square<KING>(BLACK);
+
+  Value result = (VALUE_KNOWN_WIN + 100 * std::max(rank_of(whiteKing), rank_of(blackKing)))
+                * std::clamp(rank_of(whiteKing) - rank_of(blackKing) - (pos.side_to_move() == BLACK), -1, 1);
+
+  return pos.side_to_move() == WHITE ? result : -result;
+}
+
+} // namespace Stockfish

Fairy-Stockfish-master/src/endgame.h

@@ -0,0 +1,148 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef ENDGAME_H_INCLUDED
+#define ENDGAME_H_INCLUDED
+
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+
+#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
+
+  // Fairy piece endgames
+  KFsPsK, // KFsPsK vs K
+  KNSK,  // KNS vs K
+  KNFK,  // KNF vs K
+  KNSFKR,  // KNSFKR vs K
+  KSFK,  // KSF vs K
+  KSFKF,  // KSF vs KF
+  KRKS,  // KR vs KS
+  KCKR,  // KC vs KR
+  KAKR,  // KA vs KR
+
+  // Special
+  KXKX,
+  RK,
+  KN,
+  NN,
+  KQK,
+  KRK,
+  KBK,
+  KNK,
+  KK,
+
+  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<EndgameCode E, EndgameEval V = EG_EVAL_CHESS> using
+eg_type = typename std::conditional<(E < SCALING_FUNCTIONS), Value, ScaleFactor>::type;
+
+
+/// Base and derived functors for endgame evaluation and scaling functions
+
+template<typename T>
+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<EndgameCode E, EndgameEval V = EG_EVAL_CHESS, typename T = eg_type<E, V>>
+struct Endgame : public EndgameBase<T> {
+
+  explicit Endgame(Color c) : EndgameBase<T>(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<typename T> using Ptr = std::unique_ptr<EndgameBase<T>>;
+  template<typename T> using Map = std::unordered_map<Key, Ptr<T>>;
+
+  extern std::pair<Map<Value>, Map<ScaleFactor>> maps;
+
+  void init();
+
+  template<typename T>
+  Map<T>& map() {
+    return std::get<std::is_same<T, ScaleFactor>::value>(maps);
+  }
+
+  template<EndgameCode E, EndgameEval V = EG_EVAL_CHESS, typename T = eg_type<E, V>>
+  void add(const std::string& code) {
+
+    StateInfo st;
+    map<T>()[Position().set(code, WHITE, &st).material_key(V)] = Ptr<T>(new Endgame<E, V>(WHITE));
+    map<T>()[Position().set(code, BLACK, &st).material_key(V)] = Ptr<T>(new Endgame<E, V>(BLACK));
+  }
+
+  template<typename T>
+  const EndgameBase<T>* probe(Key key) {
+    auto it = map<T>().find(key);
+    return it != map<T>().end() ? it->second.get() : nullptr;
+  }
+}
+
+} // namespace Stockfish
+
+#endif // #ifndef ENDGAME_H_INCLUDED

Fairy-Stockfish-master/src/evaluate.cpp

@@ -0,0 +1,1736 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <algorithm>
+#include <cassert>
+#include <cstdlib>
+#include <cstring>   // For std::memset
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <iostream>
+#include <streambuf>
+#include <vector>
+
+#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};
+  [[maybe_unused]]
+  const unsigned char *const gEmbeddedNNUEEnd = &gEmbeddedNNUEData[1];
+  const unsigned int         gEmbeddedNNUESize = 1;
+#endif
+
+
+using namespace std;
+
+namespace Stockfish {
+
+const Variant* currentNnueVariant;
+
+namespace Eval {
+
+  bool useNNUE;
+  string eval_file_loaded = "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"]);
+
+    // Restrict NNUE usage to corresponding variant
+    // Support multiple variant networks separated by semicolon(Windows)/colon(Unix)
+    stringstream ss(eval_file);
+    string variant = string(Options["UCI_Variant"]);
+    useNNUE = false;
+    while (getline(ss, eval_file, UCI::SepChar))
+    {
+        string basename = eval_file.substr(eval_file.find_last_of("\\/") + 1);
+        string nnueAlias = variants.find(variant)->second->nnueAlias;
+        if (basename.rfind(variant, 0) != string::npos || (!nnueAlias.empty() && basename.rfind(nnueAlias, 0) != string::npos))
+        {
+            useNNUE = true;
+            break;
+        }
+    }
+    if (!useNNUE)
+        return;
+
+    currentNnueVariant = variants.find(variant)->second;
+
+    #if defined(DEFAULT_NNUE_DIRECTORY)
+    #define stringify2(x) #x
+    #define stringify(x) stringify2(x)
+    vector<string> dirs = { "<internal>" , "" , CommandLine::binaryDirectory , stringify(DEFAULT_NNUE_DIRECTORY) };
+    #else
+    vector<string> dirs = { "<internal>" , "" , CommandLine::binaryDirectory };
+    #endif
+
+    for (string directory : dirs)
+        if (eval_file_loaded != eval_file)
+        {
+            if (directory != "<internal>")
+            {
+                ifstream stream(directory + eval_file, ios::binary);
+                if (load_eval(eval_file, stream))
+                    eval_file_loaded = eval_file;
+            }
+
+            if (directory == "<internal>" && eval_file == EvalFileDefaultName)
+            {
+                // C++ way to prepare a buffer for a memory stream
+                class MemoryBuffer : public basic_streambuf<char> {
+                    public: MemoryBuffer(char* p, size_t n) { setg(p, p, p + n); setp(p, p + n); }
+                };
+
+                MemoryBuffer buffer(const_cast<char*>(reinterpret_cast<const char*>(gEmbeddedNNUEData)),
+                                    size_t(gEmbeddedNNUESize));
+
+                istream stream(&buffer);
+                if (load_eval(eval_file, stream))
+                    eval_file_loaded = eval_file;
+            }
+        }
+  }
+
+  /// NNUE::verify() verifies that the last net used was loaded successfully
+  void NNUE::verify() {
+
+    string eval_file = string(Options["EvalFile"]);
+
+    if (useNNUE && eval_file.find(eval_file_loaded) == string::npos)
+    {
+        UCI::OptionsMap defaults;
+        UCI::init(defaults);
+
+        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/" + string(defaults["EvalFile"]);
+        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 (CurrentProtocol != XBOARD)
+    {
+        if (useNNUE)
+            sync_cout << "info string NNUE evaluation using " << eval_file_loaded << " enabled" << sync_endl;
+        else
+            sync_cout << "info string classical evaluation enabled" << sync_endl;
+    }
+  }
+}
+
+namespace Trace {
+
+  enum Tracing { NO_TRACE, TRACE };
+
+  enum Term { // The first PIECE_TYPE_NB entries are reserved for PieceType
+    MATERIAL = PIECE_TYPE_NB, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, VARIANT, WINNABLE, TOTAL, TERM_NB
+  };
+
+  Score scores[TERM_NB][COLOR_NB];
+
+  double to_cp(Value v) { return double(v) / PawnValueEg; }
+
+  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(1565);
+  constexpr Value LazyThreshold2    =  Value(1102);
+  constexpr Value SpaceThreshold    =  Value(11551);
+
+  // KingAttackWeights[PieceType] contains king attack weights by piece type
+  constexpr int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 81, 52, 44, 10, 40 };
+
+  // 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] = {
+      {}, {600, 600}, {803, 1292}, {639, 974}, {1087, 1878}, {759, 1132}, {600, 900}
+  };
+
+#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[][4 * RANK_NB] = {
+    { 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) }
+  };
+  constexpr Score MaxMobility  = S(150, 200);
+  constexpr Score DropMobility = S(10, 10);
+
+  // 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, 8), S(3, 8)
+  };
+
+  // KingProtector[knight/bishop] contains penalty for each distance unit to own king
+  constexpr Score KingProtector[] = { S(8, 9), S(6, 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(57, 38), S(31, 24) };
+
+  // PassedRank[Rank] contains a bonus according to the rank of a passed pawn
+  constexpr Score PassedRank[RANK_NB] = {
+    S(0, 0), S(7, 27), S(16, 32), S(17, 40), S(64, 71), S(170, 174), S(278, 262)
+  };
+
+  constexpr Score RookOnClosedFile = S(10, 5);
+  constexpr Score RookOnOpenFile[] = { S(19, 6), S(47, 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(5, 32), S(55, 41), S(77, 56), S(89, 119), S(79, 162)
+  };
+
+  constexpr Score ThreatByRook[PIECE_TYPE_NB] = {
+    S(0, 0), S(3, 44), S(37, 68), S(42, 60), S(0, 39), S(58, 43)
+  };
+
+  constexpr Value CorneredBishop = Value(50);
+
+  // Assorted bonuses and penalties
+  constexpr Score UncontestedOutpost  = S(  1, 10);
+  constexpr Score BishopOnKingRing    = S( 24,  0);
+  constexpr Score BishopXRayPawns     = S(  4,  5);
+  constexpr Score FlankAttacks        = S(  8,  0);
+  constexpr Score Hanging             = S( 69, 36);
+  constexpr Score KnightOnQueen       = S( 16, 11);
+  constexpr Score LongDiagonalBishop  = S( 45,  0);
+  constexpr Score MinorBehindPawn     = S( 18,  3);
+  constexpr Score PassedFile          = S( 11,  8);
+  constexpr Score PawnlessFlank       = S( 17, 95);
+  constexpr Score ReachableOutpost    = S( 31, 22);
+  constexpr Score RestrictedPiece     = S(  7,  7);
+  constexpr Score RookOnKingRing      = S( 16,  0);
+  constexpr Score SliderOnQueen       = S( 60, 18);
+  constexpr Score ThreatByKing        = S( 24, 89);
+  constexpr Score ThreatByPawnPush    = S( 48, 39);
+  constexpr Score ThreatBySafePawn    = S(173, 94);
+  constexpr Score TrappedRook         = S( 55, 13);
+  constexpr Score WeakQueenProtection = S( 14,  0);
+  constexpr Score WeakQueen           = S( 56, 15);
+
+
+  // Variant and fairy piece bonuses
+  constexpr Score KingProximity        = S(2, 6);
+  constexpr Score EndgameKingProximity = S(0, 10);
+  constexpr Score ConnectedSoldier     = S(20, 20);
+
+  constexpr int VirtualCheck = 600;
+
+#undef S
+
+  // Evaluation class computes and stores attacks tables and other working data
+  template<Tracing T>
+  class Evaluation {
+
+  public:
+    Evaluation() = delete;
+    explicit Evaluation(const Position& p) : pos(p) {}
+    Evaluation& operator=(const Evaluation&) = delete;
+    Value value();
+
+  private:
+    template<Color Us> void initialize();
+    template<Color Us> Score pieces(PieceType Pt);
+    template<Color Us> Score hand(PieceType pt);
+    template<Color Us> Score king() const;
+    template<Color Us> Score threats() const;
+    template<Color Us> Score passed() const;
+    template<Color Us> Score space() const;
+    template<Color Us> Score variant() 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];
+    int kingAttackersCountInHand[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];
+    int kingAttackersWeightInHand[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<Tracing T> template<Color Us>
+  void Evaluation<T>::initialize() {
+
+    constexpr Color     Them = ~Us;
+    constexpr Direction Up   = pawn_push(Us);
+    constexpr Direction Down = -Up;
+    Bitboard LowRanks = rank_bb(relative_rank(Us, RANK_2, pos.max_rank())) | rank_bb(relative_rank(Us, RANK_3, pos.max_rank()));
+
+    const Square ksq = pos.count<KING>(Us) ? pos.square<KING>(Us) : SQ_NONE;
+
+    Bitboard dblAttackByPawn = pawn_double_attacks_bb<Us>(pos.pieces(Us, PAWN));
+
+    // Find our pawns that are blocked or on the first two ranks
+    Bitboard b = pos.pieces(Us, PAWN) & (shift<Down>(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.
+    if (pos.must_capture())
+        mobilityArea[Us] = AllSquares;
+    else
+        mobilityArea[Us] = ~(b | pos.pieces(Us, KING, QUEEN) | pos.blockers_for_king(Us) | pe->pawn_attacks(Them)
+                               | (pos.pieces(Us, SHOGI_PAWN) & shift<Down>(pos.pieces(Us)))
+                               | shift<Down>(pos.pieces(Them, SHOGI_PAWN, SOLDIER))
+                               | shift<EAST>(pos.promoted_soldiers(Them))
+                               | shift<WEST>(pos.promoted_soldiers(Them)));
+
+    // Initialize attackedBy[] for king and pawns
+    attackedBy[Us][KING] = pos.count<KING>(Us) ? pos.attacks_from(Us, KING, ksq) : Bitboard(0);
+    attackedBy[Us][PAWN] = pe->pawn_attacks(Us);
+    attackedBy[Us][SHOGI_PAWN] = shift<Up>(pos.pieces(Us, SHOGI_PAWN));
+    attackedBy[Us][ALL_PIECES] = attackedBy[Us][KING] | attackedBy[Us][PAWN] | attackedBy[Us][SHOGI_PAWN];
+    attackedBy2[Us]            =  (attackedBy[Us][KING] & attackedBy[Us][PAWN])
+                                | (attackedBy[Us][KING] & attackedBy[Us][SHOGI_PAWN])
+                                | (attackedBy[Us][PAWN] & attackedBy[Us][SHOGI_PAWN])
+                                | dblAttackByPawn;
+
+    // Init our king safety tables
+    if (!pos.count<KING>(Us))
+        kingRing[Us] = Bitboard(0);
+    else
+    {
+        Square s = make_square(std::clamp(file_of(ksq), FILE_B, File(pos.max_file() - 1)),
+                               std::clamp(rank_of(ksq), RANK_2, Rank(pos.max_rank() - 1)));
+        kingRing[Us] = attacks_bb<KING>(s) | s;
+    }
+
+    kingAttackersCount[Them] = popcount(kingRing[Us] & (pe->pawn_attacks(Them) | shift<Down>(pos.pieces(Them, SHOGI_PAWN))));
+    kingAttacksCount[Them] = kingAttackersWeight[Them] = 0;
+    kingAttackersCountInHand[Them] = kingAttackersWeightInHand[Them] = 0;
+
+    // Remove from kingRing[] the squares defended by two pawns
+    kingRing[Us] &= ~dblAttackByPawn;
+
+    kingRing[Us] &= pos.board_bb();
+  }
+
+
+  // Evaluation::pieces() scores pieces of a given color and type
+
+  template<Tracing T> template<Color Us>
+  Score Evaluation<T>::pieces(PieceType Pt) {
+
+    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<BISHOP>(s, pos.pieces() ^ pos.pieces(QUEEN))
+          : Pt ==   ROOK && !pos.diagonal_lines() ? attacks_bb<  ROOK>(s, pos.pieces() ^ pos.pieces(QUEEN) ^ pos.pieces(Us, ROOK))
+                         : pos.attacks_from(Us, Pt, s);
+
+        // Restrict mobility to actual squares of board
+        b &= pos.board_bb(Us, Pt);
+
+        if (pos.blockers_for_king(Us) & s)
+            b &= line_bb(pos.square<KING>(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[std::min(Pt, FAIRY_PIECES)];
+            kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
+        }
+
+        else if (Pt == ROOK && (file_bb(s) & kingRing[Them]))
+            score += RookOnKingRing;
+
+        else if (Pt == BISHOP && (attacks_bb<BISHOP>(s, pos.pieces(PAWN)) & kingRing[Them]))
+            score += BishopOnKingRing;
+
+        if (Pt > QUEEN)
+             b = (b & pos.pieces()) | (pos.moves_from(Us, Pt, s) & ~pos.pieces() & pos.board_bb());
+
+        int mob = popcount(b & mobilityArea[Us]);
+        if (Pt <= QUEEN)
+            mobility[Us] += MobilityBonus[Pt - 2][mob];
+        else
+            mobility[Us] += MaxMobility * (mob - 2) / (8 + mob);
+
+        // Piece promotion bonus
+        if (pos.promoted_piece_type(Pt) != NO_PIECE_TYPE)
+        {
+            Bitboard zone = pos.promotion_zone(Us);
+            if (zone & (b | s))
+                score += make_score(PieceValue[MG][pos.promoted_piece_type(Pt)] - PieceValue[MG][Pt],
+                                    PieceValue[EG][pos.promoted_piece_type(Pt)] - PieceValue[EG][Pt]) / (zone & s && b ? 6 : 12);
+        }
+        else if (pos.piece_demotion() && pos.unpromoted_piece_on(s))
+            score -= make_score(PieceValue[MG][Pt] - PieceValue[MG][pos.unpromoted_piece_on(s)],
+                                PieceValue[EG][Pt] - PieceValue[EG][pos.unpromoted_piece_on(s)]) / 4;
+        else if (pos.captures_to_hand() && pos.unpromoted_piece_on(s))
+            score += make_score(PieceValue[MG][Pt] - PieceValue[MG][pos.unpromoted_piece_on(s)],
+                                PieceValue[EG][Pt] - PieceValue[EG][pos.unpromoted_piece_on(s)]) / 8;
+
+        // Penalty if the piece is far from the kings in drop variants
+        if ((pos.captures_to_hand() || pos.two_boards()) && pos.count<KING>(Them) && pos.count<KING>(Us))
+        {
+            if (!(b & (kingRing[Us] | kingRing[Them])))
+                score -= KingProximity * distance(s, pos.square<KING>(Us)) * distance(s, pos.square<KING>(Them));
+        }
+
+        else if (pos.count<KING>(Us) && (Pt == FERS || Pt == SILVER))
+            score -= EndgameKingProximity * (distance(s, pos.square<KING>(Us)) - 2);
+
+        if (Pt == SOLDIER && (pos.pieces(Us, SOLDIER) & rank_bb(s) & adjacent_files_bb(s)))
+            score += ConnectedSoldier;
+
+        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<Down>(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<Down>(pos.pieces(PAWN)) & s)
+                score += MinorBehindPawn;
+
+            // Penalty if the piece is far from the king
+            if (pos.count<KING>(Us))
+            score -= KingProtector[Pt == BISHOP] * distance(pos.square<KING>(Us), s);
+
+            if (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<Down>(pos.pieces());
+
+                score -= BishopPawns[edge_distance(file_of(s), pos.max_file())] * 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<BISHOP>(s) & pos.pieces(Them, PAWN));
+
+                // Bonus for bishop on a long diagonal which can "see" both center squares
+                if (more_than_one(attacks_bb<BISHOP>(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 (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<Down>(pos.pieces())
+                   & file_bb(s))
+                {
+                    score -= RookOnClosedFile;
+                }
+
+                // Penalty when trapped by the king, even more if the king cannot castle
+                if (mob <= 3 && pos.count<KING>(Us))
+                {
+                    File kf = file_of(pos.square<KING>(Us));
+                    if ((kf < FILE_E) == (file_of(s) < kf))
+                        score -= TrappedRook * (1 + !pos.castling_rights(Us));
+                }
+            }
+        }
+
+        if (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, Them))
+                score -= WeakQueen;
+        }
+    }
+    if constexpr (T)
+        Trace::add(Pt, Us, score);
+
+    return score;
+  }
+
+  // Evaluation::hand() scores pieces of a given color and type in hand
+  template<Tracing T> template<Color Us>
+  Score Evaluation<T>::hand(PieceType pt) {
+
+    constexpr Color Them = ~Us;
+
+    Score score = SCORE_ZERO;
+
+    if (pos.count_in_hand(Us, pt) > 0 && pt != KING)
+    {
+        Bitboard b = pos.drop_region(Us, pt) & ~pos.pieces() & (~attackedBy2[Them] | attackedBy[Us][ALL_PIECES]);
+        if ((b & kingRing[Them]) && pt != SHOGI_PAWN)
+        {
+            kingAttackersCountInHand[Us] += pos.count_in_hand(Us, pt);
+            kingAttackersWeightInHand[Us] += KingAttackWeights[std::min(pt, FAIRY_PIECES)] * pos.count_in_hand(Us, pt);
+            kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
+        }
+        Bitboard theirHalf = pos.board_bb() & ~forward_ranks_bb(Them, relative_rank(Them, Rank((pos.max_rank() - 1) / 2), pos.max_rank()));
+        mobility[Us] += DropMobility * popcount(b & theirHalf & ~attackedBy[Them][ALL_PIECES]);
+
+        // Bonus for Kyoto shogi style drops of promoted pieces
+        if (pos.promoted_piece_type(pt) != NO_PIECE_TYPE && pos.drop_promoted())
+            score += make_score(std::max(PieceValue[MG][pos.promoted_piece_type(pt)] - PieceValue[MG][pt], VALUE_ZERO),
+                                std::max(PieceValue[EG][pos.promoted_piece_type(pt)] - PieceValue[EG][pt], VALUE_ZERO)) / 4 * pos.count_in_hand(Us, pt);
+
+        // Mobility bonus for reversi variants
+        if (pos.enclosing_drop())
+            mobility[Us] += make_score(500, 500) * popcount(b);
+
+        // Reduce score if there is a deficit of gates
+        if (pos.seirawan_gating() && !pos.piece_drops() && pos.count_in_hand(Us, ALL_PIECES) > popcount(pos.gates(Us)))
+            score -= make_score(200, 900) / pos.count_in_hand(Us, ALL_PIECES) * (pos.count_in_hand(Us, ALL_PIECES) - popcount(pos.gates(Us)));
+
+        // Redundant pieces that can not be doubled per file (e.g., shogi pawns)
+        if (pt == pos.drop_no_doubled())
+            score -= make_score(50, 20) * std::max(pos.count_with_hand(Us, pt) - pos.max_file() - 1, 0);
+    }
+
+    return score;
+  }
+
+  // Evaluation::king() assigns bonuses and penalties to a king of a given color
+
+  template<Tracing T> template<Color Us>
+  Score Evaluation<T>::king() const {
+
+    constexpr Color    Them = ~Us;
+    Rank r = relative_rank(Us, std::min(Rank((pos.max_rank() - 1) / 2 + 1), pos.max_rank()), pos.max_rank());
+    Bitboard Camp = pos.board_bb() & ~forward_ranks_bb(Us, r);
+
+    if (!pos.count<KING>(Us) || !pos.checking_permitted() || pos.checkmate_value() != -VALUE_MATE)
+        return SCORE_ZERO;
+
+    Bitboard weak, b1, b2, b3, safe, unsafeChecks = 0;
+    Bitboard queenChecks, knightChecks, pawnChecks, otherChecks;
+    int kingDanger = 0;
+    const Square ksq = pos.square<KING>(Us);
+
+    // Init the score with king shelter and enemy pawns storm
+    Score score = pe->king_safety<Us>(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);
+    if (!pos.check_counting() || pos.checks_remaining(Them) > 1)
+    safe &= ~attackedBy[Us][ALL_PIECES] | (weak & attackedBy2[Them]);
+
+    b1 = attacks_bb<ROOK  >(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
+    b2 = attacks_bb<BISHOP>(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN));
+
+    std::function <Bitboard (Color, PieceType)> get_attacks = [this](Color c, PieceType pt) {
+        return attackedBy[c][pt] | (pos.piece_drops() && pos.count_in_hand(c, pt) > 0 ? pos.drop_region(c, pt) & ~pos.pieces() : Bitboard(0));
+    };
+    for (PieceSet ps = pos.piece_types(); ps;)
+    {
+        PieceType pt = pop_lsb(ps);
+        switch (pt)
+        {
+        case QUEEN:
+            // Enemy queen safe checks: we count them only if they are from squares from
+            // which we can't give a rook check, because rook checks are more valuable.
+            queenChecks = (b1 | b2)
+                        & get_attacks(Them, QUEEN)
+                        & pos.board_bb()
+                        & safe
+                        & ~attackedBy[Us][QUEEN]
+                        & ~(b1 & attackedBy[Them][ROOK]);
+
+            if (queenChecks)
+                kingDanger += SafeCheck[QUEEN][more_than_one(queenChecks)];
+            break;
+        case ROOK:
+        case BISHOP:
+        case KNIGHT:
+            knightChecks = attacks_bb(Us, pt, ksq, pos.pieces() ^ pos.pieces(Us, QUEEN)) & get_attacks(Them, pt) & pos.board_bb();
+            if (knightChecks & safe)
+                kingDanger += SafeCheck[pt][more_than_one(knightChecks & safe)];
+            else
+                unsafeChecks |= knightChecks;
+            break;
+        case PAWN:
+            if (pos.piece_drops() && pos.count_in_hand(Them, pt) > 0)
+            {
+                pawnChecks = attacks_bb(Us, pt, ksq, pos.pieces()) & ~pos.pieces() & pos.board_bb();
+                if (pawnChecks & safe)
+                    kingDanger += SafeCheck[PAWN][more_than_one(pawnChecks & safe)];
+                else
+                    unsafeChecks |= pawnChecks;
+            }
+            break;
+        case SHOGI_PAWN:
+            if (pos.promoted_piece_type(pt))
+            {
+                otherChecks = attacks_bb(Us, pos.promoted_piece_type(pt), ksq, pos.pieces()) & attackedBy[Them][pt]
+                                 & pos.promotion_zone(Them) & pos.board_bb();
+                if (otherChecks & safe)
+                    kingDanger += SafeCheck[FAIRY_PIECES][more_than_one(otherChecks & safe)];
+                else
+                    unsafeChecks |= otherChecks;
+            }
+            break;
+        case KING:
+            break;
+        default:
+            otherChecks = attacks_bb(Us, pt, ksq, pos.pieces()) & get_attacks(Them, pt) & pos.board_bb();
+            if (otherChecks & safe)
+                kingDanger += SafeCheck[FAIRY_PIECES][more_than_one(otherChecks & safe)];
+            else
+                unsafeChecks |= otherChecks;
+        }
+    }
+
+    // Virtual piece drops
+    if (pos.two_boards() && pos.piece_drops())
+    {
+        for (PieceSet ps = pos.piece_types(); ps;)
+        {
+            PieceType pt = pop_lsb(ps);
+            if (pos.count_in_hand(Them, pt) <= 0 && (attacks_bb(Us, pt, ksq, pos.pieces()) & safe & pos.drop_region(Them, pt) & ~pos.pieces()))
+            {
+                kingDanger += VirtualCheck * 500 / (500 + PieceValue[MG][pt]);
+                // Presumably a mate threat
+                if (!(attackedBy[Us][KING] & ~(attackedBy[Them][ALL_PIECES] | pos.pieces(Us))))
+                    kingDanger += 2000;
+            }
+        }
+    }
+
+    if (pos.check_counting())
+        kingDanger += kingDanger * 7 / (3 + pos.checks_remaining(Them));
+
+    Square s = file_of(ksq) == FILE_A ? ksq + EAST : file_of(ksq) == pos.max_file() ? ksq + WEST : ksq;
+    Bitboard kingFlank = pos.max_file() == FILE_H ? KingFlank[file_of(ksq)] : file_bb(s) | adjacent_files_bb(s);
+
+    // Find the squares that opponent attacks in our king flank, the squares
+    // which they attack twice in that flank, and the squares that we defend.
+    b1 = attackedBy[Them][ALL_PIECES] & kingFlank & Camp;
+    b2 = b1 & attackedBy2[Them];
+    b3 = attackedBy[Us][ALL_PIECES] & kingFlank & Camp;
+
+    int kingFlankAttack  = popcount(b1) + popcount(b2);
+    int kingFlankDefense = popcount(b3);
+
+    kingDanger +=        kingAttackersCount[Them] * kingAttackersWeight[Them]
+                 +       kingAttackersCountInHand[Them] * kingAttackersWeight[Them]
+                 +       kingAttackersCount[Them] * kingAttackersWeightInHand[Them]
+                 + 183 * popcount(kingRing[Us] & (weak | ~pos.board_bb(Us, KING))) * (1 + pos.captures_to_hand() + pos.check_counting())
+                 + 148 * popcount(unsafeChecks) * (1 + pos.check_counting())
+                 +  98 * popcount(pos.blockers_for_king(Us))
+                 +  69 * kingAttacksCount[Them] * (2 + 8 * pos.check_counting() + pos.captures_to_hand()) / 2
+                 +   3 * kingFlankAttack * kingFlankAttack / 8
+                 +       mg_value(mobility[Them] - mobility[Us]) * int(!pos.captures_to_hand())
+                 - 873 * !(pos.major_pieces(Them) || pos.captures_to_hand())
+                       * 2 / (2 + 2 * pos.check_counting() + 2 * pos.two_boards() + 2 * pos.makpong()
+                                + (pos.king_type() != KING) * (pos.diagonal_lines() ? 1 : 2))
+                 - 100 * bool(attackedBy[Us][KNIGHT] & attackedBy[Us][KING])
+                 -   6 * mg_value(score) / 8
+                 -   4 * kingFlankDefense
+                 +  37;
+
+    // Transform the kingDanger units into a Score, and subtract it from the evaluation
+    if (kingDanger > 100)
+        score -= make_score(std::min(kingDanger, 3500) * kingDanger / 4096, kingDanger / 16);
+
+    // Penalty when our king is on a pawnless flank
+    if (!(pos.pieces(PAWN) & kingFlank))
+        score -= PawnlessFlank;
+
+    // Penalty if king flank is under attack, potentially moving toward the king
+    score -= FlankAttacks * kingFlankAttack * (1 + 5 * pos.captures_to_hand() + pos.check_counting());
+
+    if (pos.check_counting())
+        score += make_score(0, mg_value(score) * 2 / (2 + pos.checks_remaining(Them)));
+
+    if (pos.king_type() == WAZIR)
+        score += make_score(0, mg_value(score) / 2);
+
+    // For drop games, king danger is independent of game phase, but dependent on material density
+    if (pos.captures_to_hand() || pos.two_boards())
+        score = make_score(mg_value(score) * me->material_density() / 11000,
+                           mg_value(score) * me->material_density() / 11000);
+
+    if constexpr (T)
+        Trace::add(KING, Us, score);
+
+    return score;
+  }
+
+
+  // Evaluation::threats() assigns bonuses according to the types of the
+  // attacking and the attacked pieces.
+
+  template<Tracing T> template<Color Us>
+  Score Evaluation<T>::threats() const {
+
+    constexpr Color     Them     = ~Us;
+    constexpr Direction Up       = pawn_push(Us);
+    constexpr Bitboard  TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
+
+    Bitboard b, weak, defended, nonPawnEnemies, stronglyProtected, safe;
+    Score score = SCORE_ZERO;
+
+    // Bonuses for variants with mandatory captures
+    if (pos.must_capture())
+    {
+        // Penalties for possible captures
+        Bitboard captures = attackedBy[Us][ALL_PIECES] & pos.pieces(Them);
+        if (captures)
+            score -= make_score(2000, 2000) / (1 + popcount(captures & attackedBy[Them][ALL_PIECES] & ~attackedBy2[Us]));
+
+        // Bonus if we threaten to force captures
+        Bitboard moves = 0, piecebb = pos.pieces(Us);
+        while (piecebb)
+        {
+            Square s = pop_lsb(piecebb);
+            if (type_of(pos.piece_on(s)) != KING)
+                moves |= pos.moves_from(Us, type_of(pos.piece_on(s)), s);
+        }
+        score += make_score(200, 200) * popcount(attackedBy[Them][ALL_PIECES] & moves & ~pos.pieces());
+        score += make_score(200, 220) * popcount(attackedBy[Them][ALL_PIECES] & moves & ~pos.pieces() & ~attackedBy2[Us]);
+    }
+
+    // Extinction threats
+    if (pos.extinction_value() == -VALUE_MATE)
+    {
+        Bitboard bExt = attackedBy[Us][ALL_PIECES] & pos.pieces(Them);
+        for (PieceSet ps = pos.extinction_piece_types(); ps;)
+        {
+            PieceType pt = pop_lsb(ps);
+            if (pt == ALL_PIECES)
+                continue;
+            int denom = std::max(pos.count_with_hand(Them, pt) - pos.extinction_piece_count(), 1);
+            // Explosion threats
+            if (pos.blast_on_capture())
+            {
+                int evasions = popcount(((attackedBy[Them][pt] & ~pos.pieces(Them)) | pos.pieces(Them, pt)) & ~attackedBy[Us][ALL_PIECES]) * denom;
+                int attacks = popcount((attackedBy[Them][pt] | pos.pieces(Them, pt)) & attackedBy[Us][ALL_PIECES]);
+                int explosions = 0;
+
+                Bitboard bExtBlast = bExt & (attackedBy2[Us] | ~attackedBy[Us][pt]);
+                while (bExtBlast)
+                {
+                    Square s = pop_lsb(bExtBlast);
+                    if (((attacks_bb<KING>(s) | s) & pos.pieces(Them, pt)) && !(attacks_bb<KING>(s) & pos.pieces(Us, pt)))
+                        explosions++;
+                }
+                int danger = 20 * attacks / (evasions + 1) + 40 * explosions;
+                score += make_score(danger * (100 + danger), 0);
+            }
+            else
+                // Direct extinction threats
+                score += make_score(1000, 1000) / (denom * denom) * popcount(bExt & pos.pieces(Them, pt));
+        }
+    }
+
+    // Non-pawn enemies
+    nonPawnEnemies = pos.pieces(Them) & ~pos.pieces(PAWN, SHOGI_PAWN) & ~pos.pieces(SOLDIER);
+
+    // Squares strongly protected by the enemy, either because they defend the
+    // square with a pawn, or because they defend the square twice and we don't.
+    stronglyProtected =  (attackedBy[Them][PAWN] | attackedBy[Them][SHOGI_PAWN] | attackedBy[Them][SOLDIER])
+                       | (attackedBy2[Them] & ~attackedBy2[Us]);
+
+    // Non-pawn enemies, strongly protected
+    defended = nonPawnEnemies & stronglyProtected;
+
+    // Enemies not strongly protected and under our attack
+    weak = pos.pieces(Them) & ~stronglyProtected & attackedBy[Us][ALL_PIECES];
+
+    // Bonus according to the kind of attacking pieces
+    if (defended | weak)
+    {
+        b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]);
+        while (b)
+            score += ThreatByMinor[type_of(pos.piece_on(pop_lsb(b)))];
+
+        b = weak & attackedBy[Us][ROOK];
+        while (b)
+            score += ThreatByRook[type_of(pos.piece_on(pop_lsb(b)))];
+
+        if (weak & attackedBy[Us][KING])
+            score += ThreatByKing;
+
+        b =  ~attackedBy[Them][ALL_PIECES]
+           | (nonPawnEnemies & attackedBy2[Us]);
+        score += Hanging * popcount(weak & b);
+
+        // Additional bonus if weak piece is only protected by a queen
+        score += WeakQueenProtection * popcount(weak & attackedBy[Them][QUEEN]);
+    }
+
+    // Bonus for restricting their piece moves
+    b =   attackedBy[Them][ALL_PIECES]
+       & ~stronglyProtected
+       &  attackedBy[Us][ALL_PIECES];
+    score += RestrictedPiece * popcount(b);
+
+    // Protected or unattacked squares
+    safe = ~attackedBy[Them][ALL_PIECES] | attackedBy[Us][ALL_PIECES];
+
+    // Bonus for attacking enemy pieces with our relatively safe pawns
+    b = pos.pieces(Us, PAWN) & safe;
+    b = pawn_attacks_bb<Us>(b) & nonPawnEnemies;
+    score += ThreatBySafePawn * popcount(b);
+
+    // Find squares where our pawns can push on the next move
+    b  = shift<Up>(pos.pieces(Us, PAWN)) & ~pos.pieces();
+    b |= shift<Up>(b & TRank3BB) & ~pos.pieces();
+
+    // Keep only the squares which are relatively safe
+    b &= ~attackedBy[Them][PAWN] & safe;
+
+    // Bonus for safe pawn threats on the next move
+    b = (pawn_attacks_bb<Us>(b) | shift<Up>(shift<Up>(pos.pieces(Us, SHOGI_PAWN, SOLDIER)))) & nonPawnEnemies;
+    score += ThreatByPawnPush * popcount(b);
+
+    // Bonus for threats on the next moves against enemy queen
+    if (pos.count<QUEEN>(Them) == 1)
+    {
+        bool queenImbalance = pos.count<QUEEN>() == 1;
+
+        Square s = pos.square<QUEEN>(Them);
+        safe =   mobilityArea[Us]
+              & ~pos.pieces(Us, PAWN)
+              & ~stronglyProtected;
+
+        b = attackedBy[Us][KNIGHT] & attacks_bb<KNIGHT>(s);
+
+        score += KnightOnQueen * popcount(b & safe) * (1 + queenImbalance);
+
+        b =  (attackedBy[Us][BISHOP] & attacks_bb<BISHOP>(s, pos.pieces()))
+           | (attackedBy[Us][ROOK  ] & attacks_bb<ROOK  >(s, pos.pieces()));
+
+        score += SliderOnQueen * popcount(b & safe & attackedBy2[Us]) * (1 + queenImbalance);
+    }
+
+    if constexpr (T)
+        Trace::add(THREAT, Us, score);
+
+    return score;
+  }
+
+  // Evaluation::passed() evaluates the passed pawns and candidate passed
+  // pawns of the given color.
+
+  template<Tracing T> template<Color Us>
+  Score Evaluation<T>::passed() const {
+
+    constexpr Color     Them = ~Us;
+    constexpr Direction Up   = pawn_push(Us);
+    constexpr Direction Down = -Up;
+
+    auto king_proximity = [&](Color c, Square s) {
+      return pos.extinction_value() == VALUE_MATE ? 0 : pos.count<KING>(c) ? std::min(distance(pos.square<KING>(c), s), 5) : 5;
+    };
+
+    Bitboard b, bb, squaresToQueen, unsafeSquares, blockedPassers, helpers;
+    Score score = SCORE_ZERO;
+
+    b = pe->passed_pawns(Us);
+
+    blockedPassers = b & shift<Down>(pos.pieces(Them, PAWN));
+    if (blockedPassers)
+    {
+        helpers =  shift<Up>(pos.pieces(Us, PAWN))
+                 & ~pos.pieces(Them)
+                 & (~attackedBy2[Them] | attackedBy[Us][ALL_PIECES]);
+
+        // Remove blocked candidate passers that don't have help to pass
+        b &=  ~blockedPassers
+            | shift<WEST>(helpers)
+            | shift<EAST>(helpers);
+    }
+
+    while (b)
+    {
+        Square s = pop_lsb(b);
+
+        assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up)));
+
+        int r = std::max(RANK_8 - std::max(relative_rank(Us, pos.promotion_square(Us, s), pos.max_rank()) - relative_rank(Us, s, pos.max_rank()), 0), 0);
+
+        Score bonus = PassedRank[r];
+
+        if (r > RANK_3)
+        {
+            int w = 5 * r - 13;
+            Square blockSq = s + Up;
+
+            // Adjust bonus based on the king's proximity
+            bonus += make_score(0, (  king_proximity(Them, blockSq) * 19 / 4
+                                    - king_proximity(Us,   blockSq) *  2) * w);
+
+            // If blockSq is not the queening square then consider also a second push
+            if (r != RANK_7)
+                bonus -= make_score(0, king_proximity(Us, blockSq + Up) * w);
+
+            // If the pawn is free to advance, then increase the bonus
+            if (pos.empty(blockSq))
+            {
+                squaresToQueen = forward_file_bb(Us, s);
+                unsafeSquares = passed_pawn_span(Us, s);
+
+                bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN);
+
+                if (!(pos.pieces(Them) & bb))
+                    unsafeSquares &= attackedBy[Them][ALL_PIECES] | pos.pieces(Them);
+
+                // If there are no enemy pieces or attacks on passed pawn span, assign a big bonus.
+                // Or if there is some, but they are all attacked by our pawns, assign a bit smaller bonus.
+                // Otherwise assign a smaller bonus if the path to queen is not attacked
+                // and even smaller bonus if it is attacked but block square is not.
+                int k = !unsafeSquares                    ? 36 :
+                !(unsafeSquares & ~attackedBy[Us][PAWN])  ? 30 :
+                        !(unsafeSquares & squaresToQueen) ? 17 :
+                        !(unsafeSquares & blockSq)        ?  7 :
+                                                             0 ;
+
+                // Assign a larger bonus if the block square is defended
+                if ((pos.pieces(Us) & bb) || (attackedBy[Us][ALL_PIECES] & blockSq))
+                    k += 5;
+
+                bonus += make_score(k * w, k * w);
+            }
+        } // r > RANK_3
+
+        score += bonus - PassedFile * edge_distance(file_of(s), pos.max_file());
+    }
+
+    // Passed custom pawns
+    for (PieceSet ps = (pos.promotion_pawn_types(Us) & ~piece_set(PAWN)); ps;)
+    {
+        PieceType pt = pop_lsb(ps);
+        Bitboard b2 = pos.pieces(Us, pt);
+        while (b2)
+        {
+            Square s = pop_lsb(b2);
+            if (pos.promotion_square(Us, s) == SQ_NONE || (pos.pieces(Them, pt) & forward_file_bb(Us, s)))
+                continue;
+            int r = std::max(RANK_8 - std::max(relative_rank(Us, pos.promotion_square(Us, s), pos.max_rank()) - relative_rank(Us, s, pos.max_rank()), 0), 0);
+            score += PassedRank[r];
+        }
+    }
+
+    // Scale by maximum promotion piece value
+    Value maxMg = VALUE_ZERO, maxEg = VALUE_ZERO;
+    for (PieceSet ps = pos.promotion_piece_types(Us); ps;)
+    {
+        PieceType pt = pop_lsb(ps);
+        maxMg = std::max(maxMg, PieceValue[MG][pt]);
+        maxEg = std::max(maxEg, PieceValue[EG][pt]);
+    }
+    score = make_score(mg_value(score) * int(maxMg - PawnValueMg) / (QueenValueMg - PawnValueMg),
+                       eg_value(score) * int(maxEg - PawnValueEg) / (QueenValueEg - PawnValueEg));
+
+    // Score passed shogi pawns
+    PieceType pt = pos.promoted_piece_type(SHOGI_PAWN);
+    if (pt != NO_PIECE_TYPE)
+    {
+        b = pos.pieces(Us, SHOGI_PAWN);
+        while (b)
+        {
+            Square s = pop_lsb(b);
+            if ((pos.pieces(Them, SHOGI_PAWN) & forward_file_bb(Us, s)) || pos.promotion_square(Us, s) == SQ_NONE)
+                continue;
+
+            Square blockSq = s + Up;
+            int d = 2 * std::max(relative_rank(Us, pos.promotion_square(Us, s), pos.max_rank()) - relative_rank(Us, s, pos.max_rank()), 1);
+            d += !!(attackedBy[Them][ALL_PIECES] & ~attackedBy2[Us] & blockSq);
+            score += make_score(PieceValue[MG][pt], PieceValue[EG][pt]) / (d * d);
+        }
+    }
+
+    if constexpr (T)
+        Trace::add(PASSED, Us, score);
+
+    return score;
+  }
+
+
+  // Evaluation::space() computes a space evaluation for a given side, aiming to improve game
+  // play in the opening. It is based on the number of safe squares on the four central files
+  // on ranks 2 to 4. Completely safe squares behind a friendly pawn are counted twice.
+  // Finally, the space bonus is multiplied by a weight which decreases according to occupancy.
+
+  template<Tracing T> template<Color Us>
+  Score Evaluation<T>::space() const {
+
+    bool pawnsOnly = !(pos.pieces(Us) ^ pos.pieces(Us, PAWN));
+
+    // Early exit if, for example, both queens or 6 minor pieces have been exchanged
+    if (pos.non_pawn_material() < SpaceThreshold && !pawnsOnly && pos.double_step_region(Us))
+        return SCORE_ZERO;
+
+    constexpr Color Them     = ~Us;
+    constexpr Direction Down = -pawn_push(Us);
+    constexpr Bitboard SpaceMask =
+      Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB)
+                  : CenterFiles & (Rank7BB | Rank6BB | Rank5BB);
+
+    // Find the available squares for our pieces inside the area defined by SpaceMask
+    Bitboard safe =   SpaceMask
+                   & ~pos.pieces(Us, PAWN)
+                   & ~attackedBy[Them][PAWN];
+
+    // Find all squares which are at most three squares behind some friendly pawn
+    Bitboard behind = pos.pieces(Us, PAWN);
+    behind |= shift<Down>(behind);
+    behind |= shift<Down+Down>(behind);
+
+    if (pawnsOnly)
+    {
+        safe = pos.board_bb() & ((attackedBy2[Us] & ~attackedBy2[Them]) | (attackedBy[Us][PAWN] & ~pos.pieces(Us, PAWN)));
+        behind = 0;
+    }
+
+    // Compute space score based on the number of safe squares and number of our pieces
+    // increased with number of total blocked pawns in position.
+    int bonus = popcount(safe) + popcount(behind & safe & ~attackedBy[Them][ALL_PIECES]);
+    int weight = pos.count<ALL_PIECES>(Us) - 3 + std::min(pe->blocked_count(), 9);
+    Score score = make_score(bonus * weight * weight / 16, 0);
+
+    if (pos.flag_region(Us))
+        score += make_score(200, 200) * popcount(behind & safe & pos.flag_region(Us));
+
+    if constexpr (T)
+        Trace::add(SPACE, Us, score);
+
+    return score;
+  }
+
+
+  // Evaluation::variant() computes variant-specific evaluation bonuses for a given side.
+
+  template<Tracing T> template<Color Us>
+  Score Evaluation<T>::variant() const {
+
+    constexpr Color Them = ~Us;
+    constexpr Direction Down = pawn_push(Them);
+
+    Score score = SCORE_ZERO;
+
+    // Capture the flag
+    if (pos.flag_region(Us))
+    {
+        Bitboard ctfPieces = pos.pieces(Us, pos.flag_piece(Us));
+        Bitboard ctfTargets = pos.flag_region(Us) & pos.board_bb();
+        Bitboard onHold = 0;
+        Bitboard onHold2 = 0;
+        Bitboard processed = 0;
+        Bitboard blocked = pos.pieces(Us, PAWN) | attackedBy[Them][ALL_PIECES];
+        Bitboard doubleBlocked =  attackedBy2[Them]
+                                | (pos.pieces(Us, PAWN) & (shift<Down>(pos.pieces()) | attackedBy[Them][ALL_PIECES]))
+                                | (pos.pieces(Them) & pe->pawn_attacks(Them))
+                                | (pawn_attacks_bb<Them>(pos.pieces(Them, PAWN) & pe->pawn_attacks(Them)));
+        Bitboard inaccessible = pos.pieces(Us, PAWN) & shift<Down>(pos.pieces(Them, PAWN));
+        // Traverse all paths of the CTF pieces to the CTF targets.
+        // Put squares that are attacked or occupied on hold for one iteration.
+        // This reflects that likely a move will be needed to block or capture the attack.
+        // If all piece types are eligible, use the king path as a proxy for distance.
+        PieceType ptCtf = pos.flag_piece(Us) == ALL_PIECES ? KING : pos.flag_piece(Us);
+        for (int dist = 0; (ctfPieces || onHold || onHold2) && (ctfTargets & ~processed); dist++)
+        {
+            int wins = popcount(ctfTargets & ctfPieces);
+            if (wins)
+                score += make_score(4000, 4000) * wins / (wins + dist * dist);
+            Bitboard current = ctfPieces & ~ctfTargets;
+            processed |= ctfPieces;
+            ctfPieces = onHold & ~processed;
+            onHold = onHold2 & ~processed;
+            onHold2 = 0;
+            while (current)
+            {
+                Square s = pop_lsb(current);
+                Bitboard attacks = (  (PseudoAttacks[Us][ptCtf][s] & pos.pieces())
+                                    | (PseudoMoves[0][Us][ptCtf][s] & ~pos.pieces())) & ~processed & pos.board_bb();
+                ctfPieces |= attacks & ~blocked;
+                onHold |= attacks & ~doubleBlocked;
+                onHold2 |= attacks & ~inaccessible;
+            }
+        }
+    }
+
+    // nCheck
+    if (pos.check_counting())
+    {
+        int remainingChecks = pos.checks_remaining(Us);
+        assert(remainingChecks > 0);
+        score += make_score(3600, 1000) / (remainingChecks * remainingChecks);
+    }
+
+    // Extinction
+    if (pos.extinction_value() != VALUE_NONE)
+    {
+        for (PieceSet ps = pos.extinction_piece_types(); ps;)
+        {
+            PieceType pt = pop_lsb(ps);
+            if (pt != ALL_PIECES)
+            {
+                // Single piece type extinction bonus
+                int denom = std::max(pos.count(Us, pt) - pos.extinction_piece_count(), 1);
+                if (pos.count(Them, pt) >= pos.extinction_opponent_piece_count() || pos.two_boards())
+                    score += make_score(1000000 / (500 + PieceValue[MG][pt]),
+                                        1000000 / (500 + PieceValue[EG][pt])) / (denom * denom)
+                            * (pos.extinction_value() / VALUE_MATE);
+            }
+            else if (pos.extinction_value() == VALUE_MATE)
+            {
+                // Losing chess variant bonus
+                score += make_score(pos.non_pawn_material(Us), pos.non_pawn_material(Us)) / std::max(pos.count<ALL_PIECES>(Us), 1);
+            }
+            else if (pos.count<PAWN>(Us) == pos.count<ALL_PIECES>(Us))
+            {
+                // Pawns easy to stop/capture
+                int l = 0, m = 0, r = popcount(pos.pieces(Us, PAWN) & file_bb(FILE_A));
+                for (File f = FILE_A; f <= pos.max_file(); ++f)
+                {
+                    l = m; m = r; r = popcount(pos.pieces(Us, PAWN) & shift<EAST>(file_bb(f)));
+                    score -= make_score(80 - 10 * (edge_distance(f, pos.max_file()) % 2),
+                                        80 - 15 * (edge_distance(f, pos.max_file()) % 2)) * m / (1 + l * r);
+                }
+            }
+            else if (pos.count<PAWN>(Them) == pos.count<ALL_PIECES>(Them))
+            {
+                // Add a bonus according to how close we are to breaking through the pawn wall
+                int dist = 8;
+                Bitboard breakthroughs = attackedBy[Us][ALL_PIECES] & rank_bb(relative_rank(Us, pos.max_rank(), pos.max_rank()));
+                if (breakthroughs)
+                    dist = attackedBy[Us][QUEEN] & breakthroughs ? 0 : 1;
+                else for (File f = FILE_A; f <= pos.max_file(); ++f)
+                    dist = std::min(dist, popcount(pos.pieces(PAWN) & file_bb(f)));
+                score += make_score(70, 70) * pos.count<PAWN>(Them) / (1 + dist * dist) / (pos.pieces(Us, QUEEN) ? 2 : 4);
+            }
+        }
+    }
+
+    // Connect-n
+    if (pos.connect_n() > 0)
+    {
+        //Calculate eligible pieces for connection once.
+        //Still consider all opponent pieces as blocking.
+        Bitboard connectPiecesUs = 0;
+        for (PieceSet ps = pos.connect_piece_types(); ps;){
+            PieceType pt = pop_lsb(ps);
+            connectPiecesUs |= pos.pieces(pt);
+        };
+        connectPiecesUs &= pos.pieces(Us);
+
+        for (const Direction& d : pos.getConnectDirections())
+
+        {
+            // Find sufficiently large gaps
+            Bitboard b = pos.board_bb() & ~pos.pieces(Them);
+            for (int i = 1; i < pos.connect_n(); i++)
+                b &= shift(d, b);
+            // Count number of pieces per gap
+            while (b)
+            {
+                Square s = pop_lsb(b);
+                int c = 0;
+                for (int j = 0; j < pos.connect_n(); j++)
+                    if (connectPiecesUs & (s - j * d))
+                        c++;
+                score += make_score(200, 200)  * c / (pos.connect_n() - c) / (pos.connect_n() - c);
+            }
+        }
+    }
+
+    // Potential piece flips (Reversi)
+    if (pos.flip_enclosed_pieces())
+    {
+        // Stable pieces
+        if (pos.flip_enclosed_pieces() == REVERSI)
+        {
+            Bitboard edges = (FileABB | file_bb(pos.max_file()) | Rank1BB | rank_bb(pos.max_rank())) & pos.board_bb();
+            Bitboard edgePieces = pos.pieces(Us) & edges;
+            while (edgePieces)
+            {
+                Bitboard connectedEdge = attacks_bb(Us, ROOK, pop_lsb(edgePieces), ~(pos.pieces(Us) & edges)) & edges;
+                if (!more_than_one(connectedEdge & ~pos.pieces(Us)))
+                    score += make_score(300, 300);
+                else if (!(connectedEdge & ~pos.pieces()))
+                    score += make_score(200, 200);
+            }
+        }
+
+        // Unstable
+        Bitboard unstable = 0;
+        Bitboard drops = pos.drop_region(Them, IMMOBILE_PIECE);
+        while (drops)
+        {
+            Square s = pop_lsb(drops);
+            if (pos.flip_enclosed_pieces() == REVERSI)
+            {
+                Bitboard b = attacks_bb(Them, QUEEN, s, ~pos.pieces(Us)) & ~PseudoAttacks[Them][KING][s] & pos.pieces(Them);
+                while(b)
+                    unstable |= between_bb(s, pop_lsb(b));
+            }
+            else
+                unstable |= PseudoAttacks[Them][KING][s] & pos.pieces(Us);
+        }
+        score -= make_score(200, 200) * popcount(unstable);
+    }
+
+    if (T)
+        Trace::add(VARIANT, Us, score);
+
+    return score;
+  }
+
+
+  // Evaluation::winnable() adjusts the midgame and endgame score components, based on
+  // the known attacking/defending status of the players. The final value is derived
+  // by interpolation from the midgame and endgame values.
+
+  template<Tracing T>
+  Value Evaluation<T>::winnable(Score score) const {
+
+    // No initiative bonus for variants that do not require sufficient mating material, e.g., extinction variants.
+    // This protects them from misidentification as drawish.
+    int complexity = 0;
+    bool pawnsOnBothFlanks = true;
+    if (   pos.extinction_value() == VALUE_NONE
+        && !pos.captures_to_hand()
+        && !pos.connect_n()
+        && !pos.material_counting()
+        && !(pos.flag_region(WHITE) || pos.flag_region(BLACK)))
+    {
+    int outflanking = !pos.count<KING>(WHITE) || !pos.count<KING>(BLACK) ? 0
+                     :  distance<File>(pos.square<KING>(WHITE), pos.square<KING>(BLACK))
+                    + int(rank_of(pos.square<KING>(WHITE)) - rank_of(pos.square<KING>(BLACK)));
+
+        pawnsOnBothFlanks =   (pos.pieces(PAWN) & QueenSide)
+                            && (pos.pieces(PAWN) & KingSide);
+
+    bool almostUnwinnable =   outflanking < 0
+                           && pos.stalemate_value() == VALUE_DRAW
+                           && !pawnsOnBothFlanks;
+
+    bool infiltration =   (pos.count<KING>(WHITE) && rank_of(pos.square<KING>(WHITE)) > RANK_4)
+                       || (pos.count<KING>(BLACK) && rank_of(pos.square<KING>(BLACK)) < RANK_5);
+
+    // Compute the initiative bonus for the attacking side
+    complexity =       9 * pe->passed_count()
+                    + 12 * pos.count(WHITE, pos.main_promotion_pawn_type(WHITE)) * bool(pos.main_promotion_pawn_type(WHITE))
+                    + 12 * pos.count(BLACK, pos.main_promotion_pawn_type(BLACK)) * bool(pos.main_promotion_pawn_type(BLACK))
+                    + 15 * pos.count<SOLDIER>()
+                    +  9 * outflanking
+                    + 21 * pawnsOnBothFlanks
+                    + 24 * infiltration
+                    + 51 * !pos.non_pawn_material()
+                    - 43 * almostUnwinnable
+                    -110 ;
+    }
+
+    Value mg = mg_value(score);
+    Value eg = eg_value(score);
+
+    // Now apply the bonus: note that we find the attacking side by extracting the
+    // sign of the midgame or endgame values, and that we carefully cap the bonus
+    // so that the midgame and endgame scores do not change sign after the bonus.
+    int u = ((mg > 0) - (mg < 0)) * std::clamp(complexity + 50, -abs(mg), 0);
+    int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg));
+
+    mg += u;
+    eg += v;
+
+    // Compute the scale factor for the winning side
+    Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK;
+    int sf = me->scale_factor(pos, strongSide);
+
+    // If scale factor is not already specific, scale up/down via general heuristics
+    if (sf == SCALE_FACTOR_NORMAL && !pos.captures_to_hand() && !pos.material_counting())
+    {
+        if (pos.opposite_bishops())
+        {
+            // For pure opposite colored bishops endgames use scale factor
+            // based on the number of passed pawns of the strong side.
+            if (   pos.non_pawn_material(WHITE) == BishopValueMg
+                && pos.non_pawn_material(BLACK) == BishopValueMg)
+                sf = 18 + 4 * popcount(pe->passed_pawns(strongSide));
+            // For every other opposite colored bishops endgames use scale factor
+            // based on the number of all pieces of the strong side.
+            else
+                sf = 22 + 3 * pos.count<ALL_PIECES>(strongSide);
+        }
+        // For rook endgames with strong side not having overwhelming pawn number advantage
+        // and its pawns being on one flank and weak side protecting its pieces with a king
+        // use lower scale factor.
+        else if (  pos.non_pawn_material(WHITE) == RookValueMg
+                && pos.non_pawn_material(BLACK) == RookValueMg
+                && pos.count<PAWN>(strongSide) - pos.count<PAWN>(~strongSide) <= 1
+                && bool(KingSide & pos.pieces(strongSide, PAWN)) != bool(QueenSide & pos.pieces(strongSide, PAWN))
+                && pos.count<KING>(~strongSide)
+                && (attacks_bb<KING>(pos.square<KING>(~strongSide)) & pos.pieces(~strongSide, PAWN)))
+            sf = 36;
+        // For queen vs no queen endgames use scale factor
+        // based on number of minors of side that doesn't have queen.
+        else if (pos.count<QUEEN>() == 1)
+            sf = 37 + 3 * (pos.count<QUEEN>(WHITE) == 1 ? pos.count<BISHOP>(BLACK) + pos.count<KNIGHT>(BLACK)
+                                                        : pos.count<BISHOP>(WHITE) + pos.count<KNIGHT>(WHITE));
+        // In every other case use scale factor based on
+        // the number of pawns of the strong side reduced if pawns are on a single flank.
+        else
+            sf = std::min(sf, 36 + 7 * (pos.count<PAWN>(strongSide) + pos.count<SOLDIER>(strongSide))) - 4 * !pawnsOnBothFlanks;
+
+        // Reduce scale factor in case of pawns being on a single flank
+        sf -= 4 * !pawnsOnBothFlanks;
+    }
+
+    // Interpolate between the middlegame and (scaled by 'sf') endgame score
+    v =  mg * int(me->game_phase())
+       + eg * int(PHASE_MIDGAME - me->game_phase()) * ScaleFactor(sf) / SCALE_FACTOR_NORMAL;
+    v /= PHASE_MIDGAME;
+
+    if constexpr (T)
+    {
+        Trace::add(WINNABLE, make_score(u, eg * ScaleFactor(sf) / SCALE_FACTOR_NORMAL - eg_value(score)));
+        Trace::add(TOTAL, make_score(mg, eg * ScaleFactor(sf) / SCALE_FACTOR_NORMAL));
+    }
+
+    return Value(v);
+  }
+
+
+  // Evaluation::value() is the main function of the class. It computes the various
+  // parts of the evaluation and returns the value of the position from the point
+  // of view of the side to move.
+
+  template<Tracing T>
+  Value Evaluation<T>::value() {
+
+    assert(!pos.checkers());
+    assert(!pos.is_immediate_game_end());
+
+    // Probe the material hash table
+    me = Material::probe(pos);
+
+    // If we have a specialized evaluation function for the current material
+    // configuration, call it and return.
+    if (me->specialized_eval_exists())
+        return me->evaluate(pos);
+
+    // Initialize score by reading the incrementally updated scores included in
+    // the position object (material + piece square tables) and the material
+    // imbalance. Score is computed internally from the white point of view.
+    Score score = pos.psq_score();
+    if (T)
+        Trace::add(MATERIAL, score);
+    score += me->imbalance() + pos.this_thread()->trend;
+
+    // Probe the pawn hash table
+    pe = Pawns::probe(pos);
+    score += pe->pawn_score(WHITE) - pe->pawn_score(BLACK);
+
+    // Early exit if score is high
+    auto lazy_skip = [&](Value lazyThreshold) {
+        return abs(mg_value(score) + eg_value(score)) / 2 > lazyThreshold + pos.non_pawn_material() / 64;
+    };
+
+    if (lazy_skip(LazyThreshold1) && Options["UCI_Variant"] == "chess")
+        goto make_v;
+
+    // Main evaluation begins here
+    std::memset(attackedBy, 0, sizeof(attackedBy));
+    initialize<WHITE>();
+    initialize<BLACK>();
+
+    // Pieces evaluated first (also populates attackedBy, attackedBy2).
+    // For unused piece types, we still need to set attack bitboard to zero.
+    for (PieceSet ps = pos.piece_types(); ps;)
+    {
+        PieceType pt = pop_lsb(ps);
+        if (pt != SHOGI_PAWN && pt != PAWN && pt != KING)
+            score += pieces<WHITE>(pt) - pieces<BLACK>(pt);
+    }
+
+    // Evaluate pieces in hand once attack tables are complete
+    if (pos.piece_drops() || pos.seirawan_gating())
+        for (PieceSet ps = pos.piece_types(); ps;)
+        {
+            PieceType pt = pop_lsb(ps);
+            score += hand<WHITE>(pt) - hand<BLACK>(pt);
+        }
+
+    score += (mobility[WHITE] - mobility[BLACK]) * (1 + pos.captures_to_hand() + pos.must_capture() + pos.check_counting());
+
+    // More complex interactions that require fully populated attack bitboards
+    score +=  king<   WHITE>() - king<   BLACK>()
+            + passed< WHITE>() - passed< BLACK>()
+            + variant<WHITE>() - variant<BLACK>();
+
+    if (lazy_skip(LazyThreshold2) && Options["UCI_Variant"] == "chess")
+        goto make_v;
+
+    score +=  threats<WHITE>() - threats<BLACK>()
+            + space<  WHITE>() - space<  BLACK>();
+
+make_v:
+    // Derive single value from mg and eg parts of score
+    Value v = winnable(score);
+
+    // In case of tracing add all remaining individual evaluation terms
+    if constexpr (T)
+    {
+        Trace::add(IMBALANCE, me->imbalance());
+        Trace::add(PAWN, pe->pawn_score(WHITE), pe->pawn_score(BLACK));
+        Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]);
+    }
+
+    // Evaluation grain
+    v = (v / 16) * 16;
+
+    // Side to move point of view
+    v = (pos.side_to_move() == WHITE ? v : -v) + 80 * pos.captures_to_hand();
+
+    return v;
+  }
+
+
+  /// Fisher Random Chess: correction for cornered bishops, to fix chess960 play with NNUE
+
+  Value fix_FRC(const Position& pos) {
+
+    constexpr Bitboard Corners =  Bitboard(1ULL) << SQ_A1 | Bitboard(1ULL) << SQ_H1 | Bitboard(1ULL) << SQ_A8 | Bitboard(1ULL) << SQ_H8;
+
+    if (!(pos.pieces(BISHOP) & Corners))
+        return VALUE_ZERO;
+
+    int correction = 0;
+
+    if (   pos.piece_on(SQ_A1) == W_BISHOP
+        && pos.piece_on(SQ_B2) == W_PAWN)
+        correction += !pos.empty(SQ_B3) ? -CorneredBishop * 4
+                                        : -CorneredBishop * 3;
+
+    if (   pos.piece_on(SQ_H1) == W_BISHOP
+        && pos.piece_on(SQ_G2) == W_PAWN)
+        correction += !pos.empty(SQ_G3) ? -CorneredBishop * 4
+                                        : -CorneredBishop * 3;
+
+    if (   pos.piece_on(SQ_A8) == B_BISHOP
+        && pos.piece_on(SQ_B7) == B_PAWN)
+        correction += !pos.empty(SQ_B6) ? CorneredBishop * 4
+                                        : CorneredBishop * 3;
+
+    if (   pos.piece_on(SQ_H8) == B_BISHOP
+        && pos.piece_on(SQ_G7) == B_PAWN)
+        correction += !pos.empty(SQ_G6) ? CorneredBishop * 4
+                                        : CorneredBishop * 3;
+
+    return pos.side_to_move() == WHITE ?  Value(correction)
+                                       : -Value(correction);
+  }
+
+} // namespace Eval
+
+
+/// evaluate() is the evaluator for the outer world. It returns a static
+/// evaluation of the position from the point of view of the side to move.
+
+Value Eval::evaluate(const Position& pos) {
+
+  Value v;
+
+  if (!Eval::useNNUE || !pos.nnue_applicable())
+      v = Evaluation<NO_TRACE>(pos).value();
+  else
+  {
+      // Scale and shift NNUE for compatibility with search and classical evaluation
+      auto  adjusted_NNUE = [&]()
+      {
+         int scale =   903
+                     + 32 * pos.count<PAWN>()
+                     + 32 * pos.non_pawn_material() / 1024;
+
+         Value nnue = NNUE::evaluate(pos, true) * scale / 1024;
+
+         if (pos.is_chess960())
+             nnue += fix_FRC(pos);
+
+         if (pos.check_counting())
+         {
+             Color us = pos.side_to_move();
+             nnue +=  6 * scale / (5 * pos.checks_remaining( us))
+                    - 6 * scale / (5 * pos.checks_remaining(~us));
+         }
+
+         return nnue;
+      };
+
+      // If there is PSQ imbalance we use the classical eval, but we switch to
+      // NNUE eval faster when shuffling or if the material on the board is high.
+      int r50 = pos.rule50_count();
+      Value psq = Value(abs(eg_value(pos.psq_score())));
+      bool pure = !pos.check_counting();
+      bool classical = psq * 5 > (750 + pos.non_pawn_material() / 64) * (5 + r50) && !pure;
+
+      v = classical ? Evaluation<NO_TRACE>(pos).value()  // classical
+                    : adjusted_NNUE();                   // NNUE
+  }
+
+  // Damp down the evaluation linearly when shuffling
+  if (pos.n_move_rule())
+  {
+      v = v * (2 * pos.n_move_rule() - pos.rule50_count()) / (2 * pos.n_move_rule());
+      if (pos.material_counting())
+          v += pos.material_counting_result() / (10 * std::max(2 * pos.n_move_rule() - pos.rule50_count(), 1));
+  }
+
+  // Guarantee evaluation does not hit the virtual win/loss range
+  if (pos.two_boards() && std::abs(v) >= VALUE_VIRTUAL_MATE_IN_MAX_PLY)
+      v += v > VALUE_ZERO ? MAX_PLY + 1 : -MAX_PLY - 1;
+
+  // Guarantee evaluation does not hit the tablebase range
+  v = std::clamp(v, VALUE_TB_LOSS_IN_MAX_PLY + 1, VALUE_TB_WIN_IN_MAX_PLY - 1);
+
+  return v;
+}
+
+/// trace() is like evaluate(), but instead of returning a value, it returns
+/// a string (suitable for outputting to stdout) that contains the detailed
+/// descriptions and values of each evaluation term. Useful for debugging.
+/// Trace scores are from white's point of view
+
+std::string Eval::trace(Position& pos) {
+
+  if (pos.checkers())
+      return "Final evaluation: none (in check)";
+
+  std::stringstream ss;
+  ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2);
+
+  Value v;
+
+  std::memset(scores, 0, sizeof(scores));
+
+  pos.this_thread()->trend = SCORE_ZERO; // Reset any dynamic contempt
+
+  v = Evaluation<TRACE>(pos).value();
+
+  ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2)
+     << " Contributing terms for the classical eval:\n"
+     << "+------------+-------------+-------------+-------------+\n"
+     << "|    Term    |    White    |    Black    |    Total    |\n"
+     << "|            |   MG    EG  |   MG    EG  |   MG    EG  |\n"
+     << "+------------+-------------+-------------+-------------+\n"
+     << "|   Material | " << Term(MATERIAL)
+     << "|  Imbalance | " << Term(IMBALANCE)
+     << "|      Pawns | " << Term(PAWN)
+     << "|    Knights | " << Term(KNIGHT)
+     << "|    Bishops | " << Term(BISHOP)
+     << "|      Rooks | " << Term(ROOK)
+     << "|     Queens | " << Term(QUEEN)
+     << "|   Mobility | " << Term(MOBILITY)
+     << "|King safety | " << Term(KING)
+     << "|    Threats | " << Term(THREAT)
+     << "|     Passed | " << Term(PASSED)
+     << "|      Space | " << Term(SPACE)
+     << "|    Variant | " << Term(VARIANT)
+     << "|   Winnable | " << Term(WINNABLE)
+     << "+------------+-------------+-------------+-------------+\n"
+     << "|      Total | " << Term(TOTAL)
+     << "+------------+-------------+-------------+-------------+\n";
+
+  if (Eval::useNNUE && pos.nnue_applicable())
+      ss << '\n' << NNUE::trace(pos) << '\n';
+
+  ss << std::showpoint << std::showpos << std::fixed << std::setprecision(2) << std::setw(15);
+
+  v = pos.side_to_move() == WHITE ? v : -v;
+  ss << "\nClassical evaluation   " << to_cp(v) << " (white side)\n";
+  if (Eval::useNNUE && pos.nnue_applicable())
+  {
+      v = NNUE::evaluate(pos, false);
+      v = pos.side_to_move() == WHITE ? v : -v;
+      ss << "NNUE evaluation        " << to_cp(v) << " (white side)\n";
+  }
+
+  v = evaluate(pos);
+  v = pos.side_to_move() == WHITE ? v : -v;
+  ss << "Final evaluation       " << to_cp(v) << " (white side)";
+  if (Eval::useNNUE && pos.nnue_applicable())
+     ss << " [with scaled NNUE, hybrid, ...]";
+  ss << "\n";
+
+  return ss.str();
+}
+
+} // namespace Stockfish

Fairy-Stockfish-master/src/evaluate.h

@@ -0,0 +1,66 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef EVALUATE_H_INCLUDED
+#define EVALUATE_H_INCLUDED
+
+#include <string>
+#include <optional>
+
+#include "types.h"
+
+#include "variant.h"
+
+namespace Stockfish {
+
+class Position;
+
+namespace Eval {
+
+  std::string trace(Position& pos);
+  Value evaluate(const Position& pos);
+
+  extern bool useNNUE;
+  extern std::string eval_file_loaded;
+
+  // The default net name MUST follow the format nn-[SHA256 first 12 digits].nnue
+  // for the build process (profile-build and fishtest) to work. Do not change the
+  // name of the macro, as it is used in the Makefile.
+  #define EvalFileDefaultName   "nn-3475407dc199.nnue"
+
+  namespace NNUE {
+
+    std::string trace(Position& pos);
+    Value evaluate(const Position& pos, bool adjusted = false);
+
+    void init();
+    void verify();
+
+    bool load_eval(std::string name, std::istream& stream);
+    bool save_eval(std::ostream& stream);
+    bool save_eval(const std::optional<std::string>& filename);
+
+  } // namespace NNUE
+
+} // namespace Eval
+
+extern const Variant* currentNnueVariant;
+
+} // namespace Stockfish
+
+#endif // #ifndef EVALUATE_H_INCLUDED

Fairy-Stockfish-master/src/ffishjs.cpp

@@ -0,0 +1,767 @@
+/*
+  ffish.js, a JavaScript chess variant library derived from Fairy-Stockfish
+  Copyright (C) 2022 Fabian Fichter, Johannes Czech
+
+  ffish.js 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.
+
+  ffish.js 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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <emscripten.h>
+#include <emscripten/bind.h>
+#include <vector>
+#include <string>
+#include <sstream>
+#include<iostream>
+
+#include "misc.h"
+#include "types.h"
+#include "bitboard.h"
+#include "evaluate.h"
+#include "position.h"
+#include "search.h"
+#include "syzygy/tbprobe.h"
+#include "thread.h"
+#include "tt.h"
+#include "uci.h"
+#include "piece.h"
+#include "variant.h"
+#include "movegen.h"
+#include "apiutil.h"
+
+using namespace emscripten;
+
+using namespace Stockfish;
+
+void initialize_stockfish() {
+  pieceMap.init();
+  variants.init();
+  UCI::init(Options);
+  Bitboards::init();
+  Position::init();
+  Bitbases::init();
+}
+
+#define DELIM " "
+
+inline void save_pop_back(std::string& s) {
+  if (s.size() != 0) {
+    s.pop_back();
+  }
+}
+
+const Variant* get_variant(const std::string& uciVariant) {
+  if (uciVariant.size() == 0 || uciVariant == "Standard" || uciVariant == "standard")
+    return variants.find("chess")->second;
+  return variants.find(uciVariant)->second;
+}
+
+template <bool isUCI>
+inline bool is_move_none(Move move, const std::string& strMove, const Position& pos) {
+  if (move == MOVE_NONE) {
+    std::cerr << "The given ";
+    isUCI ? std::cerr << "uciMove" : std::cerr << "sanMove";
+    std::cerr << " '" << strMove << "' for position '" << pos.fen() << "' is invalid." << std::endl;
+    return true;
+  }
+  return false;
+}
+
+class Board {
+  // note: we can't use references for strings here due to conversion to JavaScript
+private:
+  const Variant* v;
+  StateListPtr states;
+  Position pos;
+  Thread* thread;
+  std::vector<Move> moveStack;
+  bool is960;
+
+public:
+  static bool sfInitialized;
+
+  Board():
+    Board("chess", "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1" , false) {
+  }
+
+  Board(std::string uciVariant):
+    Board(uciVariant, "", false) {
+  }
+
+  Board(std::string uciVariant, std::string fen):
+    Board(uciVariant, fen, false) {
+  }
+
+  Board(std::string uciVariant, std::string fen, bool is960) {
+    init(uciVariant, fen, is960);
+  }
+
+  std::string legal_moves() {
+    std::string moves;
+    for (const ExtMove& move : MoveList<LEGAL>(this->pos)) {
+      moves += UCI::move(this->pos, move);
+      moves += DELIM;
+    }
+    save_pop_back(moves);
+    return moves;
+  }
+
+  std::string legal_moves_san() {
+    std::string movesSan;
+    for (const ExtMove& move : MoveList<LEGAL>(this->pos)) {
+      movesSan += SAN::move_to_san(this->pos, move, NOTATION_SAN);
+      movesSan += DELIM;
+    }
+    save_pop_back(movesSan);
+    return movesSan;
+  }
+
+  int number_legal_moves() const {
+    return MoveList<LEGAL>(pos).size();
+  }
+
+  bool push(std::string uciMove) {
+    const Move move = UCI::to_move(this->pos, uciMove);
+    if (is_move_none<true>(move, uciMove, pos))
+      return false;
+    do_move(move);
+    return true;
+  }
+
+  bool push_san(std::string sanMove) {
+    return push_san(sanMove, NOTATION_SAN);
+  }
+
+  // TODO: This is a naive implementation which compares all legal SAN moves with the requested string.
+  // If the SAN move wasn't found the position remains unchanged. Alternatively, implement a direct conversion.
+  bool push_san(std::string sanMove, Notation notation) {
+    Move foundMove = MOVE_NONE;
+    for (const ExtMove& move : MoveList<LEGAL>(pos)) {
+      if (sanMove == SAN::move_to_san(this->pos, move, notation)) {
+        foundMove = move;
+        break;
+      }
+    }
+    if (is_move_none<false>(foundMove, sanMove, pos))
+      return false;
+    do_move(foundMove);
+    return true;
+  }
+
+  void pop() {
+    pos.undo_move(this->moveStack.back());
+    moveStack.pop_back();
+    states->pop_back();
+  }
+
+  void reset() {
+    set_fen(v->startFen);
+  }
+
+  bool is_960() const {
+    return is960;
+  }
+
+  std::string fen() const {
+    return this->pos.fen();
+  }
+
+  std::string fen(bool showPromoted) const {
+    return this->pos.fen(false, showPromoted);
+  }
+
+  std::string fen(bool showPromoted, int countStarted) const {
+    return this->pos.fen(false, showPromoted, countStarted);
+  }
+
+  void set_fen(std::string fen) {
+    resetStates();
+    moveStack.clear();
+    pos.set(v, fen, is960, &states->back(), thread);
+  }
+
+  // note: const identifier for pos not possible due to SAN::move_to_san()
+  std::string san_move(std::string uciMove) {
+    return san_move(uciMove, NOTATION_SAN);
+  }
+
+  std::string san_move(std::string uciMove, Notation notation) {
+    const Move move = UCI::to_move(this->pos, uciMove);
+    if (is_move_none<true>(move, uciMove, pos))
+      return "";
+    return SAN::move_to_san(this->pos, UCI::to_move(this->pos, uciMove), notation);
+  }
+
+  std::string variation_san(std::string uciMoves) {
+    return variation_san(uciMoves, NOTATION_SAN, true);
+  }
+
+  std::string variation_san(std::string uciMoves, Notation notation) {
+    return variation_san(uciMoves, notation, true);
+  }
+
+  std::string variation_san(std::string uciMoves, Notation notation, bool moveNumbers) {
+    std::stringstream ss(uciMoves);
+    StateListPtr tempStates;
+    std::vector<Move> moves;
+    std::string variationSan = "";
+    std::string uciMove;
+    bool first = true;
+
+    while (std::getline(ss, uciMove, ' ')) {
+      const Move move = UCI::to_move(this->pos, uciMove);
+      if (is_move_none<true>(move, uciMove, pos))
+        return "";
+      moves.emplace_back(UCI::to_move(this->pos, uciMove));
+      if (first) {
+        first = false;
+        if (moveNumbers) {
+          variationSan = std::to_string(fullmove_number());
+          if (pos.side_to_move() == WHITE)
+          variationSan += ". ";
+          else
+          variationSan += "...";
+        }
+        variationSan += SAN::move_to_san(this->pos, moves.back(), Notation(notation));
+      }
+      else {
+        if (moveNumbers && pos.side_to_move() == WHITE) {
+          variationSan += DELIM;
+          variationSan += std::to_string(fullmove_number());
+          variationSan += ".";
+        }
+        variationSan += DELIM;
+        variationSan += SAN::move_to_san(this->pos, moves.back(), Notation(notation));
+      }
+      states->emplace_back();
+      pos.do_move(moves.back(), states->back());
+    }
+
+    // recover initial state
+    for(auto rIt = std::rbegin(moves); rIt != std::rend(moves); ++rIt) {
+      pos.undo_move(*rIt);
+    }
+
+    return variationSan;
+  }
+
+  // returns true for WHITE and false for BLACK
+  bool turn() const {
+    return !pos.side_to_move();
+  }
+
+  int fullmove_number() const {
+    return pos.game_ply() / 2 + 1;
+  }
+
+  int halfmove_clock() const {
+    return pos.rule50_count();
+  }
+
+  int game_ply() const {
+    return pos.game_ply();
+  }
+
+  bool has_insufficient_material(bool turn) const {
+    return Stockfish::has_insufficient_material(turn ? WHITE : BLACK, pos);
+  }
+
+  bool is_insufficient_material() const {
+    return Stockfish::has_insufficient_material(WHITE, pos) && Stockfish::has_insufficient_material(BLACK, pos);
+  }
+
+  bool is_game_over() const {
+    return is_game_over(false);
+  }
+
+  bool is_game_over(bool claim_draw) const {
+    if (is_insufficient_material())
+      return true;
+    if (claim_draw && pos.is_optional_game_end())
+      return true;
+    return MoveList<LEGAL>(pos).size() == 0;
+  }
+
+  std::string result() const {
+    return result(false);
+  }
+
+  std::string result(bool claim_draw) const {
+    Value result;
+    bool gameEnd = pos.is_immediate_game_end(result);
+    if (!gameEnd) {
+      if (is_insufficient_material()) {
+        gameEnd = true;
+        result = VALUE_DRAW;
+      }
+    }
+    if (!gameEnd && MoveList<LEGAL>(pos).size() == 0) {
+      gameEnd = true;
+      result = pos.checkers() ? pos.checkmate_value() : pos.stalemate_value();
+    }
+    if (!gameEnd && claim_draw)
+      gameEnd = pos.is_optional_game_end(result);
+
+    if (!gameEnd)
+      return "*";
+    if (result == 0)
+      return "1/2-1/2";
+    if (pos.side_to_move() == BLACK)
+      result = -result;
+    if (result > 0)
+      return "1-0";
+    else
+      return "0-1";
+  }
+
+  std::string checked_pieces() const {
+    Bitboard checked = Stockfish::checked(pos);
+    std::string squares;
+    while (checked) {
+      Square sr = pop_lsb(checked);
+      squares += UCI::square(pos, sr);
+      squares += DELIM;
+    }
+    save_pop_back(squares);
+    return squares;
+  }
+
+  bool is_check() const {
+    return Stockfish::checked(pos);
+  }
+
+  bool is_bikjang() const {
+    return pos.bikjang();
+  }
+
+  bool is_capture(std::string uciMove) const {
+    return pos.capture(UCI::to_move(pos, uciMove));
+  }
+
+  std::string move_stack() const {
+    std::string moves;
+    for(auto it = std::begin(moveStack); it != std::end(moveStack); ++it) {
+      moves += UCI::move(pos, *it);
+      moves += DELIM;
+    }
+    save_pop_back(moves);
+    return moves;
+  }
+
+  void push_moves(std::string uciMoves) {
+    std::stringstream ss(uciMoves);
+    std::string uciMove;
+    while (std::getline(ss, uciMove, ' ')) {
+      push(uciMove);
+    }
+  }
+
+  void push_san_moves(std::string sanMoves) {
+    return push_san_moves(sanMoves, NOTATION_SAN);
+  }
+
+  void push_san_moves(std::string sanMoves, Notation notation) {
+    std::stringstream ss(sanMoves);
+    std::string sanMove;
+    while (std::getline(ss, sanMove, ' '))
+      push_san(sanMove, notation);
+  }
+
+  std::string pocket(bool color) {
+    const Color c = Color(!color);
+    std::string pocket;
+    for (PieceType pt = KING; pt >= PAWN; --pt) {
+      for (int i = 0; i < pos.count_in_hand(c, pt); ++i) {
+        // only create BLACK pieces in order to convert to lower case
+        pocket += std::string(1, pos.piece_to_char()[make_piece(BLACK, pt)]);
+      }
+    }
+    return pocket;
+  }
+
+  std::string to_string() {
+    std::string stringBoard;
+    for (Rank r = pos.max_rank(); r >= RANK_1; --r) {
+      for (File f = FILE_A; f <= pos.max_file(); ++f) {
+        if (f != FILE_A)
+          stringBoard += " ";
+        const Piece p = pos.piece_on(make_square(f, r));
+        switch(p) {
+        case NO_PIECE:
+          stringBoard += '.';
+          break;
+        default:
+          stringBoard += pos.piece_to_char()[p];
+        }
+      }
+      if (r != RANK_1)
+        stringBoard += "\n";
+    }
+    return stringBoard;
+  }
+
+  std::string to_verbose_string() {
+    std::stringstream ss;
+    operator<<(ss, pos);
+    return ss.str();
+  }
+
+  std::string variant() {
+    // Iterate through the variants map
+    for (auto it = variants.begin(); it != variants.end(); ++it)
+      if (it->second == v)
+        return it->first;
+
+    std::cerr << "Current variant is not registered." << std::endl;
+    return "unknown";
+  }
+
+private:
+  void resetStates() {
+    this->states = StateListPtr(new std::deque<StateInfo>(1));
+  }
+
+  void do_move(Move move) {
+    states->emplace_back();
+    this->pos.do_move(move, states->back());
+    this->moveStack.emplace_back(move);
+  }
+
+  void init(std::string uciVariant, std::string fen, bool is960) {
+    if (!Board::sfInitialized) {
+      initialize_stockfish();
+      Board::sfInitialized = true;
+    }
+    v = get_variant(uciVariant);
+    UCI::init_variant(v);
+    this->resetStates();
+    if (fen == "")
+      fen = v->startFen;
+    this->pos.set(this->v, fen, is960, &this->states->back(), this->thread);
+    this->is960 = is960;
+  }
+};
+
+bool Board::sfInitialized = false;
+
+namespace ffish {
+  // returns the version of the Fairy-Stockfish binary
+  std::string info() {
+    return engine_info();
+  }
+
+  template <typename T>
+  void set_option(std::string name, T value) {
+    Options[name] = value;
+    Board::sfInitialized = false;
+  }
+
+  std::string available_variants() {
+    std::string availableVariants;
+    for (std::string variant : variants.get_keys()) {
+      availableVariants += variant;
+      availableVariants += DELIM;
+    }
+    save_pop_back(availableVariants);
+    return availableVariants;
+  }
+
+  void load_variant_config(std::string variantInitContent) {
+    std::stringstream ss(variantInitContent);
+    if (!Board::sfInitialized)
+      initialize_stockfish();
+    variants.parse_istream<false>(ss);
+    Options["UCI_Variant"].set_combo(variants.get_keys());
+    Board::sfInitialized = true;
+  }
+
+  bool captures_to_hand(std::string uciVariant) {
+    const Variant* v = get_variant(uciVariant);
+    return v->capturesToHand;
+  }
+
+  std::string starting_fen(std::string uciVariant) {
+    const Variant* v = get_variant(uciVariant);
+    return v->startFen;
+  }
+
+  int validate_fen(std::string fen, std::string uciVariant, bool chess960) {
+    const Variant* v = get_variant(uciVariant);
+    return FEN::validate_fen(fen, v, chess960);
+  }
+
+  int validate_fen(std::string fen, std::string uciVariant) {
+    return validate_fen(fen, uciVariant, false);
+  }
+
+  int validate_fen(std::string fen) {
+    return validate_fen(fen, "chess");
+  }
+}
+
+class Game {
+private:
+  std::unordered_map<std::string, std::string> header;
+  std::unique_ptr<Board> board;
+  std::string variant = "chess";
+  std::string fen = ""; // start pos
+  bool is960 = false;
+  bool parsedGame = false;
+public:
+  std::string header_keys() {
+    std::string keys;
+    for (auto it = header.begin(); it != header.end(); ++it) {
+      keys += it->first;
+      keys += DELIM;
+    }
+    save_pop_back(keys);
+    return keys;
+  }
+
+  std::string headers(std::string item) {
+    auto it = header.find(item);
+    if (it == header.end())
+      return "";
+    return it->second;
+  }
+
+  std::string mainline_moves() {
+    if (!parsedGame)
+    return "";
+    return board->move_stack();
+  }
+
+  friend Game read_game_pgn(std::string);
+};
+
+
+bool skip_comment(const std::string& pgn, size_t& curIdx, size_t& lineEnd) {
+  curIdx = pgn.find('}', curIdx);
+  if (curIdx == std::string::npos) {
+    std::cerr << "Missing '}' for move comment while reading pgn." << std::endl;
+    return false;
+  }
+  if (curIdx > lineEnd)
+    lineEnd = pgn.find('\n', curIdx);
+  return true;
+}
+
+Game read_game_pgn(std::string pgn) {
+  Game game;
+  size_t lineStart = 0;
+  bool headersParsed = false;
+
+  while(true) {
+    size_t lineEnd = pgn.find('\n', lineStart);
+
+    if (lineEnd == std::string::npos)
+      lineEnd = pgn.size();
+
+    if (!headersParsed && pgn[lineStart] == '[') {
+      // parse header
+      // look for item
+      size_t headerKeyStart = lineStart+1;
+      size_t headerKeyEnd = pgn.find(' ', lineStart);
+      size_t headerItemStart = pgn.find('"', headerKeyEnd)+1;
+      size_t headerItemEnd = pgn.find('"', headerItemStart);
+
+      // put item into list
+      game.header[pgn.substr(headerKeyStart, headerKeyEnd-headerKeyStart)] = pgn.substr(headerItemStart, headerItemEnd-headerItemStart);
+    }
+    else {
+      if (!headersParsed) {
+        headersParsed = true;
+        auto it = game.header.find("Variant");
+        if (it != game.header.end()) {
+          game.is960 = it->second.find("960", it->second.size() - 3) != std::string::npos;
+          if (game.is960) {
+            game.variant = it->second.substr(0, it->second.size() - 3);
+          } else {
+            game.variant = it->second;
+          }
+          std::transform(game.variant.begin(), game.variant.end(), game.variant.begin(),
+          [](unsigned char c){ return std::tolower(c); });
+        }
+
+        it = game.header.find("FEN");
+        if (it != game.header.end())
+          game.fen = it->second;
+
+        game.board = std::make_unique<Board>(game.variant, game.fen, game.is960);
+        game.parsedGame = true;
+      }
+
+      // game line
+      size_t curIdx = lineStart;
+      while (curIdx <= lineEnd) {
+        if (pgn[curIdx] == '*')
+          return game;
+
+        if (pgn[curIdx] == '{') {
+          if (!skip_comment(pgn, curIdx, lineEnd))
+            return game;
+          ++curIdx;
+        }
+
+        // Movetext RAV (Recursive Annotation Variation)
+        size_t openedRAV = 0;
+        if (pgn[curIdx] == '(') {
+          openedRAV = 1;
+          ++curIdx;
+        }
+        while (openedRAV != 0) {
+          switch (pgn[curIdx]) {
+            case '(':
+              ++openedRAV;
+              break;
+            case ')':
+              --openedRAV;
+              break;
+            case '{':
+              if (!skip_comment(pgn, curIdx, lineEnd))
+                return game;
+            default: ;  // pass
+          }
+          ++curIdx;
+          if (curIdx > lineEnd)
+            lineEnd = pgn.find('\n', curIdx);
+        }
+
+        if (pgn[curIdx] == '$') {
+          // we are at a glyph
+          curIdx = pgn.find(' ', curIdx);
+        }
+
+        if (pgn[curIdx] >= '0' && pgn[curIdx] <= '9') {
+          // we are at a move number -> look for next point
+          curIdx = pgn.find('.', curIdx);
+          if (curIdx == std::string::npos)
+            break;
+          ++curIdx;
+          // increment if we're at a space
+          while (curIdx < pgn.size() && pgn[curIdx] == ' ')
+            ++curIdx;
+          // increment if we're at a point
+          while (curIdx < pgn.size() && pgn[curIdx] == '.')
+            ++curIdx;
+        }
+        // extract sanMove
+        size_t sanMoveEnd = std::min(pgn.find(' ', curIdx), lineEnd);
+        if (sanMoveEnd > curIdx) {
+          std::string sanMove = pgn.substr(curIdx, sanMoveEnd-curIdx);
+          // clean possible ? and ! from string
+          size_t annotationChar1 = sanMove.find('?');
+          size_t annotationChar2 = sanMove.find('!');
+          if (annotationChar1 != std::string::npos || annotationChar2 != std::string::npos)
+            sanMove = sanMove.substr(0, std::min(annotationChar1, annotationChar2));
+          std::cout << sanMove << " ";
+          game.board->push_san(sanMove);
+        }
+        curIdx = sanMoveEnd+1;
+      }
+    }
+    lineStart = lineEnd+1;
+
+    if (lineStart >= pgn.size())
+      return game;
+  }
+  return game;
+}
+
+
+// binding code
+EMSCRIPTEN_BINDINGS(ffish_js) {
+  class_<Board>("Board")
+    .constructor<>()
+    .constructor<std::string>()
+    .constructor<std::string, std::string>()
+    .constructor<std::string, std::string, bool>()
+    .function("legalMoves", &Board::legal_moves)
+    .function("legalMovesSan", &Board::legal_moves_san)
+    .function("numberLegalMoves", &Board::number_legal_moves)
+    .function("push", &Board::push)
+    .function("pushSan", select_overload<bool(std::string)>(&Board::push_san))
+    .function("pushSan", select_overload<bool(std::string, Notation)>(&Board::push_san))
+    .function("pop", &Board::pop)
+    .function("reset", &Board::reset)
+    .function("is960", &Board::is_960)
+    .function("fen", select_overload<std::string()const>(&Board::fen))
+    .function("fen", select_overload<std::string(bool)const>(&Board::fen))
+    .function("fen", select_overload<std::string(bool, int)const>(&Board::fen))
+    .function("setFen", &Board::set_fen)
+    .function("sanMove", select_overload<std::string(std::string)>(&Board::san_move))
+    .function("sanMove", select_overload<std::string(std::string, Notation)>(&Board::san_move))
+    .function("variationSan", select_overload<std::string(std::string)>(&Board::variation_san))
+    .function("variationSan", select_overload<std::string(std::string, Notation)>(&Board::variation_san))
+    .function("variationSan", select_overload<std::string(std::string, Notation, bool)>(&Board::variation_san))
+    .function("turn", &Board::turn)
+    .function("fullmoveNumber", &Board::fullmove_number)
+    .function("halfmoveClock", &Board::halfmove_clock)
+    .function("gamePly", &Board::game_ply)
+    .function("hasInsufficientMaterial", &Board::has_insufficient_material)
+    .function("isInsufficientMaterial", &Board::is_insufficient_material)
+    .function("isGameOver", select_overload<bool() const>(&Board::is_game_over))
+    .function("isGameOver", select_overload<bool(bool) const>(&Board::is_game_over))
+    .function("result", select_overload<std::string() const>(&Board::result))
+    .function("result", select_overload<std::string(bool) const>(&Board::result))
+    .function("checkedPieces", &Board::checked_pieces)
+    .function("isCheck", &Board::is_check)
+    .function("isBikjang", &Board::is_bikjang)
+    .function("isCapture", &Board::is_capture)
+    .function("moveStack", &Board::move_stack)
+    .function("pushMoves", &Board::push_moves)
+    .function("pushSanMoves", select_overload<void(std::string)>(&Board::push_san_moves))
+    .function("pushSanMoves", select_overload<void(std::string, Notation)>(&Board::push_san_moves))
+    .function("pocket", &Board::pocket)
+    .function("toString", &Board::to_string)
+    .function("toVerboseString", &Board::to_verbose_string)
+    .function("variant", &Board::variant);
+  class_<Game>("Game")
+    .function("headerKeys", &Game::header_keys)
+    .function("headers", &Game::headers)
+    .function("mainlineMoves", &Game::mainline_moves);
+  // usage: e.g. ffish.Notation.DEFAULT
+  enum_<Notation>("Notation")
+    .value("DEFAULT", NOTATION_DEFAULT)
+    .value("SAN", NOTATION_SAN)
+    .value("LAN", NOTATION_LAN)
+    .value("SHOGI_HOSKING", NOTATION_SHOGI_HOSKING)
+    .value("SHOGI_HODGES", NOTATION_SHOGI_HODGES)
+    .value("SHOGI_HODGES_NUMBER", NOTATION_SHOGI_HODGES_NUMBER)
+    .value("JANGGI", NOTATION_JANGGI)
+    .value("XIANGQI_WXF", NOTATION_XIANGQI_WXF)
+    .value("THAI_SAN", NOTATION_THAI_SAN)
+    .value("THAI_LAN", NOTATION_THAI_LAN);
+  // usage: e.g. ffish.Termination.CHECKMATE
+  enum_<Termination>("Termination")
+    .value("ONGOING", ONGOING)
+    .value("CHECKMATE", CHECKMATE)
+    .value("STALEMATE", STALEMATE)
+    .value("INSUFFICIENT_MATERIAL", INSUFFICIENT_MATERIAL)
+    .value("N_MOVE_RULE", N_MOVE_RULE)
+    .value("N_FOLD_REPETITION", N_FOLD_REPETITION)
+    .value("VARIANT_END", VARIANT_END);
+  function("info", &ffish::info);
+  function("setOption", &ffish::set_option<std::string>);
+  function("setOptionInt", &ffish::set_option<int>);
+  function("setOptionBool", &ffish::set_option<bool>);
+  function("readGamePGN", &read_game_pgn);
+  function("variants", &ffish::available_variants);
+  function("loadVariantConfig", &ffish::load_variant_config);
+  function("capturesToHand", &ffish::captures_to_hand);
+  function("startingFen", &ffish::starting_fen);
+  function("validateFen", select_overload<int(std::string)>(&ffish::validate_fen));
+  function("validateFen", select_overload<int(std::string, std::string)>(&ffish::validate_fen));
+  function("validateFen", select_overload<int(std::string, std::string, bool)>(&ffish::validate_fen));
+  // TODO: enable to string conversion method
+  // .class_function("getStringFromInstance", &Board::get_string_from_instance);
+}

Fairy-Stockfish-master/src/incbin/UNLICENCE

@@ -0,0 +1,26 @@
+The file "incbin.h" is free and unencumbered software released into
+the public domain by Dale Weiler, see:
+   <https://github.com/graphitemaster/incbin>
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

Fairy-Stockfish-master/src/incbin/incbin.h

@@ -0,0 +1,368 @@
+/**
+ * @file incbin.h
+ * @author Dale Weiler
+ * @brief Utility for including binary files
+ *
+ * Facilities for including binary files into the current translation unit and
+ * making use from them externally in other translation units.
+ */
+#ifndef INCBIN_HDR
+#define INCBIN_HDR
+#include <limits.h>
+#if   defined(__AVX512BW__) || \
+      defined(__AVX512CD__) || \
+      defined(__AVX512DQ__) || \
+      defined(__AVX512ER__) || \
+      defined(__AVX512PF__) || \
+      defined(__AVX512VL__) || \
+      defined(__AVX512F__)
+# define INCBIN_ALIGNMENT_INDEX 6
+#elif defined(__AVX__)      || \
+      defined(__AVX2__)
+# define INCBIN_ALIGNMENT_INDEX 5
+#elif defined(__SSE__)      || \
+      defined(__SSE2__)     || \
+      defined(__SSE3__)     || \
+      defined(__SSSE3__)    || \
+      defined(__SSE4_1__)   || \
+      defined(__SSE4_2__)   || \
+      defined(__neon__)
+# define INCBIN_ALIGNMENT_INDEX 4
+#elif ULONG_MAX != 0xffffffffu
+# define INCBIN_ALIGNMENT_INDEX 3
+# else
+# define INCBIN_ALIGNMENT_INDEX 2
+#endif
+
+/* Lookup table of (1 << n) where `n' is `INCBIN_ALIGNMENT_INDEX' */
+#define INCBIN_ALIGN_SHIFT_0 1
+#define INCBIN_ALIGN_SHIFT_1 2
+#define INCBIN_ALIGN_SHIFT_2 4
+#define INCBIN_ALIGN_SHIFT_3 8
+#define INCBIN_ALIGN_SHIFT_4 16
+#define INCBIN_ALIGN_SHIFT_5 32
+#define INCBIN_ALIGN_SHIFT_6 64
+
+/* Actual alignment value */
+#define INCBIN_ALIGNMENT \
+    INCBIN_CONCATENATE( \
+        INCBIN_CONCATENATE(INCBIN_ALIGN_SHIFT, _), \
+        INCBIN_ALIGNMENT_INDEX)
+
+/* Stringize */
+#define INCBIN_STR(X) \
+    #X
+#define INCBIN_STRINGIZE(X) \
+    INCBIN_STR(X)
+/* Concatenate */
+#define INCBIN_CAT(X, Y) \
+    X ## Y
+#define INCBIN_CONCATENATE(X, Y) \
+    INCBIN_CAT(X, Y)
+/* Deferred macro expansion */
+#define INCBIN_EVAL(X) \
+    X
+#define INCBIN_INVOKE(N, ...) \
+    INCBIN_EVAL(N(__VA_ARGS__))
+
+/* Green Hills uses a different directive for including binary data */
+#if defined(__ghs__)
+#  if (__ghs_asm == 2)
+#    define INCBIN_MACRO ".file"
+/* Or consider the ".myrawdata" entry in the ld file */
+#  else
+#    define INCBIN_MACRO "\tINCBIN"
+#  endif
+#else
+#  define INCBIN_MACRO ".incbin"
+#endif
+
+#ifndef _MSC_VER
+#  define INCBIN_ALIGN \
+    __attribute__((aligned(INCBIN_ALIGNMENT)))
+#else
+#  define INCBIN_ALIGN __declspec(align(INCBIN_ALIGNMENT))
+#endif
+
+#if defined(__arm__) || /* GNU C and RealView */ \
+    defined(__arm) || /* Diab */ \
+    defined(_ARM) /* ImageCraft */
+#  define INCBIN_ARM
+#endif
+
+#ifdef __GNUC__
+/* Utilize .balign where supported */
+#  define INCBIN_ALIGN_HOST ".balign " INCBIN_STRINGIZE(INCBIN_ALIGNMENT) "\n"
+#  define INCBIN_ALIGN_BYTE ".balign 1\n"
+#elif defined(INCBIN_ARM)
+/*
+ * On arm assemblers, the alignment value is calculated as (1 << n) where `n' is
+ * the shift count. This is the value passed to `.align'
+ */
+#  define INCBIN_ALIGN_HOST ".align " INCBIN_STRINGIZE(INCBIN_ALIGNMENT_INDEX) "\n"
+#  define INCBIN_ALIGN_BYTE ".align 0\n"
+#else
+/* We assume other inline assembler's treat `.align' as `.balign' */
+#  define INCBIN_ALIGN_HOST ".align " INCBIN_STRINGIZE(INCBIN_ALIGNMENT) "\n"
+#  define INCBIN_ALIGN_BYTE ".align 1\n"
+#endif
+
+/* INCBIN_CONST is used by incbin.c generated files */
+#if defined(__cplusplus)
+#  define INCBIN_EXTERNAL extern "C"
+#  define INCBIN_CONST    extern const
+#else
+#  define INCBIN_EXTERNAL extern
+#  define INCBIN_CONST    const
+#endif
+
+/**
+ * @brief Optionally override the linker section into which data is emitted.
+ *
+ * @warning If you use this facility, you'll have to deal with platform-specific linker output
+ * section naming on your own
+ *
+ * Overriding the default linker output section, e.g for esp8266/Arduino:
+ * @code
+ * #define INCBIN_OUTPUT_SECTION ".irom.text"
+ * #include "incbin.h"
+ * INCBIN(Foo, "foo.txt");
+ * // Data is emitted into program memory that never gets copied to RAM
+ * @endcode
+ */
+#if !defined(INCBIN_OUTPUT_SECTION)
+#  if defined(__APPLE__)
+#    define INCBIN_OUTPUT_SECTION         ".const_data"
+#  else
+#    define INCBIN_OUTPUT_SECTION         ".rodata"
+#  endif
+#endif
+
+#if defined(__APPLE__)
+/* The directives are different for Apple branded compilers */
+#  define INCBIN_SECTION         INCBIN_OUTPUT_SECTION "\n"
+#  define INCBIN_GLOBAL(NAME)    ".globl " INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME "\n"
+#  define INCBIN_INT             ".long "
+#  define INCBIN_MANGLE          "_"
+#  define INCBIN_BYTE            ".byte "
+#  define INCBIN_TYPE(...)
+#else
+#  define INCBIN_SECTION         ".section " INCBIN_OUTPUT_SECTION "\n"
+#  define INCBIN_GLOBAL(NAME)    ".global " INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME "\n"
+#  if defined(__ghs__)
+#    define INCBIN_INT           ".word "
+#  else
+#    define INCBIN_INT           ".int "
+#  endif
+#  if defined(__USER_LABEL_PREFIX__)
+#    define INCBIN_MANGLE        INCBIN_STRINGIZE(__USER_LABEL_PREFIX__)
+#  else
+#    define INCBIN_MANGLE        ""
+#  endif
+#  if defined(INCBIN_ARM)
+/* On arm assemblers, `@' is used as a line comment token */
+#    define INCBIN_TYPE(NAME)    ".type " INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME ", %object\n"
+#  elif defined(__MINGW32__) || defined(__MINGW64__)
+/* Mingw doesn't support this directive either */
+#    define INCBIN_TYPE(NAME)
+#  else
+/* It's safe to use `@' on other architectures */
+#    define INCBIN_TYPE(NAME)    ".type " INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME ", @object\n"
+#  endif
+#  define INCBIN_BYTE            ".byte "
+#endif
+
+/* List of style types used for symbol names */
+#define INCBIN_STYLE_CAMEL 0
+#define INCBIN_STYLE_SNAKE 1
+
+/**
+ * @brief Specify the prefix to use for symbol names.
+ *
+ * By default this is `g', producing symbols of the form:
+ * @code
+ * #include "incbin.h"
+ * INCBIN(Foo, "foo.txt");
+ *
+ * // Now you have the following symbols:
+ * // const unsigned char gFooData[];
+ * // const unsigned char *const gFooEnd;
+ * // const unsigned int gFooSize;
+ * @endcode
+ *
+ * If however you specify a prefix before including: e.g:
+ * @code
+ * #define INCBIN_PREFIX incbin
+ * #include "incbin.h"
+ * INCBIN(Foo, "foo.txt");
+ *
+ * // Now you have the following symbols instead:
+ * // const unsigned char incbinFooData[];
+ * // const unsigned char *const incbinFooEnd;
+ * // const unsigned int incbinFooSize;
+ * @endcode
+ */
+#if !defined(INCBIN_PREFIX)
+#  define INCBIN_PREFIX g
+#endif
+
+/**
+ * @brief Specify the style used for symbol names.
+ *
+ * Possible options are
+ * - INCBIN_STYLE_CAMEL "CamelCase"
+ * - INCBIN_STYLE_SNAKE "snake_case"
+ *
+ * Default option is *INCBIN_STYLE_CAMEL* producing symbols of the form:
+ * @code
+ * #include "incbin.h"
+ * INCBIN(Foo, "foo.txt");
+ *
+ * // Now you have the following symbols:
+ * // const unsigned char <prefix>FooData[];
+ * // const unsigned char *const <prefix>FooEnd;
+ * // const unsigned int <prefix>FooSize;
+ * @endcode
+ *
+ * If however you specify a style before including: e.g:
+ * @code
+ * #define INCBIN_STYLE INCBIN_STYLE_SNAKE
+ * #include "incbin.h"
+ * INCBIN(foo, "foo.txt");
+ *
+ * // Now you have the following symbols:
+ * // const unsigned char <prefix>foo_data[];
+ * // const unsigned char *const <prefix>foo_end;
+ * // const unsigned int <prefix>foo_size;
+ * @endcode
+ */
+#if !defined(INCBIN_STYLE)
+#  define INCBIN_STYLE INCBIN_STYLE_CAMEL
+#endif
+
+/* Style lookup tables */
+#define INCBIN_STYLE_0_DATA Data
+#define INCBIN_STYLE_0_END End
+#define INCBIN_STYLE_0_SIZE Size
+#define INCBIN_STYLE_1_DATA _data
+#define INCBIN_STYLE_1_END _end
+#define INCBIN_STYLE_1_SIZE _size
+
+/* Style lookup: returning identifier */
+#define INCBIN_STYLE_IDENT(TYPE) \
+    INCBIN_CONCATENATE( \
+        INCBIN_STYLE_, \
+        INCBIN_CONCATENATE( \
+            INCBIN_EVAL(INCBIN_STYLE), \
+            INCBIN_CONCATENATE(_, TYPE)))
+
+/* Style lookup: returning string literal */
+#define INCBIN_STYLE_STRING(TYPE) \
+    INCBIN_STRINGIZE( \
+        INCBIN_STYLE_IDENT(TYPE)) \
+
+/* Generate the global labels by indirectly invoking the macro with our style
+ * type and concatenating the name against them. */
+#define INCBIN_GLOBAL_LABELS(NAME, TYPE) \
+    INCBIN_INVOKE( \
+        INCBIN_GLOBAL, \
+        INCBIN_CONCATENATE( \
+            NAME, \
+            INCBIN_INVOKE( \
+                INCBIN_STYLE_IDENT, \
+                TYPE))) \
+    INCBIN_INVOKE( \
+        INCBIN_TYPE, \
+        INCBIN_CONCATENATE( \
+            NAME, \
+            INCBIN_INVOKE( \
+                INCBIN_STYLE_IDENT, \
+                TYPE)))
+
+/**
+ * @brief Externally reference binary data included in another translation unit.
+ *
+ * Produces three external symbols that reference the binary data included in
+ * another translation unit.
+ *
+ * The symbol names are a concatenation of `INCBIN_PREFIX' before *NAME*; with
+ * "Data", as well as "End" and "Size" after. An example is provided below.
+ *
+ * @param NAME The name given for the binary data
+ *
+ * @code
+ * INCBIN_EXTERN(Foo);
+ *
+ * // Now you have the following symbols:
+ * // extern const unsigned char <prefix>FooData[];
+ * // extern const unsigned char *const <prefix>FooEnd;
+ * // extern const unsigned int <prefix>FooSize;
+ * @endcode
+ */
+#define INCBIN_EXTERN(NAME) \
+    INCBIN_EXTERNAL const INCBIN_ALIGN unsigned char \
+        INCBIN_CONCATENATE( \
+            INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), \
+            INCBIN_STYLE_IDENT(DATA))[]; \
+    INCBIN_EXTERNAL const INCBIN_ALIGN unsigned char *const \
+    INCBIN_CONCATENATE( \
+        INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), \
+        INCBIN_STYLE_IDENT(END)); \
+    INCBIN_EXTERNAL const unsigned int \
+        INCBIN_CONCATENATE( \
+            INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), \
+            INCBIN_STYLE_IDENT(SIZE))
+
+/**
+ * @brief Include a binary file into the current translation unit.
+ *
+ * Includes a binary file into the current translation unit, producing three symbols
+ * for objects that encode the data and size respectively.
+ *
+ * The symbol names are a concatenation of `INCBIN_PREFIX' before *NAME*; with
+ * "Data", as well as "End" and "Size" after. An example is provided below.
+ *
+ * @param NAME The name to associate with this binary data (as an identifier.)
+ * @param FILENAME The file to include (as a string literal.)
+ *
+ * @code
+ * INCBIN(Icon, "icon.png");
+ *
+ * // Now you have the following symbols:
+ * // const unsigned char <prefix>IconData[];
+ * // const unsigned char *const <prefix>IconEnd;
+ * // const unsigned int <prefix>IconSize;
+ * @endcode
+ *
+ * @warning This must be used in global scope
+ * @warning The identifiers may be different if INCBIN_STYLE is not default
+ *
+ * To externally reference the data included by this in another translation unit
+ * please @see INCBIN_EXTERN.
+ */
+#ifdef _MSC_VER
+#define INCBIN(NAME, FILENAME) \
+    INCBIN_EXTERN(NAME)
+#else
+#define INCBIN(NAME, FILENAME) \
+    __asm__(INCBIN_SECTION \
+            INCBIN_GLOBAL_LABELS(NAME, DATA) \
+            INCBIN_ALIGN_HOST \
+            INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(DATA) ":\n" \
+            INCBIN_MACRO " \"" FILENAME "\"\n" \
+            INCBIN_GLOBAL_LABELS(NAME, END) \
+            INCBIN_ALIGN_BYTE \
+            INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(END) ":\n" \
+                INCBIN_BYTE "1\n" \
+            INCBIN_GLOBAL_LABELS(NAME, SIZE) \
+            INCBIN_ALIGN_HOST \
+            INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(SIZE) ":\n" \
+                INCBIN_INT INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(END) " - " \
+                           INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(DATA) "\n" \
+            INCBIN_ALIGN_HOST \
+            ".text\n" \
+    ); \
+    INCBIN_EXTERN(NAME)
+
+#endif
+#endif

Fairy-Stockfish-master/src/magic.h

@@ -0,0 +1,1741 @@
+/*
+  Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish
+  Copyright (C) 2018-2022 Fabian Fichter
+
+  Fairy-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.
+
+  Fairy-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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef MAGIC_H_INCLUDED
+#define MAGIC_H_INCLUDED
+
+namespace Stockfish {
+
+#ifdef PRECOMPUTED_MAGICS
+#define B(a, b) (Bitboard(a) << 64) ^ Bitboard(b)
+  // Use precomputed magics if pext is not available,
+  // since the magics generation is very slow.
+  constexpr Bitboard RookMagicHInit[SQUARE_NB] = {
+      B(0x120000880110000, 0x1008000000020020),
+      B(0x24200C080840A052, 0x2004004000010008),
+      B(0xC030024000228800, 0x4000010400000020),
+      B(0x1A0020802008802, 0x206010208000),
+      B(0x12002000D001024, 0x80100800090138),
+      B(0x4220010000241010, 0x3098000602001500),
+      B(0x401010004801040, 0x8000280480100000),
+      B(0x820082024921836, 0x220028000),
+      B(0x100400502411400, 0x220402120240D14),
+      B(0x880202020010404, 0xA80202510000),
+      B(0x140002801000018, 0x1000346490040),
+      B(0x120000880110000, 0x1008000000020020),
+      B(0xD01004008030400, 0x104000408104420),
+      B(0x8420060100020000, 0x800280400000120),
+      B(0x4010020018010, 0x40A00001100000),
+      B(0x40006A0004000200, 0x40000000110),
+      B(0xD01004008030400, 0x104000408104420),
+      B(0x8908A20028110011, 0x800080000001A114),
+      B(0x200042000080F009, 0x20001000004000),
+      B(0x2820008820100, 0x10002400058000B9),
+      B(0x6083100420008050, 0x4040012600280080),
+      B(0x216020000000446, 0x4080204000000211),
+      B(0x340140003002089, 0x2402008000000911),
+      B(0xD01004008030400, 0x104000408104420),
+      B(0x1404040B20001000, 0x8000824010800011),
+      B(0x8C0488120024214, 0x8414880202291),
+      B(0x1010000060050000, 0x4000004050002602),
+      B(0x4022983A0060000, 0x80000040010400),
+      B(0x1404040B20001000, 0x8000824010800011),
+      B(0x6020101802002840, 0x31000003000004),
+      B(0x9000420008840, 0x4881300000000210),
+      B(0xA200808865, 0x41C0048023000128),
+      B(0x31801100400000, 0x8802DC001221240),
+      B(0x884000080200920, 0x1004002410401001),
+      B(0x2400040000884, 0x421006208040C0),
+      B(0x1404040B20001000, 0x8000824010800011),
+      B(0x24100400060009, 0x112008025042410),
+      B(0x1800040009040200, 0x180000A1004E408A),
+      B(0x24100400060009, 0x112008025042410),
+      B(0x4060402008080, 0xC240080000110000),
+      B(0x20080100920020, 0x2002248010242052),
+      B(0x10001010802050, 0x880000001C98420),
+      B(0x4000800100420022, 0x502022010A00D0),
+      B(0x4C18104500200885, 0x400880800),
+      B(0x8080810081020090, 0x8000000000000),
+      B(0x8000062812080201, 0x8004C8300800),
+      B(0xC010220920198, 0x85000A08000),
+      B(0x24100400060009, 0x112008025042410),
+      B(0x80102204040, 0x1000000900000000),
+      B(0x2080000004202804, 0x120880003461),
+      B(0x102004090A4030, 0x801020589240),
+      B(0x20001100814000A0, 0x420202000820004),
+      B(0x100800000A000120, 0x208000800010000),
+      B(0x1008205000040802, 0x80002000400040),
+      B(0x1480000098008401, 0xA0010000581010),
+      B(0x30C0008200100820, 0x102800080904834),
+      B(0x4810821884000500, 0x4400000200000212),
+      B(0x1811D00128A0180, 0x2500848803000000),
+      B(0x41618A0300040040, 0x21200200A421801),
+      B(0x80102204040, 0x1000000900000000),
+      B(0xA1808E0100108000, 0x2008000505000002),
+      B(0x8C890020410000A0, 0xA010000048000400),
+      B(0x40006002210044, 0x600008000408000),
+      B(0x1200447220090042, 0x80001000160012),
+      B(0x48410010AB000000, 0x9200600000000100),
+      B(0x2040000000240003, 0x8020080288000600),
+      B(0x9080000088848088, 0x4010210500000041),
+      B(0xA1808E0100108000, 0x2008000505000002),
+      B(0x480100400024, 0x1004800018200000),
+      B(0x808403080080200, 0x802601000000500),
+      B(0x8C890020410000A0, 0xA010000048000400),
+      B(0xA1808E0100108000, 0x2008000505000002),
+      B(0x100A40000004008, 0x2800200400200480),
+      B(0x100A40000004008, 0x2800200400200480),
+      B(0x400014006000000, 0x10006000810001F5),
+      B(0xC410062001414, 0x820080041B01044),
+      B(0x20000800310, 0x430040000201000),
+      B(0xA40010008000008, 0x4002200028000040),
+      B(0xC00102000008021C, 0x10C2000A010E024),
+      B(0x80004200104008, 0x50A00800C400020),
+      B(0x20200080012542, 0x910F0040000402C0),
+      B(0xB040100504000300, 0x24802002000040),
+      B(0x800001000014008, 0x400031004000),
+      B(0x100A40000004008, 0x2800200400200480),
+      B(0x84008002041081C0, 0x8080500200000000),
+      B(0x440090001012001, 0x4020004010),
+      B(0x100A0028088020, 0x80040E00010020),
+      B(0x2180808000810, 0xB018040A00040000),
+      B(0x40C80920304C4001, 0x42800B200800000),
+      B(0x85000425001000, 0x4810048020001100),
+      B(0x600C000801000004, 0x8015084010200020),
+      B(0x20020050000240C0, 0x100202008600800),
+      B(0x38000050001220, 0x9200010200145900),
+      B(0x1042108040005, 0x1402A0802201001),
+      B(0x824240000C20400, 0x1000000400080010),
+      B(0x84008002041081C0, 0x8080500200000000),
+      B(0x400804A1000008, 0x1024104A0200010),
+      B(0x8000402308483, 0x20006020100100),
+      B(0x80880120000080, 0x8000240100084),
+      B(0x5840020004882001, 0x1004528000A00010),
+      B(0x8001018800300002, 0x84010040804),
+      B(0x180D10004000A008, 0xA001080008020004),
+      B(0x400080B, 0x10A0000004010000),
+      B(0x8080000200000, 0x2001000082004E0),
+      B(0x40040001000C2000, 0x2024800001004008),
+      B(0x400804A1000008, 0x1024104A0200010),
+      B(0x8000402308483, 0x20006020100100),
+      B(0x400804A1000008, 0x1024104A0200010),
+      B(0x2000200000, 0x1201011000802),
+      B(0x100100000000C4, 0x208004084048201),
+      B(0x400084000044, 0x100810140300),
+      B(0x29040C0C01010, 0x300204010820080),
+      B(0x1A808000020200, 0x1000000005210040),
+      B(0x20000400150000, 0x85008020),
+      B(0x40C040008184014, 0x8002AA00024010),
+      B(0x202000081B00804, 0x10001002008),
+      B(0x40011000210060, 0x6080C40000021004),
+      B(0x2000200000, 0x1201011000802),
+      B(0x4100480203840, 0x300080100804),
+      B(0x2000200000, 0x1201011000802),
+  };
+  constexpr Bitboard RookMagicVInit[SQUARE_NB] = {
+      B(0x202000812104400, 0x24800B01C0000303),
+      B(0x340020400010D, 0x88060150C00400),
+      B(0x400802040609, 0x49010200501A0002),
+      B(0x8002680301000208, 0x628006C0C020200),
+      B(0x20400209001C0804, 0xA044000800143110),
+      B(0xC400082060010202, 0x4000480401014000),
+      B(0x22500200144040, 0x8204820084704C00),
+      B(0x8C1204009030020, 0x328400805000000),
+      B(0x84800800D0001640, 0x200080040060108),
+      B(0x804810208020040, 0x140010108020000),
+      B(0x1102010B008004, 0x300208006220020),
+      B(0x140080404A0A2428, 0x6308010100080),
+      B(0x20444002120408, 0xA080010508010001),
+      B(0x82011044000D02, 0x4112028620110809),
+      B(0x81010831000C02, 0x408802085000000),
+      B(0x81010831000C02, 0x408802085000000),
+      B(0x920008920600040, 0x8053801004000028),
+      B(0x81140283208300, 0x10040C004200420),
+      B(0x103080022201, 0xC01000081312620),
+      B(0x2200221100008, 0x1000408104000A4),
+      B(0x4402088080042008, 0x210401501040340),
+      B(0x898400202170001, 0x80040404208000),
+      B(0x20080004051012, 0x5100048200081800),
+      B(0x2320020000401018, 0x108501021040210),
+      B(0x21080410A422021, 0x83040180008800),
+      B(0x44E8100000408224, 0x20010008040400),
+      B(0x1800240002810405, 0x23004820000020),
+      B(0x80A0100400110, 0x80104020100C4028),
+      B(0x1002050001222C0, 0x5100818004024020),
+      B(0x104000200040, 0xC010A09800102000),
+      B(0x1020003A058120, 0x450900809000302),
+      B(0x40040045008B1, 0x202800400383010),
+      B(0x4640200220034, 0x8800485420304000),
+      B(0x5001042100084288, 0x110820001240080A),
+      B(0x2002C04004010120, 0xA15008020880001),
+      B(0x2800004080C4190, 0x890808280020080),
+      B(0x40C0401000104000, 0x2020880008002580),
+      B(0x40020C002400802, 0x801104010000000),
+      B(0x44842000040080, 0x2050011084000400),
+      B(0x4110040800000401, 0x2023810029008000),
+      B(0x20884000840, 0x8017102004008000),
+      B(0x10411104000480, 0x1414042000201001),
+      B(0x220040000008, 0x800306021000000),
+      B(0x41400A0008080, 0x501000298ACAD10),
+      B(0x800240012831810, 0x80120004468050E),
+      B(0x800005020801008, 0x20102400240000),
+      B(0x20C00040C114C010, 0x88080820200C00),
+      B(0x1044010100820081, 0x20080841004000),
+      B(0x8041048400022, 0x8020836040005002),
+      B(0x2001004010205, 0x8001002884042009),
+      B(0x128088400087, 0x20008002201002),
+      B(0x8084108040402000, 0x80809000A080400),
+      B(0x408081840880, 0x201002088000040),
+      B(0xA40180010280, 0x241004006000010),
+      B(0x4204100080048140, 0x2002C4F104202020),
+      B(0x100140A10204, 0x980200800840060),
+      B(0x1005140010202048, 0x1442280800202815),
+      B(0x2000082025008600, 0x1108400040600003),
+      B(0x1005050648000, 0x200020240008002),
+      B(0x202010208044000, 0x8210404060008),
+      B(0x8011040402000210, 0xC840180408016004),
+      B(0x404098801028, 0x80020A0001000400),
+      B(0x404098801028, 0x80020A0001000400),
+      B(0x80101002180140, 0x40C2080820000C0),
+      B(0x208202081260800, 0x14090E4C04000050),
+      B(0x4221201084004C2, 0x110480A011060),
+      B(0x8000008421090204, 0x1C01010800024),
+      B(0x8000008421090204, 0x1C01010800024),
+      B(0x200180C840088A0, 0x401100400820000),
+      B(0x10084043A021070, 0x202041600080200),
+      B(0x210E6202001040C, 0x10100800080B0),
+      B(0x848008021204002, 0x801004308100BAD),
+      B(0xC082C0390A000601, 0x4040080189008),
+      B(0x431200240210402D, 0x58102820000),
+      B(0x202020100A0019B0, 0x4010C0D018000000),
+      B(0x800800908402203, 0x102948C84C184),
+      B(0x26801100080845, 0x4009702022A00820),
+      B(0x8880520010401040, 0x1060084832052000),
+      B(0x100100022042081, 0x10000600008C121),
+      B(0x46020384100040, 0x800200320882021),
+      B(0xC0002010148, 0x4200800800040003),
+      B(0x2002208020090040, 0x40820210021410),
+      B(0x9000A41160002004, 0x2A09000100080043),
+      B(0x800004010008001, 0x1108002020104600),
+      B(0x800540C000A4E041, 0x18021180000401),
+      B(0x808200900A900202, 0x8364202140012005),
+      B(0x1DBA52000081010, 0x4008000023000010),
+      B(0x4100110204401481, 0x800040091020001C),
+      B(0x4100110204401481, 0x800040091020001C),
+      B(0x4101100020400482, 0x2000402302100120),
+      B(0x100408000A020212, 0xA000400111000020),
+      B(0x2000010488080104, 0x3000404410208100),
+      B(0x2684220180008DD0, 0x422040200004000A),
+      B(0x2021200C0424, 0x1010100000080200),
+      B(0x8908020020801006, 0x3010800020C2000),
+      B(0x4000030008062044, 0x244010202688000),
+      B(0x242101200408009, 0x8150040000200015),
+      B(0x42004C02180204, 0x210208014241040),
+      B(0x4E1A01C208410804, 0x8890041000012004),
+      B(0x2080200401000080, 0x8001098429008004),
+      B(0xA01400121804104, 0x280200C400000500),
+      B(0xD0080408040420, 0x1006040100224000),
+      B(0x28400205000800C9, 0x6021101401040075),
+      B(0x4000900040020104, 0x88129801100D0C),
+      B(0x8000004002180410, 0x400380200400204),
+      B(0x4002A430043008, 0x400200340100020),
+      B(0x401960004140A42, 0x100880710000464),
+      B(0x58014090102, 0xB8D30004010080),
+      B(0xA004C08000244000, 0x11280100E0000040),
+      B(0x2102008089208804, 0x110001004080040),
+      B(0x700010084E003004, 0x8080864112000D40),
+      B(0x4080881000200C20, 0x30324040880E0600),
+      B(0x2024A40401810820, 0x3000888002000000),
+      B(0x8200100400014, 0x4400340800252844),
+      B(0x24A00804288281, 0x410103002201140),
+      B(0x4080005022A08, 0x1000402200100264),
+      B(0x200080032244040, 0x200502189010001),
+      B(0x28108110404001, 0x400600120008412),
+      B(0xA00002102810020, 0xB1080240015408),
+      B(0x810080200806, 0x410440804080046)
+  };
+  constexpr Bitboard BishopMagicInit[SQUARE_NB] = {
+      B(0x2001040305000010, 0x830200040400082),
+      B(0x1042400080E01200, 0x2004904010811400),
+      B(0x400010120200, 0x880080D080018000),
+      B(0x240190C00100040, 0x100A020140044404),
+      B(0x1018010404010004, 0x1001010018081E0),
+      B(0x41200A804C0904, 0x40000322000008),
+      B(0x4001180A004, 0x8000001106000000),
+      B(0x6006020020030600, 0x1840002100004841),
+      B(0x4200200100, 0x4001041808002000),
+      B(0x4100020050124600, 0x1001802902400CA0),
+      B(0x448C0081440161, 0x200206010008000),
+      B(0x400008008008408, 0x1000080210100080),
+      B(0x200280C01008200, 0x210200813000080),
+      B(0x1A000204400, 0x222200401023000),
+      B(0x10081040640A00, 0x8410021881400000),
+      B(0x1840400318080008, 0x800800840080000),
+      B(0x4204050C040, 0x6500600200140000),
+      B(0x1012100040204, 0x402404444400000),
+      B(0x6000012680008240, 0x410140000004220),
+      B(0x1000020810040008, 0x2D0011000060000),
+      B(0x1020020400, 0x400108059001001),
+      B(0x400020001100808, 0x480204800200000B),
+      B(0x10000010030084, 0x2042000848900022),
+      B(0x10000010030084, 0x2042000848900022),
+      B(0x100D801402400, 0x1512404009000400),
+      B(0x8000208005112400, 0xA02040401000000),
+      B(0x1000420002800200, 0x4CA000183020000),
+      B(0x800811480020, 0x408801010224001),
+      B(0xC805200810900100, 0x9000084204004020),
+      B(0x8200160204100004, 0x8040004004002022),
+      B(0x104514013080080, 0x146410040001000),
+      B(0x140844000080002, 0x1008102020040001),
+      B(0x4040400041A2002, 0x8040000A8802510),
+      B(0x801014041008002, 0x80068008025200),
+      B(0xA00540A414040, 0x4101040010A0000),
+      B(0x6484008010810002, 0x1100506884024000),
+      B(0x2800401008006000, 0x1005420884029020),
+      B(0x6822091010004421, 0x2000458080480),
+      B(0x40101000200101, 0x10020100001C4E0),
+      B(0x100400008C42, 0x4000100009008000),
+      B(0x851220018800400, 0x1681800040080080),
+      B(0x64200002010, 0x900020200040002),
+      B(0x20800080000022, 0x80040810002010),
+      B(0xA88408000802080, 0x20808001000000),
+      B(0x200000400C005040, 0x100140020290108),
+      B(0x224100000800408, 0x4204802004400020),
+      B(0x80080620010210, 0x91080088804040),
+      B(0x4008002100010, 0x80AC201001000001),
+      B(0x10008200902C046, 0x8080D03004000010),
+      B(0x3002100081000180, 0x2210002121528408),
+      B(0x8C101800804420, 0x1019880200043008),
+      B(0x200022000920D0, 0x8000800081300020),
+      B(0x1D40800880000, 0x400040001400050),
+      B(0x2020004100040, 0x200008040008008),
+      B(0x4840800040100001, 0x100100040203040),
+      B(0x40084001105, 0x8800080088000089),
+      B(0x4000128008020008, 0x4004200200440020),
+      B(0x210040008520000, 0x820219001080022),
+      B(0x1494040018002116, 0x400101047020008),
+      B(0x510008001910C224, 0x80200148118000),
+      B(0xC0301002301000, 0x4211A08004801),
+      B(0x50008E0C01001080, 0x100C004102845100),
+      B(0x400600020060400, 0x88024100250050),
+      B(0x8202920002002040, 0x810012000003),
+      B(0x800004208800200, 0x18AA00201000048),
+      B(0x402100800100002, 0x411000081000400),
+      B(0x101000022004044, 0x9000100040000),
+      B(0x41068001001, 0xC00400010001),
+      B(0x310210001040, 0x1A1200020010000),
+      B(0xA082409200004048, 0x490040800124101),
+      B(0x18844820E0040212, 0x1000404420D10000),
+      B(0x802908A40003348, 0x20200040104140),
+      B(0x1800404028205003, 0xC020010401089020),
+      B(0x802100044D01000, 0x8C41888000800040),
+      B(0x1D0161011410081, 0x10008000100200),
+      B(0x401000480040100, 0x286800404002212),
+      B(0x821030000100009, 0x2000090200A00000),
+      B(0x200020800200800, 0x2000480900841012),
+      B(0x80A000048030080, 0x200000120200008),
+      B(0x40B1400008020020, 0x148000200008004),
+      B(0xA021700002002010, 0x3040E400040100),
+      B(0x400242C200200640, 0x20440210200281),
+      B(0x80AC140040206240, 0x120000102801401),
+      B(0x2020340040832040, 0x10402100A44000),
+      B(0x420100400040220, 0x80014C8004000106),
+      B(0x504300822421120, 0x8004004008400100),
+      B(0x2001100008040, 0x2020104302000000),
+      B(0xA500802000A, 0x2008008000114100),
+      B(0x8A0020000200, 0x9C00101001002408),
+      B(0x104000001001008, 0x9001000204040060),
+      B(0x1000820080108200, 0xA401000008100001),
+      B(0x2008600009000480, 0x9008020001400000),
+      B(0x4000800200040200, 0xA00030400308082),
+      B(0x4004300202004709, 0x1000100180010020),
+      B(0xC014800100440010, 0x402020280002C010),
+      B(0x220208010884680, 0x1040280000042110),
+      B(0x40B0018019202801, 0x1008408000100040),
+      B(0x8269010206080044, 0x8001810000000040),
+      B(0x4000020880081040, 0x208A44000028000),
+      B(0x4004004E9004220A, 0x2104004001400024),
+      B(0x8035006008C0904, 0x402002001080120),
+      B(0x1800884002, 0x404400820000000),
+      B(0x8088000004008910, 0x8024100401000000),
+      B(0x142200086000100, 0x28021040020002E),
+      B(0x1000409141004018, 0x100410820080040A),
+      B(0x1800801800140, 0x810801060C0801),
+      B(0x1000C00100402220, 0x808023420000000),
+      B(0x8A0A202414305008, 0x100040200000021),
+      B(0xC0208024050, 0x8003088008020401),
+      B(0x8044004201440101, 0x400820080C024022),
+      B(0x406018884120099, 0xB00088018002000),
+      B(0x2000800010403010, 0xC5A002002010010),
+      B(0x800020040840, 0x201800202800200),
+      B(0x201280120020008D, 0x258809001000040),
+      B(0x9100002020181, 0x80400082204000),
+      B(0x104010080201001, 0x40080080181080),
+      B(0x8440248092000430, 0xA200804900100000),
+      B(0x2031010C01000C20, 0x200310A560082008),
+      B(0x400202081811400, 0x40081802050000C),
+      B(0x1011002100821300, 0x2400825040804100)
+  };
+  constexpr Bitboard CannonMagicHInit[SQUARE_NB] = {
+      B(0x120000880110000, 0x1008000000020020),
+      B(0x24200C080840A052, 0x2004004000010008),
+      B(0xC030024000228800, 0x4000010400000020),
+      B(0x1A0020802008802, 0x206010208000),
+      B(0x12002000D001024, 0x80100800090138),
+      B(0x4220010000241010, 0x3098000602001500),
+      B(0x401010004801040, 0x8000280480100000),
+      B(0x820082024921836, 0x220028000),
+      B(0x100400502411400, 0x220402120240D14),
+      B(0x880202020010404, 0xA80202510000),
+      B(0x140002801000018, 0x1000346490040),
+      B(0x120000880110000, 0x1008000000020020),
+      B(0xD01004008030400, 0x104000408104420),
+      B(0x8420060100020000, 0x800280400000120),
+      B(0x4010020018010, 0x40A00001100000),
+      B(0x40006A0004000200, 0x40000000110),
+      B(0xD01004008030400, 0x104000408104420),
+      B(0x8908A20028110011, 0x800080000001A114),
+      B(0x200042000080F009, 0x20001000004000),
+      B(0x2820008820100, 0x10002400058000B9),
+      B(0x6083100420008050, 0x4040012600280080),
+      B(0x216020000000446, 0x4080204000000211),
+      B(0x340140003002089, 0x2402008000000911),
+      B(0xD01004008030400, 0x104000408104420),
+      B(0x1404040B20001000, 0x8000824010800011),
+      B(0x8C0488120024214, 0x8414880202291),
+      B(0x1010000060050000, 0x4000004050002602),
+      B(0x4022983A0060000, 0x80000040010400),
+      B(0x1404040B20001000, 0x8000824010800011),
+      B(0x6020101802002840, 0x31000003000004),
+      B(0x9000420008840, 0x4881300000000210),
+      B(0xA200808865, 0x41C0048023000128),
+      B(0x31801100400000, 0x8802DC001221240),
+      B(0x884000080200920, 0x1004002410401001),
+      B(0x2400040000884, 0x421006208040C0),
+      B(0x1404040B20001000, 0x8000824010800011),
+      B(0x24100400060009, 0x112008025042410),
+      B(0x1800040009040200, 0x180000A1004E408A),
+      B(0x24100400060009, 0x112008025042410),
+      B(0x4060402008080, 0xC240080000110000),
+      B(0x20080100920020, 0x2002248010242052),
+      B(0x10001010802050, 0x880000001C98420),
+      B(0x4000800100420022, 0x502022010A00D0),
+      B(0x4C18104500200885, 0x400880800),
+      B(0x8080810081020090, 0x8000000000000),
+      B(0x8000062812080201, 0x8004C8300800),
+      B(0x1800040009040200, 0x180000A1004E408A),
+      B(0x24100400060009, 0x112008025042410),
+      B(0x80102204040, 0x1000000900000000),
+      B(0x2080000004202804, 0x120880003461),
+      B(0x102004090A4030, 0x801020589240),
+      B(0x20001100814000A0, 0x420202000820004),
+      B(0x100800000A000120, 0x208000800010000),
+      B(0x1008205000040802, 0x80002000400040),
+      B(0x1480000098008401, 0xA0010000581010),
+      B(0x30C0008200100820, 0x102800080904834),
+      B(0x4810821884000500, 0x4400000200000212),
+      B(0x1811D00128A0180, 0x2500848803000000),
+      B(0x41618A0300040040, 0x21200200A421801),
+      B(0x80102204040, 0x1000000900000000),
+      B(0xA1808E0100108000, 0x2008000505000002),
+      B(0x8C890020410000A0, 0xA010000048000400),
+      B(0x40006002210044, 0x600008000408000),
+      B(0x1200447220090042, 0x80001000160012),
+      B(0x48410010AB000000, 0x9200600000000100),
+      B(0x2040000000240003, 0x8020080288000600),
+      B(0x9080000088848088, 0x4010210500000041),
+      B(0xA1808E0100108000, 0x2008000505000002),
+      B(0x480100400024, 0x1004800018200000),
+      B(0x808403080080200, 0x802601000000500),
+      B(0x8C890020410000A0, 0xA010000048000400),
+      B(0xA1808E0100108000, 0x2008000505000002),
+      B(0x100A40000004008, 0x2800200400200480),
+      B(0x100A40000004008, 0x2800200400200480),
+      B(0x400014006000000, 0x10006000810001F5),
+      B(0xC410062001414, 0x820080041B01044),
+      B(0x20000800310, 0x430040000201000),
+      B(0xA40010008000008, 0x4002200028000040),
+      B(0xC00102000008021C, 0x10C2000A010E024),
+      B(0x80004200104008, 0x50A00800C400020),
+      B(0x20200080012542, 0x910F0040000402C0),
+      B(0xB040100504000300, 0x24802002000040),
+      B(0x800001000014008, 0x400031004000),
+      B(0x100A40000004008, 0x2800200400200480),
+      B(0x84008002041081C0, 0x8080500200000000),
+      B(0x440090001012001, 0x4020004010),
+      B(0x100A0028088020, 0x80040E00010020),
+      B(0x2180808000810, 0xB018040A00040000),
+      B(0x40C80920304C4001, 0x42800B200800000),
+      B(0x85000425001000, 0x4810048020001100),
+      B(0x600C000801000004, 0x8015084010200020),
+      B(0x20020050000240C0, 0x100202008600800),
+      B(0x38000050001220, 0x9200010200145900),
+      B(0x1042108040005, 0x1402A0802201001),
+      B(0x824240000C20400, 0x1000000400080010),
+      B(0x84008002041081C0, 0x8080500200000000),
+      B(0x400804A1000008, 0x1024104A0200010),
+      B(0x8000402308483, 0x20006020100100),
+      B(0x80880120000080, 0x8000240100084),
+      B(0x5840020004882001, 0x1004528000A00010),
+      B(0x8001018800300002, 0x84010040804),
+      B(0x180D10004000A008, 0xA001080008020004),
+      B(0x400080B, 0x10A0000004010000),
+      B(0x8080000200000, 0x2001000082004E0),
+      B(0x40040001000C2000, 0x2024800001004008),
+      B(0x400804A1000008, 0x1024104A0200010),
+      B(0x8000402308483, 0x20006020100100),
+      B(0x400804A1000008, 0x1024104A0200010),
+      B(0x2000200000, 0x1201011000802),
+      B(0x100100000000C4, 0x208004084048201),
+      B(0x400084000044, 0x100810140300),
+      B(0x29040C0C01010, 0x300204010820080),
+      B(0x1A808000020200, 0x1000000005210040),
+      B(0x20000400150000, 0x85008020),
+      B(0x40C040008184014, 0x8002AA00024010),
+      B(0x202000081B00804, 0x10001002008),
+      B(0x40011000210060, 0x6080C40000021004),
+      B(0x2000200000, 0x1201011000802),
+      B(0x4100480203840, 0x300080100804),
+      B(0x2000200000, 0x1201011000802),
+  };
+  constexpr Bitboard CannonMagicVInit[SQUARE_NB] = {
+      B(0x202000812104400, 0x24800B01C0000303),
+      B(0x340020400010D, 0x88060150C00400),
+      B(0x400802040609, 0x49010200501A0002),
+      B(0x8002680301000208, 0x628006C0C020200),
+      B(0x20400209001C0804, 0xA044000800143110),
+      B(0xC400082060010202, 0x4000480401014000),
+      B(0x22500200144040, 0x8204820084704C00),
+      B(0x8C1204009030020, 0x328400805000000),
+      B(0x84800800D0001640, 0x200080040060108),
+      B(0x804810208020040, 0x140010108020000),
+      B(0x1102010B008004, 0x300208006220020),
+      B(0x140080404A0A2428, 0x6308010100080),
+      B(0x20444002120408, 0xA080010508010001),
+      B(0x82011044000D02, 0x4112028620110809),
+      B(0x81010831000C02, 0x408802085000000),
+      B(0x81010831000C02, 0x408802085000000),
+      B(0x920008920600040, 0x8053801004000028),
+      B(0x81140283208300, 0x10040C004200420),
+      B(0x103080022201, 0xC01000081312620),
+      B(0x2200221100008, 0x1000408104000A4),
+      B(0x4402088080042008, 0x210401501040340),
+      B(0x898400202170001, 0x80040404208000),
+      B(0x20080004051012, 0x5100048200081800),
+      B(0x2320020000401018, 0x108501021040210),
+      B(0x21080410A422021, 0x83040180008800),
+      B(0x44E8100000408224, 0x20010008040400),
+      B(0x1800240002810405, 0x23004820000020),
+      B(0x80A0100400110, 0x80104020100C4028),
+      B(0x1002050001222C0, 0x5100818004024020),
+      B(0x104000200040, 0xC010A09800102000),
+      B(0x1020003A058120, 0x450900809000302),
+      B(0x40040045008B1, 0x202800400383010),
+      B(0x4640200220034, 0x8800485420304000),
+      B(0x5001042100084288, 0x110820001240080A),
+      B(0x2002C04004010120, 0xA15008020880001),
+      B(0x2800004080C4190, 0x890808280020080),
+      B(0x40C0401000104000, 0x2020880008002580),
+      B(0x40020C002400802, 0x801104010000000),
+      B(0x44842000040080, 0x2050011084000400),
+      B(0x4110040800000401, 0x2023810029008000),
+      B(0x20884000840, 0x8017102004008000),
+      B(0x10411104000480, 0x1414042000201001),
+      B(0x220040000008, 0x800306021000000),
+      B(0x41400A0008080, 0x501000298ACAD10),
+      B(0x800240012831810, 0x80120004468050E),
+      B(0x800005020801008, 0x20102400240000),
+      B(0x20C00040C114C010, 0x88080820200C00),
+      B(0x1044010100820081, 0x20080841004000),
+      B(0x8041048400022, 0x8020836040005002),
+      B(0x2001004010205, 0x8001002884042009),
+      B(0x128088400087, 0x20008002201002),
+      B(0x8084108040402000, 0x80809000A080400),
+      B(0x408081840880, 0x201002088000040),
+      B(0xA40180010280, 0x241004006000010),
+      B(0x4204100080048140, 0x2002C4F104202020),
+      B(0x100140A10204, 0x980200800840060),
+      B(0x1005140010202048, 0x1442280800202815),
+      B(0x2000082025008600, 0x1108400040600003),
+      B(0x1005050648000, 0x200020240008002),
+      B(0x202010208044000, 0x8210404060008),
+      B(0x8011040402000210, 0xC840180408016004),
+      B(0x404098801028, 0x80020A0001000400),
+      B(0x404098801028, 0x80020A0001000400),
+      B(0x80101002180140, 0x40C2080820000C0),
+      B(0x208202081260800, 0x14090E4C04000050),
+      B(0x4221201084004C2, 0x110480A011060),
+      B(0x8000008421090204, 0x1C01010800024),
+      B(0x8000008421090204, 0x1C01010800024),
+      B(0x200180C840088A0, 0x401100400820000),
+      B(0x10084043A021070, 0x202041600080200),
+      B(0x210E6202001040C, 0x10100800080B0),
+      B(0x848008021204002, 0x801004308100BAD),
+      B(0xC082C0390A000601, 0x4040080189008),
+      B(0x431200240210402D, 0x58102820000),
+      B(0x202020100A0019B0, 0x4010C0D018000000),
+      B(0x800800908402203, 0x102948C84C184),
+      B(0x26801100080845, 0x4009702022A00820),
+      B(0x8880520010401040, 0x1060084832052000),
+      B(0x100100022042081, 0x10000600008C121),
+      B(0x46020384100040, 0x800200320882021),
+      B(0xC0002010148, 0x4200800800040003),
+      B(0x2002208020090040, 0x40820210021410),
+      B(0x9000A41160002004, 0x2A09000100080043),
+      B(0x800004010008001, 0x1108002020104600),
+      B(0x800540C000A4E041, 0x18021180000401),
+      B(0x808200900A900202, 0x8364202140012005),
+      B(0x1DBA52000081010, 0x4008000023000010),
+      B(0x4100110204401481, 0x800040091020001C),
+      B(0x4100110204401481, 0x800040091020001C),
+      B(0x4101100020400482, 0x2000402302100120),
+      B(0x100408000A020212, 0xA000400111000020),
+      B(0x2000010488080104, 0x3000404410208100),
+      B(0x2684220180008DD0, 0x422040200004000A),
+      B(0x2021200C0424, 0x1010100000080200),
+      B(0x8908020020801006, 0x3010800020C2000),
+      B(0x4000030008062044, 0x244010202688000),
+      B(0x242101200408009, 0x8150040000200015),
+      B(0x42004C02180204, 0x210208014241040),
+      B(0x4E1A01C208410804, 0x8890041000012004),
+      B(0x2080200401000080, 0x8001098429008004),
+      B(0xA01400121804104, 0x280200C400000500),
+      B(0xD0080408040420, 0x1006040100224000),
+      B(0x28400205000800C9, 0x6021101401040075),
+      B(0x4000900040020104, 0x88129801100D0C),
+      B(0x8000004002180410, 0x400380200400204),
+      B(0x4002A430043008, 0x400200340100020),
+      B(0x401960004140A42, 0x100880710000464),
+      B(0x58014090102, 0xB8D30004010080),
+      B(0xA004C08000244000, 0x11280100E0000040),
+      B(0x2102008089208804, 0x110001004080040),
+      B(0x700010084E003004, 0x8080864112000D40),
+      B(0x4080881000200C20, 0x30324040880E0600),
+      B(0x2024A40401810820, 0x3000888002000000),
+      B(0x8200100400014, 0x4400340800252844),
+      B(0x24A00804288281, 0x410103002201140),
+      B(0x4080005022A08, 0x1000402200100264),
+      B(0x200080032244040, 0x200502189010001),
+      B(0x28108110404001, 0x400600120008412),
+      B(0xA00002102810020, 0xB1080240015408),
+      B(0x810080200806, 0x410440804080046),
+  };
+  constexpr Bitboard LameDabbabaMagicInit[SQUARE_NB] = {
+      B(0x3C080482A592000C, 0x540104000020000),
+      B(0x2802C40008000420, 0x4A00000001818009),
+      B(0x1083040280804000, 0x120004C20100880),
+      B(0x6840940880000892, 0x2014A01080800C2),
+      B(0x8401489004000180, 0x2000800000400000),
+      B(0x820161C800000110, 0x8000100000204020),
+      B(0x610011A122000109, 0x1000004020008004),
+      B(0x83282004023000, 0xE000020004848446),
+      B(0x6840940880000892, 0x2014A01080800C2),
+      B(0x4020120800800002, 0x88008000010020),
+      B(0x30025B140A1000, 0x3141801401000040),
+      B(0x41104D1810100050, 0x8141002010910),
+      B(0x4200828A298400, 0x400340001040C000),
+      B(0x8016A4900110040, 0x844812001068020),
+      B(0x2250035820400A2, 0x8012010080900),
+      B(0x820080083A009000, 0x880404091080110),
+      B(0x80401500AF0020, 0x240000082201A04),
+      B(0x668020020C081005, 0x4008001004100021),
+      B(0x240100910000000, 0x82000A0030454000),
+      B(0xA24091400008, 0x200014880004A921),
+      B(0x840110042200410, 0x100080000A400000),
+      B(0x40024024102000, 0x1000000002180404),
+      B(0x92828423000530, 0x118800020110),
+      B(0x1122404A1C90A8, 0x822040280020D00),
+      B(0x41201A40900A000, 0x80C0480040605100),
+      B(0x2504A85005488280, 0x3028112120022800),
+      B(0x210180080626B048, 0x8000401000014000),
+      B(0x1000410401040200, 0x41014000050C0106),
+      B(0x1040650210802200, 0x80C0041000000),
+      B(0x4020C10110900002, 0x2140C2001050009),
+      B(0x191180092200022, 0x6010008400400800),
+      B(0x8010821088080202, 0xCA240011008208),
+      B(0x8C0488120024214, 0x8414880202291),
+      B(0x8C0488120024214, 0x8414880202291),
+      B(0x22080C8A0161401, 0x200C10004C002002),
+      B(0x8430818023034080, 0x210090800000801),
+      B(0x4845087008200, 0x40661480000),
+      B(0x1202804428812050, 0x100022038020000),
+      B(0x400016001201080, 0x24002200402060),
+      B(0x680E041300800800, 0xE00130080004000),
+      B(0x3409080200, 0x282840210000000),
+      B(0x803310108400, 0x85200000080100A0),
+      B(0xE180008A04162104, 0x9088240412404),
+      B(0x20080100920020, 0x2002248010242052),
+      B(0x8A000400C2410, 0x1000024086014300),
+      B(0x1821040024663, 0x100000100010009),
+      B(0x4000822310611, 0x120280406014008),
+      B(0x1004008010818D08, 0x800000141892000),
+      B(0x8010800004024042, 0x44B106008800896),
+      B(0xA0063423444, 0x41002C15811008),
+      B(0x2040012381001282, 0x4804080104A4000),
+      B(0x10840101820880, 0xA800008000020020),
+      B(0x10840101820880, 0xA800008000020020),
+      B(0x60201D8300408190, 0x2010020920200000),
+      B(0x4048100200090090, 0x2008090100000900),
+      B(0x24200000280210, 0xD440050008004000),
+      B(0x1280001000580020, 0x2200040089000A4),
+      B(0x10208018C1020A20, 0x84C0432240610014),
+      B(0x10208018C1020A20, 0x84C0432240610014),
+      B(0x4108000010209089, 0x913000000024840),
+      B(0x410C208008008E02, 0xE8000000000001),
+      B(0x802208004005, 0x94206000022080),
+      B(0xC00290018902002, 0x4204100000000000),
+      B(0x2102801400093816, 0x9810004001000202),
+      B(0x8008304000015800, 0x4A5C000000020000),
+      B(0x1020108380800514, 0x1144210000000080),
+      B(0xC0001000008090, 0x2812060000204000),
+      B(0x1001100200003100, 0x246240060A004004),
+      B(0xA00020A008002030, 0x2440C40000110B00),
+      B(0x80502104000C008, 0x8222200042100010),
+      B(0xC020200088014, 0x422094000000480),
+      B(0x1029002000001030, 0x8105841120000210),
+      B(0x49040D, 0x2310808A14042C0),
+      B(0x200040200080A02C, 0xB890290400080000),
+      B(0x2240180C0800002, 0x4151050280000100),
+      B(0x2240180C0800002, 0x4151050280000100),
+      B(0x8220224180420006, 0x4024501212011000),
+      B(0x1806810A0881000, 0x802002048400080),
+      B(0x400400A080842, 0x9305000401180000),
+      B(0x10008001444110, 0x4420401040041833),
+      B(0x2000002C02010E00, 0x400408D08009804),
+      B(0x69D008200020100, 0x100842240049021),
+      B(0x42C24450020000, 0xD38400880090884),
+      B(0x485800800100001, 0x2484086522018840),
+      B(0x900200020820042, 0x22302421400040C0),
+      B(0x50B0413001818000, 0x452014040800C40),
+      B(0x8004040021008, 0x20088A08000290),
+      B(0x600C000801000004, 0x8015084010200020),
+      B(0x208000C00, 0xE004804021100100),
+      B(0x20001000040204, 0x948110C0B2081),
+      B(0x268502400100021, 0x80A201840802080),
+      B(0x408C000008, 0x8822102408014),
+      B(0x1182080410100000, 0x608002046A0100),
+      B(0x100820A083C00002, 0x3100100410A00),
+      B(0x8401040000400124, 0x2000081288202200),
+      B(0xB014040003000800, 0x11960D1101210),
+      B(0x10040001900C000, 0x85603C1001280),
+      B(0x2000844000000100, 0x2000024C60800800),
+      B(0x120004234800900, 0x210010841040),
+      B(0x8010300040000002, 0x4200008222104100),
+      B(0x1000120402200100, 0x209080CC040108B4),
+      B(0x110049A00000800, 0x80000420022180A8),
+      B(0x80001C00080384, 0x1400101111081001),
+      B(0x8011200008100428, 0x2020000880800922),
+      B(0x10001000000204C8, 0x280C11104240),
+      B(0x50100C82C000500, 0x28000280618DD1),
+      B(0x8800498020000, 0x20500A0200320128),
+      B(0x20010104000860, 0x8021720186008),
+      B(0x4000000000100080, 0x35040084270C04),
+      B(0x4500080000800, 0x280100002482C842),
+      B(0x10400000000000, 0x20080051100130C2),
+      B(0x10400000000000, 0x20080051100130C2),
+      B(0x2000002110202014, 0x121004004004681),
+      B(0x400202001006D40, 0x82240082202424),
+      B(0x4500080000800, 0x280100002482C842),
+      B(0xC6000000D00804, 0x1050020C0081090C),
+      B(0x200080000000042, 0x10800661),
+      B(0x2000001011200200, 0x2A420000802A0222),
+      B(0x802020001202412, 0x2400404148426),
+      B(0x8000440801040002, 0x444002800010052A),
+  };
+  constexpr Bitboard HorseMagicInit[SQUARE_NB] = {
+      B(0x3C080482A592000C, 0x540104000020000),
+      B(0x2802C40008000420, 0x4A00000001818009),
+      B(0x1083040280804000, 0x120004C20100880),
+      B(0x6840940880000892, 0x2014A01080800C2),
+      B(0x8401489004000180, 0x2000800000400000),
+      B(0x820161C800000110, 0x8000100000204020),
+      B(0x610011A122000109, 0x1000004020008004),
+      B(0x83282004023000, 0xE000020004848446),
+      B(0x6840940880000892, 0x2014A01080800C2),
+      B(0x4020120800800002, 0x88008000010020),
+      B(0x30025B140A1000, 0x3141801401000040),
+      B(0x41104D1810100050, 0x8141002010910),
+      B(0x4200828A298400, 0x400340001040C000),
+      B(0x8016A4900110040, 0x844812001068020),
+      B(0x2250035820400A2, 0x8012010080900),
+      B(0x820080083A009000, 0x880404091080110),
+      B(0x80401500AF0020, 0x240000082201A04),
+      B(0x668020020C081005, 0x4008001004100021),
+      B(0x240100910000000, 0x82000A0030454000),
+      B(0xA24091400008, 0x200014880004A921),
+      B(0x840110042200410, 0x100080000A400000),
+      B(0x40024024102000, 0x1000000002180404),
+      B(0x92828423000530, 0x118800020110),
+      B(0x1122404A1C90A8, 0x822040280020D00),
+      B(0x41201A40900A000, 0x80C0480040605100),
+      B(0x2504A85005488280, 0x3028112120022800),
+      B(0x210180080626B048, 0x8000401000014000),
+      B(0x1000410401040200, 0x41014000050C0106),
+      B(0x1040650210802200, 0x80C0041000000),
+      B(0x4020C10110900002, 0x2140C2001050009),
+      B(0x191180092200022, 0x6010008400400800),
+      B(0x8010821088080202, 0xCA240011008208),
+      B(0x8C0488120024214, 0x8414880202291),
+      B(0x8C0488120024214, 0x8414880202291),
+      B(0x22080C8A0161401, 0x200C10004C002002),
+      B(0x8430818023034080, 0x210090800000801),
+      B(0x4845087008200, 0x40661480000),
+      B(0x1202804428812050, 0x100022038020000),
+      B(0x400016001201080, 0x24002200402060),
+      B(0x680E041300800800, 0xE00130080004000),
+      B(0x3409080200, 0x282840210000000),
+      B(0x803310108400, 0x85200000080100A0),
+      B(0xE180008A04162104, 0x9088240412404),
+      B(0x20080100920020, 0x2002248010242052),
+      B(0x8A000400C2410, 0x1000024086014300),
+      B(0x1821040024663, 0x100000100010009),
+      B(0x4000822310611, 0x120280406014008),
+      B(0x1004008010818D08, 0x800000141892000),
+      B(0x8010800004024042, 0x44B106008800896),
+      B(0xA0063423444, 0x41002C15811008),
+      B(0x2040012381001282, 0x4804080104A4000),
+      B(0x10840101820880, 0xA800008000020020),
+      B(0x10840101820880, 0xA800008000020020),
+      B(0x60201D8300408190, 0x2010020920200000),
+      B(0x4048100200090090, 0x2008090100000900),
+      B(0x24200000280210, 0xD440050008004000),
+      B(0x1280001000580020, 0x2200040089000A4),
+      B(0x10208018C1020A20, 0x84C0432240610014),
+      B(0x10208018C1020A20, 0x84C0432240610014),
+      B(0x4108000010209089, 0x913000000024840),
+      B(0x410C208008008E02, 0xE8000000000001),
+      B(0x802208004005, 0x94206000022080),
+      B(0xC00290018902002, 0x4204100000000000),
+      B(0x2102801400093816, 0x9810004001000202),
+      B(0x8008304000015800, 0x4A5C000000020000),
+      B(0x1020108380800514, 0x1144210000000080),
+      B(0xC0001000008090, 0x2812060000204000),
+      B(0x1001100200003100, 0x246240060A004004),
+      B(0xA00020A008002030, 0x2440C40000110B00),
+      B(0x80502104000C008, 0x8222200042100010),
+      B(0xC020200088014, 0x422094000000480),
+      B(0x1029002000001030, 0x8105841120000210),
+      B(0x49040D, 0x2310808A14042C0),
+      B(0x200040200080A02C, 0xB890290400080000),
+      B(0x2240180C0800002, 0x4151050280000100),
+      B(0x2240180C0800002, 0x4151050280000100),
+      B(0x8220224180420006, 0x4024501212011000),
+      B(0x1806810A0881000, 0x802002048400080),
+      B(0x400400A080842, 0x9305000401180000),
+      B(0x10008001444110, 0x4420401040041833),
+      B(0x2000002C02010E00, 0x400408D08009804),
+      B(0x69D008200020100, 0x100842240049021),
+      B(0x42C24450020000, 0xD38400880090884),
+      B(0x485800800100001, 0x2484086522018840),
+      B(0x900200020820042, 0x22302421400040C0),
+      B(0x50B0413001818000, 0x452014040800C40),
+      B(0x8004040021008, 0x20088A08000290),
+      B(0x600C000801000004, 0x8015084010200020),
+      B(0x208000C00, 0xE004804021100100),
+      B(0x20001000040204, 0x948110C0B2081),
+      B(0x268502400100021, 0x80A201840802080),
+      B(0x408C000008, 0x8822102408014),
+      B(0x1182080410100000, 0x608002046A0100),
+      B(0x100820A083C00002, 0x3100100410A00),
+      B(0x8401040000400124, 0x2000081288202200),
+      B(0xB014040003000800, 0x11960D1101210),
+      B(0x10040001900C000, 0x85603C1001280),
+      B(0x2000844000000100, 0x2000024C60800800),
+      B(0x120004234800900, 0x210010841040),
+      B(0x8010300040000002, 0x4200008222104100),
+      B(0x1000120402200100, 0x209080CC040108B4),
+      B(0x110049A00000800, 0x80000420022180A8),
+      B(0x80001C00080384, 0x1400101111081001),
+      B(0x8011200008100428, 0x2020000880800922),
+      B(0x10001000000204C8, 0x280C11104240),
+      B(0x50100C82C000500, 0x28000280618DD1),
+      B(0x8800498020000, 0x20500A0200320128),
+      B(0x20010104000860, 0x8021720186008),
+      B(0x4000000000100080, 0x35040084270C04),
+      B(0x4500080000800, 0x280100002482C842),
+      B(0x10400000000000, 0x20080051100130C2),
+      B(0x10400000000000, 0x20080051100130C2),
+      B(0x2000002110202014, 0x121004004004681),
+      B(0x400202001006D40, 0x82240082202424),
+      B(0x4500080000800, 0x280100002482C842),
+      B(0xC6000000D00804, 0x1050020C0081090C),
+      B(0x200080000000042, 0x10800661),
+      B(0x2000001011200200, 0x2A420000802A0222),
+      B(0x802020001202412, 0x2400404148426),
+      B(0x8000440801040002, 0x444002800010052A),
+  };
+  constexpr Bitboard ElephantMagicInit[SQUARE_NB] = {
+      B(0x64D2990200008, 0x4401880001C000),
+      B(0x29BAA00010020, 0x200000400800600),
+      B(0x3024240000000, 0x4100400010080),
+      B(0xA490A00480020, 0x20084001041010A4),
+      B(0x328C021008042, 0x100000000C10204),
+      B(0x1964090001018, 0x7002040148001205),
+      B(0x800302098404080, 0x4983020000000001),
+      B(0x8812244630A02080, 0x8200006204003C08),
+      B(0x41120231008000, 0x240441401020),
+      B(0x840091030C00040, 0x1400008200023400),
+      B(0x8001040E77030200, 0x100040090022000),
+      B(0x602022139D835040, 0x101002010025900),
+      B(0x405707C48400, 0x40010000008001),
+      B(0x982003456A82050, 0x60800820040030),
+      B(0x204184849200088, 0x101800004006),
+      B(0x300222470949200, 0x2A0800200200800),
+      B(0x400001211914000, 0x8200001407001),
+      B(0x2000008614831020, 0x4000020001404000),
+      B(0x84000024A2048048, 0x1200102000042),
+      B(0x424010A58422008, 0x88440242212A0110),
+      B(0x20020812C0C4408, 0x4121400000080010),
+      B(0x680200062042420, 0x2001100000800000),
+      B(0x200010060AEC855, 0x8083002040200000),
+      B(0x4000008BAA85810, 0x82000805C0200A90),
+      B(0x81450B200A025400, 0x4400101050000040),
+      B(0x820A2241409010, 0x888420030000),
+      B(0x909203000028, 0xC000004C00200041),
+      B(0x8021400A84880240, 0x100180002010020),
+      B(0x8001A20061410000, 0x14008499A000000),
+      B(0x8201444800A00080, 0x402010040588120),
+      B(0x100C06280020, 0x60010104840130),
+      B(0x520040800080044, 0x8220000080001402),
+      B(0x102021410040202, 0x2004400410006000),
+      B(0x5401832090020400, 0x300010020001),
+      B(0x180003105A84C108, 0x1012008800081000),
+      B(0x480C10210026904, 0xA006000004200418),
+      B(0x48050820210843A6, 0x108001004000C00),
+      B(0x1030101182206324, 0x4401008921502002),
+      B(0x40281060800800, 0x406000201260022),
+      B(0xC29002440040C820, 0x400001002008020),
+      B(0x40000400800241, 0xC220000000400280),
+      B(0x40880126014208, 0x2A8004C008940000),
+      B(0x121028100114080, 0x5010280481100082),
+      B(0x4000088280442, 0x908420140008041),
+      B(0x808C42400C0020, 0x3028100840801000),
+      B(0x4000000410078488, 0x501000000620000),
+      B(0x90080001421020A4, 0x4118400101060406),
+      B(0x280420004855, 0xD200100400820000),
+      B(0xA0063423444, 0x41002C15811008),
+      B(0x200061201808102, 0x4286969000200002),
+      B(0x10208018C1020A20, 0x84C0432240610014),
+      B(0x4001A04880402000, 0x8100824080000001),
+      B(0x60201D8300408190, 0x2010020920200000),
+      B(0x20018C04908019, 0x2010884002002040),
+      B(0x800000000C40810, 0x680100081150000D),
+      B(0x2002002000040040, 0x8810049000010600),
+      B(0x41618A0300040040, 0x21200200A421801),
+      B(0x10208018C1020A20, 0x84C0432240610014),
+      B(0x10208018C1020A20, 0x84C0432240610014),
+      B(0x5A04001400412854, 0x8A44006000010002),
+      B(0x13000C0810072432, 0x50049001021104),
+      B(0x400048801142130, 0x4C1204100226010C),
+      B(0x80001048, 0x408800104000080),
+      B(0x8104868204040412, 0x22244202000081),
+      B(0x8104868204040412, 0x22244202000081),
+      B(0x4140001000240440, 0x80209004410004E),
+      B(0x800800000100, 0xB111820100000002),
+      B(0x404240004220, 0x2110402802050080),
+      B(0x284010400004040, 0x100245002502020),
+      B(0x14880A100114010, 0x400208080010024),
+      B(0x4100004040440648, 0x10030D838041A80),
+      B(0x32004000210, 0x4010225C88014000),
+      B(0x2240180C0800002, 0x4151050280000100),
+      B(0x2010A12002000042, 0x189051442010000),
+      B(0x4060050080121883, 0x8250C10001000141),
+      B(0x10000000044100, 0x8401084010261009),
+      B(0xA00028040000, 0x2003224000002000),
+      B(0x2060009001000020, 0x1000432022020228),
+      B(0x404200000883080, 0x1080800848245000),
+      B(0x240000402080, 0xCA0820814210502),
+      B(0x200040200080A02C, 0xB890290400080000),
+      B(0x800000000300482, 0x9203008100100013),
+      B(0x8000210202042000, 0x22642104004C2400),
+      B(0x1040400805000401, 0x2A0300102C80010),
+      B(0x8010A01088020000, 0x122106105A06A030),
+      B(0x8000C00001010494, 0x130A1A20404120),
+      B(0x4B084010844290, 0x10A08008900840),
+      B(0x1180001802460000, 0xB08000034C82004),
+      B(0x4001880060028029, 0x204040002401000),
+      B(0x8021A0001308002A, 0x97001822040040),
+      B(0xC00000009A020AC1, 0x1000080900400),
+      B(0x60010110001990, 0x4000880900400000),
+      B(0x10290402401200, 0x230080402C08),
+      B(0x4220000219012000, 0x140204804100008),
+      B(0x1400200100002, 0x8E62200414128),
+      B(0x402808502004403, 0x20049100C0284520),
+      B(0xB30041004280280, 0x10020464DB200308),
+      B(0x440010800808, 0xA0102E295812100),
+      B(0x10008000B000, 0x2000058583220200),
+      B(0x2000844000000100, 0x2000024C60800800),
+      B(0x110000400100028, 0x24052304508004),
+      B(0x8458000000840004, 0x118006463400001),
+      B(0x804008000040050, 0x41044890228000),
+      B(0x20000050000400, 0x80A101824A00086),
+      B(0x600080404000020, 0x100007322480005),
+      B(0xD082200020020008, 0x642000630120001),
+      B(0x10000100040230, 0x8048114733320002),
+      B(0x20200442002A880A, 0x8200002CB4B8052),
+      B(0x290080000000, 0xA41297838F40D),
+      B(0x800205000080, 0xF221232039874400),
+      B(0x1444002004880C20, 0xC4100049144200),
+      B(0x4500080000800, 0x280100002482C842),
+      B(0x281240881008, 0x204084004C101900),
+      B(0x1444002004880C20, 0xC4100049144200),
+      B(0x4500080000800, 0x280100002482C842),
+      B(0xC0010928430540, 0x92041902180),
+      B(0x1051001208A, 0x4900064800C20640),
+      B(0x882020418C00000, 0x30004040092A821),
+      B(0x224404002004268C, 0x202500204C7D254),
+      B(0x290080000000, 0xA41297838F40D),
+  };
+  constexpr Bitboard JanggiElephantMagicInit[SQUARE_NB] = {
+      B(0xC502282200061400, 0x2D07081241D90200),
+      B(0xC502282200061400, 0x2D07081241D90200),
+      B(0x8084810022440C2, 0x81402202004),
+      B(0x80204010A800500, 0x5000021001740218),
+      B(0x8048100401208000, 0x2001000390000044),
+      B(0x202080020000000, 0x4010800010090424),
+      B(0x4081A0480073200, 0x100000A010406000),
+      B(0x4081A0480073200, 0x100000A010406000),
+      B(0x2040450004000C40, 0x8400000006302),
+      B(0x84010410018201, 0xA00A00000100000),
+      B(0x840091030C00040, 0x1400008200023400),
+      B(0x801058C0A0022, 0xC1920480010034),
+      B(0x80B4004800840800, 0x4080210A42040010),
+      B(0x400402221000445, 0x80321200408040),
+      B(0x4028142401012A00, 0x4005009000104448),
+      B(0x1440102040800220, 0x82800010A082000),
+      B(0x4100040300C00200, 0x800805100120000),
+      B(0x8200080061100, 0x2000101400000),
+      B(0x2000100410070001, 0x40818200B0900410),
+      B(0x400088020080000, 0x4A000402000CA0),
+      B(0x1402040410004000, 0x9840044504040),
+      B(0x20800088A00A0400, 0x1000020100180),
+      B(0x2001820520308201, 0x2008003404349000),
+      B(0x4004808022100, 0x8001000008081080),
+      B(0x102041041100425, 0x840400180B100104),
+      B(0x8806446000800214, 0x404402100010000),
+      B(0x8200141409C04101, 0x209030004A00D00),
+      B(0x8806004800880080, 0x1560004201000A01),
+      B(0x4200050600200090, 0x1CD0000000000421),
+      B(0x4820100022408100, 0x101404080320),
+      B(0x2A000A0A08080080, 0x1C02808000C2C0),
+      B(0x8808425040040014, 0x2021000100020),
+      B(0x5282104044A0020, 0x6B402104200008),
+      B(0x4001091040068120, 0x202000004003031),
+      B(0x4001091040068120, 0x202000004003031),
+      B(0x98040200A0214344, 0xA00300840010),
+      B(0x82508040A40808A, 0x40010000110042),
+      B(0x4400100101023, 0x450C8480040022),
+      B(0x210588880010800, 0x800A000108018102),
+      B(0x9400010144400, 0xC00010100018000),
+      B(0x20A0400100040004, 0x1242000101002040),
+      B(0x8022900040001001, 0x100000014000260),
+      B(0x51004124000A080, 0x40098400000002),
+      B(0x2158040001080022, 0x80009238401222),
+      B(0xA0103A0000802220, 0x20000200400010),
+      B(0x1101001208240, 0x100000800001064),
+      B(0x821020002090081, 0x5840D0010290280),
+      B(0x821020002090081, 0x5840D0010290280),
+      B(0x10400C1042000400, 0x4005000000440200),
+      B(0x844022008804820, 0x1000800100118000),
+      B(0x10802A9800800139, 0x4802840100842200),
+      B(0x4000A008200081, 0x4001100200402000),
+      B(0x200000008108400, 0x1000C00008080020),
+      B(0x120C11500100081, 0x440300308041100),
+      B(0x8080040080060100, 0xC00101B0040028),
+      B(0x901420A00110000, 0x8200010044700280),
+      B(0x140080080410000, 0x808040000C001001),
+      B(0x80210C0200A0008, 0x88088004600201),
+      B(0x8000004202020301, 0x2100142104002000),
+      B(0x1101011210004880, 0x8500840400000000),
+      B(0x40208802004800, 0x8080806009011240),
+      B(0x800000140408880, 0xC001018004060040),
+      B(0xC008080420500, 0x8024A10000000000),
+      B(0x2800000000400010, 0x44001C00400408),
+      B(0xA804008001200408, 0x202000020001000),
+      B(0xC08288805004080, 0x200042000800004),
+      B(0xA40A01000080012, 0x8800080042408),
+      B(0x2200100000100810, 0x800200010000100),
+      B(0x9881800004040001, 0x8058100100884004),
+      B(0x820000044020014, 0x4AA00010245012),
+      B(0x820000044020014, 0x4AA00010245012),
+      B(0x4000080240000808, 0x10100022054000),
+      B(0x5002000840101, 0x202020004000A00),
+      B(0x1188008200008402, 0x8088100020A2204),
+      B(0x304012004044080, 0x8028108818006010),
+      B(0x102210000008400, 0x1008000200380002),
+      B(0x51410E114200, 0x100C00084000000),
+      B(0x5001242320218, 0x800025000040040),
+      B(0x4008000200008190, 0x400020021000000),
+      B(0x10910022F0040, 0x450084400040001),
+      B(0x180010810000040, 0x4004100040040),
+      B(0x1088801424062010, 0x400084010030401),
+      B(0x3000120408000040, 0x10802001080A4051),
+      B(0x200008420, 0x40C0100020008804),
+      B(0x1048C000004000, 0x4220120804004000),
+      B(0x404A180000000E, 0x4C30412008110102),
+      B(0x400000404202005, 0x800808550EC40044),
+      B(0x282000200212010, 0x8001C0C102000210),
+      B(0x9012240000008100, 0x280CA04010040000),
+      B(0x2000C04001020C00, 0x2002010101042000),
+      B(0x1010000204408408, 0x8008004800E0C4A),
+      B(0x800286801000025, 0x8402401040050088),
+      B(0x40002000A0880000, 0x8400300108082086),
+      B(0x2080004404011, 0x20C080400100001),
+      B(0xB0010218100800, 0x8040200482C14103),
+      B(0x8011035000000C20, 0x4200044043200040),
+      B(0x804008000040050, 0x41044890228000),
+      B(0x80000400A0020020, 0x5308022021000000),
+      B(0x2118200000008004, 0x4141014004423D00),
+      B(0x90C0000200008040, 0x41041062000082),
+      B(0x1D000100941204, 0x12402001200420),
+      B(0x8C0040400400065, 0x22300B408100000),
+      B(0x8C0040400400065, 0x22300B408100000),
+      B(0x802802044600000, 0x1210100401030082),
+      B(0x9400488010000000, 0x8005404902040000),
+      B(0x2214020200001, 0x40102100820200),
+      B(0x2022000000800000, 0x6400440108480),
+      B(0x110000400100028, 0x24052304508004),
+      B(0x848820140010000, 0x201012500A000),
+      B(0x848820140010000, 0x201012500A000),
+      B(0x100100000000C4, 0x208004084048201),
+      B(0x100500000000290, 0x10102818208000),
+      B(0x2800414000C000, 0x20004005001301),
+      B(0x698180005101241, 0x10002014800210),
+      B(0x20000080000009, 0x440340C040),
+      B(0x1C0220200290020, 0x42100004004011C0),
+      B(0x200E620018320208, 0x440410402),
+      B(0xD04101010004024, 0x20000121104010A4),
+      B(0x220400000A80040, 0x806080020810010C),
+      B(0xA000200000000080, 0x1040801A0081208),
+  };
+  constexpr Bitboard CannonDiagMagicInit[SQUARE_NB] = {
+      B(0x811801000400, 0x312260280280202),
+      B(0x44A000402022680, 0x1020224880420005),
+      B(0x8000C80800200880, 0x2000810060080C0),
+      B(0x2010300240428040, 0x40240002C004E30),
+      B(0x1018010404010004, 0x1001010018081E0),
+      B(0x2042040010080090, 0x100000008410300),
+      B(0x400080020102000, 0x4500005300000000),
+      B(0x2D00C80420010200, 0x804003280020008),
+      B(0x8038820024420, 0x6010010080012040),
+      B(0x1202028004200088, 0x50018100004000C6),
+      B(0xA02010F0410081, 0x20013001000009A),
+      B(0x4013002041030588, 0x4802004110000004),
+      B(0x110020802000081, 0x202001800908002),
+      B(0x22010404103, 0x2020882080491200),
+      B(0x60000220400580, 0x85902800100100),
+      B(0x100080800050100, 0x200010220021088),
+      B(0x8088840404200080, 0x140011040104000),
+      B(0x4008508080082015, 0x8010100200580048),
+      B(0x4010400420201001, 0x260002080A80808),
+      B(0xC2002004A0008008, 0x8020082000110840),
+      B(0xA000A0820042400, 0x810408082100420),
+      B(0x80231808100004, 0x204002000800400),
+      B(0x8296144044004900, 0x4A1003008001840),
+      B(0x80A0020A0011008, 0x800104846080810),
+      B(0x803800801041000, 0x1030500102000404),
+      B(0x240C00900800850, 0x1804000108810000),
+      B(0x800400000088800, 0x800021801020000),
+      B(0x84800409300082, 0x1002D40680044000),
+      B(0xA110C0000200010, 0x401010001200260),
+      B(0x8200160204100004, 0x8040004004002022),
+      B(0x10001000000100C0, 0x84002811000200),
+      B(0x2000080020014001, 0x42002020000102),
+      B(0x109040044020018, 0x2020400202001000),
+      B(0x620000CD0108, 0x40040201008000),
+      B(0xA1402200A0020, 0x81400400300912),
+      B(0x20020CF100018020, 0x801A14086404000),
+      B(0x800801844001, 0x11621488425000),
+      B(0x10201004A8080, 0x100A000801000010),
+      B(0x2800411001000800, 0x80224084900020),
+      B(0x40400024028100, 0x501000400230060),
+      B(0x404808010080, 0x1201000400100004),
+      B(0x80802005200, 0x2000200008A0000),
+      B(0x20800080000022, 0x80040810002010),
+      B(0x40016004808240, 0x400114000801100),
+      B(0x8410004204240, 0x20011000604050),
+      B(0x8000C1009008268, 0x201004000209000),
+      B(0x10240C000920, 0xE000A5C14003002),
+      B(0x10184024280008, 0x90240802000000),
+      B(0x40889081081000, 0x8010050008800000),
+      B(0x100008C089000019, 0x802032014020010),
+      B(0x401C1804C00, 0x402501002002020),
+      B(0x200022000920D0, 0x8000800081300020),
+      B(0x801000400011, 0x400100044010226),
+      B(0x4A04010100100000, 0x500400080400000),
+      B(0xA000050200080000, 0x8500090001010000),
+      B(0x40400040001812, 0x4403000400100A0),
+      B(0x20C2250203020004, 0x210001C000080000),
+      B(0x21000408C6020001, 0x4200830012D1001),
+      B(0x840082016080A210, 0x2400080801081008),
+      B(0x40001020000, 0x4041240200083120),
+      B(0x2C04030010C0818, 0xA670002000818100),
+      B(0x4704A07085000510, 0x914001000040),
+      B(0x900210304100100, 0x1010004000281840),
+      B(0x8202920002002040, 0x810012000003),
+      B(0x4001400100050, 0x1144000408002000),
+      B(0x5900200020008100, 0x40200020002004),
+      B(0x301020002000480, 0x202000C0004),
+      B(0x20D000201104040, 0x34840100020010),
+      B(0x800004200080408, 0x40184200100240),
+      B(0x8430080100404020, 0x90042100244500),
+      B(0x3800100010220062, 0x50404030200218),
+      B(0x42E20008002020, 0x2000008200200300),
+      B(0xE488008280A004, 0x200001010CC80000),
+      B(0x6018010041109810, 0x800002000242041A),
+      B(0x40A8002438980, 0x8000810008208009),
+      B(0x401000480040100, 0x286800404002212),
+      B(0x821030000100009, 0x2000090200A00000),
+      B(0x20000100C0008028, 0x5000000100400082),
+      B(0x80A000048030080, 0x200000120200008),
+      B(0x6300280800204003, 0x48000105C0040100),
+      B(0x83008802420C0200, 0x2008020200080100),
+      B(0x1050C3102200042, 0x20103900010008),
+      B(0x8040902021408180, 0x12000021806200A4),
+      B(0x3008204008C10004, 0x680110100010401),
+      B(0x204321100421000, 0x400E204820494000),
+      B(0x8000044022404048, 0x4024010090024021),
+      B(0x140201424050, 0x280A000130008000),
+      B(0x900340808004002, 0x21026008000380),
+      B(0x82808000300444, 0x20002000A2001141),
+      B(0x140180100406002, 0x4004480001000004),
+      B(0x4808420800841900, 0x14008C0041000000),
+      B(0x2008600009000480, 0x9008020001400000),
+      B(0x2000100800100002, 0x2004100820210020),
+      B(0x2062010401A8100, 0x12200108420090),
+      B(0x1403188200032, 0x40048166105000),
+      B(0x410020020140041, 0x4400348102940040),
+      B(0x414040209208041, 0x4402400028B004),
+      B(0x8008010100421202, 0x401418002008800),
+      B(0x4000020010062200, 0xA02009148048000),
+      B(0x4443080082008B, 0x104014022801010),
+      B(0x42B440A0C000800, 0x9001009016111020),
+      B(0x400000214002, 0x8008080209020009),
+      B(0x480C414A001900, 0x3400100400210200),
+      B(0x1006008800604, 0x20240004030A050),
+      B(0x4C022401002A8300, 0x405008400000600),
+      B(0x3104000800A1042, 0x2004800204406200),
+      B(0xA09010280008200C, 0x4004000208C4168),
+      B(0x2800401120C20120, 0x4A00450200022030),
+      B(0x88001800304C0200, 0x204288102080000),
+      B(0x8044004201440101, 0x400820080C024022),
+      B(0xA000100C080, 0x4B40341004008081),
+      B(0x94802001300810, 0x140206008000800),
+      B(0x40002020202820, 0x280680404000040),
+      B(0xA820800004200, 0x80E1401012000491),
+      B(0x804000010020C000, 0x9403020200802000),
+      B(0x8C0001284201400, 0xC000100C01620800),
+      B(0x4010004002200414, 0x403080080200000),
+      B(0x140400A100800101, 0x10054C031080400),
+      B(0x20012C2400880082, 0x7000880020C03200),
+      B(0x204040300004, 0x840800041101002),
+  };
+  constexpr Bitboard NightriderMagicInit[SQUARE_NB] = {
+      B(0x8008100800020052, 0x8001440000000000),
+      B(0x24028400210090, 0x4200000000021),
+      B(0x22002020A0200800, 0x100820120000082),
+      B(0x424009020002200, 0x84810D4100002A),
+      B(0x404008020000600, 0x1000202000000081),
+      B(0x21020001000680, 0x2140200000000000),
+      B(0x2060021100000608, 0x8080020040000C8),
+      B(0x910C20408001200, 0x80A4030800000500),
+      B(0x2C40100010400009, 0x40400000200000C),
+      B(0x4090210034400004, 0x2104008000000),
+      B(0x1082008040840180, 0x140082080000000F),
+      B(0x8041001002101002, 0x8C002000000),
+      B(0x102205086800080, 0x84400030020D600),
+      B(0x2120080A32044E0, 0x400A02000016000),
+      B(0x6040003021040A0, 0x8000200206040040),
+      B(0x8001000008104082, 0x4002104202000114),
+      B(0x100400081080000, 0x201020020000020),
+      B(0x203000090010040, 0x140040010000000C),
+      B(0x9140000108100040, 0x4004004C08450010),
+      B(0x4402A12120020000, 0x450C002C000040C),
+      B(0x2028000200120800, 0x100100401001000),
+      B(0x800890081000, 0x10700A080180048),
+      B(0x41040C4008400, 0x8080001000080020),
+      B(0x2404000001060401, 0x10800116C0009110),
+      B(0x2001810020400110, 0xA0100800000480E2),
+      B(0x4081400120200218, 0x8800410800000000),
+      B(0x4C020020300E00, 0x810800000000808),
+      B(0xC8002200100108, 0x4860040380000100),
+      B(0x8000E0000804080, 0x4C800000000000),
+      B(0x211880010934041, 0x31000040000188),
+      B(0x4800801000003140, 0x80000000028),
+      B(0x61240410840004, 0x230100050000002),
+      B(0x61240410840004, 0x230100050000002),
+      B(0x4020008000C04C42, 0x3000021000000804),
+      B(0x829808040040840, 0x288010000002200),
+      B(0xA0420002040084, 0x1008604002000048),
+      B(0x10200004980, 0x2010410028000000),
+      B(0x4900200420100010, 0x1000A00401001898),
+      B(0x20000801600134, 0xC0002400000021C),
+      B(0x200040021010001, 0x8800000400000088),
+      B(0x88000824, 0x8800000040010000),
+      B(0x40000000200000D0, 0x8200004000AA84),
+      B(0x1002000000812002, 0x4000001C1008480),
+      B(0xC00010420003, 0x400002C00000004),
+      B(0x208400008008040, 0x111004280000C0),
+      B(0x60004000E800241, 0x202001000010040),
+      B(0x200004800061, 0x1109100480045800),
+      B(0x52880000200001, 0x608204100012DA0),
+      B(0x1000429008100800, 0x2008001000006018),
+      B(0x8490024200123001, 0x1041400080020),
+      B(0x810001020200014, 0x2C50500220000020),
+      B(0x20234B8000A0080, 0x4091200200000020),
+      B(0x400401010012600, 0xE00200000000020),
+      B(0x8040C00804004000, 0x8208014000000083),
+      B(0x102000410001044, 0x8200000000000),
+      B(0x102000410001044, 0x8200000000000),
+      B(0x242E00508040001, 0x80028000000000),
+      B(0x40810368002080, 0x4008080000224),
+      B(0x48200010208800, 0x1020800C000022),
+      B(0x220C4018008000, 0x282100130000211),
+      B(0x8008004400100, 0xC128208200020400),
+      B(0x44C004100020, 0x4008004000011000),
+      B(0x1008000000600008, 0x41C00180480183),
+      B(0x10080000, 0x404090018800020A),
+      B(0x4500000000004200, 0x45200200A0140),
+      B(0x2040000000240003, 0x8020080288000600),
+      B(0x2040000000240003, 0x8020080288000600),
+      B(0x2040000000240003, 0x8020080288000600),
+      B(0x48000000020A0080, 0x1000020200088),
+      B(0xA00000008404200, 0x4204010101001004),
+      B(0x10008030082, 0x2002800200100104),
+      B(0x44080002460010, 0x8007804100082D00),
+      B(0x98400040001802, 0x913002002020301),
+      B(0xA0400501040028, 0x8040481824002024),
+      B(0x4C0A0600100080A0, 0x8005000080008200),
+      B(0x802124000860008, 0x1009081800100080),
+      B(0x4000110040011000, 0x4080422200001081),
+      B(0x422008008000080, 0x4001020C00000202),
+      B(0x8000202008002101, 0xA008010000040),
+      B(0x804200020000020, 0xE0B0008010000001),
+      B(0x14040200002, 0x2000000006000004),
+      B(0x45000002010020, 0xA4040008400000),
+      B(0x800040020204184A, 0x10000402000006),
+      B(0x908000080400004, 0x5040100038400050),
+      B(0x3100002000040014, 0x804008008120000),
+      B(0x6002200000020008, 0xC011409081008881),
+      B(0xC02004060280001, 0x2003004010220254),
+      B(0x16410101, 0x100040108600000),
+      B(0x100000000200000, 0x201200010800200),
+      B(0xC400000004090002, 0x808808010224000A),
+      B(0xC400000004090002, 0x808808010224000A),
+      B(0x1000000000890001, 0x4050002001040),
+      B(0x618000000008484, 0x40000A0150000D4),
+      B(0x500000400009004, 0x1100200204100A1),
+      B(0x6006000008080480, 0x100254800C00904),
+      B(0x6006000008080480, 0x100254800C00904),
+      B(0x404808040044040, 0x4202020040000200),
+      B(0x2000080440810, 0x9044008844920000),
+      B(0x40204418040, 0x412000204080010),
+      B(0x88400820040248, 0x408040010C040800),
+      B(0x8110084000803, 0x102000000000),
+      B(0x4000040140001100, 0x80808102002),
+      B(0x100480044020008, 0x4601000100084488),
+      B(0x6200204420840, 0x41802043B0000),
+      B(0x540000010091010, 0x409004800A01208),
+      B(0x300040008000008, 0x2030080800010000),
+      B(0x408804010400090, 0x4008100800004000),
+      B(0x401600A0000080, 0x8400200201002200),
+      B(0x44000000100000, 0x1140040210000001),
+      B(0xC6000000D00804, 0x1050020C0081090C),
+      B(0x4098002, 0x900000C045008300),
+      B(0x245190008020, 0x2000C00100041000),
+      B(0x1000000A100046, 0x88000084800004),
+      B(0x1000000220240002, 0x400000401001088),
+      B(0x1000000220240002, 0x400000401001088),
+      B(0x820000118808000, 0x8000048161004A),
+      B(0x1100000000071A02, 0x500146102000048),
+      B(0x610000, 0x10010080040641),
+      B(0x2000010441A0044, 0x500800502020188),
+      B(0xA80000000180000, 0x234402012110080),
+  };
+  constexpr Bitboard GrasshopperMagicHInit[SQUARE_NB] = {
+      B(0x120000880110000, 0x1008000000020020),
+      B(0x24200C080840A052, 0x2004004000010008),
+      B(0xC030024000228800, 0x4000010400000020),
+      B(0x1A0020802008802, 0x206010208000),
+      B(0x12002000D001024, 0x80100800090138),
+      B(0x4220010000241010, 0x3098000602001500),
+      B(0x401010004801040, 0x8000280480100000),
+      B(0x820082024921836, 0x220028000),
+      B(0x100400502411400, 0x220402120240D14),
+      B(0x880202020010404, 0xA80202510000),
+      B(0x140002801000018, 0x1000346490040),
+      B(0x120000880110000, 0x1008000000020020),
+      B(0xD01004008030400, 0x104000408104420),
+      B(0x8420060100020000, 0x800280400000120),
+      B(0x4010020018010, 0x40A00001100000),
+      B(0x40006A0004000200, 0x40000000110),
+      B(0xD01004008030400, 0x104000408104420),
+      B(0x8908A20028110011, 0x800080000001A114),
+      B(0x200042000080F009, 0x20001000004000),
+      B(0x2820008820100, 0x10002400058000B9),
+      B(0x6083100420008050, 0x4040012600280080),
+      B(0x216020000000446, 0x4080204000000211),
+      B(0x340140003002089, 0x2402008000000911),
+      B(0xD01004008030400, 0x104000408104420),
+      B(0x1404040B20001000, 0x8000824010800011),
+      B(0x8C0488120024214, 0x8414880202291),
+      B(0x1010000060050000, 0x4000004050002602),
+      B(0x4022983A0060000, 0x80000040010400),
+      B(0x1404040B20001000, 0x8000824010800011),
+      B(0x6020101802002840, 0x31000003000004),
+      B(0x9000420008840, 0x4881300000000210),
+      B(0xA200808865, 0x41C0048023000128),
+      B(0x31801100400000, 0x8802DC001221240),
+      B(0x884000080200920, 0x1004002410401001),
+      B(0x2400040000884, 0x421006208040C0),
+      B(0x1404040B20001000, 0x8000824010800011),
+      B(0x24100400060009, 0x112008025042410),
+      B(0x1800040009040200, 0x180000A1004E408A),
+      B(0x24100400060009, 0x112008025042410),
+      B(0x4060402008080, 0xC240080000110000),
+      B(0x20080100920020, 0x2002248010242052),
+      B(0x10001010802050, 0x880000001C98420),
+      B(0x4000800100420022, 0x502022010A00D0),
+      B(0x4C18104500200885, 0x400880800),
+      B(0x8080810081020090, 0x8000000000000),
+      B(0x8000062812080201, 0x8004C8300800),
+      B(0xC010220920198, 0x85000A08000),
+      B(0x24100400060009, 0x112008025042410),
+      B(0x80102204040, 0x1000000900000000),
+      B(0x2080000004202804, 0x120880003461),
+      B(0x102004090A4030, 0x801020589240),
+      B(0x20001100814000A0, 0x420202000820004),
+      B(0x100800000A000120, 0x208000800010000),
+      B(0x1008205000040802, 0x80002000400040),
+      B(0x1480000098008401, 0xA0010000581010),
+      B(0x30C0008200100820, 0x102800080904834),
+      B(0x4810821884000500, 0x4400000200000212),
+      B(0x1811D00128A0180, 0x2500848803000000),
+      B(0x41618A0300040040, 0x21200200A421801),
+      B(0x80102204040, 0x1000000900000000),
+      B(0xA1808E0100108000, 0x2008000505000002),
+      B(0x8C890020410000A0, 0xA010000048000400),
+      B(0x40006002210044, 0x600008000408000),
+      B(0x1200447220090042, 0x80001000160012),
+      B(0x48410010AB000000, 0x9200600000000100),
+      B(0x2040000000240003, 0x8020080288000600),
+      B(0x9080000088848088, 0x4010210500000041),
+      B(0xA1808E0100108000, 0x2008000505000002),
+      B(0x480100400024, 0x1004800018200000),
+      B(0x808403080080200, 0x802601000000500),
+      B(0x8C890020410000A0, 0xA010000048000400),
+      B(0xA1808E0100108000, 0x2008000505000002),
+      B(0x100A40000004008, 0x2800200400200480),
+      B(0x100A40000004008, 0x2800200400200480),
+      B(0x400014006000000, 0x10006000810001F5),
+      B(0xC410062001414, 0x820080041B01044),
+      B(0x20000800310, 0x430040000201000),
+      B(0xA40010008000008, 0x4002200028000040),
+      B(0xC00102000008021C, 0x10C2000A010E024),
+      B(0x80004200104008, 0x50A00800C400020),
+      B(0x20200080012542, 0x910F0040000402C0),
+      B(0xB040100504000300, 0x24802002000040),
+      B(0x800001000014008, 0x400031004000),
+      B(0x100A40000004008, 0x2800200400200480),
+      B(0x84008002041081C0, 0x8080500200000000),
+      B(0x440090001012001, 0x4020004010),
+      B(0x100A0028088020, 0x80040E00010020),
+      B(0x2180808000810, 0xB018040A00040000),
+      B(0x40C80920304C4001, 0x42800B200800000),
+      B(0x85000425001000, 0x4810048020001100),
+      B(0x600C000801000004, 0x8015084010200020),
+      B(0x20020050000240C0, 0x100202008600800),
+      B(0x38000050001220, 0x9200010200145900),
+      B(0x1042108040005, 0x1402A0802201001),
+      B(0x824240000C20400, 0x1000000400080010),
+      B(0x84008002041081C0, 0x8080500200000000),
+      B(0x400804A1000008, 0x1024104A0200010),
+      B(0x8000402308483, 0x20006020100100),
+      B(0x80880120000080, 0x8000240100084),
+      B(0x5840020004882001, 0x1004528000A00010),
+      B(0x8001018800300002, 0x84010040804),
+      B(0x180D10004000A008, 0xA001080008020004),
+      B(0x400080B, 0x10A0000004010000),
+      B(0x8080000200000, 0x2001000082004E0),
+      B(0x40040001000C2000, 0x2024800001004008),
+      B(0x400804A1000008, 0x1024104A0200010),
+      B(0x8000402308483, 0x20006020100100),
+      B(0x400804A1000008, 0x1024104A0200010),
+      B(0x2000200000, 0x1201011000802),
+      B(0x100100000000C4, 0x208004084048201),
+      B(0x400084000044, 0x100810140300),
+      B(0x29040C0C01010, 0x300204010820080),
+      B(0x1A808000020200, 0x1000000005210040),
+      B(0x20000400150000, 0x85008020),
+      B(0x40C040008184014, 0x8002AA00024010),
+      B(0x202000081B00804, 0x10001002008),
+      B(0x40011000210060, 0x6080C40000021004),
+      B(0x2000200000, 0x1201011000802),
+      B(0x4100480203840, 0x300080100804),
+      B(0x2000200000, 0x1201011000802),
+  };
+  constexpr Bitboard GrasshopperMagicVInit[SQUARE_NB] = {
+      B(0x202000812104400, 0x24800B01C0000303),
+      B(0x340020400010D, 0x88060150C00400),
+      B(0x400802040609, 0x49010200501A0002),
+      B(0x8002680301000208, 0x628006C0C020200),
+      B(0x20400209001C0804, 0xA044000800143110),
+      B(0xC400082060010202, 0x4000480401014000),
+      B(0x22500200144040, 0x8204820084704C00),
+      B(0x8C1204009030020, 0x328400805000000),
+      B(0x84800800D0001640, 0x200080040060108),
+      B(0x804810208020040, 0x140010108020000),
+      B(0x1102010B008004, 0x300208006220020),
+      B(0x140080404A0A2428, 0x6308010100080),
+      B(0x20444002120408, 0xA080010508010001),
+      B(0x82011044000D02, 0x4112028620110809),
+      B(0x81010831000C02, 0x408802085000000),
+      B(0x81010831000C02, 0x408802085000000),
+      B(0x920008920600040, 0x8053801004000028),
+      B(0x81140283208300, 0x10040C004200420),
+      B(0x103080022201, 0xC01000081312620),
+      B(0x2200221100008, 0x1000408104000A4),
+      B(0x4402088080042008, 0x210401501040340),
+      B(0x898400202170001, 0x80040404208000),
+      B(0x20080004051012, 0x5100048200081800),
+      B(0x2320020000401018, 0x108501021040210),
+      B(0x21080410A422021, 0x83040180008800),
+      B(0x44E8100000408224, 0x20010008040400),
+      B(0x1800240002810405, 0x23004820000020),
+      B(0x80A0100400110, 0x80104020100C4028),
+      B(0x1002050001222C0, 0x5100818004024020),
+      B(0x104000200040, 0xC010A09800102000),
+      B(0x1020003A058120, 0x450900809000302),
+      B(0x40040045008B1, 0x202800400383010),
+      B(0x4640200220034, 0x8800485420304000),
+      B(0x5001042100084288, 0x110820001240080A),
+      B(0x2002C04004010120, 0xA15008020880001),
+      B(0x2800004080C4190, 0x890808280020080),
+      B(0x40C0401000104000, 0x2020880008002580),
+      B(0x40020C002400802, 0x801104010000000),
+      B(0x44842000040080, 0x2050011084000400),
+      B(0x4110040800000401, 0x2023810029008000),
+      B(0x20884000840, 0x8017102004008000),
+      B(0x10411104000480, 0x1414042000201001),
+      B(0x220040000008, 0x800306021000000),
+      B(0x41400A0008080, 0x501000298ACAD10),
+      B(0x800240012831810, 0x80120004468050E),
+      B(0x800005020801008, 0x20102400240000),
+      B(0x20C00040C114C010, 0x88080820200C00),
+      B(0x1044010100820081, 0x20080841004000),
+      B(0x8041048400022, 0x8020836040005002),
+      B(0x2001004010205, 0x8001002884042009),
+      B(0x128088400087, 0x20008002201002),
+      B(0x8084108040402000, 0x80809000A080400),
+      B(0x408081840880, 0x201002088000040),
+      B(0xA40180010280, 0x241004006000010),
+      B(0x4204100080048140, 0x2002C4F104202020),
+      B(0x100140A10204, 0x980200800840060),
+      B(0x1005140010202048, 0x1442280800202815),
+      B(0x2000082025008600, 0x1108400040600003),
+      B(0x1005050648000, 0x200020240008002),
+      B(0x202010208044000, 0x8210404060008),
+      B(0x8011040402000210, 0xC840180408016004),
+      B(0x404098801028, 0x80020A0001000400),
+      B(0x404098801028, 0x80020A0001000400),
+      B(0x80101002180140, 0x40C2080820000C0),
+      B(0x208202081260800, 0x14090E4C04000050),
+      B(0x4221201084004C2, 0x110480A011060),
+      B(0x8000008421090204, 0x1C01010800024),
+      B(0x8000008421090204, 0x1C01010800024),
+      B(0x200180C840088A0, 0x401100400820000),
+      B(0x10084043A021070, 0x202041600080200),
+      B(0x210E6202001040C, 0x10100800080B0),
+      B(0x848008021204002, 0x801004308100BAD),
+      B(0xC082C0390A000601, 0x4040080189008),
+      B(0x431200240210402D, 0x58102820000),
+      B(0x202020100A0019B0, 0x4010C0D018000000),
+      B(0x800800908402203, 0x102948C84C184),
+      B(0x26801100080845, 0x4009702022A00820),
+      B(0x8880520010401040, 0x1060084832052000),
+      B(0x100100022042081, 0x10000600008C121),
+      B(0x46020384100040, 0x800200320882021),
+      B(0xC0002010148, 0x4200800800040003),
+      B(0x2002208020090040, 0x40820210021410),
+      B(0x9000A41160002004, 0x2A09000100080043),
+      B(0x800004010008001, 0x1108002020104600),
+      B(0x800540C000A4E041, 0x18021180000401),
+      B(0x808200900A900202, 0x8364202140012005),
+      B(0x1DBA52000081010, 0x4008000023000010),
+      B(0x4100110204401481, 0x800040091020001C),
+      B(0x4100110204401481, 0x800040091020001C),
+      B(0x4101100020400482, 0x2000402302100120),
+      B(0x100408000A020212, 0xA000400111000020),
+      B(0x2000010488080104, 0x3000404410208100),
+      B(0x2684220180008DD0, 0x422040200004000A),
+      B(0x2021200C0424, 0x1010100000080200),
+      B(0x8908020020801006, 0x3010800020C2000),
+      B(0x4000030008062044, 0x244010202688000),
+      B(0x242101200408009, 0x8150040000200015),
+      B(0x42004C02180204, 0x210208014241040),
+      B(0x4E1A01C208410804, 0x8890041000012004),
+      B(0x2080200401000080, 0x8001098429008004),
+      B(0xA01400121804104, 0x280200C400000500),
+      B(0xD0080408040420, 0x1006040100224000),
+      B(0x28400205000800C9, 0x6021101401040075),
+      B(0x4000900040020104, 0x88129801100D0C),
+      B(0x8000004002180410, 0x400380200400204),
+      B(0x4002A430043008, 0x400200340100020),
+      B(0x401960004140A42, 0x100880710000464),
+      B(0x58014090102, 0xB8D30004010080),
+      B(0xA004C08000244000, 0x11280100E0000040),
+      B(0x2102008089208804, 0x110001004080040),
+      B(0x700010084E003004, 0x8080864112000D40),
+      B(0x4080881000200C20, 0x30324040880E0600),
+      B(0x2024A40401810820, 0x3000888002000000),
+      B(0x8200100400014, 0x4400340800252844),
+      B(0x24A00804288281, 0x410103002201140),
+      B(0x4080005022A08, 0x1000402200100264),
+      B(0x200080032244040, 0x200502189010001),
+      B(0x28108110404001, 0x400600120008412),
+      B(0xA00002102810020, 0xB1080240015408),
+      B(0x810080200806, 0x410440804080046),
+  };
+  constexpr Bitboard GrasshopperMagicDInit[SQUARE_NB] = {
+      B(0x811801000400, 0x312260280280202),
+      B(0x44A000402022680, 0x1020224880420005),
+      B(0x8000C80800200880, 0x2000810060080C0),
+      B(0x2010300240428040, 0x40240002C004E30),
+      B(0x1018010404010004, 0x1001010018081E0),
+      B(0x2042040010080090, 0x100000008410300),
+      B(0x400080020102000, 0x4500005300000000),
+      B(0x2D00C80420010200, 0x804003280020008),
+      B(0x8038820024420, 0x6010010080012040),
+      B(0x1202028004200088, 0x50018100004000C6),
+      B(0xA02010F0410081, 0x20013001000009A),
+      B(0x4013002041030588, 0x4802004110000004),
+      B(0x110020802000081, 0x202001800908002),
+      B(0x22010404103, 0x2020882080491200),
+      B(0x60000220400580, 0x85902800100100),
+      B(0x100080800050100, 0x200010220021088),
+      B(0x8088840404200080, 0x140011040104000),
+      B(0x4008508080082015, 0x8010100200580048),
+      B(0x4010400420201001, 0x260002080A80808),
+      B(0xC2002004A0008008, 0x8020082000110840),
+      B(0xA000A0820042400, 0x810408082100420),
+      B(0x80231808100004, 0x204002000800400),
+      B(0x8296144044004900, 0x4A1003008001840),
+      B(0x80A0020A0011008, 0x800104846080810),
+      B(0x803800801041000, 0x1030500102000404),
+      B(0x240C00900800850, 0x1804000108810000),
+      B(0x800400000088800, 0x800021801020000),
+      B(0x84800409300082, 0x1002D40680044000),
+      B(0xA110C0000200010, 0x401010001200260),
+      B(0x8200160204100004, 0x8040004004002022),
+      B(0x10001000000100C0, 0x84002811000200),
+      B(0x2000080020014001, 0x42002020000102),
+      B(0x109040044020018, 0x2020400202001000),
+      B(0x620000CD0108, 0x40040201008000),
+      B(0xA1402200A0020, 0x81400400300912),
+      B(0x20020CF100018020, 0x801A14086404000),
+      B(0x800801844001, 0x11621488425000),
+      B(0x10201004A8080, 0x100A000801000010),
+      B(0x2800411001000800, 0x80224084900020),
+      B(0x40400024028100, 0x501000400230060),
+      B(0x404808010080, 0x1201000400100004),
+      B(0x80802005200, 0x2000200008A0000),
+      B(0x20800080000022, 0x80040810002010),
+      B(0x40016004808240, 0x400114000801100),
+      B(0x8410004204240, 0x20011000604050),
+      B(0x8000C1009008268, 0x201004000209000),
+      B(0x10240C000920, 0xE000A5C14003002),
+      B(0x10184024280008, 0x90240802000000),
+      B(0x40889081081000, 0x8010050008800000),
+      B(0x100008C089000019, 0x802032014020010),
+      B(0x401C1804C00, 0x402501002002020),
+      B(0x200022000920D0, 0x8000800081300020),
+      B(0x801000400011, 0x400100044010226),
+      B(0x4A04010100100000, 0x500400080400000),
+      B(0xA000050200080000, 0x8500090001010000),
+      B(0x40400040001812, 0x4403000400100A0),
+      B(0x20C2250203020004, 0x210001C000080000),
+      B(0x21000408C6020001, 0x4200830012D1001),
+      B(0x840082016080A210, 0x2400080801081008),
+      B(0x40001020000, 0x4041240200083120),
+      B(0x2C04030010C0818, 0xA670002000818100),
+      B(0x4704A07085000510, 0x914001000040),
+      B(0x900210304100100, 0x1010004000281840),
+      B(0x8202920002002040, 0x810012000003),
+      B(0x4001400100050, 0x1144000408002000),
+      B(0x5900200020008100, 0x40200020002004),
+      B(0x301020002000480, 0x202000C0004),
+      B(0x20D000201104040, 0x34840100020010),
+      B(0x800004200080408, 0x40184200100240),
+      B(0x8430080100404020, 0x90042100244500),
+      B(0x3800100010220062, 0x50404030200218),
+      B(0x42E20008002020, 0x2000008200200300),
+      B(0xE488008280A004, 0x200001010CC80000),
+      B(0x6018010041109810, 0x800002000242041A),
+      B(0x40A8002438980, 0x8000810008208009),
+      B(0x401000480040100, 0x286800404002212),
+      B(0x821030000100009, 0x2000090200A00000),
+      B(0x20000100C0008028, 0x5000000100400082),
+      B(0x80A000048030080, 0x200000120200008),
+      B(0x6300280800204003, 0x48000105C0040100),
+      B(0x83008802420C0200, 0x2008020200080100),
+      B(0x1050C3102200042, 0x20103900010008),
+      B(0x8040902021408180, 0x12000021806200A4),
+      B(0x3008204008C10004, 0x680110100010401),
+      B(0x204321100421000, 0x400E204820494000),
+      B(0x8000044022404048, 0x4024010090024021),
+      B(0x140201424050, 0x280A000130008000),
+      B(0x900340808004002, 0x21026008000380),
+      B(0x82808000300444, 0x20002000A2001141),
+      B(0x140180100406002, 0x4004480001000004),
+      B(0x4808420800841900, 0x14008C0041000000),
+      B(0x2008600009000480, 0x9008020001400000),
+      B(0x2000100800100002, 0x2004100820210020),
+      B(0x2062010401A8100, 0x12200108420090),
+      B(0x1403188200032, 0x40048166105000),
+      B(0x410020020140041, 0x4400348102940040),
+      B(0x414040209208041, 0x4402400028B004),
+      B(0x8008010100421202, 0x401418002008800),
+      B(0x4000020010062200, 0xA02009148048000),
+      B(0x4443080082008B, 0x104014022801010),
+      B(0x42B440A0C000800, 0x9001009016111020),
+      B(0x400000214002, 0x8008080209020009),
+      B(0x480C414A001900, 0x3400100400210200),
+      B(0x1006008800604, 0x20240004030A050),
+      B(0x4C022401002A8300, 0x405008400000600),
+      B(0x3104000800A1042, 0x2004800204406200),
+      B(0xA09010280008200C, 0x4004000208C4168),
+      B(0x2800401120C20120, 0x4A00450200022030),
+      B(0x88001800304C0200, 0x204288102080000),
+      B(0x8044004201440101, 0x400820080C024022),
+      B(0xA000100C080, 0x4B40341004008081),
+      B(0x94802001300810, 0x140206008000800),
+      B(0x40002020202820, 0x280680404000040),
+      B(0xA820800004200, 0x80E1401012000491),
+      B(0x804000010020C000, 0x9403020200802000),
+      B(0x8C0001284201400, 0xC000100C01620800),
+      B(0x4010004002200414, 0x403080080200000),
+      B(0x140400A100800101, 0x10054C031080400),
+      B(0x20012C2400880082, 0x7000880020C03200),
+      B(0x204040300004, 0x840800041101002),
+  };
+#undef B
+#endif
+
+} // namespace Stockfish
+
+#endif // #ifndef MAGIC_H_INCLUDED

Fairy-Stockfish-master/src/main.cpp

@@ -0,0 +1,63 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <iostream>
+
+#include "bitboard.h"
+#include "endgame.h"
+#include "position.h"
+#include "psqt.h"
+#include "search.h"
+#include "syzygy/tbprobe.h"
+#include "thread.h"
+#include "tt.h"
+#include "uci.h"
+
+#include "piece.h"
+#include "variant.h"
+#include "xboard.h"
+
+
+using namespace Stockfish;
+
+int main(int argc, char* argv[]) {
+
+  std::cout << engine_info() << std::endl;
+
+  pieceMap.init();
+  variants.init();
+  CommandLine::init(argc, argv);
+  UCI::init(Options);
+  Tune::init();
+  PSQT::init(variants.find(Options["UCI_Variant"])->second);
+  Bitboards::init();
+  Position::init();
+  Bitbases::init();
+  Endgames::init();
+  Threads.set(size_t(Options["Threads"]));
+  Search::clear(); // After threads are up
+  Eval::NNUE::init();
+
+  UCI::loop(argc, argv);
+
+  Threads.set(0);
+  variants.clear_all();
+  pieceMap.clear_all();
+  delete XBoard::stateMachine;
+  return 0;
+}

Fairy-Stockfish-master/src/material.cpp

@@ -0,0 +1,321 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <cassert>
+#include <cstring>   // For std::memset
+
+#include "material.h"
+#include "thread.h"
+
+using namespace std;
+
+namespace Stockfish {
+
+namespace {
+  #define S(mg, eg) make_score(mg, eg)
+
+  // Polynomial material imbalance parameters
+
+  // One Score parameter for each pair (our piece, another of our pieces)
+  constexpr Score QuadraticOurs[][PIECE_TYPE_NB] = {
+    // OUR PIECE 2
+    // bishop pair    pawn         knight       bishop       rook           queen
+    {S(1419, 1455)                                                                  }, // Bishop pair
+    {S( 101,   28), S( 37,  39)                                                     }, // Pawn
+    {S(  57,   64), S(249, 187), S(-49, -62)                                        }, // Knight      OUR PIECE 1
+    {S(   0,    0), S(118, 137), S( 10,  27), S(  0,   0)                           }, // Bishop
+    {S( -63,  -68), S( -5,   3), S(100,  81), S(132, 118), S(-246, -244)            }, // Rook
+    {S(-210, -211), S( 37,  14), S(147, 141), S(161, 105), S(-158, -174), S(-9,-31) }  // Queen
+  };
+
+  // One Score parameter for each pair (our piece, their piece)
+  constexpr Score QuadraticTheirs[][PIECE_TYPE_NB] = {
+    // THEIR PIECE
+    // bishop pair   pawn         knight       bishop       rook         queen
+    {                                                                               }, // Bishop pair
+    {S(  33,  30)                                                                   }, // Pawn
+    {S(  46,  18), S(106,  84)                                                      }, // Knight      OUR PIECE
+    {S(  75,  35), S( 59,  44), S( 60,  15)                                         }, // Bishop
+    {S(  26,  35), S(  6,  22), S( 38,  39), S(-12,  -2)                            }, // Rook
+    {S(  97,  93), S(100, 163), S(-58, -91), S(112, 192), S(276, 225)               }  // Queen
+  };
+
+  #undef S
+
+  // Endgame evaluation and scaling functions are accessed directly and not through
+  // the function maps because they correspond to more than one material hash key.
+  Endgame<KFsPsK> EvaluateKFsPsK[] = { Endgame<KFsPsK>(WHITE), Endgame<KFsPsK>(BLACK) };
+  Endgame<KXK>    EvaluateKXK[] = { Endgame<KXK>(WHITE),    Endgame<KXK>(BLACK) };
+  Endgame<KXK, EG_EVAL_ATOMIC> EvaluateKXKAtomic[] = { Endgame<KXK, EG_EVAL_ATOMIC>(WHITE), Endgame<KXK, EG_EVAL_ATOMIC>(BLACK) };
+  Endgame<KXK, EG_EVAL_DUCK> EvaluateKXKDuck[] = { Endgame<KXK, EG_EVAL_DUCK>(WHITE), Endgame<KXK, EG_EVAL_DUCK>(BLACK) };
+  Endgame<KXKX, EG_EVAL_MISERE> EvaluateKXKXMisere[] = { Endgame<KXKX, EG_EVAL_MISERE>(WHITE), Endgame<KXKX, EG_EVAL_MISERE>(BLACK) };
+
+  Endgame<KBPsK>  ScaleKBPsK[]  = { Endgame<KBPsK>(WHITE),  Endgame<KBPsK>(BLACK) };
+  Endgame<KQKRPs> ScaleKQKRPs[] = { Endgame<KQKRPs>(WHITE), Endgame<KQKRPs>(BLACK) };
+  Endgame<KPsK>   ScaleKPsK[]   = { Endgame<KPsK>(WHITE),   Endgame<KPsK>(BLACK) };
+  Endgame<KPKP>   ScaleKPKP[]   = { Endgame<KPKP>(WHITE),   Endgame<KPKP>(BLACK) };
+
+  // Helper used to detect a given material distribution
+  bool is_KFsPsK(const Position& pos, Color us) {
+    return    (pos.promotion_piece_types(us) == piece_set(FERS))
+          && !more_than_one(pos.pieces(~us))
+          && (pos.count<FERS>(us) || pos.count<PAWN>(us))
+          && !(pos.count<ALL_PIECES>(us) - pos.count<FERS>(us) - pos.count<PAWN>(us) - pos.count<KING>(us));
+  }
+
+  bool is_KXK(const Position& pos, Color us) {
+    return  !more_than_one(pos.pieces(~us))
+          && pos.non_pawn_material(us) >= std::min(RookValueMg, 2 * SilverValueMg);
+  }
+
+  bool is_KXK_atomic(const Position& pos, Color us) {
+    return  !more_than_one(pos.pieces(~us))
+          && pos.non_pawn_material(us) >= RookValueMg + KnightValueMg;
+  }
+
+  bool is_KXKX(const Position& pos, Color us) {
+    return  pos.non_pawn_material(us) - pos.non_pawn_material(~us) > QueenValueMg;
+  }
+
+  bool is_KBPsK(const Position& pos, Color us) {
+    return   pos.non_pawn_material(us) == BishopValueMg
+          && pos.count<PAWN>(us) >= 1;
+  }
+
+  bool is_KQKRPs(const Position& pos, Color us) {
+    return  !pos.count<PAWN>(us)
+          && pos.non_pawn_material(us) == QueenValueMg
+          && pos.count<ROOK>(~us) == 1
+          && pos.count<PAWN>(~us) >= 1;
+  }
+
+
+  /// imbalance() calculates the imbalance by comparing the piece count of each
+  /// piece type for both colors.
+
+  template<Color Us>
+  Score imbalance(const Position& pos, const int pieceCount[][PIECE_TYPE_NB]) {
+
+    constexpr Color Them = ~Us;
+
+    Score bonus = SCORE_ZERO;
+
+    // Second-degree polynomial material imbalance, by Tord Romstad
+    for (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; ++pt1)
+    {
+        if (!pieceCount[Us][pt1])
+            continue;
+
+        int v = QuadraticOurs[pt1][pt1] * pieceCount[Us][pt1];
+
+        for (int pt2 = NO_PIECE_TYPE; pt2 < pt1; ++pt2)
+            v +=  QuadraticOurs[pt1][pt2] * pieceCount[Us][pt2]
+                + QuadraticTheirs[pt1][pt2] * pieceCount[Them][pt2];
+
+        bonus += pieceCount[Us][pt1] * v;
+    }
+
+    if (pos.must_capture())
+        bonus +=  (make_score(mg_value(QuadraticOurs[PAWN][PAWN]), 0) * pieceCount[Us][PAWN]
+                   + 3 * QuadraticOurs[KNIGHT][PAWN] * pieceCount[Us][KNIGHT]
+                   + QuadraticOurs[QUEEN][PAWN] * pieceCount[Us][QUEEN]) * pieceCount[Us][PAWN]
+                + make_score( mg_value(QuadraticOurs[KNIGHT][KNIGHT]),
+                             -eg_value(QuadraticOurs[KNIGHT][KNIGHT])) * pieceCount[Us][KNIGHT] * pieceCount[Us][KNIGHT];
+    else if (pos.blast_on_capture())
+        bonus -= make_score(mg_value(QuadraticOurs[KNIGHT][PAWN]) * pieceCount[Us][KNIGHT] * pieceCount[Us][PAWN] / 2, 0);
+    else if (pos.check_counting())
+        bonus -= 2 * QuadraticOurs[PAWN][PAWN] * pieceCount[Us][PAWN] * pieceCount[Us][PAWN];
+    else if (pos.captures_to_hand())
+        bonus -= bonus / 10;
+
+    return bonus;
+  }
+
+} // namespace
+
+namespace Material {
+
+
+/// Material::probe() looks up the current position's material configuration in
+/// the material hash table. It returns a pointer to the Entry if the position
+/// is found. Otherwise a new Entry is computed and stored there, so we don't
+/// have to recompute all when the same material configuration occurs again.
+
+Entry* probe(const Position& pos) {
+
+  Key key = pos.material_key(pos.endgame_eval());
+  Entry* e = pos.this_thread()->materialTable[key];
+
+  if (e->key == key)
+      return e;
+
+  std::memset(e, 0, sizeof(Entry));
+  e->key = key;
+  e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
+
+  Value npm_w = pos.non_pawn_material(WHITE);
+  Value npm_b = pos.non_pawn_material(BLACK);
+  Value npm   = std::clamp(npm_w + npm_b, EndgameLimit, MidgameLimit);
+
+  // Map total non-pawn material into [PHASE_ENDGAME, PHASE_MIDGAME]
+  if (pos.captures_to_hand() || pos.two_boards())
+  {
+      Value npm2 = VALUE_ZERO;
+      for (PieceSet ps = pos.piece_types(); ps;)
+      {
+          PieceType pt = pop_lsb(ps);
+          npm2 += pos.count_in_hand(pt) * PieceValue[MG][make_piece(WHITE, pt)];
+      }
+      e->gamePhase = Phase(PHASE_MIDGAME * npm / std::max(int(npm + npm2), 1));
+      int countAll = pos.count_with_hand(WHITE, ALL_PIECES) + pos.count_with_hand(BLACK, ALL_PIECES);
+      e->materialDensity = (npm + npm2 + pos.count<PAWN>() * PawnValueMg) * countAll / (pos.files() * pos.ranks());
+  }
+  else
+      e->gamePhase = Phase(((npm - EndgameLimit) * PHASE_MIDGAME) / (MidgameLimit - EndgameLimit));
+
+  // Let's look if we have a specialized evaluation function for this particular
+  // material configuration. Firstly we look for a fixed configuration one, then
+  // for a generic one if the previous search failed.
+  if (pos.endgame_eval() && (e->evaluationFunction = Endgames::probe<Value>(key)) != nullptr)
+      return e;
+
+  switch (pos.endgame_eval())
+  {
+  case EG_EVAL_CHESS:
+      for (Color c : { WHITE, BLACK })
+          if (is_KFsPsK(pos, c))
+          {
+              e->evaluationFunction = &EvaluateKFsPsK[c];
+              return e;
+          }
+
+      for (Color c : { WHITE, BLACK })
+          if (is_KXK(pos, c))
+          {
+              e->evaluationFunction = &EvaluateKXK[c];
+              return e;
+          }
+
+      // OK, we didn't find any special evaluation function for the current material
+      // configuration. Is there a suitable specialized scaling function?
+      {
+          const auto* sf = Endgames::probe<ScaleFactor>(key);
+
+          if (sf)
+          {
+              e->scalingFunction[sf->strongSide] = sf; // Only strong color assigned
+              return e;
+          }
+      }
+
+      // We didn't find any specialized scaling function, so fall back on generic
+      // ones that refer to more than one material distribution. Note that in this
+      // case we don't return after setting the function.
+      for (Color c : { WHITE, BLACK })
+      {
+          if (is_KBPsK(pos, c))
+              e->scalingFunction[c] = &ScaleKBPsK[c];
+
+          else if (is_KQKRPs(pos, c))
+              e->scalingFunction[c] = &ScaleKQKRPs[c];
+      }
+
+      if (npm_w + npm_b == VALUE_ZERO && pos.pieces(PAWN)) // Only pawns on the board
+      {
+          if (!pos.count<PAWN>(BLACK))
+          {
+              assert(pos.count<PAWN>(WHITE) >= 2);
+
+              e->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
+          }
+          else if (!pos.count<PAWN>(WHITE))
+          {
+              assert(pos.count<PAWN>(BLACK) >= 2);
+
+              e->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
+          }
+          else if (pos.count<PAWN>(WHITE) == 1 && pos.count<PAWN>(BLACK) == 1)
+          {
+              // This is a special case because we set scaling functions
+              // for both colors instead of only one.
+              e->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
+              e->scalingFunction[BLACK] = &ScaleKPKP[BLACK];
+          }
+      }
+
+      // Zero or just one pawn makes it difficult to win, even with a small material
+      // advantage. This catches some trivial draws like KK, KBK and KNK and gives a
+      // drawish scale factor for cases such as KRKBP and KmmKm (except for KBBKN).
+      if (!pos.count<PAWN>(WHITE) && npm_w - npm_b <= BishopValueMg)
+          e->factor[WHITE] = uint8_t(npm_w <  RookValueMg && pos.count<ALL_PIECES>(WHITE) <= 2 ? SCALE_FACTOR_DRAW :
+                                      npm_b <= BishopValueMg && pos.count<ALL_PIECES>(WHITE) <= 3 ? 4 : 14);
+
+      if (!pos.count<PAWN>(BLACK) && npm_b - npm_w <= BishopValueMg)
+          e->factor[BLACK] = uint8_t(npm_b <  RookValueMg && pos.count<ALL_PIECES>(BLACK) <= 2 ? SCALE_FACTOR_DRAW :
+                                      npm_w <= BishopValueMg && pos.count<ALL_PIECES>(BLACK) <= 3 ? 4 : 14);
+      break;
+  case EG_EVAL_ANTI:
+      break;
+  case EG_EVAL_ATOMIC:
+      for (Color c : { WHITE, BLACK })
+          if (is_KXK_atomic(pos, c))
+          {
+              e->evaluationFunction = &EvaluateKXKAtomic[c];
+              return e;
+          }
+      break;
+  case EG_EVAL_DUCK:
+      for (Color c : { WHITE, BLACK })
+          if (is_KXK(pos, c))
+          {
+              e->evaluationFunction = &EvaluateKXKDuck[c];
+              return e;
+          }
+      break;
+  case EG_EVAL_MISERE:
+      for (Color c : { WHITE, BLACK })
+          if (is_KXKX(pos, c))
+          {
+              e->evaluationFunction = &EvaluateKXKXMisere[c];
+              return e;
+          }
+      break;
+  case EG_EVAL_RK:
+      break;
+  case NO_EG_EVAL:
+      break;
+  default:
+      assert(false);
+  }
+
+  // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder
+  // for the bishop pair "extended piece", which allows us to be more flexible
+  // in defining bishop pair bonuses.
+  const int pieceCount[COLOR_NB][PIECE_TYPE_NB] = {
+  { pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE),
+    pos.count<BISHOP>(WHITE)    , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) },
+  { pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK),
+    pos.count<BISHOP>(BLACK)    , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } };
+
+  e->score = (imbalance<WHITE>(pos, pieceCount) - imbalance<BLACK>(pos, pieceCount)) / 16;
+  return e;
+}
+
+} // namespace Material
+
+} // namespace Stockfish

Fairy-Stockfish-master/src/material.h

@@ -0,0 +1,75 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef MATERIAL_H_INCLUDED
+#define MATERIAL_H_INCLUDED
+
+#include "endgame.h"
+#include "misc.h"
+#include "position.h"
+#include "types.h"
+
+namespace Stockfish::Material {
+
+/// Material::Entry contains various information about a material configuration.
+/// It contains a material imbalance evaluation, a function pointer to a special
+/// endgame evaluation function (which in most cases is NULL, meaning that the
+/// standard evaluation function will be used), and scale factors.
+///
+/// The scale factors are used to scale the evaluation score up or down. For
+/// instance, in KRB vs KR endgames, the score is scaled down by a factor of 4,
+/// which will result in scores of absolute value less than one pawn.
+
+struct Entry {
+
+  Score imbalance() const { return score; }
+  Phase game_phase() const { return (Phase)gamePhase; }
+  bool specialized_eval_exists() const { return evaluationFunction != nullptr; }
+  Value evaluate(const Position& pos) const { return (*evaluationFunction)(pos); }
+
+  int material_density() const { return materialDensity; }
+
+  // scale_factor() takes a position and a color as input and returns a scale factor
+  // for the given color. We have to provide the position in addition to the color
+  // because the scale factor may also be a function which should be applied to
+  // the position. For instance, in KBP vs K endgames, the scaling function looks
+  // for rook pawns and wrong-colored bishops.
+  ScaleFactor scale_factor(const Position& pos, Color c) const {
+    ScaleFactor sf = scalingFunction[c] ? (*scalingFunction[c])(pos)
+                                        :  SCALE_FACTOR_NONE;
+    return sf != SCALE_FACTOR_NONE ? sf : ScaleFactor(factor[c]);
+  }
+
+  Key key;
+  const EndgameBase<Value>* evaluationFunction;
+  const EndgameBase<ScaleFactor>* scalingFunction[COLOR_NB]; // Could be one for each
+                                                             // side (e.g. KPKP, KBPsK)
+  Score score;
+  int16_t gamePhase;
+  uint8_t factor[COLOR_NB];
+
+  int materialDensity;
+};
+
+typedef HashTable<Entry, 8192> Table;
+
+Entry* probe(const Position& pos);
+
+} // namespace Stockfish::Material
+
+#endif // #ifndef MATERIAL_H_INCLUDED

Fairy-Stockfish-master/src/misc.cpp

@@ -0,0 +1,656 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef _WIN32
+#if _WIN32_WINNT < 0x0601
+#undef  _WIN32_WINNT
+#define _WIN32_WINNT 0x0601 // Force to include needed API prototypes
+#endif
+
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#include <windows.h>
+// The needed Windows API for processor groups could be missed from old Windows
+// versions, so instead of calling them directly (forcing the linker to resolve
+// the calls at compile time), try to load them at runtime. To do this we need
+// first to define the corresponding function pointers.
+extern "C" {
+typedef bool(*fun1_t)(LOGICAL_PROCESSOR_RELATIONSHIP,
+                      PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, PDWORD);
+typedef bool(*fun2_t)(USHORT, PGROUP_AFFINITY);
+typedef bool(*fun3_t)(HANDLE, CONST GROUP_AFFINITY*, PGROUP_AFFINITY);
+}
+#endif
+
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <cstdlib>
+
+#if defined(__linux__) && !defined(__ANDROID__)
+#include <stdlib.h>
+#include <sys/mman.h>
+#endif
+
+#if defined(__APPLE__) || defined(__ANDROID__) || defined(__OpenBSD__) || (defined(__GLIBCXX__) && !defined(_GLIBCXX_HAVE_ALIGNED_ALLOC) && !defined(_WIN32)) || defined(__e2k__)
+#define POSIXALIGNEDALLOC
+#include <stdlib.h>
+#endif
+
+#include "misc.h"
+#include "thread.h"
+
+using namespace std;
+
+namespace Stockfish {
+
+namespace {
+
+/// Version number. If Version is left empty, then compile date in the format
+/// DD-MM-YY and show in engine_info.
+const string Version = "";
+
+/// Our fancy logging facility. The trick here is to replace cin.rdbuf() and
+/// cout.rdbuf() with two Tie objects that tie cin and cout to a file stream. We
+/// can toggle the logging of std::cout and std:cin at runtime whilst preserving
+/// usual I/O functionality, all without changing a single line of code!
+/// Idea from http://groups.google.com/group/comp.lang.c++/msg/1d941c0f26ea0d81
+
+struct Tie: public streambuf { // MSVC requires split streambuf for cin and cout
+
+  Tie(streambuf* b, streambuf* l) : buf(b), logBuf(l) {}
+
+  int sync() override { return logBuf->pubsync(), buf->pubsync(); }
+  int overflow(int c) override { return log(buf->sputc((char)c), "<< "); }
+  int underflow() override { return buf->sgetc(); }
+  int uflow() override { return log(buf->sbumpc(), ">> "); }
+
+  streambuf *buf, *logBuf;
+
+  int log(int c, const char* prefix) {
+
+    static int last = '\n'; // Single log file
+
+    if (last == '\n')
+        logBuf->sputn(prefix, 3);
+
+    return last = logBuf->sputc((char)c);
+  }
+};
+
+class Logger {
+
+  Logger() : in(cin.rdbuf(), file.rdbuf()), out(cout.rdbuf(), file.rdbuf()) {}
+ ~Logger() { start(""); }
+
+  ofstream file;
+  Tie in, out;
+
+public:
+  static void start(const std::string& fname) {
+
+    static Logger l;
+
+    if (!fname.empty() && !l.file.is_open())
+    {
+        l.file.open(fname, ifstream::out);
+
+        if (!l.file.is_open())
+        {
+            cerr << "Unable to open debug log file " << fname << endl;
+            exit(EXIT_FAILURE);
+        }
+
+        cin.rdbuf(&l.in);
+        cout.rdbuf(&l.out);
+    }
+    else if (fname.empty() && l.file.is_open())
+    {
+        cout.rdbuf(l.out.buf);
+        cin.rdbuf(l.in.buf);
+        l.file.close();
+    }
+  }
+};
+
+} // namespace
+
+
+/// engine_info() returns the full name of the current Stockfish version. This
+/// will be either "Stockfish <Tag> DD-MM-YY" (where DD-MM-YY is the date when
+/// the program was compiled) or "Stockfish <Version>", depending on whether
+/// Version is empty.
+
+string engine_info(bool to_uci, bool to_xboard) {
+
+  const string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
+  string month, day, year;
+  stringstream ss, date(__DATE__); // From compiler, format is "Sep 21 2008"
+
+  ss << "Fairy-Stockfish " << Version << setfill('0');
+
+  if (Version.empty())
+  {
+      date >> month >> day >> year;
+      ss << setw(2) << day << setw(2) << (1 + months.find(month) / 4) << year.substr(2);
+  }
+
+#ifdef LARGEBOARDS
+  ss << " LB";
+#endif
+
+  if (!to_xboard)
+    ss << (to_uci  ? "\nid author ": " by ")
+       << "Fabian Fichter";
+
+  return ss.str();
+}
+
+
+/// compiler_info() returns a string trying to describe the compiler we use
+
+std::string compiler_info() {
+
+  #define stringify2(x) #x
+  #define stringify(x) stringify2(x)
+  #define make_version_string(major, minor, patch) stringify(major) "." stringify(minor) "." stringify(patch)
+
+/// Predefined macros hell:
+///
+/// __GNUC__           Compiler is gcc, Clang or Intel on Linux
+/// __INTEL_COMPILER   Compiler is Intel
+/// _MSC_VER           Compiler is MSVC or Intel on Windows
+/// _WIN32             Building on Windows (any)
+/// _WIN64             Building on Windows 64 bit
+
+  std::string compiler = "\nCompiled by ";
+
+  #ifdef __clang__
+     compiler += "clang++ ";
+     compiler += make_version_string(__clang_major__, __clang_minor__, __clang_patchlevel__);
+  #elif __INTEL_COMPILER
+     compiler += "Intel compiler ";
+     compiler += "(version ";
+     compiler += stringify(__INTEL_COMPILER) " update " stringify(__INTEL_COMPILER_UPDATE);
+     compiler += ")";
+  #elif _MSC_VER
+     compiler += "MSVC ";
+     compiler += "(version ";
+     compiler += stringify(_MSC_FULL_VER) "." stringify(_MSC_BUILD);
+     compiler += ")";
+  #elif defined(__e2k__) && defined(__LCC__)
+    #define dot_ver2(n) \
+      compiler += (char)'.'; \
+      compiler += (char)('0' + (n) / 10); \
+      compiler += (char)('0' + (n) % 10);
+
+     compiler += "MCST LCC ";
+     compiler += "(version ";
+     compiler += std::to_string(__LCC__ / 100);
+     dot_ver2(__LCC__ % 100)
+     dot_ver2(__LCC_MINOR__)
+     compiler += ")";
+  #elif __GNUC__
+     compiler += "g++ (GNUC) ";
+     compiler += make_version_string(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
+  #else
+     compiler += "Unknown compiler ";
+     compiler += "(unknown version)";
+  #endif
+
+  #if defined(__APPLE__)
+     compiler += " on Apple";
+  #elif defined(__CYGWIN__)
+     compiler += " on Cygwin";
+  #elif defined(__MINGW64__)
+     compiler += " on MinGW64";
+  #elif defined(__MINGW32__)
+     compiler += " on MinGW32";
+  #elif defined(__ANDROID__)
+     compiler += " on Android";
+  #elif defined(__linux__)
+     compiler += " on Linux";
+  #elif defined(_WIN64)
+     compiler += " on Microsoft Windows 64-bit";
+  #elif defined(_WIN32)
+     compiler += " on Microsoft Windows 32-bit";
+  #else
+     compiler += " on unknown system";
+  #endif
+
+  compiler += "\nCompilation settings include: ";
+  compiler += (Is64Bit ? " 64bit" : " 32bit");
+  #if defined(USE_VNNI)
+    compiler += " VNNI";
+  #endif
+  #if defined(USE_AVX512)
+    compiler += " AVX512";
+  #endif
+  compiler += (HasPext ? " BMI2" : "");
+  #if defined(USE_AVX2)
+    compiler += " AVX2";
+  #endif
+  #if defined(USE_SSE41)
+    compiler += " SSE41";
+  #endif
+  #if defined(USE_SSSE3)
+    compiler += " SSSE3";
+  #endif
+  #if defined(USE_SSE2)
+    compiler += " SSE2";
+  #endif
+  compiler += (HasPopCnt ? " POPCNT" : "");
+  #if defined(USE_MMX)
+    compiler += " MMX";
+  #endif
+  #if defined(USE_NEON)
+    compiler += " NEON";
+  #endif
+
+  #if !defined(NDEBUG)
+    compiler += " DEBUG";
+  #endif
+
+  compiler += "\n__VERSION__ macro expands to: ";
+  #ifdef __VERSION__
+     compiler += __VERSION__;
+  #else
+     compiler += "(undefined macro)";
+  #endif
+  compiler += "\n";
+
+  return compiler;
+}
+
+
+/// Debug functions used mainly to collect run-time statistics
+static std::atomic<int64_t> hits[2], means[2];
+
+void dbg_hit_on(bool b) { ++hits[0]; if (b) ++hits[1]; }
+void dbg_hit_on(bool c, bool b) { if (c) dbg_hit_on(b); }
+void dbg_mean_of(int v) { ++means[0]; means[1] += v; }
+
+void dbg_print() {
+
+  if (hits[0])
+      cerr << "Total " << hits[0] << " Hits " << hits[1]
+           << " hit rate (%) " << 100 * hits[1] / hits[0] << endl;
+
+  if (means[0])
+      cerr << "Total " << means[0] << " Mean "
+           << (double)means[1] / means[0] << endl;
+}
+
+
+/// Used to serialize access to std::cout to avoid multiple threads writing at
+/// the same time.
+
+std::ostream& operator<<(std::ostream& os, SyncCout sc) {
+
+  static std::mutex m;
+
+  if (sc == IO_LOCK)
+      m.lock();
+
+  if (sc == IO_UNLOCK)
+      m.unlock();
+
+  return os;
+}
+
+
+/// Trampoline helper to avoid moving Logger to misc.h
+void start_logger(const std::string& fname) { Logger::start(fname); }
+
+
+/// prefetch() preloads the given address in L1/L2 cache. This is a non-blocking
+/// function that doesn't stall the CPU waiting for data to be loaded from memory,
+/// which can be quite slow.
+#ifdef NO_PREFETCH
+
+void prefetch(void*) {}
+
+#else
+
+void prefetch(void* addr) {
+
+#  if defined(__INTEL_COMPILER)
+   // This hack prevents prefetches from being optimized away by
+   // Intel compiler. Both MSVC and gcc seem not be affected by this.
+   __asm__ ("");
+#  endif
+
+#  if defined(__INTEL_COMPILER) || defined(_MSC_VER)
+  _mm_prefetch((char*)addr, _MM_HINT_T0);
+#  else
+  __builtin_prefetch(addr);
+#  endif
+}
+
+#endif
+
+
+/// std_aligned_alloc() is our wrapper for systems where the c++17 implementation
+/// does not guarantee the availability of aligned_alloc(). Memory allocated with
+/// std_aligned_alloc() must be freed with std_aligned_free().
+
+void* std_aligned_alloc(size_t alignment, size_t size) {
+
+#if defined(POSIXALIGNEDALLOC)
+  void *mem;
+  return posix_memalign(&mem, alignment, size) ? nullptr : mem;
+#elif defined(_WIN32)
+  return _mm_malloc(size, alignment);
+#else
+  return aligned_alloc(alignment, size);
+#endif
+}
+
+void std_aligned_free(void* ptr) {
+
+#if defined(POSIXALIGNEDALLOC)
+  free(ptr);
+#elif defined(_WIN32)
+  _mm_free(ptr);
+#else
+  free(ptr);
+#endif
+}
+
+/// aligned_large_pages_alloc() will return suitably aligned memory, if possible using large pages.
+
+#if defined(_WIN32)
+
+static void* aligned_large_pages_alloc_windows(size_t allocSize) {
+
+  #if !defined(_WIN64)
+    return nullptr;
+  #else
+
+  HANDLE hProcessToken { };
+  LUID luid { };
+  void* mem = nullptr;
+
+  const size_t largePageSize = GetLargePageMinimum();
+  if (!largePageSize)
+      return nullptr;
+
+  // We need SeLockMemoryPrivilege, so try to enable it for the process
+  if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hProcessToken))
+      return nullptr;
+
+  if (LookupPrivilegeValue(NULL, SE_LOCK_MEMORY_NAME, &luid))
+  {
+      TOKEN_PRIVILEGES tp { };
+      TOKEN_PRIVILEGES prevTp { };
+      DWORD prevTpLen = 0;
+
+      tp.PrivilegeCount = 1;
+      tp.Privileges[0].Luid = luid;
+      tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
+
+      // Try to enable SeLockMemoryPrivilege. Note that even if AdjustTokenPrivileges() succeeds,
+      // we still need to query GetLastError() to ensure that the privileges were actually obtained.
+      if (AdjustTokenPrivileges(
+              hProcessToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), &prevTp, &prevTpLen) &&
+          GetLastError() == ERROR_SUCCESS)
+      {
+          // Round up size to full pages and allocate
+          allocSize = (allocSize + largePageSize - 1) & ~size_t(largePageSize - 1);
+          mem = VirtualAlloc(
+              NULL, allocSize, MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE);
+
+          // Privilege no longer needed, restore previous state
+          AdjustTokenPrivileges(hProcessToken, FALSE, &prevTp, 0, NULL, NULL);
+      }
+  }
+
+  CloseHandle(hProcessToken);
+
+  return mem;
+
+  #endif
+}
+
+void* aligned_large_pages_alloc(size_t allocSize) {
+
+  // Try to allocate large pages
+  void* mem = aligned_large_pages_alloc_windows(allocSize);
+
+  // Fall back to regular, page aligned, allocation if necessary
+  if (!mem)
+      mem = VirtualAlloc(NULL, allocSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+
+  return mem;
+}
+
+#else
+
+void* aligned_large_pages_alloc(size_t allocSize) {
+
+#if defined(__linux__)
+  constexpr size_t alignment = 2 * 1024 * 1024; // assumed 2MB page size
+#else
+  constexpr size_t alignment = 4096; // assumed small page size
+#endif
+
+  // round up to multiples of alignment
+  size_t size = ((allocSize + alignment - 1) / alignment) * alignment;
+  void *mem = std_aligned_alloc(alignment, size);
+#if defined(MADV_HUGEPAGE)
+  madvise(mem, size, MADV_HUGEPAGE);
+#endif
+  return mem;
+}
+
+#endif
+
+
+/// aligned_large_pages_free() will free the previously allocated ttmem
+
+#if defined(_WIN32)
+
+void aligned_large_pages_free(void* mem) {
+
+  if (mem && !VirtualFree(mem, 0, MEM_RELEASE))
+  {
+      DWORD err = GetLastError();
+      std::cerr << "Failed to free large page memory. Error code: 0x"
+                << std::hex << err
+                << std::dec << std::endl;
+      exit(EXIT_FAILURE);
+  }
+}
+
+#else
+
+void aligned_large_pages_free(void *mem) {
+  std_aligned_free(mem);
+}
+
+#endif
+
+
+namespace WinProcGroup {
+
+#ifndef _WIN32
+
+void bindThisThread(size_t) {}
+
+#else
+
+/// best_group() retrieves logical processor information using Windows specific
+/// API and returns the best group id for the thread with index idx. Original
+/// code from Texel by Peter Österlund.
+
+int best_group(size_t idx) {
+
+  int threads = 0;
+  int nodes = 0;
+  int cores = 0;
+  DWORD returnLength = 0;
+  DWORD byteOffset = 0;
+
+  // Early exit if the needed API is not available at runtime
+  HMODULE k32 = GetModuleHandle("Kernel32.dll");
+  auto fun1 = (fun1_t)(void(*)())GetProcAddress(k32, "GetLogicalProcessorInformationEx");
+  if (!fun1)
+      return -1;
+
+  // First call to get returnLength. We expect it to fail due to null buffer
+  if (fun1(RelationAll, nullptr, &returnLength))
+      return -1;
+
+  // Once we know returnLength, allocate the buffer
+  SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *buffer, *ptr;
+  ptr = buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)malloc(returnLength);
+
+  // Second call, now we expect to succeed
+  if (!fun1(RelationAll, buffer, &returnLength))
+  {
+      free(buffer);
+      return -1;
+  }
+
+  while (byteOffset < returnLength)
+  {
+      if (ptr->Relationship == RelationNumaNode)
+          nodes++;
+
+      else if (ptr->Relationship == RelationProcessorCore)
+      {
+          cores++;
+          threads += (ptr->Processor.Flags == LTP_PC_SMT) ? 2 : 1;
+      }
+
+      assert(ptr->Size);
+      byteOffset += ptr->Size;
+      ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((char*)ptr) + ptr->Size);
+  }
+
+  free(buffer);
+
+  std::vector<int> groups;
+
+  // Run as many threads as possible on the same node until core limit is
+  // reached, then move on filling the next node.
+  for (int n = 0; n < nodes; n++)
+      for (int i = 0; i < cores / nodes; i++)
+          groups.push_back(n);
+
+  // In case a core has more than one logical processor (we assume 2) and we
+  // have still threads to allocate, then spread them evenly across available
+  // nodes.
+  for (int t = 0; t < threads - cores; t++)
+      groups.push_back(t % nodes);
+
+  // If we still have more threads than the total number of logical processors
+  // then return -1 and let the OS to decide what to do.
+  return idx < groups.size() ? groups[idx] : -1;
+}
+
+
+/// bindThisThread() set the group affinity of the current thread
+
+void bindThisThread(size_t idx) {
+
+  // Use only local variables to be thread-safe
+  int group = best_group(idx);
+
+  if (group == -1)
+      return;
+
+  // Early exit if the needed API are not available at runtime
+  HMODULE k32 = GetModuleHandle("Kernel32.dll");
+  auto fun2 = (fun2_t)(void(*)())GetProcAddress(k32, "GetNumaNodeProcessorMaskEx");
+  auto fun3 = (fun3_t)(void(*)())GetProcAddress(k32, "SetThreadGroupAffinity");
+
+  if (!fun2 || !fun3)
+      return;
+
+  GROUP_AFFINITY affinity;
+  if (fun2(group, &affinity))
+      fun3(GetCurrentThread(), &affinity, nullptr);
+}
+
+#endif
+
+} // namespace WinProcGroup
+
+#ifdef _WIN32
+#include <direct.h>
+#define GETCWD _getcwd
+#else
+#include <unistd.h>
+#define GETCWD getcwd
+#endif
+
+namespace CommandLine {
+
+string argv0;            // path+name of the executable binary, as given by argv[0]
+string binaryDirectory;  // path of the executable directory
+string workingDirectory; // path of the working directory
+
+void init(int argc, char* argv[]) {
+    (void)argc;
+    string pathSeparator;
+
+    // extract the path+name of the executable binary
+    argv0 = argv[0];
+
+#ifdef _WIN32
+    pathSeparator = "\\";
+  #ifdef _MSC_VER
+    // Under windows argv[0] may not have the extension. Also _get_pgmptr() had
+    // issues in some windows 10 versions, so check returned values carefully.
+    char* pgmptr = nullptr;
+    if (!_get_pgmptr(&pgmptr) && pgmptr != nullptr && *pgmptr)
+        argv0 = pgmptr;
+  #endif
+#else
+    pathSeparator = "/";
+#endif
+
+    // extract the working directory
+    workingDirectory = "";
+    char buff[40000];
+    char* cwd = GETCWD(buff, 40000);
+    if (cwd)
+        workingDirectory = cwd;
+
+    // extract the binary directory path from argv0
+    binaryDirectory = argv0;
+    size_t pos = binaryDirectory.find_last_of("\\/");
+    if (pos == std::string::npos)
+        binaryDirectory = "." + pathSeparator;
+    else
+        binaryDirectory.resize(pos + 1);
+
+    // pattern replacement: "./" at the start of path is replaced by the working directory
+    if (binaryDirectory.find("." + pathSeparator) == 0)
+        binaryDirectory.replace(0, 1, workingDirectory);
+}
+
+
+} // namespace CommandLine
+
+} // namespace Stockfish

Fairy-Stockfish-master/src/misc.h

@@ -0,0 +1,200 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef MISC_H_INCLUDED
+#define MISC_H_INCLUDED
+
+#include <cassert>
+#include <chrono>
+#include <ostream>
+#include <string>
+#include <vector>
+#include <cstdint>
+
+#include "types.h"
+
+namespace Stockfish {
+
+std::string engine_info(bool to_uci = false, bool to_xboard = false);
+std::string compiler_info();
+void prefetch(void* addr);
+void start_logger(const std::string& fname);
+void* std_aligned_alloc(size_t alignment, size_t size);
+void std_aligned_free(void* ptr);
+void* aligned_large_pages_alloc(size_t size); // memory aligned by page size, min alignment: 4096 bytes
+void aligned_large_pages_free(void* mem); // nop if mem == nullptr
+
+void dbg_hit_on(bool b);
+void dbg_hit_on(bool c, bool b);
+void dbg_mean_of(int v);
+void dbg_print();
+
+typedef std::chrono::milliseconds::rep TimePoint; // A value in milliseconds
+static_assert(sizeof(TimePoint) == sizeof(int64_t), "TimePoint should be 64 bits");
+inline TimePoint now() {
+  return std::chrono::duration_cast<std::chrono::milliseconds>
+        (std::chrono::steady_clock::now().time_since_epoch()).count();
+}
+
+template<class Entry, int Size>
+struct HashTable {
+  Entry* operator[](Key key) { return &table[(uint32_t)key & (Size - 1)]; }
+
+private:
+  std::vector<Entry> table = std::vector<Entry>(Size); // Allocate on the heap
+};
+
+
+enum SyncCout { IO_LOCK, IO_UNLOCK };
+std::ostream& operator<<(std::ostream&, SyncCout);
+
+#define sync_cout std::cout << IO_LOCK
+#define sync_endl std::endl << IO_UNLOCK
+
+
+// align_ptr_up() : get the first aligned element of an array.
+// ptr must point to an array of size at least `sizeof(T) * N + alignment` bytes,
+// where N is the number of elements in the array.
+template <uintptr_t Alignment, typename T>
+T* align_ptr_up(T* ptr)
+{
+  static_assert(alignof(T) < Alignment);
+
+  const uintptr_t ptrint = reinterpret_cast<uintptr_t>(reinterpret_cast<char*>(ptr));
+  return reinterpret_cast<T*>(reinterpret_cast<char*>((ptrint + (Alignment - 1)) / Alignment * Alignment));
+}
+
+
+// IsLittleEndian : true if and only if the binary is compiled on a little endian machine
+static inline const union { uint32_t i; char c[4]; } Le = { 0x01020304 };
+static inline const bool IsLittleEndian = (Le.c[0] == 4);
+
+
+template <typename T>
+class ValueListInserter {
+public:
+  ValueListInserter(T* v, std::size_t& s) :
+    values(v),
+    size(&s)
+  {
+  }
+
+  void push_back(const T& value) { values[(*size)++] = value; }
+private:
+  T* values;
+  std::size_t* size;
+};
+
+template <typename T, std::size_t MaxSize>
+class ValueList {
+
+public:
+  std::size_t size() const { return size_; }
+  void resize(std::size_t newSize) { size_ = newSize; }
+  void push_back(const T& value) { values_[size_++] = value; }
+  T& operator[](std::size_t index) { return values_[index]; }
+  T* begin() { return values_; }
+  T* end() { return values_ + size_; }
+  const T& operator[](std::size_t index) const { return values_[index]; }
+  const T* begin() const { return values_; }
+  const T* end() const { return values_ + size_; }
+  operator ValueListInserter<T>() { return ValueListInserter(values_, size_); }
+
+  void swap(ValueList& other) {
+    const std::size_t maxSize = std::max(size_, other.size_);
+    for (std::size_t i = 0; i < maxSize; ++i) {
+      std::swap(values_[i], other.values_[i]);
+    }
+    std::swap(size_, other.size_);
+  }
+
+private:
+  T values_[MaxSize];
+  std::size_t size_ = 0;
+};
+
+/// xorshift64star Pseudo-Random Number Generator
+/// This class is based on original code written and dedicated
+/// to the public domain by Sebastiano Vigna (2014).
+/// It has the following characteristics:
+///
+///  -  Outputs 64-bit numbers
+///  -  Passes Dieharder and SmallCrush test batteries
+///  -  Does not require warm-up, no zeroland to escape
+///  -  Internal state is a single 64-bit integer
+///  -  Period is 2^64 - 1
+///  -  Speed: 1.60 ns/call (Core i7 @3.40GHz)
+///
+/// For further analysis see
+///   <http://vigna.di.unimi.it/ftp/papers/xorshift.pdf>
+
+class PRNG {
+
+  uint64_t s;
+
+  uint64_t rand64() {
+
+    s ^= s >> 12, s ^= s << 25, s ^= s >> 27;
+    return s * 2685821657736338717LL;
+  }
+
+public:
+  PRNG(uint64_t seed) : s(seed) { assert(seed); }
+
+  template<typename T> T rand() { return T(rand64()); }
+
+  /// Special generator used to fast init magic numbers.
+  /// Output values only have 1/8th of their bits set on average.
+  template<typename T> T sparse_rand()
+  { return T(rand64() & rand64() & rand64()); }
+};
+
+inline uint64_t mul_hi64(uint64_t a, uint64_t b) {
+#if defined(__GNUC__) && defined(IS_64BIT)
+    __extension__ typedef unsigned __int128 uint128;
+    return ((uint128)a * (uint128)b) >> 64;
+#else
+    uint64_t aL = (uint32_t)a, aH = a >> 32;
+    uint64_t bL = (uint32_t)b, bH = b >> 32;
+    uint64_t c1 = (aL * bL) >> 32;
+    uint64_t c2 = aH * bL + c1;
+    uint64_t c3 = aL * bH + (uint32_t)c2;
+    return aH * bH + (c2 >> 32) + (c3 >> 32);
+#endif
+}
+
+/// Under Windows it is not possible for a process to run on more than one
+/// logical processor group. This usually means to be limited to use max 64
+/// cores. To overcome this, some special platform specific API should be
+/// called to set group affinity for each thread. Original code from Texel by
+/// Peter Österlund.
+
+namespace WinProcGroup {
+  void bindThisThread(size_t idx);
+}
+
+namespace CommandLine {
+  void init(int argc, char* argv[]);
+
+  extern std::string binaryDirectory;  // path of the executable directory
+  extern std::string workingDirectory; // path of the working directory
+}
+
+} // namespace Stockfish
+
+#endif // #ifndef MISC_H_INCLUDED

Fairy-Stockfish-master/src/movegen.cpp

@@ -0,0 +1,528 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <cassert>
+
+#include "movegen.h"
+#include "position.h"
+
+namespace Stockfish {
+
+namespace {
+
+  template<MoveType T>
+  ExtMove* make_move_and_gating(const Position& pos, ExtMove* moveList, Color us, Square from, Square to, PieceType pt = NO_PIECE_TYPE) {
+
+    // Wall placing moves
+    //if it's "wall or move", and they chose non-null move, skip even generating wall move
+    if (pos.walling() && !(pos.wall_or_move() && (from!=to)))
+    {
+        Bitboard b = pos.board_bb() & ~((pos.pieces() ^ from) | to);
+        if (T == CASTLING)
+        {
+            Square kto = make_square(to > from ? pos.castling_kingside_file() : pos.castling_queenside_file(), pos.castling_rank(us));
+            Direction step = kto > from ? EAST : WEST;
+            Square rto = kto - step;
+            b ^= square_bb(to) ^ kto ^ rto;
+        }
+        if (T == EN_PASSANT)
+            b ^= pos.capture_square(to);
+
+        if (pos.walling_rule() == ARROW)
+            b &= moves_bb(us, type_of(pos.piece_on(from)), to, pos.pieces() ^ from);
+
+        //Any current or future wall variant must follow the walling region rule if set:
+        b &= pos.walling_region(us);
+
+        if (pos.walling_rule() == PAST)
+            b &= square_bb(from);
+        if (pos.walling_rule() == EDGE)
+        {
+            Bitboard wallsquares = pos.state()->wallSquares;
+
+            b &= (FileABB | file_bb(pos.max_file()) | Rank1BB | rank_bb(pos.max_rank())) |
+               ( shift<NORTH     >(wallsquares) | shift<SOUTH     >(wallsquares)
+               | shift<EAST      >(wallsquares) | shift<WEST      >(wallsquares));
+        }
+        while (b)
+            *moveList++ = make_gating<T>(from, to, pt, pop_lsb(b));
+        return moveList;
+    }
+
+    *moveList++ = make<T>(from, to, pt);
+
+    // Gating moves
+    if (pos.seirawan_gating() && (pos.gates(us) & from))
+        for (PieceSet ps = pos.piece_types(); ps;)
+        {
+            PieceType pt_gating = pop_lsb(ps);
+            if (pos.can_drop(us, pt_gating) && (pos.drop_region(us, pt_gating) & from))
+                *moveList++ = make_gating<T>(from, to, pt_gating, from);
+        }
+    if (pos.seirawan_gating() && T == CASTLING && (pos.gates(us) & to))
+        for (PieceSet ps = pos.piece_types(); ps;)
+        {
+            PieceType pt_gating = pop_lsb(ps);
+            if (pos.can_drop(us, pt_gating) && (pos.drop_region(us, pt_gating) & to))
+                *moveList++ = make_gating<T>(from, to, pt_gating, to);
+        }
+
+    return moveList;
+  }
+
+  template<Color c, GenType Type, Direction D>
+  ExtMove* make_promotions(const Position& pos, ExtMove* moveList, Square to) {
+
+    if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
+    {
+        for (PieceSet promotions = pos.promotion_piece_types(c); promotions;)
+        {
+            PieceType pt = pop_msb(promotions);
+            if (!pos.promotion_limit(pt) || pos.promotion_limit(pt) > pos.count(c, pt))
+                moveList = make_move_and_gating<PROMOTION>(pos, moveList, pos.side_to_move(), to - D, to, pt);
+        }
+        PieceType pt = pos.promoted_piece_type(PAWN);
+        if (pt && !(pos.piece_promotion_on_capture() && pos.empty(to)))
+            moveList = make_move_and_gating<PIECE_PROMOTION>(pos, moveList, pos.side_to_move(), to - D, to);
+    }
+
+    return moveList;
+  }
+
+  template<Color Us, GenType Type>
+  ExtMove* generate_drops(const Position& pos, ExtMove* moveList, PieceType pt, Bitboard b) {
+    assert(Type != CAPTURES);
+    // Do not generate virtual drops for perft and at root
+    if (pos.can_drop(Us, pt) || (Type != NON_EVASIONS && pos.two_boards() && pos.allow_virtual_drop(Us, pt)))
+    {
+        // Restrict to valid target
+        b &= pos.drop_region(Us, pt);
+
+        // Add to move list
+        if (pos.drop_promoted() && pos.promoted_piece_type(pt))
+        {
+            Bitboard b2 = b;
+            if (Type == QUIET_CHECKS)
+                b2 &= pos.check_squares(pos.promoted_piece_type(pt));
+            while (b2)
+                *moveList++ = make_drop(pop_lsb(b2), pt, pos.promoted_piece_type(pt));
+        }
+        if (Type == QUIET_CHECKS || !pos.can_drop(Us, pt))
+            b &= pos.check_squares(pt);
+        while (b)
+            *moveList++ = make_drop(pop_lsb(b), pt, pt);
+    }
+
+    return moveList;
+  }
+
+  template<Color Us, GenType Type>
+  ExtMove* generate_pawn_moves(const Position& pos, ExtMove* moveList, Bitboard target) {
+
+    if (!pos.pieces(Us, PAWN))
+        return moveList;
+
+    constexpr Color     Them     = ~Us;
+    constexpr Direction Up       = pawn_push(Us);
+    constexpr Direction UpRight  = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
+    constexpr Direction UpLeft   = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
+
+    const Bitboard promotionZone = pos.promotion_zone(Us);
+    const Bitboard standardPromotionZone = pos.sittuyin_promotion() ? Bitboard(0) : promotionZone;
+    const Bitboard doubleStepRegion = pos.double_step_region(Us);
+    const Bitboard tripleStepRegion = pos.triple_step_region(Us);
+
+    const Bitboard pawns      = pos.pieces(Us, PAWN);
+    const Bitboard movable    = pos.board_bb(Us, PAWN) & ~pos.pieces();
+    const Bitboard capturable = pos.board_bb(Us, PAWN) &  pos.pieces(Them);
+
+    target = Type == EVASIONS ? target : AllSquares;
+
+    // Define single and double push, left and right capture, as well as respective promotion moves
+    Bitboard b1 = shift<Up>(pawns) & movable & target;
+    Bitboard b2 = shift<Up>(shift<Up>(pawns & doubleStepRegion) & movable) & movable & target;
+    Bitboard b3 = shift<Up>(shift<Up>(shift<Up>(pawns & tripleStepRegion) & movable) & movable) & movable & target;
+    Bitboard brc = shift<UpRight>(pawns) & capturable & target;
+    Bitboard blc = shift<UpLeft >(pawns) & capturable & target;
+
+    Bitboard b1p = b1 & standardPromotionZone;
+    Bitboard b2p = b2 & standardPromotionZone;
+    Bitboard b3p = b3 & standardPromotionZone;
+    Bitboard brcp = brc & standardPromotionZone;
+    Bitboard blcp = blc & standardPromotionZone;
+
+    // Restrict regions based on rules and move generation type
+    if (pos.mandatory_pawn_promotion())
+    {
+        b1 &= ~standardPromotionZone;
+        b2 &= ~standardPromotionZone;
+        b3 &= ~standardPromotionZone;
+        brc &= ~standardPromotionZone;
+        blc &= ~standardPromotionZone;
+    }
+
+    if (Type == QUIET_CHECKS && pos.count<KING>(Them))
+    {
+        // To make a quiet check, you either make a direct check by pushing a pawn
+        // or push a blocker pawn that is not on the same file as the enemy king.
+        // Discovered check promotion has been already generated amongst the captures.
+        Square ksq = pos.square<KING>(Them);
+        Bitboard dcCandidatePawns = pos.blockers_for_king(Them) & ~file_bb(ksq);
+        b1 &= pawn_attacks_bb(Them, ksq) | shift<   Up>(dcCandidatePawns);
+        b2 &= pawn_attacks_bb(Them, ksq) | shift<Up+Up>(dcCandidatePawns);
+    }
+
+    // Single and double pawn pushes, no promotions
+    if (Type != CAPTURES)
+    {
+        while (b1)
+        {
+            Square to = pop_lsb(b1);
+            moveList = make_move_and_gating<NORMAL>(pos, moveList, Us, to - Up, to);
+        }
+
+        while (b2)
+        {
+            Square to = pop_lsb(b2);
+            moveList = make_move_and_gating<NORMAL>(pos, moveList, Us, to - Up - Up, to);
+        }
+
+        while (b3)
+        {
+            Square to = pop_lsb(b3);
+            moveList = make_move_and_gating<NORMAL>(pos, moveList, Us, to - Up - Up - Up, to);
+        }
+    }
+
+    // Promotions and underpromotions
+    while (brcp)
+        moveList = make_promotions<Us, Type, UpRight>(pos, moveList, pop_lsb(brcp));
+
+    while (blcp)
+        moveList = make_promotions<Us, Type, UpLeft >(pos, moveList, pop_lsb(blcp));
+
+    while (b1p)
+        moveList = make_promotions<Us, Type, Up     >(pos, moveList, pop_lsb(b1p));
+
+    while (b2p)
+        moveList = make_promotions<Us, Type, Up+Up  >(pos, moveList, pop_lsb(b2p));
+
+    while (b3p)
+        moveList = make_promotions<Us, Type, Up+Up+Up>(pos, moveList, pop_lsb(b3p));
+
+    // Sittuyin promotions
+    if (pos.sittuyin_promotion() && (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS))
+    {
+        // Pawns need to be in promotion zone if there is more than one pawn
+        Bitboard promotionPawns = pos.count<PAWN>(Us) > 1 ? pawns & promotionZone : pawns;
+        while (promotionPawns)
+        {
+            Square from = pop_lsb(promotionPawns);
+            for (PieceSet ps = pos.promotion_piece_types(Us); ps;)
+            {
+                PieceType pt = pop_msb(ps);
+                if (pos.promotion_limit(pt) && pos.promotion_limit(pt) <= pos.count(Us, pt))
+                    continue;
+                Bitboard b = ((pos.attacks_from(Us, pt, from) & ~pos.pieces()) | from) & target;
+                while (b)
+                {
+                    Square to = pop_lsb(b);
+                    if (!(attacks_bb(Us, pt, to, pos.pieces() ^ from) & pos.pieces(Them)))
+                        *moveList++ = make<PROMOTION>(from, to, pt);
+                }
+            }
+        }
+    }
+
+    // Standard and en passant captures
+    if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
+    {
+        while (brc)
+        {
+            Square to = pop_lsb(brc);
+            moveList = make_move_and_gating<NORMAL>(pos, moveList, Us, to - UpRight, to);
+        }
+
+        while (blc)
+        {
+            Square to = pop_lsb(blc);
+            moveList = make_move_and_gating<NORMAL>(pos, moveList, Us, to - UpLeft, to);
+        }
+
+        for (Bitboard epSquares = pos.ep_squares() & ~pos.pieces(); epSquares; )
+        {
+            Square epSquare = pop_lsb(epSquares);
+
+            // An en passant capture cannot resolve a discovered check (unless there non-sliding riders)
+            if (Type == EVASIONS && (target & (epSquare + Up)) && !pos.non_sliding_riders())
+                return moveList;
+
+            Bitboard b = pawns & pawn_attacks_bb(Them, epSquare);
+
+            // En passant square is already disabled for non-fairy variants if there is no attacker
+            assert(b || !pos.fast_attacks());
+
+            while (b)
+                moveList = make_move_and_gating<EN_PASSANT>(pos, moveList, Us, pop_lsb(b), epSquare);
+        }
+    }
+
+    return moveList;
+  }
+
+
+  template<Color Us, GenType Type>
+  ExtMove* generate_moves(const Position& pos, ExtMove* moveList, PieceType Pt, Bitboard target) {
+
+    assert(Pt != KING && Pt != PAWN);
+
+    Bitboard bb = pos.pieces(Us, Pt);
+
+    while (bb)
+    {
+        Square from = pop_lsb(bb);
+
+        Bitboard attacks = pos.attacks_from(Us, Pt, from);
+        Bitboard quiets = pos.moves_from(Us, Pt, from);
+        Bitboard b = (  (attacks & pos.pieces())
+                       | (quiets & ~pos.pieces()));
+        Bitboard b1 = b & target;
+        Bitboard promotion_zone = pos.promotion_zone(Us);
+        PieceType promPt = pos.promoted_piece_type(Pt);
+        Bitboard b2 = promPt && (!pos.promotion_limit(promPt) || pos.promotion_limit(promPt) > pos.count(Us, promPt)) ? b1 : Bitboard(0);
+        Bitboard b3 = pos.piece_demotion() && pos.is_promoted(from) ? b1 : Bitboard(0);
+        Bitboard pawnPromotions = (pos.promotion_pawn_types(Us) & Pt) ? (b & (Type == EVASIONS ? target : ~pos.pieces(Us)) & promotion_zone) : Bitboard(0);
+        Bitboard epSquares = (pos.en_passant_types(Us) & Pt) ? (attacks & ~quiets & pos.ep_squares() & ~pos.pieces()) : Bitboard(0);
+
+        // target squares considering pawn promotions
+        if (pawnPromotions && pos.mandatory_pawn_promotion())
+            b1 &= ~pawnPromotions;
+
+        // Restrict target squares considering promotion zone
+        if (b2 | b3)
+        {
+            if (pos.mandatory_piece_promotion())
+                b1 &= (promotion_zone & from ? Bitboard(0) : ~promotion_zone) | (pos.piece_promotion_on_capture() ? ~pos.pieces() : Bitboard(0));
+            // Exclude quiet promotions/demotions
+            if (pos.piece_promotion_on_capture())
+            {
+                b2 &= pos.pieces();
+                b3 &= pos.pieces();
+            }
+            // Consider promotions/demotions into promotion zone
+            if (!(promotion_zone & from))
+            {
+                b2 &= promotion_zone;
+                b3 &= promotion_zone;
+            }
+        }
+
+        if (Type == QUIET_CHECKS)
+        {
+            b1 &= pos.check_squares(Pt);
+            if (b2)
+                b2 &= pos.check_squares(pos.promoted_piece_type(Pt));
+            if (b3)
+                b3 &= pos.check_squares(type_of(pos.unpromoted_piece_on(from)));
+        }
+
+        while (b1)
+            moveList = make_move_and_gating<NORMAL>(pos, moveList, Us, from, pop_lsb(b1));
+
+        // Shogi-style piece promotions
+        while (b2)
+            *moveList++ = make<PIECE_PROMOTION>(from, pop_lsb(b2));
+
+        // Piece demotions
+        while (b3)
+            *moveList++ = make<PIECE_DEMOTION>(from, pop_lsb(b3));
+
+        // Pawn-style promotions
+        if ((Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS) && pawnPromotions)
+            for (PieceSet ps = pos.promotion_piece_types(Us); ps;)
+            {
+                PieceType ptP = pop_msb(ps);
+                if (!pos.promotion_limit(ptP) || pos.promotion_limit(ptP) > pos.count(Us, ptP))
+                    for (Bitboard promotions = pawnPromotions; promotions; )
+                        moveList = make_move_and_gating<PROMOTION>(pos, moveList, pos.side_to_move(), from, pop_lsb(promotions), ptP);
+            }
+
+        // En passant captures
+        if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
+            while (epSquares)
+                moveList = make_move_and_gating<EN_PASSANT>(pos, moveList, Us, from, pop_lsb(epSquares));
+    }
+
+    return moveList;
+  }
+
+
+  template<Color Us, GenType Type>
+  ExtMove* generate_all(const Position& pos, ExtMove* moveList) {
+
+    static_assert(Type != LEGAL, "Unsupported type in generate_all()");
+
+    constexpr bool Checks = Type == QUIET_CHECKS; // Reduce template instantiations
+    const Square ksq = pos.count<KING>(Us) ? pos.square<KING>(Us) : SQ_NONE;
+    Bitboard target;
+
+    // Skip generating non-king moves when in double check
+    if (Type != EVASIONS || !more_than_one(pos.checkers() & ~pos.non_sliding_riders()))
+    {
+        target = Type == EVASIONS     ?  between_bb(ksq, lsb(pos.checkers()))
+               : Type == NON_EVASIONS ? ~pos.pieces( Us)
+               : Type == CAPTURES     ?  pos.pieces(~Us)
+                                      : ~pos.pieces(   ); // QUIETS || QUIET_CHECKS
+
+        if (Type == EVASIONS)
+        {
+            if (pos.checkers() & pos.non_sliding_riders())
+                target = ~pos.pieces(Us);
+            // Leaper attacks can not be blocked
+            Square checksq = lsb(pos.checkers());
+            if (LeaperAttacks[~Us][type_of(pos.piece_on(checksq))][checksq] & pos.square<KING>(Us))
+                target = pos.checkers();
+        }
+
+        // Remove inaccessible squares (outside board + wall squares)
+        target &= pos.board_bb();
+
+        moveList = generate_pawn_moves<Us, Type>(pos, moveList, target);
+        for (PieceSet ps = pos.piece_types() & ~(piece_set(PAWN) | KING); ps;)
+            moveList = generate_moves<Us, Type>(pos, moveList, pop_lsb(ps), target);
+        // generate drops
+        if (pos.piece_drops() && Type != CAPTURES && (pos.can_drop(Us, ALL_PIECES) || pos.two_boards()))
+            for (PieceSet ps = pos.piece_types(); ps;)
+                moveList = generate_drops<Us, Type>(pos, moveList, pop_lsb(ps), target & ~pos.pieces(~Us));
+
+        // Castling with non-king piece
+        if (!pos.count<KING>(Us) && Type != CAPTURES && pos.can_castle(Us & ANY_CASTLING))
+        {
+            Square from = pos.castling_king_square(Us);
+            for(CastlingRights cr : { Us & KING_SIDE, Us & QUEEN_SIDE } )
+                if (!pos.castling_impeded(cr) && pos.can_castle(cr))
+                    moveList = make_move_and_gating<CASTLING>(pos, moveList, Us, from, pos.castling_rook_square(cr));
+        }
+
+        // Special moves
+        if (pos.cambodian_moves() && pos.gates(Us) && Type != CAPTURES)
+        {
+            if (Type != EVASIONS && (pos.pieces(Us, KING) & pos.gates(Us)))
+            {
+                Square from = pos.square<KING>(Us);
+                Bitboard b = PseudoAttacks[WHITE][KNIGHT][from] & rank_bb(rank_of(from + (Us == WHITE ? NORTH : SOUTH)))
+                    & target & ~pos.pieces();
+                while (b)
+                    moveList = make_move_and_gating<SPECIAL>(pos, moveList, Us, from, pop_lsb(b));
+            }
+
+            Bitboard b = pos.pieces(Us, FERS) & pos.gates(Us);
+            while (b)
+            {
+                Square from = pop_lsb(b);
+                Square to = from + 2 * (Us == WHITE ? NORTH : SOUTH);
+                if (is_ok(to) && (target & to & ~pos.pieces()))
+                    moveList = make_move_and_gating<SPECIAL>(pos, moveList, Us, from, to);
+            }
+        }
+
+        // Workaround for passing: Execute a non-move with any piece
+        if (pos.pass(Us) && !pos.count<KING>(Us) && pos.pieces(Us))
+            *moveList++ = make<SPECIAL>(lsb(pos.pieces(Us)), lsb(pos.pieces(Us)));
+
+        //if "wall or move", generate walling action with null move
+        if (pos.wall_or_move())
+        {
+            moveList = make_move_and_gating<SPECIAL>(pos, moveList, Us, lsb(pos.pieces(Us)), lsb(pos.pieces(Us)));
+        }
+    }
+
+    // King moves
+    if (pos.count<KING>(Us) && (!Checks || pos.blockers_for_king(~Us) & ksq))
+    {
+        Bitboard b = (  (pos.attacks_from(Us, KING, ksq) & pos.pieces())
+                      | (pos.moves_from(Us, KING, ksq) & ~pos.pieces())) & (Type == EVASIONS ? ~pos.pieces(Us) : target);
+        while (b)
+            moveList = make_move_and_gating<NORMAL>(pos, moveList, Us, ksq, pop_lsb(b));
+
+        // Passing move by king
+        if (pos.pass(Us))
+            *moveList++ = make<SPECIAL>(ksq, ksq);
+
+        if ((Type == QUIETS || Type == NON_EVASIONS) && pos.can_castle(Us & ANY_CASTLING))
+            for (CastlingRights cr : { Us & KING_SIDE, Us & QUEEN_SIDE } )
+                if (!pos.castling_impeded(cr) && pos.can_castle(cr))
+                    moveList = make_move_and_gating<CASTLING>(pos, moveList, Us,ksq, pos.castling_rook_square(cr));
+    }
+
+    return moveList;
+  }
+
+} // namespace
+
+
+/// <CAPTURES>     Generates all pseudo-legal captures plus queen promotions
+/// <QUIETS>       Generates all pseudo-legal non-captures and underpromotions
+/// <EVASIONS>     Generates all pseudo-legal check evasions when the side to move is in check
+/// <QUIET_CHECKS> Generates all pseudo-legal non-captures giving check, except castling and promotions
+/// <NON_EVASIONS> Generates all pseudo-legal captures and non-captures
+///
+/// Returns a pointer to the end of the move list.
+
+template<GenType Type>
+ExtMove* generate(const Position& pos, ExtMove* moveList) {
+
+  static_assert(Type != LEGAL, "Unsupported type in generate()");
+  assert((Type == EVASIONS) == (bool)pos.checkers());
+
+  Color us = pos.side_to_move();
+
+  return us == WHITE ? generate_all<WHITE, Type>(pos, moveList)
+                     : generate_all<BLACK, Type>(pos, moveList);
+}
+
+// Explicit template instantiations
+template ExtMove* generate<CAPTURES>(const Position&, ExtMove*);
+template ExtMove* generate<QUIETS>(const Position&, ExtMove*);
+template ExtMove* generate<EVASIONS>(const Position&, ExtMove*);
+template ExtMove* generate<QUIET_CHECKS>(const Position&, ExtMove*);
+template ExtMove* generate<NON_EVASIONS>(const Position&, ExtMove*);
+
+
+/// generate<LEGAL> generates all the legal moves in the given position
+
+template<>
+ExtMove* generate<LEGAL>(const Position& pos, ExtMove* moveList) {
+
+  if (pos.is_immediate_game_end())
+      return moveList;
+
+  ExtMove* cur = moveList;
+
+  moveList = pos.checkers() ? generate<EVASIONS    >(pos, moveList)
+                            : generate<NON_EVASIONS>(pos, moveList);
+  while (cur != moveList)
+      if (!pos.legal(*cur) || pos.virtual_drop(*cur))
+          *cur = (--moveList)->move;
+      else
+          ++cur;
+
+  return moveList;
+}
+
+} // namespace Stockfish

Fairy-Stockfish-master/src/movegen.h

@@ -0,0 +1,107 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef MOVEGEN_H_INCLUDED
+#define MOVEGEN_H_INCLUDED
+
+#include <algorithm>
+
+#include "types.h"
+
+namespace Stockfish {
+
+class Position;
+
+enum GenType {
+  CAPTURES,
+  QUIETS,
+  QUIET_CHECKS,
+  EVASIONS,
+  NON_EVASIONS,
+  LEGAL
+};
+
+struct ExtMove {
+  Move move;
+  int value;
+
+  operator Move() const { return move; }
+  void operator=(Move m) { move = m; }
+
+  // Inhibit unwanted implicit conversions to Move
+  // with an ambiguity that yields to a compile error.
+  operator float() const = delete;
+};
+
+inline bool operator<(const ExtMove& f, const ExtMove& s) {
+  return f.value < s.value;
+}
+
+template<GenType>
+ExtMove* generate(const Position& pos, ExtMove* moveList);
+
+constexpr size_t moveListSize = sizeof(ExtMove) * MAX_MOVES;
+
+/// The MoveList struct is a simple wrapper around generate(). It sometimes comes
+/// in handy to use this class instead of the low level generate() function.
+template<GenType T>
+struct MoveList {
+
+  
+#ifdef USE_HEAP_INSTEAD_OF_STACK_FOR_MOVE_LIST
+    explicit MoveList(const Position& pos)
+    {
+        this->moveList = (ExtMove*)malloc(moveListSize);
+        if (this->moveList == 0)
+        {
+            printf("Error: Failed to allocate memory in heap.");
+            exit(1);
+        }
+        this->last = generate<T>(pos, this->moveList);
+    }
+
+    ~MoveList()
+    {
+        free(this->moveList);
+    }
+#else
+    explicit MoveList(const Position& pos) : last(generate<T>(pos, moveList))
+    {
+        ;
+    }
+#endif
+  
+  const ExtMove* begin() const { return moveList; }
+  const ExtMove* end() const { return last; }
+  size_t size() const { return last - moveList; }
+  bool contains(Move move) const {
+    return std::find(begin(), end(), move) != end();
+  }
+
+private:
+    ExtMove* last;
+#ifdef USE_HEAP_INSTEAD_OF_STACK_FOR_MOVE_LIST
+    ExtMove* moveList = 0;
+#else
+    ExtMove moveList[MAX_MOVES];
+#endif
+};
+
+} // namespace Stockfish
+
+#endif // #ifndef MOVEGEN_H_INCLUDED

Fairy-Stockfish-master/src/movepick.cpp

@@ -0,0 +1,279 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <cassert>
+
+#include "movepick.h"
+
+namespace Stockfish {
+
+// Since continuation history grows quadratically with the number of piece types,
+// we need to reserve a limited number of slots and map piece types to these slots
+// in order to reduce memory consumption to a reasonable level.
+int history_slot(Piece pc) {
+    return pc == NO_PIECE ? 0 : (type_of(pc) == KING ? PIECE_SLOTS - 1 : type_of(pc) % (PIECE_SLOTS - 1)) + color_of(pc) * PIECE_SLOTS;
+}
+
+namespace {
+
+  enum Stages {
+    MAIN_TT, CAPTURE_INIT, GOOD_CAPTURE, REFUTATION, QUIET_INIT, QUIET, BAD_CAPTURE,
+    EVASION_TT, EVASION_INIT, EVASION,
+    PROBCUT_TT, PROBCUT_INIT, PROBCUT,
+    QSEARCH_TT, QCAPTURE_INIT, QCAPTURE, QCHECK_INIT, QCHECK
+  };
+
+  // partial_insertion_sort() sorts moves in descending order up to and including
+  // a given limit. The order of moves smaller than the limit is left unspecified.
+  void partial_insertion_sort(ExtMove* begin, ExtMove* end, int limit) {
+
+    for (ExtMove *sortedEnd = begin, *p = begin + 1; p < end; ++p)
+        if (p->value >= limit)
+        {
+            ExtMove tmp = *p, *q;
+            *p = *++sortedEnd;
+            for (q = sortedEnd; q != begin && *(q - 1) < tmp; --q)
+                *q = *(q - 1);
+            *q = tmp;
+        }
+  }
+
+} // namespace
+
+
+/// Constructors of the MovePicker class. As arguments we pass information
+/// to help it to return the (presumably) good moves first, to decide which
+/// moves to return (in the quiescence search, for instance, we only want to
+/// search captures, promotions, and some checks) and how important good move
+/// ordering is at the current node.
+
+/// MovePicker constructor for the main search
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh, const GateHistory* dh, const LowPlyHistory* lp,
+                       const CapturePieceToHistory* cph, const PieceToHistory** ch, Move cm, const Move* killers, int pl)
+           : pos(p), mainHistory(mh), gateHistory(dh), lowPlyHistory(lp), captureHistory(cph), continuationHistory(ch),
+             ttMove(ttm), refutations{{killers[0], 0}, {killers[1], 0}, {cm, 0}}, depth(d), ply(pl) {
+
+  assert(d > 0);
+
+  stage = (pos.checkers() ? EVASION_TT : MAIN_TT) +
+          !(ttm && pos.pseudo_legal(ttm));
+}
+
+/// MovePicker constructor for quiescence search
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh, const GateHistory* dh,
+                       const CapturePieceToHistory* cph, const PieceToHistory** ch, Square rs)
+           : pos(p), mainHistory(mh), gateHistory(dh), captureHistory(cph), continuationHistory(ch), ttMove(ttm), recaptureSquare(rs), depth(d) {
+
+  assert(d <= 0);
+
+  stage = (pos.checkers() ? EVASION_TT : QSEARCH_TT) +
+          !(   ttm
+            && (pos.checkers() || depth > DEPTH_QS_RECAPTURES || to_sq(ttm) == recaptureSquare)
+            && pos.pseudo_legal(ttm));
+}
+
+/// MovePicker constructor for ProbCut: we generate captures with SEE greater
+/// than or equal to the given threshold.
+MovePicker::MovePicker(const Position& p, Move ttm, Value th, const GateHistory* dh, const CapturePieceToHistory* cph)
+           : pos(p), gateHistory(dh), captureHistory(cph), ttMove(ttm), threshold(th) {
+
+  assert(!pos.checkers());
+
+  stage = PROBCUT_TT + !(ttm && pos.capture(ttm)
+                             && pos.pseudo_legal(ttm)
+                             && pos.see_ge(ttm, threshold));
+}
+
+/// MovePicker::score() assigns a numerical value to each move in a list, used
+/// for sorting. Captures are ordered by Most Valuable Victim (MVV), preferring
+/// captures with a good history. Quiets moves are ordered using the histories.
+template<GenType Type>
+void MovePicker::score() {
+
+  static_assert(Type == CAPTURES || Type == QUIETS || Type == EVASIONS, "Wrong type");
+
+  for (auto& m : *this)
+      if constexpr (Type == CAPTURES)
+          m.value =  int(PieceValue[MG][pos.piece_on(to_sq(m))]) * 6
+                   + (*gateHistory)[pos.side_to_move()][gating_square(m)]
+                   + (*captureHistory)[pos.moved_piece(m)][to_sq(m)][type_of(pos.piece_on(to_sq(m)))];
+
+      else if constexpr (Type == QUIETS)
+          m.value =      (*mainHistory)[pos.side_to_move()][from_to(m)]
+                   +     (*gateHistory)[pos.side_to_move()][gating_square(m)]
+                   + 2 * (*continuationHistory[0])[history_slot(pos.moved_piece(m))][to_sq(m)]
+                   +     (*continuationHistory[1])[history_slot(pos.moved_piece(m))][to_sq(m)]
+                   +     (*continuationHistory[3])[history_slot(pos.moved_piece(m))][to_sq(m)]
+                   +     (*continuationHistory[5])[history_slot(pos.moved_piece(m))][to_sq(m)]
+                   + (ply < MAX_LPH ? std::min(4, depth / 3) * (*lowPlyHistory)[ply][from_to(m)] : 0);
+
+      else // Type == EVASIONS
+      {
+          if (pos.capture(m))
+              m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
+                       - Value(type_of(pos.moved_piece(m)));
+          else
+              m.value =      (*mainHistory)[pos.side_to_move()][from_to(m)]
+                       + 2 * (*continuationHistory[0])[history_slot(pos.moved_piece(m))][to_sq(m)]
+                       - (1 << 28);
+      }
+}
+
+/// MovePicker::select() returns the next move satisfying a predicate function.
+/// It never returns the TT move.
+template<MovePicker::PickType T, typename Pred>
+Move MovePicker::select(Pred filter) {
+
+  while (cur < endMoves)
+  {
+      if (T == Best)
+          std::swap(*cur, *std::max_element(cur, endMoves));
+
+      if (*cur != ttMove && filter())
+          return *cur++;
+
+      cur++;
+  }
+  return MOVE_NONE;
+}
+
+/// MovePicker::next_move() is the most important method of the MovePicker class. It
+/// returns a new pseudo-legal move every time it is called until there are no more
+/// moves left, picking the move with the highest score from a list of generated moves.
+Move MovePicker::next_move(bool skipQuiets) {
+
+top:
+  switch (stage) {
+
+  case MAIN_TT:
+  case EVASION_TT:
+  case QSEARCH_TT:
+  case PROBCUT_TT:
+      ++stage;
+      assert(pos.legal(ttMove) == MoveList<LEGAL>(pos).contains(ttMove) || pos.virtual_drop(ttMove));
+      return ttMove;
+
+  case CAPTURE_INIT:
+  case PROBCUT_INIT:
+  case QCAPTURE_INIT:
+      cur = endBadCaptures = moves;
+      endMoves = generate<CAPTURES>(pos, cur);
+
+      score<CAPTURES>();
+      ++stage;
+      goto top;
+
+  case GOOD_CAPTURE:
+      if (select<Best>([&](){
+                       return pos.see_ge(*cur, Value(-69 * cur->value / 1024 - 500 * (pos.captures_to_hand() && pos.gives_check(*cur))))?
+                              // Move losing capture to endBadCaptures to be tried later
+                              true : (*endBadCaptures++ = *cur, false); }))
+          return *(cur - 1);
+
+      // Prepare the pointers to loop over the refutations array
+      cur = std::begin(refutations);
+      endMoves = std::end(refutations);
+
+      // If the countermove is the same as a killer, skip it
+      if (   refutations[0].move == refutations[2].move
+          || refutations[1].move == refutations[2].move)
+          --endMoves;
+
+      ++stage;
+      [[fallthrough]];
+
+  case REFUTATION:
+      if (select<Next>([&](){ return    *cur != MOVE_NONE
+                                    && !pos.capture(*cur)
+                                    &&  pos.pseudo_legal(*cur); }))
+          return *(cur - 1);
+      ++stage;
+      [[fallthrough]];
+
+  case QUIET_INIT:
+      if (!skipQuiets && !(pos.must_capture() && pos.has_capture()))
+      {
+          cur = endBadCaptures;
+          endMoves = generate<QUIETS>(pos, cur);
+
+          score<QUIETS>();
+          partial_insertion_sort(cur, endMoves, -3000 * depth);
+      }
+
+      ++stage;
+      [[fallthrough]];
+
+  case QUIET:
+      if (   !skipQuiets
+          && select<Next>([&](){return   *cur != refutations[0].move
+                                      && *cur != refutations[1].move
+                                      && *cur != refutations[2].move;}))
+          return *(cur - 1);
+
+      // Prepare the pointers to loop over the bad captures
+      cur = moves;
+      endMoves = endBadCaptures;
+
+      ++stage;
+      [[fallthrough]];
+
+  case BAD_CAPTURE:
+      return select<Next>([](){ return true; });
+
+  case EVASION_INIT:
+      cur = moves;
+      endMoves = generate<EVASIONS>(pos, cur);
+
+      score<EVASIONS>();
+      ++stage;
+      [[fallthrough]];
+
+  case EVASION:
+      return select<Best>([](){ return true; });
+
+  case PROBCUT:
+      return select<Best>([&](){ return pos.see_ge(*cur, threshold); });
+
+  case QCAPTURE:
+      if (select<Best>([&](){ return   depth > DEPTH_QS_RECAPTURES
+                                    || to_sq(*cur) == recaptureSquare; }))
+          return *(cur - 1);
+
+      // If we did not find any move and we do not try checks, we have finished
+      if (depth != DEPTH_QS_CHECKS)
+          return MOVE_NONE;
+
+      ++stage;
+      [[fallthrough]];
+
+  case QCHECK_INIT:
+      cur = moves;
+      endMoves = generate<QUIET_CHECKS>(pos, cur);
+
+      ++stage;
+      [[fallthrough]];
+
+  case QCHECK:
+      return select<Next>([](){ return true; });
+  }
+
+  assert(false);
+  return MOVE_NONE; // Silence warning
+}
+
+} // namespace Stockfish

Fairy-Stockfish-master/src/movepick.h

@@ -0,0 +1,169 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef MOVEPICK_H_INCLUDED
+#define MOVEPICK_H_INCLUDED
+
+#include <array>
+#include <limits>
+#include <type_traits>
+
+#include "movegen.h"
+#include "position.h"
+#include "types.h"
+
+namespace Stockfish {
+
+/// StatsEntry stores the stat table value. It is usually a number but could
+/// be a move or even a nested history. We use a class instead of naked value
+/// to directly call history update operator<<() on the entry so to use stats
+/// tables at caller sites as simple multi-dim arrays.
+template<typename T, int D>
+class StatsEntry {
+
+  T entry;
+
+public:
+  void operator=(const T& v) { entry = v; }
+  T* operator&() { return &entry; }
+  T* operator->() { return &entry; }
+  operator const T&() const { return entry; }
+
+  void operator<<(int bonus) {
+    assert(abs(bonus) <= D); // Ensure range is [-D, D]
+    static_assert(D <= std::numeric_limits<T>::max(), "D overflows T");
+
+    entry += bonus - entry * abs(bonus) / D;
+
+    assert(abs(entry) <= D);
+  }
+};
+
+/// Stats is a generic N-dimensional array used to store various statistics.
+/// The first template parameter T is the base type of the array, the second
+/// template parameter D limits the range of updates in [-D, D] when we update
+/// values with the << operator, while the last parameters (Size and Sizes)
+/// encode the dimensions of the array.
+template <typename T, int D, int Size, int... Sizes>
+struct Stats : public std::array<Stats<T, D, Sizes...>, Size>
+{
+  typedef Stats<T, D, Size, Sizes...> stats;
+
+  void fill(const T& v) {
+
+    // For standard-layout 'this' points to first struct member
+    assert(std::is_standard_layout<stats>::value);
+
+    typedef StatsEntry<T, D> entry;
+    entry* p = reinterpret_cast<entry*>(this);
+    std::fill(p, p + sizeof(*this) / sizeof(entry), v);
+  }
+};
+
+template <typename T, int D, int Size>
+struct Stats<T, D, Size> : public std::array<StatsEntry<T, D>, Size> {};
+
+/// In stats table, D=0 means that the template parameter is not used
+enum StatsParams { NOT_USED = 0, PIECE_SLOTS = 8 };
+enum StatsType { NoCaptures, Captures };
+
+/// ButterflyHistory records how often quiet moves have been successful or
+/// unsuccessful during the current search, and is used for reduction and move
+/// ordering decisions. It uses 2 tables (one for each color) indexed by
+/// the move's from and to squares, see www.chessprogramming.org/Butterfly_Boards
+typedef Stats<int16_t, 13365, COLOR_NB, int(SQUARE_NB + 1) * int(1 << SQUARE_BITS)> ButterflyHistory;
+
+typedef Stats<int16_t, 13365, COLOR_NB, SQUARE_NB> GateHistory;
+
+/// At higher depths LowPlyHistory records successful quiet moves near the root
+/// and quiet moves which are/were in the PV (ttPv). It is cleared with each new
+/// search and filled during iterative deepening.
+constexpr int MAX_LPH = 4;
+typedef Stats<int16_t, 10692, MAX_LPH, int(SQUARE_NB + 1) * int(1 << SQUARE_BITS)> LowPlyHistory;
+
+/// CounterMoveHistory stores counter moves indexed by [piece][to] of the previous
+/// move, see www.chessprogramming.org/Countermove_Heuristic
+typedef Stats<Move, NOT_USED, PIECE_NB, SQUARE_NB> CounterMoveHistory;
+
+/// CapturePieceToHistory is addressed by a move's [piece][to][captured piece type]
+typedef Stats<int16_t, 10692, PIECE_NB, SQUARE_NB, PIECE_TYPE_NB> CapturePieceToHistory;
+
+/// PieceToHistory is like ButterflyHistory but is addressed by a move's [piece][to]
+typedef Stats<int16_t, 29952, 2 * PIECE_SLOTS, SQUARE_NB> PieceToHistory;
+
+/// ContinuationHistory is the combined history of a given pair of moves, usually
+/// the current one given a previous one. The nested history table is based on
+/// PieceToHistory instead of ButterflyBoards.
+typedef Stats<PieceToHistory, NOT_USED, 2 * PIECE_SLOTS, SQUARE_NB> ContinuationHistory;
+
+int history_slot(Piece pc);
+
+/// MovePicker class is used to pick one pseudo-legal move at a time from the
+/// current position. The most important method is next_move(), which returns a
+/// new pseudo-legal move each time it is called, until there are no moves left,
+/// when MOVE_NONE is returned. In order to improve the efficiency of the
+/// alpha-beta algorithm, MovePicker attempts to return the moves which are most
+/// likely to get a cut-off first.
+class MovePicker {
+
+  enum PickType { Next, Best };
+
+public:
+  MovePicker(const MovePicker&) = delete;
+  MovePicker& operator=(const MovePicker&) = delete;
+  MovePicker(const Position&, Move, Value, const GateHistory*, const CapturePieceToHistory*);
+  MovePicker(const Position&, Move, Depth, const ButterflyHistory*,
+                                           const GateHistory*,
+                                           const CapturePieceToHistory*,
+                                           const PieceToHistory**,
+                                           Square);
+  MovePicker(const Position&, Move, Depth, const ButterflyHistory*,
+                                           const GateHistory*,
+                                           const LowPlyHistory*,
+                                           const CapturePieceToHistory*,
+                                           const PieceToHistory**,
+                                           Move,
+                                           const Move*,
+                                           int);
+  Move next_move(bool skipQuiets = false);
+
+private:
+  template<PickType T, typename Pred> Move select(Pred);
+  template<GenType> void score();
+  ExtMove* begin() { return cur; }
+  ExtMove* end() { return endMoves; }
+
+  const Position& pos;
+  const ButterflyHistory* mainHistory;
+  const GateHistory* gateHistory;
+  const LowPlyHistory* lowPlyHistory;
+  const CapturePieceToHistory* captureHistory;
+  const PieceToHistory** continuationHistory;
+  Move ttMove;
+  ExtMove refutations[3], *cur, *endMoves, *endBadCaptures;
+  int stage;
+  Square recaptureSquare;
+  Value threshold;
+  Depth depth;
+  int ply;
+  ExtMove moves[MAX_MOVES];
+};
+
+} // namespace Stockfish
+
+#endif // #ifndef MOVEPICK_H_INCLUDED

Fairy-Stockfish-master/src/nnue/evaluate_nnue.cpp

@@ -0,0 +1,443 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+// Code for calculating NNUE evaluation function
+
+#include <iostream>
+#include <set>
+#include <sstream>
+#include <iomanip>
+#include <fstream>
+
+#include "../evaluate.h"
+#include "../position.h"
+#include "../misc.h"
+#include "../uci.h"
+#include "../types.h"
+
+#include "evaluate_nnue.h"
+
+namespace Stockfish::Eval::NNUE {
+
+  // Input feature converter
+  LargePagePtr<FeatureTransformer> featureTransformer;
+
+  // Evaluation function
+  AlignedPtr<Network> network[LayerStacks];
+
+  // Evaluation function file name
+  std::string fileName;
+  std::string netDescription;
+
+  namespace Detail {
+
+  // Initialize the evaluation function parameters
+  template <typename T>
+  void initialize(AlignedPtr<T>& pointer) {
+
+    pointer.reset(reinterpret_cast<T*>(std_aligned_alloc(alignof(T), sizeof(T))));
+    std::memset(pointer.get(), 0, sizeof(T));
+  }
+
+  template <typename T>
+  void initialize(LargePagePtr<T>& pointer) {
+
+    static_assert(alignof(T) <= 4096, "aligned_large_pages_alloc() may fail for such a big alignment requirement of T");
+    pointer.reset(reinterpret_cast<T*>(aligned_large_pages_alloc(sizeof(T))));
+    std::memset(pointer.get(), 0, sizeof(T));
+  }
+
+  // Read evaluation function parameters
+  template <typename T>
+  bool read_parameters(std::istream& stream, T& reference) {
+
+    std::uint32_t header;
+    header = read_little_endian<std::uint32_t>(stream);
+    if (!stream || header != T::get_hash_value()) return false;
+    return reference.read_parameters(stream);
+  }
+
+  // Write evaluation function parameters
+  template <typename T>
+  bool write_parameters(std::ostream& stream, const T& reference) {
+
+    write_little_endian<std::uint32_t>(stream, T::get_hash_value());
+    return reference.write_parameters(stream);
+  }
+
+  }  // namespace Detail
+
+  // Initialize the evaluation function parameters
+  void initialize() {
+
+    Detail::initialize(featureTransformer);
+    for (std::size_t i = 0; i < LayerStacks; ++i)
+      Detail::initialize(network[i]);
+  }
+
+  // Read network header
+  bool read_header(std::istream& stream, std::uint32_t* hashValue, std::string* desc)
+  {
+    std::uint32_t version, size;
+
+    version     = read_little_endian<std::uint32_t>(stream);
+    *hashValue  = read_little_endian<std::uint32_t>(stream);
+    size        = read_little_endian<std::uint32_t>(stream);
+    if (!stream || version != Version) return false;
+    desc->resize(size);
+    stream.read(&(*desc)[0], size);
+    return !stream.fail();
+  }
+
+  // Write network header
+  bool write_header(std::ostream& stream, std::uint32_t hashValue, const std::string& desc)
+  {
+    write_little_endian<std::uint32_t>(stream, Version);
+    write_little_endian<std::uint32_t>(stream, hashValue);
+    write_little_endian<std::uint32_t>(stream, desc.size());
+    stream.write(&desc[0], desc.size());
+    return !stream.fail();
+  }
+
+  // Read network parameters
+  bool read_parameters(std::istream& stream) {
+
+    std::uint32_t hashValue;
+    if (!read_header(stream, &hashValue, &netDescription)) return false;
+    if (hashValue != HashValue) return false;
+    if (!Detail::read_parameters(stream, *featureTransformer)) return false;
+    for (std::size_t i = 0; i < LayerStacks; ++i)
+      if (!Detail::read_parameters(stream, *(network[i]))) return false;
+    return stream && stream.peek() == std::ios::traits_type::eof();
+  }
+
+  // Write network parameters
+  bool write_parameters(std::ostream& stream) {
+
+    if (!write_header(stream, HashValue, netDescription)) return false;
+    if (!Detail::write_parameters(stream, *featureTransformer)) return false;
+    for (std::size_t i = 0; i < LayerStacks; ++i)
+      if (!Detail::write_parameters(stream, *(network[i]))) return false;
+    return (bool)stream;
+  }
+
+  // Evaluation function. Perform differential calculation.
+  Value evaluate(const Position& pos, bool adjusted) {
+
+    // We manually align the arrays on the stack because with gcc < 9.3
+    // overaligning stack variables with alignas() doesn't work correctly.
+
+    constexpr uint64_t alignment = CacheLineSize;
+
+#if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
+    TransformedFeatureType transformedFeaturesUnaligned[
+      FeatureTransformer::BufferSize + alignment / sizeof(TransformedFeatureType)];
+    char bufferUnaligned[Network::BufferSize + alignment];
+
+    auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]);
+    auto* buffer = align_ptr_up<alignment>(&bufferUnaligned[0]);
+#else
+    alignas(alignment)
+      TransformedFeatureType transformedFeatures[FeatureTransformer::BufferSize];
+    alignas(alignment) char buffer[Network::BufferSize];
+#endif
+
+    ASSERT_ALIGNED(transformedFeatures, alignment);
+    ASSERT_ALIGNED(buffer, alignment);
+
+    const std::size_t bucket = std::min((pos.count<ALL_PIECES>() - 1) * 8 / currentNnueVariant->nnueMaxPieces, 7);
+    const auto psqt = featureTransformer->transform(pos, transformedFeatures, bucket);
+    const auto output = network[bucket]->propagate(transformedFeatures, buffer);
+
+    int materialist = psqt;
+    int positional  = output[0];
+
+    int delta_npm = abs(pos.non_pawn_material(WHITE) - pos.non_pawn_material(BLACK));
+    int entertainment = (adjusted && delta_npm <= BishopValueMg - KnightValueMg ? 7 : 0);
+
+    int A = 128 - entertainment;
+    int B = 128 + entertainment;
+
+    int sum = (A * materialist + B * positional) / 128;
+
+    return static_cast<Value>( sum / OutputScale );
+  }
+
+  struct NnueEvalTrace {
+    static_assert(LayerStacks == PSQTBuckets);
+
+    Value psqt[LayerStacks];
+    Value positional[LayerStacks];
+    std::size_t correctBucket;
+  };
+
+  static NnueEvalTrace trace_evaluate(const Position& pos) {
+
+    // We manually align the arrays on the stack because with gcc < 9.3
+    // overaligning stack variables with alignas() doesn't work correctly.
+
+    constexpr uint64_t alignment = CacheLineSize;
+
+#if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
+    TransformedFeatureType transformedFeaturesUnaligned[
+      FeatureTransformer::BufferSize + alignment / sizeof(TransformedFeatureType)];
+    char bufferUnaligned[Network::BufferSize + alignment];
+
+    auto* transformedFeatures = align_ptr_up<alignment>(&transformedFeaturesUnaligned[0]);
+    auto* buffer = align_ptr_up<alignment>(&bufferUnaligned[0]);
+#else
+    alignas(alignment)
+      TransformedFeatureType transformedFeatures[FeatureTransformer::BufferSize];
+    alignas(alignment) char buffer[Network::BufferSize];
+#endif
+
+    ASSERT_ALIGNED(transformedFeatures, alignment);
+    ASSERT_ALIGNED(buffer, alignment);
+
+    NnueEvalTrace t{};
+    t.correctBucket = std::min((pos.count<ALL_PIECES>() - 1) * 8 / currentNnueVariant->nnueMaxPieces, 7);
+    for (std::size_t bucket = 0; bucket < LayerStacks; ++bucket) {
+      const auto psqt = featureTransformer->transform(pos, transformedFeatures, bucket);
+      const auto output = network[bucket]->propagate(transformedFeatures, buffer);
+
+      int materialist = psqt;
+      int positional  = output[0];
+
+      t.psqt[bucket] = static_cast<Value>( materialist / OutputScale );
+      t.positional[bucket] = static_cast<Value>( positional / OutputScale );
+    }
+
+    return t;
+  }
+
+  // Requires the buffer to have capacity for at least 5 values
+  static void format_cp_compact(Value v, char* buffer) {
+
+    buffer[0] = (v < 0 ? '-' : v > 0 ? '+' : ' ');
+
+    int cp = std::abs(100 * v / PawnValueEg);
+
+    if (cp >= 10000)
+    {
+      buffer[1] = '0' + cp / 10000; cp %= 10000;
+      buffer[2] = '0' + cp / 1000; cp %= 1000;
+      buffer[3] = '0' + cp / 100; cp %= 100;
+      buffer[4] = ' ';
+    }
+    else if (cp >= 1000)
+    {
+      buffer[1] = '0' + cp / 1000; cp %= 1000;
+      buffer[2] = '0' + cp / 100; cp %= 100;
+      buffer[3] = '.';
+      buffer[4] = '0' + cp / 10;
+    }
+    else
+    {
+      buffer[1] = '0' + cp / 100; cp %= 100;
+      buffer[2] = '.';
+      buffer[3] = '0' + cp / 10; cp %= 10;
+      buffer[4] = '0' + cp / 1;
+    }
+  }
+
+  // Requires the buffer to have capacity for at least 7 values
+  static void format_cp_aligned_dot(Value v, char* buffer) {
+    buffer[0] = (v < 0 ? '-' : v > 0 ? '+' : ' ');
+
+    int cp = std::abs(100 * v / PawnValueEg);
+
+    if (cp >= 10000)
+    {
+      buffer[1] = '0' + cp / 10000; cp %= 10000;
+      buffer[2] = '0' + cp / 1000; cp %= 1000;
+      buffer[3] = '0' + cp / 100; cp %= 100;
+      buffer[4] = '.';
+      buffer[5] = '0' + cp / 10; cp %= 10;
+      buffer[6] = '0' + cp;
+    }
+    else if (cp >= 1000)
+    {
+      buffer[1] = ' ';
+      buffer[2] = '0' + cp / 1000; cp %= 1000;
+      buffer[3] = '0' + cp / 100; cp %= 100;
+      buffer[4] = '.';
+      buffer[5] = '0' + cp / 10; cp %= 10;
+      buffer[6] = '0' + cp;
+    }
+    else
+    {
+      buffer[1] = ' ';
+      buffer[2] = ' ';
+      buffer[3] = '0' + cp / 100; cp %= 100;
+      buffer[4] = '.';
+      buffer[5] = '0' + cp / 10; cp %= 10;
+      buffer[6] = '0' + cp / 1;
+    }
+  }
+
+
+  // trace() returns a string with the value of each piece on a board,
+  // and a table for (PSQT, Layers) values bucket by bucket.
+
+  std::string trace(Position& pos) {
+
+    std::stringstream ss;
+
+    char board[3*RANK_NB+1][8*FILE_NB+2];
+    std::memset(board, ' ', sizeof(board));
+    for (int row = 0; row < 3*pos.ranks()+1; ++row)
+      board[row][8*FILE_NB+1] = '\0';
+
+    // A lambda to output one box of the board
+    auto writeSquare = [&board, &pos](File file, Rank rank, Piece pc, Value value) {
+
+      const int x = ((int)file) * 8;
+      const int y = (pos.max_rank() - (int)rank) * 3;
+      for (int i = 1; i < 8; ++i)
+         board[y][x+i] = board[y+3][x+i] = '-';
+      for (int i = 1; i < 3; ++i)
+         board[y+i][x] = board[y+i][x+8] = '|';
+      board[y][x] = board[y][x+8] = board[y+3][x+8] = board[y+3][x] = '+';
+      if (pc != NO_PIECE)
+        board[y+1][x+4] = pos.piece_to_char()[pc];
+      if (value != VALUE_NONE)
+        format_cp_compact(value, &board[y+2][x+2]);
+    };
+
+    // We estimate the value of each piece by doing a differential evaluation from
+    // the current base eval, simulating the removal of the piece from its square.
+    Value base = evaluate(pos);
+    base = pos.side_to_move() == WHITE ? base : -base;
+
+    for (File f = FILE_A; f <= pos.max_file(); ++f)
+      for (Rank r = RANK_1; r <= pos.max_rank(); ++r)
+      {
+        Square sq = make_square(f, r);
+        Piece pc = pos.piece_on(sq);
+        Piece unpromotedPc = pos.unpromoted_piece_on(sq);
+        bool isPromoted = pos.is_promoted(sq);
+        Value v = VALUE_NONE;
+
+        if (pc != NO_PIECE && type_of(pc) != pos.nnue_king())
+        {
+          auto st = pos.state();
+
+          pos.remove_piece(sq);
+          st->accumulator.computed[WHITE] = false;
+          st->accumulator.computed[BLACK] = false;
+
+          Value eval = evaluate(pos);
+          eval = pos.side_to_move() == WHITE ? eval : -eval;
+          v = base - eval;
+
+          pos.put_piece(pc, sq, isPromoted, unpromotedPc);
+          st->accumulator.computed[WHITE] = false;
+          st->accumulator.computed[BLACK] = false;
+        }
+
+        writeSquare(f, r, pc, v);
+      }
+
+    ss << " NNUE derived piece values:\n";
+    for (int row = 0; row < 3*pos.ranks()+1; ++row)
+        ss << board[row] << '\n';
+    ss << '\n';
+
+    auto t = trace_evaluate(pos);
+
+    ss << " NNUE network contributions "
+       << (pos.side_to_move() == WHITE ? "(White to move)" : "(Black to move)") << std::endl
+       << "+------------+------------+------------+------------+\n"
+       << "|   Bucket   |  Material  | Positional |   Total    |\n"
+       << "|            |   (PSQT)   |  (Layers)  |            |\n"
+       << "+------------+------------+------------+------------+\n";
+
+    for (std::size_t bucket = 0; bucket < LayerStacks; ++bucket)
+    {
+      char buffer[3][8];
+      std::memset(buffer, '\0', sizeof(buffer));
+
+      format_cp_aligned_dot(t.psqt[bucket], buffer[0]);
+      format_cp_aligned_dot(t.positional[bucket], buffer[1]);
+      format_cp_aligned_dot(t.psqt[bucket] + t.positional[bucket], buffer[2]);
+
+      ss <<  "|  " << bucket    << "        "
+         << " |  " << buffer[0] << "  "
+         << " |  " << buffer[1] << "  "
+         << " |  " << buffer[2] << "  "
+         << " |";
+      if (bucket == t.correctBucket)
+          ss << " <-- this bucket is used";
+      ss << '\n';
+    }
+
+    ss << "+------------+------------+------------+------------+\n";
+
+    return ss.str();
+  }
+
+
+  // Load eval, from a file stream or a memory stream
+  bool load_eval(std::string name, std::istream& stream) {
+
+    initialize();
+    fileName = name;
+    return read_parameters(stream);
+  }
+
+  // Save eval, to a file stream or a memory stream
+  bool save_eval(std::ostream& stream) {
+
+    if (fileName.empty())
+      return false;
+
+    return write_parameters(stream);
+  }
+
+  /// Save eval, to a file given by its name
+  bool save_eval(const std::optional<std::string>& filename) {
+
+    std::string actualFilename;
+    std::string msg;
+
+    if (filename.has_value())
+        actualFilename = filename.value();
+    else
+    {
+        if (eval_file_loaded != EvalFileDefaultName)
+        {
+             msg = "Failed to export a net. A non-embedded net can only be saved if the filename is specified";
+
+             sync_cout << msg << sync_endl;
+             return false;
+        }
+        actualFilename = EvalFileDefaultName;
+    }
+
+    std::ofstream stream(actualFilename, std::ios_base::binary);
+    bool saved = save_eval(stream);
+
+    msg = saved ? "Network saved successfully to " + actualFilename
+                : "Failed to export a net";
+
+    sync_cout << msg << sync_endl;
+    return saved;
+  }
+
+
+} // namespace Stockfish::Eval::NNUE

Fairy-Stockfish-master/src/nnue/evaluate_nnue.h

@@ -0,0 +1,59 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+// header used in NNUE evaluation function
+
+#ifndef NNUE_EVALUATE_NNUE_H_INCLUDED
+#define NNUE_EVALUATE_NNUE_H_INCLUDED
+
+#include "nnue_feature_transformer.h"
+
+#include <memory>
+
+namespace Stockfish::Eval::NNUE {
+
+  // Hash value of evaluation function structure
+  constexpr std::uint32_t HashValue =
+      FeatureTransformer::get_hash_value() ^ Network::get_hash_value();
+
+  // Deleter for automating release of memory area
+  template <typename T>
+  struct AlignedDeleter {
+    void operator()(T* ptr) const {
+      ptr->~T();
+      std_aligned_free(ptr);
+    }
+  };
+
+  template <typename T>
+  struct LargePageDeleter {
+    void operator()(T* ptr) const {
+      ptr->~T();
+      aligned_large_pages_free(ptr);
+    }
+  };
+
+  template <typename T>
+  using AlignedPtr = std::unique_ptr<T, AlignedDeleter<T>>;
+
+  template <typename T>
+  using LargePagePtr = std::unique_ptr<T, LargePageDeleter<T>>;
+
+}  // namespace Stockfish::Eval::NNUE
+
+#endif // #ifndef NNUE_EVALUATE_NNUE_H_INCLUDED

Fairy-Stockfish-master/src/nnue/features/half_ka_v2.cpp

@@ -0,0 +1,90 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+//Definition of input features HalfKAv2 of NNUE evaluation function
+
+#include "half_ka_v2.h"
+
+#include "../../position.h"
+
+namespace Stockfish::Eval::NNUE::Features {
+
+  // Map square to numbering on 8x8 board
+  constexpr Square to_chess_square(Square s) {
+    return Square(s - rank_of(s) * (FILE_MAX - FILE_H));
+  }
+
+  // Orient a square according to perspective (rotates by 180 for black)
+  inline Square HalfKAv2::orient(Color perspective, Square s) {
+    return Square(int(to_chess_square(s)) ^ (bool(perspective) * 56));
+  }
+
+  // Index of a feature for a given king position and another piece on some square
+  inline IndexType HalfKAv2::make_index(Color perspective, Square s, Piece pc, Square ksq) {
+    return IndexType(orient(perspective, s) + PieceSquareIndex[perspective][pc] + PS_NB * ksq);
+  }
+
+  // Get a list of indices for active features
+  void HalfKAv2::append_active_indices(
+    const Position& pos,
+    Color perspective,
+    ValueListInserter<IndexType> active
+  ) {
+    Square ksq = orient(perspective, pos.square<KING>(perspective));
+    Bitboard bb = pos.pieces();
+    while (bb)
+    {
+      Square s = pop_lsb(bb);
+      active.push_back(make_index(perspective, s, pos.piece_on(s), ksq));
+    }
+  }
+
+
+  // append_changed_indices() : get a list of indices for recently changed features
+
+  void HalfKAv2::append_changed_indices(
+    Square ksq,
+    StateInfo* st,
+    Color perspective,
+    ValueListInserter<IndexType> removed,
+    ValueListInserter<IndexType> added
+  ) {
+    const auto& dp = st->dirtyPiece;
+    Square oriented_ksq = orient(perspective, ksq);
+    for (int i = 0; i < dp.dirty_num; ++i) {
+      Piece pc = dp.piece[i];
+      if (dp.from[i] != SQ_NONE)
+        removed.push_back(make_index(perspective, dp.from[i], pc, oriented_ksq));
+      if (dp.to[i] != SQ_NONE)
+        added.push_back(make_index(perspective, dp.to[i], pc, oriented_ksq));
+    }
+  }
+
+  int HalfKAv2::update_cost(StateInfo* st) {
+    return st->dirtyPiece.dirty_num;
+  }
+
+  int HalfKAv2::refresh_cost(const Position& pos) {
+    return pos.count<ALL_PIECES>();
+  }
+
+  bool HalfKAv2::requires_refresh(StateInfo* st, Color perspective) {
+    return st->dirtyPiece.piece[0] == make_piece(perspective, KING);
+  }
+
+}  // namespace Stockfish::Eval::NNUE::Features

Fairy-Stockfish-master/src/nnue/features/half_ka_v2.h

@@ -0,0 +1,152 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+//Definition of input features HalfKAv2 of NNUE evaluation function
+
+#ifndef NNUE_FEATURES_HALF_KA_V2_H_INCLUDED
+#define NNUE_FEATURES_HALF_KA_V2_H_INCLUDED
+
+#include "../nnue_common.h"
+
+#include "../../evaluate.h"
+#include "../../misc.h"
+
+namespace Stockfish {
+  struct StateInfo;
+}
+
+namespace Stockfish::Eval::NNUE::Features {
+
+  // Feature HalfKAv2: Combination of the position of own king
+  // and the position of pieces
+  class HalfKAv2 {
+
+    // unique number for each piece type on each square
+    enum {
+      PS_NONE     =  0,
+      PS_W_PAWN   =  0,
+      PS_B_PAWN   =  1 * SQUARE_NB_CHESS,
+      PS_W_KNIGHT =  2 * SQUARE_NB_CHESS,
+      PS_B_KNIGHT =  3 * SQUARE_NB_CHESS,
+      PS_W_BISHOP =  4 * SQUARE_NB_CHESS,
+      PS_B_BISHOP =  5 * SQUARE_NB_CHESS,
+      PS_W_ROOK   =  6 * SQUARE_NB_CHESS,
+      PS_B_ROOK   =  7 * SQUARE_NB_CHESS,
+      PS_W_QUEEN  =  8 * SQUARE_NB_CHESS,
+      PS_B_QUEEN  =  9 * SQUARE_NB_CHESS,
+      PS_KING     =  10 * SQUARE_NB_CHESS,
+      PS_NB = 11 * SQUARE_NB_CHESS
+    };
+
+    static constexpr uint32_t PieceSquareIndex[COLOR_NB][PIECE_NB] = {
+      // convention: W - us, B - them
+      // viewed from other side, W and B are reversed
+      {
+        PS_NONE, PS_W_PAWN, PS_W_KNIGHT, PS_W_BISHOP, PS_W_ROOK, PS_W_QUEEN, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_KING,
+
+        PS_NONE, PS_B_PAWN, PS_B_KNIGHT, PS_B_BISHOP, PS_B_ROOK, PS_B_QUEEN, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_KING,
+      },
+
+      {
+        PS_NONE, PS_B_PAWN, PS_B_KNIGHT, PS_B_BISHOP, PS_B_ROOK, PS_B_QUEEN, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_KING,
+
+        PS_NONE, PS_W_PAWN, PS_W_KNIGHT, PS_W_BISHOP, PS_W_ROOK, PS_W_QUEEN, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE,
+        PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_NONE, PS_KING,
+      }
+    };
+    // Check that the fragile array definition is correct
+    static_assert(PieceSquareIndex[WHITE][make_piece(WHITE, PAWN)] == PS_W_PAWN);
+    static_assert(PieceSquareIndex[WHITE][make_piece(WHITE, KING)] == PS_KING);
+    static_assert(PieceSquareIndex[WHITE][make_piece(BLACK, PAWN)] == PS_B_PAWN);
+    static_assert(PieceSquareIndex[WHITE][make_piece(BLACK, KING)] == PS_KING);
+
+
+    // Orient a square according to perspective (rotates by 180 for black)
+    static Square orient(Color perspective, Square s);
+
+    // Index of a feature for a given king position and another piece on some square
+    static IndexType make_index(Color perspective, Square s, Piece pc, Square ksq);
+
+   public:
+    // Feature name
+    static constexpr const char* Name = "HalfKAv2(Friend)";
+
+    // Hash value embedded in the evaluation file
+    static constexpr std::uint32_t HashValue = 0x5f234cb8u;
+
+    // Number of feature dimensions
+    static constexpr IndexType Dimensions =
+        static_cast<IndexType>(SQUARE_NB_CHESS) * static_cast<IndexType>(PS_NB);
+
+    // Maximum number of simultaneously active features.
+    static constexpr IndexType MaxActiveDimensions = 32;
+
+    // Get a list of indices for active features
+    static void append_active_indices(
+      const Position& pos,
+      Color perspective,
+      ValueListInserter<IndexType> active);
+
+    // Get a list of indices for recently changed features
+    static void append_changed_indices(
+      Square ksq,
+      StateInfo* st,
+      Color perspective,
+      ValueListInserter<IndexType> removed,
+      ValueListInserter<IndexType> added);
+
+    // Returns the cost of updating one perspective, the most costly one.
+    // Assumes no refresh needed.
+    static int update_cost(StateInfo* st);
+    static int refresh_cost(const Position& pos);
+
+    // Returns whether the change stored in this StateInfo means that
+    // a full accumulator refresh is required.
+    static bool requires_refresh(StateInfo* st, Color perspective);
+  };
+
+}  // namespace Stockfish::Eval::NNUE::Features
+
+#endif // #ifndef NNUE_FEATURES_HALF_KA_V2_H_INCLUDED

Fairy-Stockfish-master/src/nnue/features/half_ka_v2_variants.cpp

@@ -0,0 +1,112 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+//Definition of input features HalfKAv2 of NNUE evaluation function
+
+#include "half_ka_v2_variants.h"
+
+#include "../../position.h"
+
+namespace Stockfish::Eval::NNUE::Features {
+
+  // Map square to numbering on variant board
+  inline Square to_variant_square(Square s, const Position& pos) {
+    return Square(s - rank_of(s) * (FILE_MAX - pos.max_file()));
+  }
+
+  // Orient a square according to perspective (rotates by 180 for black)
+  // Missing kings map to index 0 (SQ_A1)
+  inline Square HalfKAv2Variants::orient(Color perspective, Square s, const Position& pos) {
+    return s != SQ_NONE ? to_variant_square(  perspective == WHITE || (pos.flag_region(BLACK) & Rank8BB) ? s
+                                            : flip_rank(s, pos.max_rank()), pos) : SQ_A1;
+  }
+
+  // Index of a feature for a given king position and another piece on some square
+  inline IndexType HalfKAv2Variants::make_index(Color perspective, Square s, Piece pc, Square ksq, const Position& pos) {
+    return IndexType(orient(perspective, s, pos) + pos.nnue_piece_square_index(perspective, pc) + pos.nnue_king_square_index(ksq));
+  }
+
+  // Index of a feature for a given king position and another piece on some square
+  inline IndexType HalfKAv2Variants::make_index(Color perspective, int handCount, Piece pc, Square ksq, const Position& pos) {
+    return IndexType(handCount + pos.nnue_piece_hand_index(perspective, pc) + pos.nnue_king_square_index(ksq));
+  }
+
+  // Get a list of indices for active features
+  void HalfKAv2Variants::append_active_indices(
+    const Position& pos,
+    Color perspective,
+    ValueListInserter<IndexType> active
+  ) {
+    Square oriented_ksq = orient(perspective, pos.nnue_king_square(perspective), pos);
+    Bitboard bb = pos.pieces(WHITE) | pos.pieces(BLACK);
+    while (bb)
+    {
+      Square s = pop_lsb(bb);
+      active.push_back(make_index(perspective, s, pos.piece_on(s), oriented_ksq, pos));
+    }
+
+    // Indices for pieces in hand
+    if (pos.nnue_use_pockets())
+      for (Color c : {WHITE, BLACK})
+          for (PieceSet ps = pos.piece_types(); ps;)
+          {
+              PieceType pt = pop_lsb(ps);
+              for (int i = 0; i < pos.count_in_hand(c, pt); i++)
+                  active.push_back(make_index(perspective, i, make_piece(c, pt), oriented_ksq, pos));
+          }
+
+  }
+
+  // append_changed_indices() : get a list of indices for recently changed features
+
+  void HalfKAv2Variants::append_changed_indices(
+    Square ksq,
+    StateInfo* st,
+    Color perspective,
+    ValueListInserter<IndexType> removed,
+    ValueListInserter<IndexType> added,
+    const Position& pos
+  ) {
+    const auto& dp = st->dirtyPiece;
+    Square oriented_ksq = orient(perspective, ksq, pos);
+    for (int i = 0; i < dp.dirty_num; ++i) {
+      Piece pc = dp.piece[i];
+      if (dp.from[i] != SQ_NONE)
+        removed.push_back(make_index(perspective, dp.from[i], pc, oriented_ksq, pos));
+      else if (dp.handPiece[i] != NO_PIECE)
+        removed.push_back(make_index(perspective, dp.handCount[i] - 1, dp.handPiece[i], oriented_ksq, pos));
+      if (dp.to[i] != SQ_NONE)
+        added.push_back(make_index(perspective, dp.to[i], pc, oriented_ksq, pos));
+      else if (dp.handPiece[i] != NO_PIECE)
+        added.push_back(make_index(perspective, dp.handCount[i] - 1, dp.handPiece[i], oriented_ksq, pos));
+    }
+  }
+
+  int HalfKAv2Variants::update_cost(StateInfo* st) {
+    return st->dirtyPiece.dirty_num;
+  }
+
+  int HalfKAv2Variants::refresh_cost(const Position& pos) {
+    return pos.count<ALL_PIECES>();
+  }
+
+  bool HalfKAv2Variants::requires_refresh(StateInfo* st, Color perspective, const Position& pos) {
+    return st->dirtyPiece.piece[0] == make_piece(perspective, pos.nnue_king()) || pos.flip_enclosed_pieces();
+  }
+
+}  // namespace Stockfish::Eval::NNUE::Features

Fairy-Stockfish-master/src/nnue/features/half_ka_v2_variants.h

@@ -0,0 +1,94 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+//Definition of input features HalfKAv2 of NNUE evaluation function
+
+#ifndef NNUE_FEATURES_HALF_KA_V2_VARIANTS_H_INCLUDED
+#define NNUE_FEATURES_HALF_KA_V2_VARIANTS_H_INCLUDED
+
+#include "../nnue_common.h"
+
+#include "../../evaluate.h"
+#include "../../misc.h"
+
+#include "half_ka_v2.h"
+
+namespace Stockfish {
+  struct StateInfo;
+}
+
+namespace Stockfish::Eval::NNUE::Features {
+
+  // Feature HalfKAv2: Combination of the position of own king
+  // and the position of pieces
+  class HalfKAv2Variants {
+
+    // Orient a square according to perspective (rotates by 180 for black)
+    static Square orient(Color perspective, Square s, const Position& pos);
+
+    // Index of a feature for a given king position and another piece on some square
+    static IndexType make_index(Color perspective, Square s, Piece pc, Square ksq, const Position& pos);
+
+    // Index of a feature for a given king position and another piece in hand
+    static IndexType make_index(Color perspective, int handCount, Piece pc, Square ksq, const Position& pos);
+
+   public:
+    // Feature name
+    static constexpr const char* Name = "HalfKAv2(Friend)";
+
+    // Hash value embedded in the evaluation file
+    static constexpr std::uint32_t HashValue = 0x5f234cb8u;
+
+    // Number of feature dimensions
+    static constexpr IndexType Dimensions = static_cast<IndexType>(SQUARE_NB) * static_cast<IndexType>(SQUARE_NB) * 19;
+
+    static IndexType get_dimensions() {
+      return currentNnueVariant->nnueDimensions;
+    }
+
+    // Maximum number of simultaneously active features.
+    static constexpr IndexType MaxActiveDimensions = 128;
+
+    // Get a list of indices for active features
+    static void append_active_indices(
+      const Position& pos,
+      Color perspective,
+      ValueListInserter<IndexType> active);
+
+    // Get a list of indices for recently changed features
+    static void append_changed_indices(
+      Square ksq,
+      StateInfo* st,
+      Color perspective,
+      ValueListInserter<IndexType> removed,
+      ValueListInserter<IndexType> added,
+      const Position& pos);
+
+    // Returns the cost of updating one perspective, the most costly one.
+    // Assumes no refresh needed.
+    static int update_cost(StateInfo* st);
+    static int refresh_cost(const Position& pos);
+
+    // Returns whether the change stored in this StateInfo means that
+    // a full accumulator refresh is required.
+    static bool requires_refresh(StateInfo* st, Color perspective, const Position& pos);
+  };
+
+}  // namespace Stockfish::Eval::NNUE::Features
+
+#endif // #ifndef NNUE_FEATURES_HALF_KA_V2_VARIANTS_H_INCLUDED

Fairy-Stockfish-master/src/nnue/layers/affine_transform.h

@@ -0,0 +1,435 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+// Definition of layer AffineTransform of NNUE evaluation function
+
+#ifndef NNUE_LAYERS_AFFINE_TRANSFORM_H_INCLUDED
+#define NNUE_LAYERS_AFFINE_TRANSFORM_H_INCLUDED
+
+#include <iostream>
+#include "../nnue_common.h"
+
+namespace Stockfish::Eval::NNUE::Layers {
+
+  // Affine transformation layer
+  template <typename PreviousLayer, IndexType OutDims>
+  class AffineTransform {
+   public:
+    // Input/output type
+    using InputType = typename PreviousLayer::OutputType;
+    using OutputType = std::int32_t;
+    static_assert(std::is_same<InputType, std::uint8_t>::value, "");
+
+    // Number of input/output dimensions
+    static constexpr IndexType InputDimensions =
+        PreviousLayer::OutputDimensions;
+    static constexpr IndexType OutputDimensions = OutDims;
+    static constexpr IndexType PaddedInputDimensions =
+        ceil_to_multiple<IndexType>(InputDimensions, MaxSimdWidth);
+#if defined (USE_AVX512)
+    static constexpr const IndexType OutputSimdWidth = SimdWidth / 2;
+#elif defined (USE_SSSE3)
+    static constexpr const IndexType OutputSimdWidth = SimdWidth / 4;
+#endif
+
+    // Size of forward propagation buffer used in this layer
+    static constexpr std::size_t SelfBufferSize =
+        ceil_to_multiple(OutputDimensions * sizeof(OutputType), CacheLineSize);
+
+    // Size of the forward propagation buffer used from the input layer to this layer
+    static constexpr std::size_t BufferSize =
+        PreviousLayer::BufferSize + SelfBufferSize;
+
+    // Hash value embedded in the evaluation file
+    static constexpr std::uint32_t get_hash_value() {
+      std::uint32_t hashValue = 0xCC03DAE4u;
+      hashValue += OutputDimensions;
+      hashValue ^= PreviousLayer::get_hash_value() >> 1;
+      hashValue ^= PreviousLayer::get_hash_value() << 31;
+      return hashValue;
+    }
+
+    // Read network parameters
+    bool read_parameters(std::istream& stream) {
+      if (!previousLayer.read_parameters(stream)) return false;
+      for (std::size_t i = 0; i < OutputDimensions; ++i)
+        biases[i] = read_little_endian<BiasType>(stream);
+      for (std::size_t i = 0; i < OutputDimensions * PaddedInputDimensions; ++i)
+#if !defined (USE_SSSE3)
+        weights[i] = read_little_endian<WeightType>(stream);
+#else
+        weights[
+          (i / 4) % (PaddedInputDimensions / 4) * OutputDimensions * 4 +
+          i / PaddedInputDimensions * 4 +
+          i % 4
+        ] = read_little_endian<WeightType>(stream);
+#endif
+
+      return !stream.fail();
+    }
+
+    // Write network parameters
+    bool write_parameters(std::ostream& stream) const {
+      if (!previousLayer.write_parameters(stream)) return false;
+      for (std::size_t i = 0; i < OutputDimensions; ++i)
+          write_little_endian<BiasType>(stream, biases[i]);
+#if !defined (USE_SSSE3)
+      for (std::size_t i = 0; i < OutputDimensions * PaddedInputDimensions; ++i)
+          write_little_endian<WeightType>(stream, weights[i]);
+#else
+      std::unique_ptr<WeightType[]> unscrambledWeights = std::make_unique<WeightType[]>(OutputDimensions * PaddedInputDimensions);
+      for (std::size_t i = 0; i < OutputDimensions * PaddedInputDimensions; ++i) {
+          unscrambledWeights[i] =
+              weights[
+                (i / 4) % (PaddedInputDimensions / 4) * OutputDimensions * 4 +
+                i / PaddedInputDimensions * 4 +
+                i % 4
+              ];
+      }
+
+      for (std::size_t i = 0; i < OutputDimensions * PaddedInputDimensions; ++i)
+          write_little_endian<WeightType>(stream, unscrambledWeights[i]);
+#endif
+
+      return !stream.fail();
+    }
+
+    // Forward propagation
+    const OutputType* propagate(
+        const TransformedFeatureType* transformedFeatures, char* buffer) const {
+      const auto input = previousLayer.propagate(
+          transformedFeatures, buffer + SelfBufferSize);
+
+#if defined (USE_AVX512)
+
+      [[maybe_unused]] const __m512i Ones512 = _mm512_set1_epi16(1);
+
+      [[maybe_unused]] auto m512_hadd = [](__m512i sum, int bias) -> int {
+        return _mm512_reduce_add_epi32(sum) + bias;
+      };
+
+      [[maybe_unused]] auto m512_add_dpbusd_epi32 = [=](__m512i& acc, __m512i a, __m512i b) {
+#if defined (USE_VNNI)
+        acc = _mm512_dpbusd_epi32(acc, a, b);
+#else
+        __m512i product0 = _mm512_maddubs_epi16(a, b);
+        product0 = _mm512_madd_epi16(product0, Ones512);
+        acc = _mm512_add_epi32(acc, product0);
+#endif
+      };
+
+      [[maybe_unused]] auto m512_add_dpbusd_epi32x4 = [=](__m512i& acc, __m512i a0, __m512i b0, __m512i a1, __m512i b1,
+                                                                        __m512i a2, __m512i b2, __m512i a3, __m512i b3) {
+#if defined (USE_VNNI)
+        acc = _mm512_dpbusd_epi32(acc, a0, b0);
+        acc = _mm512_dpbusd_epi32(acc, a1, b1);
+        acc = _mm512_dpbusd_epi32(acc, a2, b2);
+        acc = _mm512_dpbusd_epi32(acc, a3, b3);
+#else
+        __m512i product0 = _mm512_maddubs_epi16(a0, b0);
+        __m512i product1 = _mm512_maddubs_epi16(a1, b1);
+        __m512i product2 = _mm512_maddubs_epi16(a2, b2);
+        __m512i product3 = _mm512_maddubs_epi16(a3, b3);
+        product0 = _mm512_adds_epi16(product0, product1);
+        product0 = _mm512_madd_epi16(product0, Ones512);
+        product2 = _mm512_adds_epi16(product2, product3);
+        product2 = _mm512_madd_epi16(product2, Ones512);
+        acc = _mm512_add_epi32(acc, _mm512_add_epi32(product0, product2));
+#endif
+      };
+
+#endif
+#if defined (USE_AVX2)
+
+      [[maybe_unused]] const __m256i Ones256 = _mm256_set1_epi16(1);
+
+      [[maybe_unused]] auto m256_hadd = [](__m256i sum, int bias) -> int {
+        __m128i sum128 = _mm_add_epi32(_mm256_castsi256_si128(sum), _mm256_extracti128_si256(sum, 1));
+        sum128 = _mm_add_epi32(sum128, _mm_shuffle_epi32(sum128, _MM_PERM_BADC));
+        sum128 = _mm_add_epi32(sum128, _mm_shuffle_epi32(sum128, _MM_PERM_CDAB));
+        return _mm_cvtsi128_si32(sum128) + bias;
+      };
+
+      [[maybe_unused]] auto m256_add_dpbusd_epi32 = [=](__m256i& acc, __m256i a, __m256i b) {
+#if defined (USE_VNNI)
+        acc = _mm256_dpbusd_epi32(acc, a, b);
+#else
+        __m256i product0 = _mm256_maddubs_epi16(a, b);
+        product0 = _mm256_madd_epi16(product0, Ones256);
+        acc = _mm256_add_epi32(acc, product0);
+#endif
+      };
+
+      [[maybe_unused]] auto m256_add_dpbusd_epi32x4 = [=](__m256i& acc, __m256i a0, __m256i b0, __m256i a1, __m256i b1,
+                                                                        __m256i a2, __m256i b2, __m256i a3, __m256i b3) {
+#if defined (USE_VNNI)
+        acc = _mm256_dpbusd_epi32(acc, a0, b0);
+        acc = _mm256_dpbusd_epi32(acc, a1, b1);
+        acc = _mm256_dpbusd_epi32(acc, a2, b2);
+        acc = _mm256_dpbusd_epi32(acc, a3, b3);
+#else
+        __m256i product0 = _mm256_maddubs_epi16(a0, b0);
+        __m256i product1 = _mm256_maddubs_epi16(a1, b1);
+        __m256i product2 = _mm256_maddubs_epi16(a2, b2);
+        __m256i product3 = _mm256_maddubs_epi16(a3, b3);
+        product0 = _mm256_adds_epi16(product0, product1);
+        product0 = _mm256_madd_epi16(product0, Ones256);
+        product2 = _mm256_adds_epi16(product2, product3);
+        product2 = _mm256_madd_epi16(product2, Ones256);
+        acc = _mm256_add_epi32(acc, _mm256_add_epi32(product0, product2));
+#endif
+      };
+
+#endif
+#if defined (USE_SSSE3)
+
+      [[maybe_unused]] const __m128i Ones128 = _mm_set1_epi16(1);
+
+      [[maybe_unused]] auto m128_hadd = [](__m128i sum, int bias) -> int {
+        sum = _mm_add_epi32(sum, _mm_shuffle_epi32(sum, 0x4E)); //_MM_PERM_BADC
+        sum = _mm_add_epi32(sum, _mm_shuffle_epi32(sum, 0xB1)); //_MM_PERM_CDAB
+        return _mm_cvtsi128_si32(sum) + bias;
+      };
+
+      [[maybe_unused]] auto m128_add_dpbusd_epi32 = [=](__m128i& acc, __m128i a, __m128i b) {
+        __m128i product0 = _mm_maddubs_epi16(a, b);
+        product0 = _mm_madd_epi16(product0, Ones128);
+        acc = _mm_add_epi32(acc, product0);
+      };
+
+      [[maybe_unused]] auto m128_add_dpbusd_epi32x4 = [=](__m128i& acc, __m128i a0, __m128i b0, __m128i a1, __m128i b1,
+                                                                        __m128i a2, __m128i b2, __m128i a3, __m128i b3) {
+        __m128i product0 = _mm_maddubs_epi16(a0, b0);
+        __m128i product1 = _mm_maddubs_epi16(a1, b1);
+        __m128i product2 = _mm_maddubs_epi16(a2, b2);
+        __m128i product3 = _mm_maddubs_epi16(a3, b3);
+        product0 = _mm_adds_epi16(product0, product1);
+        product0 = _mm_madd_epi16(product0, Ones128);
+        product2 = _mm_adds_epi16(product2, product3);
+        product2 = _mm_madd_epi16(product2, Ones128);
+        acc = _mm_add_epi32(acc, _mm_add_epi32(product0, product2));
+      };
+
+#endif
+
+#if defined (USE_AVX512)
+      using vec_t = __m512i;
+      #define vec_setzero _mm512_setzero_si512
+      #define vec_set_32 _mm512_set1_epi32
+      auto& vec_add_dpbusd_32 = m512_add_dpbusd_epi32;
+      auto& vec_add_dpbusd_32x4 = m512_add_dpbusd_epi32x4;
+      auto& vec_hadd = m512_hadd;
+#elif defined (USE_AVX2)
+      using vec_t = __m256i;
+      #define vec_setzero _mm256_setzero_si256
+      #define vec_set_32 _mm256_set1_epi32
+      auto& vec_add_dpbusd_32 = m256_add_dpbusd_epi32;
+      auto& vec_add_dpbusd_32x4 = m256_add_dpbusd_epi32x4;
+      auto& vec_hadd = m256_hadd;
+#elif defined (USE_SSSE3)
+      using vec_t = __m128i;
+      #define vec_setzero _mm_setzero_si128
+      #define vec_set_32 _mm_set1_epi32
+      auto& vec_add_dpbusd_32 = m128_add_dpbusd_epi32;
+      auto& vec_add_dpbusd_32x4 = m128_add_dpbusd_epi32x4;
+      auto& vec_hadd = m128_hadd;
+#endif
+
+#if defined (USE_SSSE3)
+      // Different layout, we process 4 inputs at a time, always.
+      static_assert(InputDimensions % 4 == 0);
+
+      const auto output = reinterpret_cast<OutputType*>(buffer);
+      const auto inputVector = reinterpret_cast<const vec_t*>(input);
+
+      static_assert(OutputDimensions % OutputSimdWidth == 0 || OutputDimensions == 1);
+
+      // OutputDimensions is either 1 or a multiple of SimdWidth
+      // because then it is also an input dimension.
+      if constexpr (OutputDimensions % OutputSimdWidth == 0)
+      {
+          constexpr IndexType NumChunks = InputDimensions / 4;
+
+          const auto input32 = reinterpret_cast<const std::int32_t*>(input);
+          vec_t* outptr = reinterpret_cast<vec_t*>(output);
+          std::memcpy(output, biases, OutputDimensions * sizeof(OutputType));
+
+          for (int i = 0; i < (int)NumChunks - 3; i += 4)
+          {
+              const vec_t in0 = vec_set_32(input32[i + 0]);
+              const vec_t in1 = vec_set_32(input32[i + 1]);
+              const vec_t in2 = vec_set_32(input32[i + 2]);
+              const vec_t in3 = vec_set_32(input32[i + 3]);
+              const auto col0 = reinterpret_cast<const vec_t*>(&weights[(i + 0) * OutputDimensions * 4]);
+              const auto col1 = reinterpret_cast<const vec_t*>(&weights[(i + 1) * OutputDimensions * 4]);
+              const auto col2 = reinterpret_cast<const vec_t*>(&weights[(i + 2) * OutputDimensions * 4]);
+              const auto col3 = reinterpret_cast<const vec_t*>(&weights[(i + 3) * OutputDimensions * 4]);
+              for (int j = 0; j * OutputSimdWidth < OutputDimensions; ++j)
+                  vec_add_dpbusd_32x4(outptr[j], in0, col0[j], in1, col1[j], in2, col2[j], in3, col3[j]);
+          }
+      }
+      else if constexpr (OutputDimensions == 1)
+      {
+#if defined (USE_AVX512)
+          if constexpr (PaddedInputDimensions % (SimdWidth * 2) != 0)
+          {
+              constexpr IndexType NumChunks = PaddedInputDimensions / SimdWidth;
+              const auto inputVector256 = reinterpret_cast<const __m256i*>(input);
+
+              __m256i sum0 = _mm256_setzero_si256();
+              const auto row0 = reinterpret_cast<const __m256i*>(&weights[0]);
+
+              for (int j = 0; j < (int)NumChunks; ++j)
+              {
+                  const __m256i in = inputVector256[j];
+                  m256_add_dpbusd_epi32(sum0, in, row0[j]);
+              }
+              output[0] = m256_hadd(sum0, biases[0]);
+          }
+          else
+#endif
+          {
+#if defined (USE_AVX512)
+              constexpr IndexType NumChunks = PaddedInputDimensions / (SimdWidth * 2);
+#else
+              constexpr IndexType NumChunks = PaddedInputDimensions / SimdWidth;
+#endif
+              vec_t sum0 = vec_setzero();
+              const auto row0 = reinterpret_cast<const vec_t*>(&weights[0]);
+
+              for (int j = 0; j < (int)NumChunks; ++j)
+              {
+                  const vec_t in = inputVector[j];
+                  vec_add_dpbusd_32(sum0, in, row0[j]);
+              }
+              output[0] = vec_hadd(sum0, biases[0]);
+          }
+      }
+
+#else
+
+// Use old implementation for the other architectures.
+
+      auto output = reinterpret_cast<OutputType*>(buffer);
+
+#if defined(USE_SSE2)
+      // At least a multiple of 16, with SSE2.
+      static_assert(InputDimensions % SimdWidth == 0);
+      constexpr IndexType NumChunks = InputDimensions / SimdWidth;
+      const __m128i Zeros = _mm_setzero_si128();
+      const auto inputVector = reinterpret_cast<const __m128i*>(input);
+
+#elif defined(USE_MMX)
+      static_assert(InputDimensions % SimdWidth == 0);
+      constexpr IndexType NumChunks = InputDimensions / SimdWidth;
+      const __m64 Zeros = _mm_setzero_si64();
+      const auto inputVector = reinterpret_cast<const __m64*>(input);
+
+#elif defined(USE_NEON)
+      static_assert(InputDimensions % SimdWidth == 0);
+      constexpr IndexType NumChunks = InputDimensions / SimdWidth;
+      const auto inputVector = reinterpret_cast<const int8x8_t*>(input);
+#endif
+
+      for (IndexType i = 0; i < OutputDimensions; ++i) {
+        const IndexType offset = i * PaddedInputDimensions;
+
+#if defined(USE_SSE2)
+        __m128i sumLo = _mm_cvtsi32_si128(biases[i]);
+        __m128i sumHi = Zeros;
+        const auto row = reinterpret_cast<const __m128i*>(&weights[offset]);
+        for (IndexType j = 0; j < NumChunks; ++j) {
+          __m128i row_j = _mm_load_si128(&row[j]);
+          __m128i input_j = _mm_load_si128(&inputVector[j]);
+          __m128i extendedRowLo = _mm_srai_epi16(_mm_unpacklo_epi8(row_j, row_j), 8);
+          __m128i extendedRowHi = _mm_srai_epi16(_mm_unpackhi_epi8(row_j, row_j), 8);
+          __m128i extendedInputLo = _mm_unpacklo_epi8(input_j, Zeros);
+          __m128i extendedInputHi = _mm_unpackhi_epi8(input_j, Zeros);
+          __m128i productLo = _mm_madd_epi16(extendedRowLo, extendedInputLo);
+          __m128i productHi = _mm_madd_epi16(extendedRowHi, extendedInputHi);
+          sumLo = _mm_add_epi32(sumLo, productLo);
+          sumHi = _mm_add_epi32(sumHi, productHi);
+        }
+        __m128i sum = _mm_add_epi32(sumLo, sumHi);
+        __m128i sumHigh_64 = _mm_shuffle_epi32(sum, _MM_SHUFFLE(1, 0, 3, 2));
+        sum = _mm_add_epi32(sum, sumHigh_64);
+        __m128i sum_second_32 = _mm_shufflelo_epi16(sum, _MM_SHUFFLE(1, 0, 3, 2));
+        sum = _mm_add_epi32(sum, sum_second_32);
+        output[i] = _mm_cvtsi128_si32(sum);
+
+#elif defined(USE_MMX)
+        __m64 sumLo = _mm_cvtsi32_si64(biases[i]);
+        __m64 sumHi = Zeros;
+        const auto row = reinterpret_cast<const __m64*>(&weights[offset]);
+        for (IndexType j = 0; j < NumChunks; ++j) {
+          __m64 row_j = row[j];
+          __m64 input_j = inputVector[j];
+          __m64 extendedRowLo = _mm_srai_pi16(_mm_unpacklo_pi8(row_j, row_j), 8);
+          __m64 extendedRowHi = _mm_srai_pi16(_mm_unpackhi_pi8(row_j, row_j), 8);
+          __m64 extendedInputLo = _mm_unpacklo_pi8(input_j, Zeros);
+          __m64 extendedInputHi = _mm_unpackhi_pi8(input_j, Zeros);
+          __m64 productLo = _mm_madd_pi16(extendedRowLo, extendedInputLo);
+          __m64 productHi = _mm_madd_pi16(extendedRowHi, extendedInputHi);
+          sumLo = _mm_add_pi32(sumLo, productLo);
+          sumHi = _mm_add_pi32(sumHi, productHi);
+        }
+        __m64 sum = _mm_add_pi32(sumLo, sumHi);
+        sum = _mm_add_pi32(sum, _mm_unpackhi_pi32(sum, sum));
+        output[i] = _mm_cvtsi64_si32(sum);
+
+#elif defined(USE_NEON)
+        int32x4_t sum = {biases[i]};
+        const auto row = reinterpret_cast<const int8x8_t*>(&weights[offset]);
+        for (IndexType j = 0; j < NumChunks; ++j) {
+          int16x8_t product = vmull_s8(inputVector[j * 2], row[j * 2]);
+          product = vmlal_s8(product, inputVector[j * 2 + 1], row[j * 2 + 1]);
+          sum = vpadalq_s16(sum, product);
+        }
+        output[i] = sum[0] + sum[1] + sum[2] + sum[3];
+
+#else
+        OutputType sum = biases[i];
+        for (IndexType j = 0; j < InputDimensions; ++j) {
+          sum += weights[offset + j] * input[j];
+        }
+        output[i] = sum;
+#endif
+
+      }
+#if defined(USE_MMX)
+      _mm_empty();
+#endif
+
+#endif
+
+      return output;
+    }
+
+   private:
+    using BiasType = OutputType;
+    using WeightType = std::int8_t;
+
+    PreviousLayer previousLayer;
+
+    alignas(CacheLineSize) BiasType biases[OutputDimensions];
+    alignas(CacheLineSize) WeightType weights[OutputDimensions * PaddedInputDimensions];
+  };
+
+}  // namespace Stockfish::Eval::NNUE::Layers
+
+#endif // #ifndef NNUE_LAYERS_AFFINE_TRANSFORM_H_INCLUDED

Fairy-Stockfish-master/src/nnue/layers/clipped_relu.h

@@ -0,0 +1,191 @@
+/*
+  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 <http://www.gnu.org/licenses/>.
+*/
+
+// Definition of layer ClippedReLU of NNUE evaluation function
+
+#ifndef NNUE_LAYERS_CLIPPED_RELU_H_INCLUDED
+#define NNUE_LAYERS_CLIPPED_RELU_H_INCLUDED
+
+#include "../nnue_common.h"
+
+namespace Stockfish::Eval::NNUE::Layers {
+
+  // Clipped ReLU
+  template <typename PreviousLayer>
+  class ClippedReLU {
+   public:
+    // Input/output type
+    using InputType = typename PreviousLayer::OutputType;
+    using OutputType = std::uint8_t;
+    static_assert(std::is_same<InputType, std::int32_t>::value, "");
+
+    // Number of input/output dimensions
+    static constexpr IndexType InputDimensions =
+        PreviousLayer::OutputDimensions;
+    static constexpr IndexType OutputDimensions = InputDimensions;
+
+    // Size of forward propagation buffer used in this layer
+    static constexpr std::size_t SelfBufferSize =
+        ceil_to_multiple(OutputDimensions * sizeof(OutputType), CacheLineSize);
+
+    // Size of the forward propagation buffer used from the input layer to this layer
+    static constexpr std::size_t BufferSize =
+        PreviousLayer::BufferSize + SelfBufferSize;
+
+    // Hash value embedded in the evaluation file
+    static constexpr std::uint32_t get_hash_value() {
+      std::uint32_t hashValue = 0x538D24C7u;
+      hashValue += PreviousLayer::get_hash_value();
+      return hashValue;
+    }
+
+    // Read network parameters
+    bool read_parameters(std::istream& stream) {
+      return previousLayer.read_parameters(stream);
+    }
+
+    // Write network parameters
+    bool write_parameters(std::ostream& stream) const {
+      return previousLayer.write_parameters(stream);
+    }
+
+    // Forward propagation
+    const OutputType* propagate(
+        const TransformedFeatureType* transformedFeatures, char* buffer) const {
+      const auto input = previousLayer.propagate(
+          transformedFeatures, buffer + SelfBufferSize);
+      const auto output = reinterpret_cast<OutputType*>(buffer);
+
+  #if defined(USE_AVX2)
+      if constexpr (InputDimensions % SimdWidth == 0) {
+        constexpr IndexType NumChunks = InputDimensions / SimdWidth;
+        const __m256i Zero = _mm256_setzero_si256();
+        const __m256i Offsets = _mm256_set_epi32(7, 3, 6, 2, 5, 1, 4, 0);
+        const auto in = reinterpret_cast<const __m256i*>(input);
+        const auto out = reinterpret_cast<__m256i*>(output);
+        for (IndexType i = 0; i < NumChunks; ++i) {
+          const __m256i words0 = _mm256_srai_epi16(_mm256_packs_epi32(
+              _mm256_load_si256(&in[i * 4 + 0]),
+              _mm256_load_si256(&in[i * 4 + 1])), WeightScaleBits);
+          const __m256i words1 = _mm256_srai_epi16(_mm256_packs_epi32(
+              _mm256_load_si256(&in[i * 4 + 2]),
+              _mm256_load_si256(&in[i * 4 + 3])), WeightScaleBits);
+          _mm256_store_si256(&out[i], _mm256_permutevar8x32_epi32(_mm256_max_epi8(
+              _mm256_packs_epi16(words0, words1), Zero), Offsets));
+        }
+      } else {
+        constexpr IndexType NumChunks = InputDimensions / (SimdWidth / 2);
+        const __m128i Zero = _mm_setzero_si128();
+        const auto in = reinterpret_cast<const __m128i*>(input);
+        const auto out = reinterpret_cast<__m128i*>(output);
+        for (IndexType i = 0; i < NumChunks; ++i) {
+          const __m128i words0 = _mm_srai_epi16(_mm_packs_epi32(
+              _mm_load_si128(&in[i * 4 + 0]),
+              _mm_load_si128(&in[i * 4 + 1])), WeightScaleBits);
+          const __m128i words1 = _mm_srai_epi16(_mm_packs_epi32(
+              _mm_load_si128(&in[i * 4 + 2]),
+              _mm_load_si128(&in[i * 4 + 3])), WeightScaleBits);
+          const __m128i packedbytes = _mm_packs_epi16(words0, words1);
+          _mm_store_si128(&out[i], _mm_max_epi8(packedbytes, Zero));
+        }
+      }
+      constexpr IndexType Start =
+        InputDimensions % SimdWidth == 0
+        ? InputDimensions / SimdWidth * SimdWidth
+        : InputDimensions / (SimdWidth / 2) * (SimdWidth / 2);
+
+  #elif defined(USE_SSE2)
+      constexpr IndexType NumChunks = InputDimensions / SimdWidth;
+
+  #ifdef USE_SSE41
+      const __m128i Zero = _mm_setzero_si128();
+  #else
+      const __m128i k0x80s = _mm_set1_epi8(-128);
+  #endif
+
+      const auto in = reinterpret_cast<const __m128i*>(input);
+      const auto out = reinterpret_cast<__m128i*>(output);
+      for (IndexType i = 0; i < NumChunks; ++i) {
+        const __m128i words0 = _mm_srai_epi16(_mm_packs_epi32(
+            _mm_load_si128(&in[i * 4 + 0]),
+            _mm_load_si128(&in[i * 4 + 1])), WeightScaleBits);
+        const __m128i words1 = _mm_srai_epi16(_mm_packs_epi32(
+            _mm_load_si128(&in[i * 4 + 2]),
+            _mm_load_si128(&in[i * 4 + 3])), WeightScaleBits);
+        const __m128i packedbytes = _mm_packs_epi16(words0, words1);
+        _mm_store_si128(&out[i],
+
+  #ifdef USE_SSE41
+          _mm_max_epi8(packedbytes, Zero)
+  #else
+          _mm_subs_epi8(_mm_adds_epi8(packedbytes, k0x80s), k0x80s)
+  #endif
+
+        );
+      }
+      constexpr IndexType Start = NumChunks * SimdWidth;
+
+  #elif defined(USE_MMX)
+      constexpr IndexType NumChunks = InputDimensions / SimdWidth;
+      const __m64 k0x80s = _mm_set1_pi8(-128);
+      const auto in = reinterpret_cast<const __m64*>(input);
+      const auto out = reinterpret_cast<__m64*>(output);
+      for (IndexType i = 0; i < NumChunks; ++i) {
+        const __m64 words0 = _mm_srai_pi16(
+            _mm_packs_pi32(in[i * 4 + 0], in[i * 4 + 1]),
+            WeightScaleBits);
+        const __m64 words1 = _mm_srai_pi16(
+            _mm_packs_pi32(in[i * 4 + 2], in[i * 4 + 3]),
+            WeightScaleBits);
+        const __m64 packedbytes = _mm_packs_pi16(words0, words1);
+        out[i] = _mm_subs_pi8(_mm_adds_pi8(packedbytes, k0x80s), k0x80s);
+      }
+      _mm_empty();
+      constexpr IndexType Start = NumChunks * SimdWidth;
+
+  #elif defined(USE_NEON)
+      constexpr IndexType NumChunks = InputDimensions / (SimdWidth / 2);
+      const int8x8_t Zero = {0};
+      const auto in = reinterpret_cast<const int32x4_t*>(input);
+      const auto out = reinterpret_cast<int8x8_t*>(output);
+      for (IndexType i = 0; i < NumChunks; ++i) {
+        int16x8_t shifted;
+        const auto pack = reinterpret_cast<int16x4_t*>(&shifted);
+        pack[0] = vqshrn_n_s32(in[i * 2 + 0], WeightScaleBits);
+        pack[1] = vqshrn_n_s32(in[i * 2 + 1], WeightScaleBits);
+        out[i] = vmax_s8(vqmovn_s16(shifted), Zero);
+      }
+      constexpr IndexType Start = NumChunks * (SimdWidth / 2);
+  #else
+      constexpr IndexType Start = 0;
+  #endif
+
+      for (IndexType i = Start; i < InputDimensions; ++i) {
+        output[i] = static_cast<OutputType>(
+            std::max(0, std::min(127, input[i] >> WeightScaleBits)));
+      }
+      return output;
+    }
+
+   private:
+    PreviousLayer previousLayer;
+  };
+
+}  // namespace Stockfish::Eval::NNUE::Layers
+
+#endif // NNUE_LAYERS_CLIPPED_RELU_H_INCLUDED