Delete Fairy-Stockfish-master

Fairy-Stockfish-master/.gitattributes

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

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

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

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

@@ -1,13 +0,0 @@
-# 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

@@ -1,93 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

@@ -1,213 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,43 +0,0 @@
-# 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

@@ -1,158 +0,0 @@
-# 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

@@ -1,231 +0,0 @@
-# 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

@@ -1,674 +0,0 @@
-                    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

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

Fairy-Stockfish-master/README.md

@@ -1,126 +0,0 @@
-# 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

@@ -1,205 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,56 +0,0 @@
-# -*- 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

@@ -1,982 +0,0 @@
-# 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

@@ -1,95 +0,0 @@
-# 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

@@ -1,1165 +0,0 @@
-/*
-  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

@@ -1,195 +0,0 @@
-/*
-  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

@@ -1,177 +0,0 @@
-/*
-  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

@@ -1,501 +0,0 @@
-/*
-  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

@@ -1,787 +0,0 @@
-/*
-  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

@@ -1,1321 +0,0 @@
-/*
-  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

@@ -1,148 +0,0 @@
-/*
-  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

@@ -1,1736 +0,0 @@
-/*
-  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

@@ -1,66 +0,0 @@
-/*
-  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

@@ -1,767 +0,0 @@
-/*
-  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

@@ -1,26 +0,0 @@
-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

@@ -1,368 +0,0 @@
-/**
- * @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

@@ -1,1741 +0,0 @@
-/*
-  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

@@ -1,63 +0,0 @@
-/*
-  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

@@ -1,321 +0,0 @@
-/*
-  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

@@ -1,75 +0,0 @@
-/*
-  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

@@ -1,656 +0,0 @@
-/*
-  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

@@ -1,200 +0,0 @@
-/*
-  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

@@ -1,528 +0,0 @@
-/*
-  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

@@ -1,107 +0,0 @@
-/*
-  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

@@ -1,279 +0,0 @@
-/*
-  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

@@ -1,169 +0,0 @@
-/*
-  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

@@ -1,443 +0,0 @@
-/*
-  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

@@ -1,59 +0,0 @@
-/*
-  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

@@ -1,90 +0,0 @@
-/*
-  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

@@ -1,152 +0,0 @@
-/*
-  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

@@ -1,112 +0,0 @@
-/*
-  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

@@ -1,94 +0,0 @@
-/*
-  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

@@ -1,435 +0,0 @@
-/*
-  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

@@ -1,191 +0,0 @@
-/*
-  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