Stockfish 15.1

Official release version of Stockfish 15.1 Bench: 3467381 --- Today, we have the pleasure to announce Stockfish 15.1. As usual, downloads will be freely available at stockfishchess.org/download *Elo gain and competition results* With this release, version 5 of the NNUE neural net architecture has been introduced, and the training data has been extended to include Fischer random chess (FRC) positions. As a result, Elo gains are largest for FRC, reaching up to 50 Elo for doubly randomized FRC[1] (DFRC). More importantly, also for standard chess this release progressed and will win two times more game pairs than it loses[2] against Stockfish 15. Stockfish continues to win in a dominating way[3] all chess engine tournaments, including the TCEC Superfinal, Cup, FRC, DFRC, and Swiss as well as the CCC Bullet, Blitz, and Rapid events. *New evaluation* This release also introduces a new convention for the evaluation that is reported by search. An evaluation of +1 is now no longer tied to the value of one pawn, but to the likelihood of winning the game. With a +1 evaluation, Stockfish has now a 50% chance of winning the game against an equally strong opponent. This convention scales down evaluations a bit compared to Stockfish 15 and allows for consistent evaluations in the future. *ChessBase settlement* In this release period, the Stockfish team has successfully enforced its GPL license against ChessBase. This has been an intense process that included filing a lawsuit[4], a court hearing[5], and finally negotiating a settlement[6] that established that ChessBase infringed on the license by not distributing the Stockfish derivatives Fat Fritz 2 and Houdini 6 as free software, and that ensures ChessBase will respect the Free Software principles in the future. This settlement has been covered by major chess sites (see e.g. lichess.org[7] and chess.com[8]), and we are proud that it has been hailed as a ‘historic violation settlement[9]’ by the Software Freedom Conservancy. *Thank you* The Stockfish project builds on a thriving community of enthusiasts (thanks everybody!) that contribute their expertise, time, and resources to build a free and open-source chess engine that is robust, widely available, and very strong. We invite our chess fans to join the fishtest testing framework and programmers to contribute to the project[10]. The Stockfish team [1] https://tests.stockfishchess.org/tests/view/638a6170d2b9c924c4c62cb4 [2] https://tests.stockfishchess.org/tests/view/638a4dd7d2b9c924c4c6297b [3] https://en.wikipedia.org/wiki/Stockfish_(chess)#Competition_results [4] https://stockfishchess.org/blog/2021/our-lawsuit-against-chessbase/ [5] https://stockfishchess.org/blog/2022/public-court-hearing-soon/ [6] https://stockfishchess.org/blog/2022/chessbase-stockfish-agreement/ [7] https://lichess.org/blog/Y3u1mRAAACIApBVn/settlement-reached-in-stockfish-v-chessbase [8] https://www.chess.com/news/view/chessbase-stockfish-reach-settlement [9] https://sfconservancy.org/news/2022/nov/28/sfc-named-trusted-party-in-gpl-case/ [10] https://stockfishchess.org/get-involved/
Fix bestThread selection
2026-05-20 03:57:45 +00:00 · 2022-12-04 14:17:15 +01:00 · 2022-12-02 20:06:59 +01:00 · 2022-12-02 20:05:50 +01:00 · 2022-12-02 20:03:49 +01:00 · 2022-11-23 21:45:06 +01:00
38 changed files with 1612 additions and 1021 deletions
@@ -0,0 +1,65 @@
 name: Report issue
 description: Create a report to help us fix issues with the engine
 body:
 - type: textarea
  attributes:
    label: Describe the issue
    description: A clear and concise description of what you're experiencing.
  validations:
    required: true
 - type: textarea
  attributes:
    label: Expected behavior
    description: A clear and concise description of what you expected to happen.
  validations:
    required: true
 - type: textarea
  attributes:
    label: Steps to reproduce
    description: |
      Steps to reproduce the behavior.
      You can also use this section to paste the command line output.
    placeholder: |
      ```
      position startpos moves g2g4 e7e5 f2f3
      go mate 1
      info string NNUE evaluation using nn-6877cd24400e.nnue enabled
      info depth 1 seldepth 1 multipv 1 score mate 1 nodes 33 nps 11000 tbhits 0 time 3 pv d8h4
      bestmove d8h4
      ```
  validations:
    required: true
 - type: textarea
  attributes:
    label: Anything else?
    description: |
      Anything that will give us more context about the issue you are encountering.
      You can also use this section to propose ideas on how to solve the issue. 
  validations:
    required: false
 - type: dropdown
  attributes:
    label: Operating system
    options:
      - All
      - Windows
      - Linux
      - MacOS
      - Android
      - Other or N/A
  validations:
    required: true
 - type: input
  attributes:
    label: Stockfish version
    description: |
      This can be found by running the engine.
      You can also use the commit ID.
    placeholder: Stockfish 15 / e6e324e
  validations:
    required: true
@@ -0,0 +1,8 @@
 blank_issues_enabled: false
 contact_links:
  - name: Discord server
    url: https://discord.gg/GWDRS3kU6R
    about: Feel free to ask for support or have a chat with us in our Discord server!
  - name: Discussions, Q&A, ideas, show us something...
    url: https://github.com/official-stockfish/Stockfish/discussions/new
    about: Do you have an idea for Stockfish? Do you want to show something that you made? Please open a discussion about it!
@@ -5,329 +5,17 @@ on:
      - master
      - tools
      - github_ci
      - github_ci_armv7
  pull_request:
    branches:
      - master
      - tools
 jobs:
-  Stockfish:
+  Sanitizers:
-    name: ${{ matrix.config.name }}
+    uses: ./.github/workflows/stockfish_sanitizers.yml
-    runs-on: ${{ matrix.config.os }}
+  Tests:
-    env:
+    uses: ./.github/workflows/stockfish_test.yml
-      COMPILER: ${{ matrix.config.compiler }}
+  Compiles:
-      COMP: ${{ matrix.config.comp }}
+    uses: ./.github/workflows/stockfish_compile_test.yml
-      CXXFLAGS: "-Werror"
+  Binaries:
-    strategy:
+    if: github.ref == 'refs/heads/master'
-      matrix:
+    uses: ./.github/workflows/stockfish_binaries.yml
        config:
          # set the variable for the required tests:
          # run_expensive_tests: true
          # run_32bit_tests: true
          # run_64bit_tests: true
          # run_armv8_tests: true
          # run_armv7_tests: true
          - {
              name: "Ubuntu 20.04 GCC",
              os: ubuntu-20.04,
              compiler: g++,
              comp: gcc,
              run_expensive_tests: true,
              run_32bit_tests: true,
              run_64bit_tests: true,
              shell: 'bash {0}'
            }
          - {
              name: "Ubuntu 20.04 Clang",
              os: ubuntu-20.04,
              compiler: clang++,
              comp: clang,
              run_32bit_tests: true,
              run_64bit_tests: true,
              shell: 'bash {0}'
            }
          - {
              name: "Ubuntu 20.04 NDK armv8",
              os: ubuntu-20.04,
              compiler: aarch64-linux-android21-clang++,
              comp: ndk,
              run_armv8_tests: true,
              shell: 'bash {0}'
            }
          - {
              name: "Ubuntu 20.04 NDK armv7",
              os: ubuntu-20.04,
              compiler: armv7a-linux-androideabi21-clang++,
              comp: ndk,
              run_armv7_tests: true,
              shell: 'bash {0}'
            }
          - {
              name: "MacOS 10.15 Apple Clang",
              os: macos-10.15,
              compiler: clang++,
              comp: clang,
              run_64bit_tests: true,
              shell: 'bash {0}'
            }
          - {
              name: "MacOS 10.15 GCC 10",
              os: macos-10.15,
              compiler: g++-10,
              comp: gcc,
              run_64bit_tests: true,
              shell: 'bash {0}'
            }
          - {
              name: "Windows 2022 Mingw-w64 GCC x86_64",
              os: windows-2022,
              compiler: g++,
              comp: mingw,
              run_64bit_tests: true,
              msys_sys: 'mingw64',
              msys_env: 'x86_64-gcc',
              shell: 'msys2 {0}'
            }
          - {
              name: "Windows 2022 Mingw-w64 GCC i686",
              os: windows-2022,
              compiler: g++,
              comp: mingw,
              run_32bit_tests: true,
              msys_sys: 'mingw32',
              msys_env: 'i686-gcc',
              shell: 'msys2 {0}'
            }
          - {
              name: "Windows 2022 Mingw-w64 Clang x86_64",
              os: windows-2022,
              compiler: clang++,
              comp: clang,
              run_64bit_tests: true,
              msys_sys: 'clang64',
              msys_env: 'clang-x86_64-clang',
              shell: 'msys2 {0}'
            }
    defaults:
      run:
        working-directory: src
        shell: ${{ matrix.config.shell }}
    steps:
      - uses: actions/checkout@v2
        with:
          fetch-depth: 0
      - name: Download required linux packages
        if: runner.os == 'Linux'
        run: |
          sudo apt update
          sudo apt install expect valgrind g++-multilib qemu-user
      - name: Setup msys and install required packages
        if: runner.os == 'Windows'
        uses: msys2/setup-msys2@v2
        with:
          msystem: ${{matrix.config.msys_sys}}
          install: mingw-w64-${{matrix.config.msys_env}} make git expect
      - 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: |
          export PATH=$PATH:$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin
          $COMPILER -v
      - name: Test help target
        run: |
          make help
      # x86-32 tests
      - name: Test debug x86-32 build
        if: ${{ matrix.config.run_32bit_tests }}
        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 x86-32 build
        if: ${{ matrix.config.run_32bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-32 build
          ../tests/signature.sh $benchref
      - name: Test x86-32-sse41-popcnt build
        if: ${{ matrix.config.run_32bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-32-sse41-popcnt build
          ../tests/signature.sh $benchref
      - name: Test x86-32-sse2 build
        if: ${{ matrix.config.run_32bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-32-sse2 build
          ../tests/signature.sh $benchref
      - name: Test general-32 build
        if: ${{ matrix.config.run_32bit_tests }}
        run: |
          make clean
          make -j2 ARCH=general-32 build
          ../tests/signature.sh $benchref
      # x86-64 tests
      - name: Test debug x86-64-modern build
        if: ${{ matrix.config.run_64bit_tests }}
        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 x86-64-modern build
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64-modern build
          ../tests/signature.sh $benchref
      - name: Test x86-64-ssse3 build
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64-ssse3 build
          ../tests/signature.sh $benchref
      - name: Test x86-64-sse3-popcnt build
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64-sse3-popcnt build
          ../tests/signature.sh $benchref
      - name: Test x86-64 build
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64 build
          ../tests/signature.sh $benchref
      - name: Test general-64 build
        if: matrix.config.run_64bit_tests
        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
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64-avx2 build
      - name: Compile x86-64-bmi2 build
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64-bmi2 build
      - name: Compile x86-64-avx512 build
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64-avx512 build
      - name: Compile x86-64-vnni512 build
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64-vnni512 build
      - name: Compile x86-64-vnni256 build
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64-vnni256 build
      # armv8 tests
      - name: Test armv8 build
        if: ${{ matrix.config.run_armv8_tests }}
        run: |
          export PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin:$PATH
          export LDFLAGS="-static -Wno-unused-command-line-argument"
          make clean
          make -j2 ARCH=armv8 build
          ../tests/signature.sh $benchref
      # armv7 tests
      - name: Test armv7 build
        if: ${{ matrix.config.run_armv7_tests }}
        run: |
          export PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin:$PATH
          export LDFLAGS="-static -Wno-unused-command-line-argument"
          make clean
          make -j2 ARCH=armv7 build
          ../tests/signature.sh $benchref
      - name: Test armv7-neon build
        if: ${{ matrix.config.run_armv7_tests }}
        run: |
          export PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin:$PATH
          export LDFLAGS="-static -Wno-unused-command-line-argument"
          make clean
          make -j2 ARCH=armv7-neon build
          ../tests/signature.sh $benchref
      # Other tests
      - name: Check perft and search reproducibility
        if: ${{ matrix.config.run_64bit_tests }}
        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
@@ -0,0 +1,110 @@
 name: Stockfish
 on:
  workflow_call:
 jobs:
  Stockfish:
    name: ${{ matrix.config.name }} ${{ matrix.binaries }}
    runs-on: ${{ matrix.config.os }}
    env:
      COMPILER: ${{ matrix.config.compiler }}
      COMP: ${{ matrix.config.comp }}
      EXT: ${{ matrix.config.ext }}
      OS: ${{ matrix.config.os }}
      BINARY: ${{ matrix.binaries }}
    strategy:
      matrix:
        config:
          - {
              name: "Ubuntu 20.04 GCC",
              os: ubuntu-20.04,
              compiler: g++,
              comp: gcc,
              shell: 'bash {0}'
            }
          - {
              name: "MacOS 12 Apple Clang",
              os: macos-12,
              compiler: clang++,
              comp: clang,
              shell: 'bash {0}'
            }
          - {
              name: "Windows 2022 Mingw-w64 GCC x86_64",
              os: windows-2022,
              compiler: g++,
              comp: mingw,
              msys_sys: 'mingw64',
              msys_env: 'x86_64-gcc',
              shell: 'msys2 {0}',
              ext: .exe
            }
        binaries:
          - x86-64
          - x86-64-modern
          - x86-64-avx2
        exclude:
          - binaries: x86-64-avx2
            config: {os: macos-12}
    defaults:
      run:
        working-directory: src
        shell: ${{ matrix.config.shell }}
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0
      - name: Download required linux packages
        if: runner.os == 'Linux'
        run: |
          sudo apt update
      - name: Setup msys and install required packages
        if: runner.os == 'Windows'
        uses: msys2/setup-msys2@v2
        with:
          msystem: ${{matrix.config.msys_sys}}
          install: mingw-w64-${{matrix.config.msys_env}} make git expect
      - name: Download the used network from the fishtest framework
        run: |
          make net
      - name: Check compiler
        run: |
          export PATH=$PATH:$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin
          $COMPILER -v
      - name: Test help target
        run: |
          make help
      # Compile profile guided builds
      - name: Compile ${{ matrix.binaries }} build
        run: |
          make clean
          make -j2 profile-build ARCH=$BINARY COMP=$COMP
          strip ./stockfish$EXT
          mv ./stockfish$EXT ../stockfish-$OS-$BINARY$EXT
      - name: Remove non src files
        run: rm -f *.o .depend *.nnue
      - name: Create tar archive.
        run: |
          cd ..
          mkdir stockfish
          cp -r src stockfish/
          cp stockfish-$OS-$BINARY$EXT stockfish/
          cp "Top CPU Contributors.txt" stockfish/
          cp Copying.txt stockfish/
          cp AUTHORS stockfish/
          tar -cvf stockfish-$OS-$BINARY.tar stockfish
      - name: Upload binaries
        uses: actions/upload-artifact@v3
        with:
          name: stockfish-${{ matrix.config.os }}-${{ matrix.binaries }}
          path: |
            stockfish-${{ matrix.config.os }}-${{ matrix.binaries }}.tar
@@ -0,0 +1,115 @@
 name: Stockfish
 on:
  workflow_call:
 jobs:
  Stockfish:
    name: ${{ matrix.config.name }}
    runs-on: ${{ matrix.config.os }}
    env:
      COMPILER: ${{ matrix.config.compiler }}
      COMP: ${{ matrix.config.comp }}
    strategy:
      matrix:
        config:
          - {
              name: "Ubuntu 20.04 GCC",
              os: ubuntu-20.04,
              compiler: g++,
              comp: gcc,
              shell: 'bash {0}'
            }
          - {
              name: "Ubuntu 20.04 Clang",
              os: ubuntu-20.04,
              compiler: clang++,
              comp: clang,
              shell: 'bash {0}'
            }
          - {
              name: "MacOS 12 Apple Clang",
              os: macos-12,
              compiler: clang++,
              comp: clang,
              shell: 'bash {0}'
            }
          - {
              name: "MacOS 12 GCC 11",
              os: macos-12,
              compiler: g++-11,
              comp: gcc,
              shell: 'bash {0}'
            }
          - {
              name: "Windows 2022 Mingw-w64 GCC x86_64",
              os: windows-2022,
              compiler: g++,
              comp: mingw,
              msys_sys: 'mingw64',
              msys_env: 'x86_64-gcc',
              shell: 'msys2 {0}'
            }
          - {
              name: "Windows 2022 Mingw-w64 Clang x86_64",
              os: windows-2022,
              compiler: clang++,
              comp: clang,
              msys_sys: 'clang64',
              msys_env: 'clang-x86_64-clang',
              shell: 'msys2 {0}'
            }
    defaults:
      run:
        working-directory: src
        shell: ${{ matrix.config.shell }}
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0
      - name: Setup msys and install required packages
        if: runner.os == 'Windows'
        uses: msys2/setup-msys2@v2
        with:
          msystem: ${{matrix.config.msys_sys}}
          install: mingw-w64-${{matrix.config.msys_env}} make git expect
      - name: Download the used network from the fishtest framework
        run: |
          make net
      - name: Check compiler
        run: |
          export PATH=$PATH:$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin
          $COMPILER -v
      - name: Test help target
        run: |
          make help
      # 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
@@ -0,0 +1,77 @@
 name: Stockfish
 on:
  workflow_call:
 jobs:
  Stockfish:
    name: ${{ matrix.sanitizers.name }}
    runs-on: ${{ matrix.config.os }}
    env:
      COMPILER: ${{ matrix.config.compiler }}
      COMP: ${{ matrix.config.comp }}
      CXXFLAGS: "-Werror"
    strategy:
      matrix:
        config:
          - {
              name: "Ubuntu 20.04 GCC",
              os: ubuntu-20.04,
              compiler: g++,
              comp: gcc,
              shell: 'bash {0}'
            }
        sanitizers:
          - {
              name: Run with thread sanitizer,
              make_option: sanitize=thread,
              instrumented_option: sanitizer-thread
            }
          - {
              name: Run with UB sanitizer,
              make_option: sanitize=undefined,
              instrumented_option: sanitizer-undefined
            }
          - {
              name: Run under valgrind,
              make_option: "",
              instrumented_option: valgrind
            }
          - {
              name: Run under valgrind-thread,
              make_option: "",
              instrumented_option: valgrind-thread
            }
    defaults:
      run:
        working-directory: src
        shell: ${{ matrix.config.shell }}
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0
      - name: Download required linux packages
        run: |
          sudo apt update
          sudo apt install expect valgrind g++-multilib qemu-user
      - name: Download the used network from the fishtest framework
        run: |
          make net
      - name: Check compiler
        run: |
          export PATH=$PATH:$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin
          $COMPILER -v
      - name: Test help target
        run: |
          make help
      # Sanitizers
      - name: ${{ matrix.sanitizers.name }}
        run: |
          export CXXFLAGS="-O1 -fno-inline"
          make clean
          make -j2 ARCH=x86-64-modern ${{ matrix.sanitizers.make_option }} debug=yes optimize=no build > /dev/null
          ../tests/instrumented.sh --${{ matrix.sanitizers.instrumented_option }}
@@ -0,0 +1,284 @@
 name: Stockfish
 on:
  workflow_call:
 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 20.04 GCC",
              os: ubuntu-20.04,
              compiler: g++,
              comp: gcc,
              run_32bit_tests: true,
              run_64bit_tests: true,
              shell: 'bash {0}'
            }
          - {
              name: "Ubuntu 20.04 Clang",
              os: ubuntu-20.04,
              compiler: clang++,
              comp: clang,
              run_32bit_tests: true,
              run_64bit_tests: true,
              shell: 'bash {0}'
            }
          - {
              name: "Ubuntu 20.04 NDK armv8",
              os: ubuntu-20.04,
              compiler: aarch64-linux-android21-clang++,
              comp: ndk,
              run_armv8_tests: false,
              shell: 'bash {0}'
            }
          - {
              name: "Ubuntu 20.04 NDK armv7",
              os: ubuntu-20.04,
              compiler: armv7a-linux-androideabi21-clang++,
              comp: ndk,
              run_armv7_tests: false,
              shell: 'bash {0}'
            }
          - {
              name: "MacOS 12 Apple Clang",
              os: macos-12,
              compiler: clang++,
              comp: clang,
              run_64bit_tests: true,
              shell: 'bash {0}'
            }
          - {
              name: "MacOS 12 GCC 11",
              os: macos-12,
              compiler: g++-11,
              comp: gcc,
              run_64bit_tests: true,
              shell: 'bash {0}'
            }
          - {
              name: "Windows 2022 Mingw-w64 GCC x86_64",
              os: windows-2022,
              compiler: g++,
              comp: mingw,
              run_64bit_tests: true,
              msys_sys: 'mingw64',
              msys_env: 'x86_64-gcc',
              shell: 'msys2 {0}'
            }
          - {
              name: "Windows 2022 Mingw-w64 GCC i686",
              os: windows-2022,
              compiler: g++,
              comp: mingw,
              run_32bit_tests: true,
              msys_sys: 'mingw32',
              msys_env: 'i686-gcc',
              shell: 'msys2 {0}'
            }
          - {
              name: "Windows 2022 Mingw-w64 Clang x86_64",
              os: windows-2022,
              compiler: clang++,
              comp: clang,
              run_64bit_tests: true,
              msys_sys: 'clang64',
              msys_env: 'clang-x86_64-clang',
              shell: 'msys2 {0}'
            }
        exclude:
          - config: 
              {
                name: "Ubuntu 20.04 NDK armv7"
              }
          - config:
              {
                name: "Ubuntu 20.04 NDK armv8"
              }
    defaults:
      run:
        working-directory: src
        shell: ${{ matrix.config.shell }}
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0
      - name: Download required linux packages
        if: runner.os == 'Linux'
        run: |
          sudo apt update
          sudo apt install expect valgrind g++-multilib qemu-user
      - name: Setup msys and install required packages
        if: runner.os == 'Windows'
        uses: msys2/setup-msys2@v2
        with:
          msystem: ${{matrix.config.msys_sys}}
          install: mingw-w64-${{matrix.config.msys_env}} make git expect
      - 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: |
          export PATH=$PATH:$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin
          $COMPILER -v
      - name: Test help target
        run: |
          make help
      # x86-32 tests
      - name: Test debug x86-32 build
        if: ${{ matrix.config.run_32bit_tests }}
        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 x86-32 build
        if: ${{ matrix.config.run_32bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-32 build
          ../tests/signature.sh $benchref
      - name: Test x86-32-sse41-popcnt build
        if: ${{ matrix.config.run_32bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-32-sse41-popcnt build
          ../tests/signature.sh $benchref
      - name: Test x86-32-sse2 build
        if: ${{ matrix.config.run_32bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-32-sse2 build
          ../tests/signature.sh $benchref
      - name: Test general-32 build
        if: ${{ matrix.config.run_32bit_tests }}
        run: |
          make clean
          make -j2 ARCH=general-32 build
          ../tests/signature.sh $benchref
      # x86-64 tests
      - name: Test debug x86-64-modern build
        if: ${{ matrix.config.run_64bit_tests }}
        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 x86-64-modern build
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64-modern build
          ../tests/signature.sh $benchref
      - name: Test x86-64-ssse3 build
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64-ssse3 build
          ../tests/signature.sh $benchref
      - name: Test x86-64-sse3-popcnt build
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64-sse3-popcnt build
          ../tests/signature.sh $benchref
      - name: Test x86-64 build
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64 build
          ../tests/signature.sh $benchref
      - name: Test general-64 build
        if: matrix.config.run_64bit_tests
        run: |
          make clean
          make -j2 ARCH=general-64 build
          ../tests/signature.sh $benchref
      # armv8 tests
      - name: Test armv8 build
        if: ${{ matrix.config.run_armv8_tests }}
        run: |
          ANDROID_ROOT=/usr/local/lib/android
          ANDROID_SDK_ROOT=${ANDROID_ROOT}/sdk
          SDKMANAGER=${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager
          echo "y" | $SDKMANAGER "ndk;21.4.7075529"
          ANDROID_NDK_ROOT=${ANDROID_SDK_ROOT}/ndk-bundle
          ln -sfn $ANDROID_SDK_ROOT/ndk/21.4.7075529 $ANDROID_NDK_ROOT
          export PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin:$PATH
          export LDFLAGS="-static -Wno-unused-command-line-argument"
          make clean
          make -j2 ARCH=armv8 build
          ../tests/signature.sh $benchref
      # armv7 tests
      - name: Test armv7 build
        if: ${{ matrix.config.run_armv7_tests }}
        run: |
          ANDROID_ROOT=/usr/local/lib/android
          ANDROID_SDK_ROOT=${ANDROID_ROOT}/sdk
          SDKMANAGER=${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager
          echo "y" | $SDKMANAGER "ndk;21.4.7075529"
          ANDROID_NDK_ROOT=${ANDROID_SDK_ROOT}/ndk-bundle
          ln -sfn $ANDROID_SDK_ROOT/ndk/21.4.7075529 $ANDROID_NDK_ROOT
          export PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin:$PATH
          export LDFLAGS="-static -Wno-unused-command-line-argument"
          make clean
          make -j2 ARCH=armv7 build
          ../tests/signature.sh $benchref
      - name: Test armv7-neon build
        if: ${{ matrix.config.run_armv7_tests }}
        run: |
          ANDROID_ROOT=/usr/local/lib/android
          ANDROID_SDK_ROOT=${ANDROID_ROOT}/sdk
          SDKMANAGER=${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager
          echo "y" | $SDKMANAGER "ndk;21.4.7075529"
          ANDROID_NDK_ROOT=${ANDROID_SDK_ROOT}/ndk-bundle
          ln -sfn $ANDROID_SDK_ROOT/ndk/21.4.7075529 $ANDROID_NDK_ROOT
          export PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin:$PATH
          export LDFLAGS="-static -Wno-unused-command-line-argument"
          make clean
          make -j2 ARCH=armv7-neon build
          ../tests/signature.sh $benchref
      # Other tests
      - name: Check perft and search reproducibility
        if: ${{ matrix.config.run_64bit_tests }}
        run: |
          make clean
          make -j2 ARCH=x86-64-modern build
          ../tests/perft.sh
          ../tests/reprosearch.sh
@@ -35,19 +35,23 @@ Ben Chaney (Chaneybenjamini)
 Ben Koshy (BKSpurgeon)
 Bill Henry (VoyagerOne)
 Bojun Guo (noobpwnftw, Nooby)
 Boštjan Mejak (PedanticHacker)
 braich
 Brian Sheppard (SapphireBrand, briansheppard-toast)
 Bruno de Melo Costa (BM123499)
 Bruno Pellanda (pellanda)
 Bryan Cross (crossbr)
 candirufish
 Chess13234
 Chris Cain (ceebo)
 clefrks
 Dale Weiler (graphitemaster)
 Dan Schmidt (dfannius)
 Daniel Axtens (daxtens)
 Daniel Dugovic (ddugovic)
 Dariusz Orzechowski (dorzechowski)
 David Zar
 David (dav1312)
 Daylen Yang (daylen)
 Deshawn Mohan-Smith (GoldenRare)
 Dieter Dobbelaere (ddobbelaere)
@@ -55,6 +59,7 @@ DiscanX
 Dominik Schlösser (domschl)
 double-beep
 Douglas Matos Gomes (dsmsgms)
 Dubslow
 Eduardo Cáceres (eduherminio)
 Eelco de Groot (KingDefender)
 Elvin Liu (solarlight2)
@@ -86,7 +91,7 @@ Hongzhi Cheng
 Ivan Ivec (IIvec)
 Jacques B. (Timshel)
 Jan Ondruš (hxim)
-Jared Kish (Kurtbusch)
+Jared Kish (Kurtbusch, kurt22i)
 Jarrod Torriero (DU-jdto)
 Jean Gauthier (OuaisBla)
 Jean-Francois Romang (jromang)
@@ -125,6 +130,7 @@ marotear
 Matt Ginsberg (mattginsberg)
 Matthew Lai (matthewlai)
 Matthew Sullivan (Matt14916)
 Max A. (Disservin)
 Maxim Molchanov (Maxim)
 Michael An (man)
 Michael Byrne (MichaelB7)
@@ -155,7 +161,6 @@ Panthee
 Pascal Romaret
 Pasquale Pigazzini (ppigazzini)
 Patrick Jansen (mibere)
 pellanda
 Peter Schneider (pschneider1968)
 Peter Zsifkovits (CoffeeOne)
 Praveen Kumar Tummala (praveentml)
@@ -163,9 +168,10 @@ Rahul Dsilva (silversolver1)
 Ralph Stößer (Ralph Stoesser)
 Raminder Singh
 renouve
-Reuven Peleg
+Reuven Peleg (R-Peleg)
-Richard Lloyd
+Richard Lloyd (Richard-Lloyd)
 Rodrigo Exterckötter Tjäder
 Rodrigo Roim (roim)
 Ron Britvich (Britvich)
 Ronald de Man (syzygy1, syzygy)
 rqs
@@ -185,6 +191,7 @@ Stefan Geschwentner (locutus2)
 Stefano Cardanobile (Stefano80)
 Steinar Gunderson (sesse)
 Stéphane Nicolet (snicolet)
 Syine Mineta (MinetaS)
 Prokop Randáček (ProkopRandacek)
 Thanar2
 thaspel
@@ -1,48 +1,58 @@
 <div align="center">
  [![Stockfish][stockfish128-logo]][website-link]
  [![Build][build-badge]][build-link]
  [![License][license-badge]][license-link]
  <br>
  [![Release][release-badge]][release-link]
  [![Commits][commits-badge]][commits-link]
  <br>
  [![Website][website-badge]][website-link]
  [![Fishtest][fishtest-badge]][fishtest-link]
  [![Discord][discord-badge]][discord-link]
 </div>
 ## Overview
-[![Build Status](https://github.com/official-stockfish/Stockfish/actions/workflows/stockfish.yml/badge.svg)](https://github.com/official-stockfish/Stockfish/actions)
+[Stockfish][website-link] is a free, powerful UCI chess engine derived from
-[![Build Status](https://ci.appveyor.com/api/projects/status/github/official-stockfish/Stockfish?branch=master&svg=true)](https://ci.appveyor.com/project/mcostalba/stockfish/branch/master)
+Glaurung 2.1. Stockfish is not a complete chess program and requires a UCI-compatible
 graphical user interface (GUI) (e.g. XBoard with PolyGlot, Scid, Cute Chess, eboard,
 Arena, Sigma Chess, Shredder, Chess Partner or Fritz) in order to be used comfortably.
 Read the documentation for your GUI of choice for information about how to use
 Stockfish with it.
-[Stockfish](https://stockfishchess.org) is a free, powerful UCI chess engine
+The Stockfish engine features two evaluation functions for chess. The efficiently
 derived from Glaurung 2.1. Stockfish is not a complete chess program and requires a
 UCI-compatible graphical user interface (GUI) (e.g. XBoard with PolyGlot, Scid,
 Cute Chess, eboard, Arena, Sigma Chess, Shredder, Chess Partner or Fritz) in order
 to be used comfortably. Read the documentation for your GUI of choice for information
 about how to use Stockfish with it.
 The Stockfish engine features two evaluation functions for chess. The efficiently 
 updatable neural network (NNUE) based evaluation is the default and by far the strongest.
-The classical evaluation based on handcrafted terms remains available. The strongest 
+The classical evaluation based on handcrafted terms remains available. The strongest
 network is integrated in the binary and downloaded automatically during the build process.
-The NNUE evaluation benefits from the vector intrinsics available on most CPUs (sse2, 
+The NNUE evaluation benefits from the vector intrinsics available on most CPUs (sse2,
 avx2, neon, or similar).
 ## Files
 This distribution of Stockfish consists of the following files:
-  * [Readme.md](https://github.com/official-stockfish/Stockfish/blob/master/README.md),
+  * [README.md][readme-link], the file you are currently reading.
    the file you are currently reading.
-  * [Copying.txt](https://github.com/official-stockfish/Stockfish/blob/master/Copying.txt),
+  * [Copying.txt][license-link], a text file containing the GNU General Public License
-    a text file containing the GNU General Public License version 3.
+    version 3.
-  * [AUTHORS](https://github.com/official-stockfish/Stockfish/blob/master/AUTHORS), 
+  * [AUTHORS][authors-link], a text file with the list of authors for the project.
    a text file with the list of authors for the project
-  * [src](https://github.com/official-stockfish/Stockfish/tree/master/src),
+  * [src][src-link], a subdirectory containing the full source code, including a Makefile
    a subdirectory containing the full source code, including a Makefile
    that can be used to compile Stockfish on Unix-like systems.
-  * a file with the .nnue extension, storing the neural network for the NNUE
+  * a file with the .nnue extension, storing the neural network for the NNUE evaluation.
-    evaluation. Binary distributions will have this file embedded.
+    Binary distributions will have this file embedded.
 ## The UCI protocol and available options
 The Universal Chess Interface (UCI) is a standard protocol used to communicate with
 a chess engine, and is the recommended way to do so for typical graphical user interfaces
 (GUI) or chess tools. Stockfish implements the majority of its options as described
-in [the UCI protocol](https://www.shredderchess.com/download/div/uci.zip).
+in [the UCI protocol][uci-link].
 Developers can see the default values for UCI options available in Stockfish by typing
 `./stockfish uci` in a terminal, but the majority of users will typically see them and
@@ -142,8 +152,8 @@ change them via a chess GUI. This is a list of available UCI options in Stockfis
 For developers the following non-standard commands might be of interest, mainly useful for debugging:
  * #### bench *ttSize threads limit fenFile limitType evalType*
-    Performs a standard benchmark using various options. The signature of a version 
+    Performs a standard benchmark using various options. The signature of a version
-    (standard node count) is obtained using all defaults. `bench` is currently 
+    (standard node count) is obtained using all defaults. `bench` is currently
    `bench 16 1 13 default depth mixed`.
  * #### compiler
@@ -180,12 +190,10 @@ on the evaluations of millions of positions at moderate search depth.
 The NNUE evaluation was first introduced in shogi, and ported to Stockfish afterward.
 It can be evaluated efficiently on CPUs, and exploits the fact that only parts
 of the neural network need to be updated after a typical chess move.
-[The nodchip repository](https://github.com/nodchip/Stockfish) provided the first 
+[The nodchip repository][nodchip-link] provided the first version of the needed tools
-version of the needed tools to train and develop the NNUE networks. Today, more 
+to train and develop the NNUE networks. Today, more advanced training tools are
-advanced training tools are available in 
+available in [the nnue-pytorch repository][pytorch-link], while data generation tools
-[the nnue-pytorch repository](https://github.com/glinscott/nnue-pytorch/), 
+are available in [a dedicated branch][tools-link].
 while data generation tools are available in 
 [a dedicated branch](https://github.com/official-stockfish/Stockfish/tree/tools).
 On CPUs supporting modern vector instructions (avx2 and similar), the NNUE evaluation
 results in much stronger playing strength, even if the nodes per second computed by
@@ -193,9 +201,9 @@ the engine is somewhat lower (roughly 80% of nps is typical).
 Notes:
-1) the NNUE evaluation depends on the Stockfish binary and the network parameter file 
+1) the NNUE evaluation depends on the Stockfish binary and the network parameter file
 (see the EvalFile UCI option). Not every parameter file is compatible with a given
-Stockfish binary, but the default value of the EvalFile UCI option is the name of a 
+Stockfish binary, but the default value of the EvalFile UCI option is the name of a
 network that is guaranteed to be compatible with that binary.
 2) to use the NNUE evaluation, the additional data file with neural network parameters
@@ -251,8 +259,8 @@ are already enabled, and no configuration is needed.
 ### Support on Windows
 The use of large pages requires "Lock Pages in Memory" privilege. See
-[Enable the Lock Pages in Memory Option (Windows)](https://docs.microsoft.com/en-us/sql/database-engine/configure-windows/enable-the-lock-pages-in-memory-option-windows)
+[Enable the Lock Pages in Memory Option (Windows)][lockpages-link]
-on how to enable this privilege, then run [RAMMap](https://docs.microsoft.com/en-us/sysinternals/downloads/rammap)
+on how to enable this privilege, then run [RAMMap][rammap-link]
 to double-check that large pages are used. We suggest that you reboot
 your computer after you have enabled large pages, because long Windows
 sessions suffer from memory fragmentation, which may prevent Stockfish
@@ -295,26 +303,26 @@ effort. There are a few ways to help contribute to its growth.
 ### Donating hardware
 Improving Stockfish requires a massive amount of testing. You can donate
-your hardware resources by installing the [Fishtest Worker](https://github.com/glinscott/fishtest/wiki/Running-the-worker:-overview)
+your hardware resources by installing the [Fishtest Worker][worker-link]
-and view the current tests on [Fishtest](https://tests.stockfishchess.org/tests).
+and view the current tests on [Fishtest][fishtest-link].
 ### Improving the code
 If you want to help improve the code, there are several valuable resources:
-* [In this wiki,](https://www.chessprogramming.org) many techniques used in
+* [In this wiki,][programming-link] many techniques used in
 Stockfish are explained with a lot of background information.
-* [The section on Stockfish](https://www.chessprogramming.org/Stockfish)
+* [The section on Stockfish][programmingsf-link]
 describes many features and techniques used by Stockfish. However, it is
 generic rather than being focused on Stockfish's precise implementation.
 Nevertheless, a helpful resource.
-* The latest source can always be found on [GitHub](https://github.com/official-stockfish/Stockfish).
+* The latest source can always be found on [GitHub][github-link].
-Discussions about Stockfish take place these days mainly in the [FishCooking](https://groups.google.com/forum/#!forum/fishcooking)
+Discussions about Stockfish take place these days mainly in the [FishCooking][fishcooking-link]
-group and on the [Stockfish Discord channel](https://discord.gg/nv8gDtt).
+group and on the [Stockfish Discord channel][discord-link].
-The engine testing is done on [Fishtest](https://tests.stockfishchess.org/tests).
+The engine testing is done on [Fishtest][fishtest-link].
-If you want to help improve Stockfish, please read this [guideline](https://github.com/glinscott/fishtest/wiki/Creating-my-first-test)
+If you want to help improve Stockfish, please read this [guideline][guideline-link]
 first, where the basics of Stockfish development are explained.
@@ -329,9 +337,42 @@ using it as the starting point for a software project of your own.
 The only real limitation is that whenever you distribute Stockfish in
 some way, you MUST always include the license and the full source code
-(or a pointer to where the source code can be found) to generate the 
+(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 v3.
 For full details, read the copy of the GPL v3 found in the file named
-[*Copying.txt*](https://github.com/official-stockfish/Stockfish/blob/master/Copying.txt).
+[*Copying.txt*][license-link].
 [authors-link]:       https://github.com/official-stockfish/Stockfish/blob/master/AUTHORS
 [build-link]:         https://github.com/official-stockfish/Stockfish/actions/workflows/stockfish.yml
 [commits-link]:       https://github.com/official-stockfish/Stockfish/commits/master
 [discord-link]:       https://discord.gg/GWDRS3kU6R
 [fishcooking-link]:   https://groups.google.com/g/fishcooking
 [fishtest-link]:      https://tests.stockfishchess.org/tests
 [github-link]:        https://github.com/official-stockfish/Stockfish
 [guideline-link]:     https://github.com/glinscott/fishtest/wiki/Creating-my-first-test
 [license-link]:       https://github.com/official-stockfish/Stockfish/blob/master/Copying.txt
 [lockpages-link]:     https://docs.microsoft.com/en-us/sql/database-engine/configure-windows/enable-the-lock-pages-in-memory-option-windows
 [nodchip-link]:       https://github.com/nodchip/Stockfish
 [programming-link]:   https://www.chessprogramming.org/Main_Page
 [programmingsf-link]: https://www.chessprogramming.org/Stockfish
 [pytorch-link]:       https://github.com/glinscott/nnue-pytorch
 [rammap-link]:        https://docs.microsoft.com/en-us/sysinternals/downloads/rammap
 [readme-link]:        https://github.com/official-stockfish/Stockfish/blob/master/README.md
 [release-link]:       https://github.com/official-stockfish/Stockfish/releases/latest
 [src-link]:           https://github.com/official-stockfish/Stockfish/tree/master/src
 [stockfish128-logo]:  https://stockfishchess.org/images/logo/icon_128x128.png
 [tools-link]:         https://github.com/official-stockfish/Stockfish/tree/tools
 [uci-link]:           https://www.shredderchess.com/download/div/uci.zip
 [website-link]:       https://stockfishchess.org
 [worker-link]:        https://github.com/glinscott/fishtest/wiki/Running-the-worker:-overview
 [build-badge]:        https://img.shields.io/github/workflow/status/official-stockfish/Stockfish/Stockfish?style=for-the-badge&label=stockfish&logo=github
 [commits-badge]:      https://img.shields.io/github/commits-since/official-stockfish/Stockfish/latest?style=for-the-badge
 [discord-badge]:      https://img.shields.io/discord/435943710472011776?style=for-the-badge&label=discord&logo=Discord
 [fishtest-badge]:     https://img.shields.io/website?style=for-the-badge&down_color=red&down_message=Offline&label=Fishtest&up_color=success&up_message=Online&url=https%3A%2F%2Ftests.stockfishchess.org%2Ftests%2Ffinished
 [license-badge]:      https://img.shields.io/github/license/official-stockfish/Stockfish?style=for-the-badge&label=license&color=success
 [release-badge]:      https://img.shields.io/github/v/release/official-stockfish/Stockfish?style=for-the-badge&label=official%20release
 [website-badge]:      https://img.shields.io/website?style=for-the-badge&down_color=red&down_message=Offline&label=website&up_color=success&up_message=Online&url=https%3A%2F%2Fstockfishchess.org
@@ -1,235 +1,260 @@
-Contributors to Fishtest with >10,000 CPU hours, as of 2022-04-14.
+Contributors to Fishtest with >10,000 CPU hours, as of 2022-11-19.
 Thank you!
 Username                                CPU Hours     Games played
 ------------------------------------------------------------------
-noobpwnftw                               31714850       2267266129
+noobpwnftw                               36475307       2748033975
-mlang                                     2954099        198421098
+technologov                              14570711        760073590
-technologov                               2324150        102449398
+mlang                                     3026000        200065824
-dew                                       1670874         99276012
+dew                                       1689222        100034318
-grandphish2                               1134273         68070459
+grandphish2                               1442171         86798057
-okrout                                     901194         77738874
+okrout                                    1439985        133471766
-TueRens                                    821388         50207666
+pemo                                      1405374         44189811
-tvijlbrief                                 795993         51894442
+linrock                                   1299003         28382783
-pemo                                       744463         32486677
+TueRens                                   1163420         71159522
-JojoM                                      724378         43660674
+JojoM                                      897158         55177114
 tvijlbrief                                 796125         51897690
 mibere                                     703840         46867607
-linrock                                    626939         17408017
+gvreuls                                    635982         40652394
-gvreuls                                    534079         34352532
+oz                                         590763         41201352
-cw                                         507221         34006775
+sebastronomy                               581517         23307132
-fastgm                                     489749         29344518
+cw                                         517915         34865769
 fastgm                                     504266         30264740
 CSU_Dynasty                                479901         31846710
 ctoks                                      433503         28180725
 crunchy                                    427035         27344275
-CSU_Dynasty                                424643         28525220
+leszek                                     416883         27493447
-ctoks                                      415771         27364603
+bcross                                     409982         28062127
-oz                                         369200         27017658
+velislav                                   345954         22232274
 bcross                                     342642         23671289
 Fisherman                                  327231         21829379
-velislav                                   325670         20911076
+Dantist                                    296386         18031762
-leszek                                     321295         19874113
+mgrabiak                                   288928         18869896
-Dantist                                    274747         16910258
+rpngn                                      259965         16281463
-mgrabiak                                   237604         15418700
+robal                                      237653         15148350
-robal                                      217959         13840386
+ncfish1                                    231764         15275003
-glinscott                                  217799         13780820
+nordlandia                                 226923         14624832
-nordlandia                                 211692         13484886
+glinscott                                  208125         13277240
-drabel                                     201967         13798360
+drabel                                     204167         13930674
 mhoram                                     202894         12601997
 bking_US                                   198894         11876016
-mhoram                                     194862         12261809
+thirdlife                                  198844          5453268
 Thanar                                     179852         12365359
 vdv                                        175544          9904472
 armo9494                                   168201         11136452
 spams                                      157128         10319326
-rpngn                                      154081          9652139
+marrco                                     151599          9551115
 marrco                                     150300          9402229
 sqrt2                                      147963          9724586
-vdbergh                                    137430          8955097
+vdbergh                                    137690          8971569
 CoffeeOne                                  137100          5024116
 malala                                     136182          8002293
 DesolatedDodo                              135276          8657464
 xoto                                       133759          9159372
-davar                                      125240          8117121
+davar                                      129023          8376525
 dsmith                                     122059          7570238
-amicic                                     119659          7937885
+amicic                                     119661          7938029
 Data                                       113305          8220352
 BrunoBanani                                112960          7436849
-CypressChess                               108321          7759588
+CypressChess                               108331          7759788
-DesolatedDodo                              106811          6776980
+skiminki                                   106518          7062598
 MaZePallas                                 102823          6633619
 sterni1971                                 100532          5880772
 sunu                                       100167          7040199
 zeryl                                       99331          6221261
 ElbertoOne                                  99028          7023771
-skiminki                                    98123          6478402
+DMBK                                        97572          6950312
 Calis007                                    96779          5611552
 cuistot                                     93111          5536500
 brabos                                      92118          6186135
-cuistot                                     90358          5351004
+Wolfgang                                    91769          5720158
 psk                                         89957          5984901
-racerschmacer                               85712          6119648
+racerschmacer                               85805          6122790
 jcAEie                                      85527          5630616
 Vizvezdenec                                 83761          5344740
-zeryl                                       83680          5250995
+sschnee                                     83557          4853690
 sschnee                                     83003          4840890
 0x3C33                                      82614          5271253
 BRAVONE                                     81239          5054681
 Dubslow                                     78461          5042980
 nssy                                        76497          5259388
 jromang                                     76106          5236025
 teddybaer                                   75125          5407666
-jromang                                     74796          5175825
+yurikvelo                                   73933          5031096
 tolkki963                                   73885          4721430
 Pking_cda                                   73776          5293873
-Calis007                                    72477          4088576
+Bobo1239                                    71675          4860987
 solarlight                                  70517          5028306
 dv8silencer                                 70287          3883992
-Bobo1239                                    68515          4652287
+Gelma                                       69304          3980932
 manap                                       66273          4121774
-yurikvelo                                   65716          4457300
+megaman7de                                  65419          4120200
 markkulix                                   65331          4114860
 bigpen0r                                    64932          4683883
 tinker                                      64333          4268790
 Wolfgang                                    62644          3817410
 qurashee                                    61208          3429862
 AGI                                         58325          4258646
 robnjr                                      57262          4053117
 Freja                                       56938          3733019
 MaxKlaxxMiner                               56879          3423958
 ttruscott                                   56010          3680085
 rkl                                         55132          4164467
 renouve                                     53811          3501516
-megaman7de                                  52434          3243016
+Spprtr                                      52736          3410019
 MaxKlaxxMiner                               51977          3153032
 finfish                                     51360          3370515
 eva42                                       51272          3599691
-eastorwest                                  51058          3451555
+eastorwest                                  51117          3454811
 rap                                         49985          3219146
 unixwizard                                  49734          2536230
 pb00067                                     49727          3298270
 Spprtr                                      48920          3161711
 bigpen0r                                    47667          3336927
 ronaldjerum                                 47654          3240695
 biffhero                                    46564          3111352
 GPUex                                       45861          2926502
 Fifis                                       45843          3088497
 oryx                                        45578          3493978
 VoyagerOne                                  45476          3452465
 Wencey                                      44943          2654490
 speedycpu                                   43842          3003273
 jbwiebe                                     43305          2805433
 Antihistamine                               41788          2761312
 mhunt                                       41735          2691355
 olafm                                       41277          3284344
 homyur                                      39893          2850481
 gri                                         39871          2515779
-armo9494                                    39064          2832326
+MarcusTullius                               38303          2251097
-oryx                                        38867          2976992
+Garf                                        37741          2999686
 kdave                                       37424          2557406
 SC                                          37299          2731694
 Garf                                        37213          2986270
 tolkki963                                   37059          2154330
 csnodgrass                                  36207          2688994
 jmdana                                      36157          2210661
 strelock                                    34716          2074055
 DMBK                                        34010          2482916
 EthanOConnor                                33370          2090311
 slakovv                                     32915          2021889
-gopeto                                      30993          2028106
+gopeto                                      31669          2060958
 manapbk                                     30987          1810399
 Prcuvu                                      30377          2170122
 anst                                        30301          2190091
 jkiiski                                     30136          1904470
 spcc                                        30135          1903728
 hyperbolic.tom                              29840          2017394
 xwziegtm                                    29763          2347412
 chuckstablers                               29659          2093438
 Pyafue                                      29650          1902349
-ncfish1                                     29105          1704011
+belzedar94                                  28846          1811530
 belzedar94                                  27935          1789106
 OuaisBla                                    27636          1578800
 chriswk                                     26902          1868317
 achambord                                   26582          1767323
 Patrick_G                                   26276          1801617
 yorkman                                     26193          1992080
 Ulysses                                     25289          1674274
 SFTUser                                     25182          1675689
 nabildanial                                 24942          1519409
 Sharaf_DG                                   24765          1786697
-rodneyc                                     24275          1410450
+rodneyc                                     24376          1416402
 agg177                                      23890          1395014
 Ente                                        23747          1674582
 Karpovbot                                   23629          1313186
 JanErik                                     23408          1703875
 Isidor                                      23388          1680691
-Norabor                                     23339          1602636
+Norabor                                     23371          1603244
-Ente                                        23270          1651432
+cisco2015                                   22934          1763773
 cisco2015                                   22897          1762669
 MarcusTullius                               22688          1274821
 Zirie                                       22542          1472937
 team-oh                                     22272          1636708
 Roady                                       22220          1465606
 MazeOfGalious                               21978          1629593
-sg4032                                      21947          1643265
+sg4032                                      21947          1643353
 ianh2105                                    21725          1632562
 xor12                                       21628          1680365
 dex                                         21612          1467203
 nesoneg                                     21494          1463031
-Roady                                       21323          1433822
+user213718                                  21454          1404128
 AndreasKrug                                 21227          1577833
 sphinx                                      21211          1384728
 user213718                                  21196          1397710
 spcc                                        21065          1311338
 jjoshua2                                    21001          1423089
 horst.prack                                 20878          1465656
 jsys14                                      20729          1221010
 0xB00B1ES                                   20590          1208666
 j3corre                                     20405           941444
 kdave                                       20364          1389254
 Adrian.Schmidt123                           20316          1281436
-Ulysses                                     20217          1351500
+bonsi                                       20022          1300682
 markkulix                                   19976          1115258
 wei                                         19973          1745989
 dapper                                      19754          1167758
 Zake9298                                    19745          1458416
 fishtester                                  19617          1257388
 rstoesser                                   19569          1293588
 eudhan                                      19274          1283717
 fishtester                                  18995          1238686
 vulcan                                      18871          1729392
 Jopo12321                                   18803          1036284
 jundery                                     18445          1115855
 iisiraider                                  18247          1101015
 ville                                       17883          1384026
 5t0ckf15hTr4in3r                            17809          1105858
 chris                                       17698          1487385
 dju                                         17697           994333
 purplefishies                               17595          1092533
-dju                                         17353           978595
+iisiraider                                  17275          1049015
 Wencey                                      17125           805964
 DragonLord                                  17014          1162790
-thirdlife                                   16996           447356
+Karby                                       16457          1010138
 Goatminola                                  16278          1145026
 IgorLeMasson                                16064          1147232
 Gaster319                                   16056          1109070
 redstone59                                  15953          1161664
 scuzzi                                      15757           968735
 ako027ako                                   15671          1173203
 AndreasKrug                                 15550          1194497
 Nikolay.IT                                  15154          1068349
 Andrew Grant                                15114           895539
-scuzzi                                      14928           953313
+Naven94                                     15054           834762
 OssumOpossum                                14857          1007129
-Karby                                       14808           867120
+qoo_charly_cai                              14490           847865
 jsys14                                      14652           855642
 enedene                                     14476           905279
-bpfliegel                                   14298           884523
+szupaw                                      14252           929130
 bpfliegel                                   14233           882523
 mpx86                                       14019           759568
 jpulman                                     13982           870599
 crocogoat                                   13803          1117422
 joster                                      13794           950160
 Nesa92                                      13786          1114691
 joster                                      13710           946160
 mbeier                                      13650          1044928
 Hjax                                        13535           915487
 Dark_wizzie                                 13422          1007152
 Jopo12321                                   13367           678852
 Rudolphous                                  13244           883140
 Machariel                                   13010           863104
 infinigon                                   12991           943216
 pirt                                        12925           985437
 Skiff84                                     12923           649994
 mabichito                                   12903           749391
 thijsk                                      12886           722107
 AdrianSA                                    12860           804972
 infinigon                                   12807           937332
 Flopzee                                     12698           894821
 fatmurphy                                   12547           853210
 woutboat                                    12419           836696
 SapphireBrand                               12416           969604
 Oakwen                                      12406           840961
 deflectooor                                 12386           579392
 modolief                                    12386           896470
 Farseer                                     12249           694108
 pgontarz                                    12151           848794
 pirt                                        12008           923149
 stocky                                      11954           699440
 mschmidt                                    11941           803401
-dbernier                                    11609           818636
+MooTheCow                                   11871           773654
 Jackfish                                    11867           773550
 dbernier                                    11705           821780
 whelanh                                     11557           245188
 Maxim                                       11543           836024
 Nullvalue                                   11534           731410
 icewulf                                     11528           650470
 FormazChar                                  11523           861599
 infinity                                    11470           727027
-aga                                         11409           695071
+aga                                         11412           695127
 torbjo                                      11395           729145
 Thomas A. Anderson                          11372           732094
 savage84                                    11358           670860
-FormazChar                                  11349           850327
+ali-al-zhrani                               11272           781310
 d64                                         11263           789184
-MooTheCow                                   11237           720174
+Bourbaki                                    11108           709144
 snicolet                                    11106           869170
-ali-al-zhrani                               11098           768494
+Alb11747                                    10855           696920
 whelanh                                     11067           235676
 Jackfish                                    10978           720078
 deflectooor                                 10886           520116
 basepi                                      10637           744851
 Cubox                                       10621           826448
 Karmatron                                   10616           674818
 michaelrpg                                  10509           739239
 OIVAS7572                                   10420           995586
 Garruk                                      10348           704905
 dzjp                                        10343           732529
 Garruk                                      10334           704065
 ols                                         10259           570669
 lbraesch                                    10252           647825
 qoo_charly_cai                              10212           620407
 Naven94                                     10069           503192
@@ -116,7 +116,7 @@ ifeq ($(ARCH), $(filter $(ARCH), \
                 x86-64-vnni512 x86-64-vnni256 x86-64-avx512 x86-64-avxvnni x86-64-bmi2 \
                 x86-64-avx2 x86-64-sse41-popcnt x86-64-modern x86-64-ssse3 x86-64-sse3-popcnt \
                 x86-64 x86-32-sse41-popcnt x86-32-sse2 x86-32 ppc-64 ppc-32 e2k \
-                 armv7 armv7-neon armv8 apple-silicon general-64 general-32))
+                 armv7 armv7-neon armv8 apple-silicon general-64 general-32 riscv64))
   SUPPORTED_ARCH=true
 else
   SUPPORTED_ARCH=false
@@ -338,16 +338,26 @@ ifeq ($(findstring e2k,$(ARCH)),e2k)
 	popcnt = yes
 endif
 ifeq ($(ARCH),riscv64)
 	arch = riscv64
 endif
 endif
 ### ==========================================================================
 ### Section 3. Low-level Configuration
 ### ==========================================================================
 ### 3.1 Selecting compiler (default = gcc)
-CXXFLAGS += -Wall -Wcast-qual -fno-exceptions -std=c++17 $(EXTRACXXFLAGS)
+ifeq ($(MAKELEVEL),0)
-DEPENDFLAGS += -std=c++17
+       export ENV_CXXFLAGS := $(CXXFLAGS)
-LDFLAGS += $(EXTRALDFLAGS)
+       export ENV_DEPENDFLAGS := $(DEPENDFLAGS)
       export ENV_LDFLAGS := $(LDFLAGS)
 endif
 CXXFLAGS = $(ENV_CXXFLAGS) -Wall -Wcast-qual -fno-exceptions -std=c++17 $(EXTRACXXFLAGS)
 DEPENDFLAGS = $(ENV_DEPENDFLAGS) -std=c++17
 LDFLAGS = $(ENV_LDFLAGS) $(EXTRALDFLAGS)
 ifeq ($(COMP),)
 	COMP=gcc
@@ -358,11 +368,14 @@ ifeq ($(COMP),gcc)
 	CXX=g++
 	CXXFLAGS += -pedantic -Wextra -Wshadow
-	ifeq ($(arch),$(filter $(arch),armv7 armv8))
+	ifeq ($(arch),$(filter $(arch),armv7 armv8 riscv64))
 		ifeq ($(OS),Android)
 			CXXFLAGS += -m$(bits)
 			LDFLAGS += -m$(bits)
 		endif
 		ifeq ($(ARCH),riscv64)
 			CXXFLAGS += -latomic
 		endif
 	else
 		CXXFLAGS += -m$(bits)
 		LDFLAGS += -m$(bits)
@@ -423,11 +436,14 @@ ifeq ($(COMP),clang)
 	endif
 	endif
-	ifeq ($(arch),$(filter $(arch),armv7 armv8))
+	ifeq ($(arch),$(filter $(arch),armv7 armv8 riscv64))
 		ifeq ($(OS),Android)
 			CXXFLAGS += -m$(bits)
 			LDFLAGS += -m$(bits)
 		endif
 		ifeq ($(ARCH),riscv64)
 			CXXFLAGS += -latomic
 		endif
 	else
 		CXXFLAGS += -m$(bits)
 		LDFLAGS += -m$(bits)
@@ -542,17 +558,17 @@ ifeq ($(optimize),yes)
 		endif
 	endif
-    ifeq ($(KERNEL),Darwin)
+	ifeq ($(KERNEL),Darwin)
-        ifeq ($(comp),$(filter $(comp),clang icc))
+		ifeq ($(comp),$(filter $(comp),clang icc))
-            CXXFLAGS += -mdynamic-no-pic
+			CXXFLAGS += -mdynamic-no-pic
-        endif
+		endif
-        ifeq ($(comp),gcc)
+		ifeq ($(comp),gcc)
-            ifneq ($(arch),arm64)
+			ifneq ($(arch),arm64)
-                CXXFLAGS += -mdynamic-no-pic
+				CXXFLAGS += -mdynamic-no-pic
-            endif
+			endif
-        endif
+		endif
-    endif
+	endif
 	ifeq ($(comp),clang)
 		CXXFLAGS += -fexperimental-new-pass-manager
@@ -587,7 +603,7 @@ endif
 ifeq ($(avx2),yes)
 	CXXFLAGS += -DUSE_AVX2
 	ifeq ($(comp),$(filter $(comp),gcc clang mingw))
-		CXXFLAGS += -mavx2
+		CXXFLAGS += -mavx2 -mbmi
 	endif
 endif
@@ -666,13 +682,25 @@ ifeq ($(pext),yes)
 	endif
 endif
 ### 3.7.1 Try to include git commit sha for versioning
 GIT_SHA = $(shell git rev-parse --short HEAD 2>/dev/null)
 ifneq ($(GIT_SHA), )
 	CXXFLAGS += -DGIT_SHA=\"$(GIT_SHA)\"
 endif
 ### 3.7.2 Try to include git commit date for versioning
 GIT_DATE = $(shell git show -s --date=format:'%Y%m%d' --format=%cd HEAD 2>/dev/null)
 ifneq ($(GIT_DATE), )
 	CXXFLAGS += -DGIT_DATE=\"$(GIT_DATE)\"
 endif
 ### 3.8 Link Time Optimization
 ### This is a mix of compile and link time options because the lto link phase
 ### needs access to the optimization flags.
 ifeq ($(optimize),yes)
 ifeq ($(debug), no)
 	ifeq ($(comp),clang)
-		CXXFLAGS += -flto
+		CXXFLAGS += -flto=full
 		ifeq ($(target_windows),yes)
 			CXXFLAGS += -fuse-ld=lld
 		endif
@@ -682,21 +710,19 @@ ifeq ($(debug), no)
 # GCC on some systems.
 	else ifeq ($(comp),gcc)
 	ifeq ($(gccisclang),)
-		CXXFLAGS += -flto
+		CXXFLAGS += -flto -flto-partition=one
 		LDFLAGS += $(CXXFLAGS) -flto=jobserver
 	else
-		CXXFLAGS += -flto
+		CXXFLAGS += -flto=full
 		LDFLAGS += $(CXXFLAGS)
 	endif
 # To use LTO and static linking on Windows,
 # the tool chain requires gcc version 10.1 or later.
 	else ifeq ($(comp),mingw)
-	ifneq ($(arch),i386)
+		CXXFLAGS += -flto -flto-partition=one
 		CXXFLAGS += -flto
 		LDFLAGS += $(CXXFLAGS) -save-temps
 	endif
 	endif
 endif
 endif
@@ -753,6 +779,7 @@ help:
 	@echo "apple-silicon           > Apple silicon ARM64"
 	@echo "general-64              > unspecified 64-bit"
 	@echo "general-32              > unspecified 32-bit"
 	@echo "riscv64                 > RISC-V 64-bit"
 	@echo ""
 	@echo "Supported compilers:"
 	@echo ""
@@ -785,7 +812,7 @@ 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
+        clang-profile-use clang-profile-make FORCE
 build: net config-sanity
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
@@ -821,25 +848,35 @@ clean: objclean profileclean
 net:
 	$(eval nnuenet := $(shell grep EvalFileDefaultName evaluate.h | grep define | sed 's/.*\(nn-[a-z0-9]\{12\}.nnue\).*/\1/'))
 	@echo "Default net: $(nnuenet)"
-	$(eval nnuedownloadurl := https://tests.stockfishchess.org/api/nn/$(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 test -f "$(nnuenet)"; then \
+	@if [ "x$(curl_or_wget)" = "x" ]; then \
-            echo "Already available."; \
+	    echo "Automatic download failed: neither curl nor wget is installed. Install one of these tools or download the net manually"; exit 1; \
-         else \
+        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; \
            else \
               echo "Downloading $(nnuedownloadurl)"; $(curl_or_wget) $(nnuedownloadurl) > $(nnuenet);\
            fi; \
        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 \
+	@if [ "x$(shasum_command)" = "x" ]; then \
 	    if [ "$(nnuenet)" != "nn-"`$(shasum_command) $(nnuenet) | cut -c1-12`".nnue" ]; then \
                echo "Failed download or $(nnuenet) corrupted, please delete!"; exit 1; \
            fi \
         else \
            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:
@@ -902,7 +939,7 @@ config-sanity: net
 	@test "$(SUPPORTED_ARCH)" = "true"
 	@test "$(arch)" = "any" || test "$(arch)" = "x86_64" || test "$(arch)" = "i386" || \
 	 test "$(arch)" = "ppc64" || test "$(arch)" = "ppc" || test "$(arch)" = "e2k" || \
-	 test "$(arch)" = "armv7" || test "$(arch)" = "armv8" || test "$(arch)" = "arm64"
+	 test "$(arch)" = "armv7" || test "$(arch)" = "armv8" || test "$(arch)" = "arm64" || test "$(arch)" = "riscv64"
 	@test "$(bits)" = "32" || test "$(bits)" = "64"
 	@test "$(prefetch)" = "yes" || test "$(prefetch)" = "no"
 	@test "$(popcnt)" = "yes" || test "$(popcnt)" = "no"
@@ -923,6 +960,10 @@ config-sanity: net
 $(EXE): $(OBJS)
 	+$(CXX) -o $@ $(OBJS) $(LDFLAGS)
 # Force recompilation to ensure version info is up-to-date
 misc.o: FORCE
 FORCE:
 clang-profile-make:
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
 	EXTRACXXFLAGS='-fprofile-instr-generate ' \
@@ -159,7 +159,7 @@ namespace Trace {
  Score scores[TERM_NB][COLOR_NB];
-  double to_cp(Value v) { return double(v) / PawnValueEg; }
+  double to_cp(Value v) { return double(v) / UCI::NormalizeToPawnValue; }
  void add(int idx, Color c, Score s) {
    scores[idx][c] = s;
@@ -981,7 +981,7 @@ namespace {
    // 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() + me->imbalance() + pos.this_thread()->trend;
+    Score score = pos.psq_score() + me->imbalance();
    // Probe the pawn hash table
    pe = Pawns::probe(pos);
@@ -1042,74 +1042,46 @@ make_v:
    return v;
  }
  /// Fisher Random Chess: correction for cornered bishops, to fix chess960 play with NNUE
  Value fix_FRC(const Position& pos) {
    constexpr Bitboard Corners =  1ULL << SQ_A1 | 1ULL << SQ_H1 | 1ULL << SQ_A8 | 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 -= CorneredBishop;
    if (   pos.piece_on(SQ_H1) == W_BISHOP
        && pos.piece_on(SQ_G2) == W_PAWN)
        correction -= CorneredBishop;
    if (   pos.piece_on(SQ_A8) == B_BISHOP
        && pos.piece_on(SQ_B7) == B_PAWN)
        correction += CorneredBishop;
    if (   pos.piece_on(SQ_H8) == B_BISHOP
        && pos.piece_on(SQ_G7) == B_PAWN)
        correction += CorneredBishop;
    return pos.side_to_move() == WHITE ?  Value(3 * correction)
                                       : -Value(3 * 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 Eval::evaluate(const Position& pos, int* complexity) {
  Value v;
-  bool useClassical = false;
+  Value psq = pos.psq_eg_stm();
-  // Deciding between classical and NNUE eval (~10 Elo): for high PSQ imbalance we use classical,
+  // We use the much less accurate but faster Classical eval when the NNUE
-  // but we switch to NNUE during long shuffling or with high material on the board.
+  // option is set to false. Otherwise we use the NNUE eval unless the
-  if (  !useNNUE
+  // PSQ advantage is decisive and several pieces remain. (~3 Elo)
-      || ((pos.this_thread()->depth > 9 || pos.count<ALL_PIECES>() > 7) &&
+  bool useClassical = !useNNUE || (pos.count<ALL_PIECES>() > 7 && abs(psq) > 1760);
-          abs(eg_value(pos.psq_score())) * 5 > (856 + pos.non_pawn_material() / 64) * (10 + pos.rule50_count())))
+
  if (useClassical)
      v = Evaluation<NO_TRACE>(pos).value();
  else
  {
-      v = Evaluation<NO_TRACE>(pos).value();          // classical
+      int nnueComplexity;
-      useClassical = abs(v) >= 297;
+      int scale = 1064 + 106 * pos.non_pawn_material() / 5120;
  }
-  // If result of a classical evaluation is much lower than threshold fall back to NNUE
+      Color stm = pos.side_to_move();
-  if (useNNUE && !useClassical)
+      Value optimism = pos.this_thread()->optimism[stm];
  {
       Value nnue     = NNUE::evaluate(pos, true);     // NNUE
       int scale      = 1036 + 22 * pos.non_pawn_material() / 1024;
       Color stm      = pos.side_to_move();
       Value optimism = pos.this_thread()->optimism[stm];
       Value psq      = (stm == WHITE ? 1 : -1) * eg_value(pos.psq_score());
       int complexity = 35 * abs(nnue - psq) / 256;
-       optimism = optimism * (44 + complexity) / 31;
+      Value nnue = NNUE::evaluate(pos, true, &nnueComplexity);
       v = (nnue + optimism) * scale / 1024 - optimism;
-       if (pos.is_chess960())
+      // Blend nnue complexity with (semi)classical complexity
-           v += fix_FRC(pos);
+      nnueComplexity = (  416 * nnueComplexity
                        + 424 * abs(psq - nnue)
                        + (optimism  > 0 ? int(optimism) * int(psq - nnue) : 0)
                        ) / 1024;
      // Return hybrid NNUE complexity to caller
      if (complexity)
          *complexity = nnueComplexity;
      optimism = optimism * (269 + nnueComplexity) / 256;
      v = (nnue * scale + optimism * (scale - 754)) / 1024;
  }
  // Damp down the evaluation linearly when shuffling
@@ -1118,6 +1090,10 @@ Value Eval::evaluate(const Position& pos) {
  // 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);
  // When not using NNUE, return classical complexity to caller
  if (complexity && (!useNNUE || useClassical))
      *complexity = abs(v - psq);
  return v;
 }
@@ -1139,8 +1115,6 @@ std::string Eval::trace(Position& pos) {
  std::memset(scores, 0, sizeof(scores));
  // Reset any global variable used in eval
  pos.this_thread()->depth           = 0;
  pos.this_thread()->trend           = SCORE_ZERO;
  pos.this_thread()->bestValue       = VALUE_ZERO;
  pos.this_thread()->optimism[WHITE] = VALUE_ZERO;
  pos.this_thread()->optimism[BLACK] = VALUE_ZERO;
@@ -31,7 +31,7 @@ class Position;
 namespace Eval {
  std::string trace(Position& pos);
-  Value evaluate(const Position& pos);
+  Value evaluate(const Position& pos, int* complexity = nullptr);
  extern bool useNNUE;
  extern std::string currentEvalFileName;
@@ -39,12 +39,12 @@ namespace Eval {
  // 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-6877cd24400e.nnue"
+  #define EvalFileDefaultName   "nn-ad9b42354671.nnue"
  namespace NNUE {
    std::string trace(Position& pos);
-    Value evaluate(const Position& pos, bool adjusted = false);
+    Value evaluate(const Position& pos, bool adjusted = false, int* complexity = nullptr);
    void init();
    void verify();
@@ -67,9 +67,8 @@ namespace Stockfish {
 namespace {
-/// Version number. If Version is left empty, then compile date in the format
+/// Version number or dev.
-/// DD-MM-YY and show in engine_info.
+const string version = "15.1";
 const string Version = "15";
 /// 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
@@ -138,23 +137,41 @@ public:
 } // namespace
-/// engine_info() returns the full name of the current Stockfish version. This
+/// engine_info() returns the full name of the current Stockfish version.
-/// will be either "Stockfish <Tag> DD-MM-YY" (where DD-MM-YY is the date when
+/// For local dev compiles we try to append the commit sha and commit date
-/// the program was compiled) or "Stockfish <Version>", depending on whether
+/// from git if that fails only the local compilation date is set and "nogit" is specified:
-/// Version is empty.
+/// Stockfish dev-YYYYMMDD-SHA
 /// or
 /// Stockfish dev-YYYYMMDD-nogit
 ///
 /// For releases (non dev builds) we only include the version number:
 /// Stockfish version
 string engine_info(bool to_uci) {
  stringstream ss;
  ss << "Stockfish " << version << setfill('0');
-  const string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
+  if (version == "dev")
  string month, day, year;
  stringstream ss, date(__DATE__); // From compiler, format is "Sep 21 2008"
  ss << "Stockfish " << Version << setfill('0');
  if (Version.empty())
  {
      ss << "-";
      #ifdef GIT_DATE
      ss << GIT_DATE;
      #else
      const string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
      string month, day, year;
      stringstream date(__DATE__); // From compiler, format is "Sep 21 2008"
      date >> month >> day >> year;
-      ss << setw(2) << day << setw(2) << (1 + months.find(month) / 4) << year.substr(2);
+      ss << year << setw(2) << setfill('0') << (1 + months.find(month) / 4) << setw(2) << setfill('0') << day;
      #endif
      ss << "-";
      #ifdef GIT_SHA
      ss << GIT_SHA;
      #else
      ss << "nogit";
      #endif
  }
  ss << (to_uci  ? "\nid author ": " by ")
@@ -378,10 +395,9 @@ void std_aligned_free(void* ptr) {
 #if defined(_WIN32)
-static void* aligned_large_pages_alloc_windows(size_t allocSize) {
+static void* aligned_large_pages_alloc_windows([[maybe_unused]] size_t allocSize) {
  #if !defined(_WIN64)
    (void)allocSize; // suppress unused-parameter compiler warning
    return nullptr;
  #else
@@ -626,8 +642,7 @@ string argv0;            // path+name of the executable binary, as given by argv
 string binaryDirectory;  // path of the executable directory
 string workingDirectory; // path of the working directory
-void init(int argc, char* argv[]) {
+void init([[maybe_unused]] int argc, char* argv[]) {
    (void)argc;
    string pathSeparator;
    // extract the path+name of the executable binary
@@ -116,56 +116,16 @@ 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_; }
  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;
 };
 /// sigmoid(t, x0, y0, C, P, Q) implements a sigmoid-like function using only integers,
 /// with the following properties:
 ///
 ///  -  sigmoid is centered in (x0, y0)
 ///  -  sigmoid has amplitude [-P/Q , P/Q] instead of [-1 , +1]
 ///  -  limit is (y0 - P/Q) when t tends to -infinity
 ///  -  limit is (y0 + P/Q) when t tends to +infinity
 ///  -  the slope can be adjusted using C > 0, smaller C giving a steeper sigmoid
 ///  -  the slope of the sigmoid when t = x0 is P/(Q*C)
 ///  -  sigmoid is increasing with t when P > 0 and Q > 0
 ///  -  to get a decreasing sigmoid, change sign of P
 ///  -  mean value of the sigmoid is y0
 ///
 /// Use <https://www.desmos.com/calculator/jhh83sqq92> to draw the sigmoid
 inline int64_t sigmoid(int64_t t, int64_t x0,
                                  int64_t y0,
                                  int64_t  C,
                                  int64_t  P,
                                  int64_t  Q)
 {
   assert(C > 0);
   assert(Q != 0);
   return y0 + P * (t-x0) / (Q * (std::abs(t-x0) + C)) ;
 }
 /// xorshift64star Pseudo-Random Number Generator
 /// This class is based on original code written and dedicated
 /// to the public domain by Sebastiano Vigna (2014).
@@ -69,6 +69,7 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHist
  stage = (pos.checkers() ? EVASION_TT : MAIN_TT) +
          !(ttm && pos.pseudo_legal(ttm));
  threatenedPieces = 0;
 }
 /// MovePicker constructor for quiescence search
@@ -82,14 +83,13 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHist
  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, Depth d, const CapturePieceToHistory* cph)
+MovePicker::MovePicker(const Position& p, Move ttm, Value th, const CapturePieceToHistory* cph)
-           : pos(p), captureHistory(cph), ttMove(ttm), threshold(th), depth(d)
+           : pos(p), captureHistory(cph), ttMove(ttm), threshold(th)
 {
  assert(!pos.checkers());
@@ -106,29 +106,19 @@ void MovePicker::score() {
  static_assert(Type == CAPTURES || Type == QUIETS || Type == EVASIONS, "Wrong type");
-  Bitboard threatened, threatenedByPawn, threatenedByMinor, threatenedByRook;
+  [[maybe_unused]] Bitboard threatenedByPawn, threatenedByMinor, threatenedByRook;
  if constexpr (Type == QUIETS)
  {
      Color us = pos.side_to_move();
-      // squares threatened by pawns
+
      threatenedByPawn  = pos.attacks_by<PAWN>(~us);
      // squares threatened by minors or pawns
      threatenedByMinor = pos.attacks_by<KNIGHT>(~us) | pos.attacks_by<BISHOP>(~us) | threatenedByPawn;
      // squares threatened by rooks, minors or pawns
      threatenedByRook  = pos.attacks_by<ROOK>(~us) | threatenedByMinor;
-      // pieces threatened by pieces of lesser material value
+      // Pieces threatened by pieces of lesser material value
-      threatened =  (pos.pieces(us, QUEEN) & threatenedByRook)
+      threatenedPieces = (pos.pieces(us, QUEEN) & threatenedByRook)
-                  | (pos.pieces(us, ROOK)  & threatenedByMinor)
+                       | (pos.pieces(us, ROOK)  & threatenedByMinor)
-                  | (pos.pieces(us, KNIGHT, BISHOP) & threatenedByPawn);
+                       | (pos.pieces(us, KNIGHT, BISHOP) & threatenedByPawn);
  }
  else
  {
      // Silence unused variable warnings
      (void) threatened;
      (void) threatenedByPawn;
      (void) threatenedByMinor;
      (void) threatenedByRook;
  }
  for (auto& m : *this)
@@ -137,27 +127,27 @@ void MovePicker::score() {
                   +     (*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)]
+          m.value =  2 * (*mainHistory)[pos.side_to_move()][from_to(m)]
                   + 2 * (*continuationHistory[0])[pos.moved_piece(m)][to_sq(m)]
                   +     (*continuationHistory[1])[pos.moved_piece(m)][to_sq(m)]
                   +     (*continuationHistory[3])[pos.moved_piece(m)][to_sq(m)]
                   +     (*continuationHistory[5])[pos.moved_piece(m)][to_sq(m)]
-                   +     (threatened & from_sq(m) ?
+                   +     (threatenedPieces & from_sq(m) ?
                           (type_of(pos.moved_piece(m)) == QUEEN && !(to_sq(m) & threatenedByRook)  ? 50000
                          : type_of(pos.moved_piece(m)) == ROOK  && !(to_sq(m) & threatenedByMinor) ? 25000
                          :                                         !(to_sq(m) & threatenedByPawn)  ? 15000
                          :                                                                           0)
-                          :                                                                           0);
+                          :                                                                           0)
-
+                   +     bool(pos.check_squares(type_of(pos.moved_piece(m))) & to_sq(m)) * 16384;
      else // Type == EVASIONS
      {
          if (pos.capture(m))
              m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
-                       - Value(type_of(pos.moved_piece(m)));
+                       - Value(type_of(pos.moved_piece(m)))
                       + (1 << 28);
          else
-              m.value =      (*mainHistory)[pos.side_to_move()][from_to(m)]
+              m.value =  (*mainHistory)[pos.side_to_move()][from_to(m)]
-                       + 2 * (*continuationHistory[0])[pos.moved_piece(m)][to_sq(m)]
+                       + (*continuationHistory[0])[pos.moved_piece(m)][to_sq(m)];
                       - (1 << 28);
      }
 }
@@ -201,7 +191,7 @@ top:
      endMoves = generate<CAPTURES>(pos, cur);
      score<CAPTURES>();
-      partial_insertion_sort(cur, endMoves, -3000 * depth);
+      partial_insertion_sort(cur, endMoves, std::numeric_limits<int>::min());
      ++stage;
      goto top;
@@ -86,7 +86,8 @@ enum StatsType { NoCaptures, Captures };
 /// 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, 14365, COLOR_NB, int(SQUARE_NB) * int(SQUARE_NB)> ButterflyHistory;
+/// (~11 elo)
 typedef Stats<int16_t, 7183, COLOR_NB, int(SQUARE_NB) * int(SQUARE_NB)> ButterflyHistory;
 /// CounterMoveHistory stores counter moves indexed by [piece][to] of the previous
 /// move, see www.chessprogramming.org/Countermove_Heuristic
@@ -101,6 +102,7 @@ typedef Stats<int16_t, 29952, PIECE_NB, 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.
 /// (~63 elo)
 typedef Stats<PieceToHistory, NOT_USED, PIECE_NB, SQUARE_NB> ContinuationHistory;
@@ -126,9 +128,11 @@ public:
                                           const CapturePieceToHistory*,
                                           const PieceToHistory**,
                                           Square);
-  MovePicker(const Position&, Move, Value, Depth, const CapturePieceToHistory*);
+  MovePicker(const Position&, Move, Value, const CapturePieceToHistory*);
  Move next_move(bool skipQuiets = false);
  Bitboard threatenedPieces;
 private:
  template<PickType T, typename Pred> Move select(Pred);
  template<GenType> void score();
@@ -137,13 +137,13 @@ namespace Stockfish::Eval::NNUE {
  }
  // Evaluation function. Perform differential calculation.
-  Value evaluate(const Position& pos, bool adjusted) {
+  Value evaluate(const Position& pos, bool adjusted, int* complexity) {
    // 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;
-    int delta = 10 - pos.non_pawn_material() / 1515;
+    int delta = 24 - pos.non_pawn_material() / 9560;
 #if defined(ALIGNAS_ON_STACK_VARIABLES_BROKEN)
    TransformedFeatureType transformedFeaturesUnaligned[
@@ -161,9 +161,12 @@ namespace Stockfish::Eval::NNUE {
    const auto psqt = featureTransformer->transform(pos, transformedFeatures, bucket);
    const auto positional = network[bucket]->propagate(transformedFeatures);
    if (complexity)
        *complexity = abs(psqt - positional) / OutputScale;
    // Give more value to positional evaluation when adjusted flag is set
    if (adjusted)
-        return static_cast<Value>(((128 - delta) * psqt + (128 + delta) * positional) / 128 / OutputScale);
+        return static_cast<Value>(((1024 - delta) * psqt + (1024 + delta) * positional) / (1024 * OutputScale));
    else
        return static_cast<Value>((psqt + positional) / OutputScale);
  }
@@ -217,7 +220,7 @@ namespace Stockfish::Eval::NNUE {
    buffer[0] = (v < 0 ? '-' : v > 0 ? '+' : ' ');
-    int cp = std::abs(100 * v / PawnValueEg);
+    int cp = std::abs(100 * v / UCI::NormalizeToPawnValue);
    if (cp >= 10000)
    {
        buffer[1] = '0' + cp / 10000; cp %= 10000;
@@ -248,7 +251,7 @@ namespace Stockfish::Eval::NNUE {
    buffer[0] = (v < 0 ? '-' : v > 0 ? '+' : ' ');
-    double cp = 1.0 * std::abs(int(v)) / PawnValueEg;
+    double cp = 1.0 * std::abs(int(v)) / UCI::NormalizeToPawnValue;
    sprintf(&buffer[1], "%6.2f", cp);
  }
@@ -24,50 +24,51 @@
 namespace Stockfish::Eval::NNUE::Features {
  // Orient a square according to perspective (rotates by 180 for black)
  inline Square HalfKAv2_hm::orient(Color perspective, Square s, Square ksq) {
    return Square(int(s) ^ (bool(perspective) * SQ_A8) ^ ((file_of(ksq) < FILE_E) * SQ_H1));
  }
  // Index of a feature for a given king position and another piece on some square
-  inline IndexType HalfKAv2_hm::make_index(Color perspective, Square s, Piece pc, Square ksq) {
+  template<Color Perspective>
-    Square o_ksq = orient(perspective, ksq, ksq);
+  inline IndexType HalfKAv2_hm::make_index(Square s, Piece pc, Square ksq) {
-    return IndexType(orient(perspective, s, ksq) + PieceSquareIndex[perspective][pc] + PS_NB * KingBuckets[o_ksq]);
+    return IndexType((int(s) ^ OrientTBL[Perspective][ksq]) + PieceSquareIndex[Perspective][pc] + KingBuckets[Perspective][ksq]);
  }
  // Get a list of indices for active features
  template<Color Perspective>
  void HalfKAv2_hm::append_active_indices(
    const Position& pos,
    Color perspective,
    IndexList& active
  ) {
-    Square ksq = pos.square<KING>(perspective);
+    Square ksq = 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));
+      active.push_back(make_index<Perspective>(s, pos.piece_on(s), ksq));
    }
  }
  // Explicit template instantiations
  template void HalfKAv2_hm::append_active_indices<WHITE>(const Position& pos, IndexList& active);
  template void HalfKAv2_hm::append_active_indices<BLACK>(const Position& pos, IndexList& active);
  // append_changed_indices() : get a list of indices for recently changed features
-
+  template<Color Perspective>
  void HalfKAv2_hm::append_changed_indices(
    Square ksq,
    const DirtyPiece& dp,
    Color perspective,
    IndexList& removed,
    IndexList& added
  ) {
    for (int i = 0; i < dp.dirty_num; ++i) {
      if (dp.from[i] != SQ_NONE)
-        removed.push_back(make_index(perspective, dp.from[i], dp.piece[i], ksq));
+        removed.push_back(make_index<Perspective>(dp.from[i], dp.piece[i], ksq));
      if (dp.to[i] != SQ_NONE)
-        added.push_back(make_index(perspective, dp.to[i], dp.piece[i], ksq));
+        added.push_back(make_index<Perspective>(dp.to[i], dp.piece[i], ksq));
    }
  }
  // Explicit template instantiations
  template void HalfKAv2_hm::append_changed_indices<WHITE>(Square ksq, const DirtyPiece& dp, IndexList& removed, IndexList& added);
  template void HalfKAv2_hm::append_changed_indices<BLACK>(Square ksq, const DirtyPiece& dp, IndexList& removed, IndexList& added);
  int HalfKAv2_hm::update_cost(const StateInfo* st) {
    return st->dirtyPiece.dirty_num;
  }
@@ -49,8 +49,8 @@ namespace Stockfish::Eval::NNUE::Features {
      PS_B_ROOK   =  7 * SQUARE_NB,
      PS_W_QUEEN  =  8 * SQUARE_NB,
      PS_B_QUEEN  =  9 * SQUARE_NB,
-      PS_KING     =  10 * SQUARE_NB,
+      PS_KING     = 10 * SQUARE_NB,
-      PS_NB       =  11 * SQUARE_NB
+      PS_NB       = 11 * SQUARE_NB
    };
    static constexpr IndexType PieceSquareIndex[COLOR_NB][PIECE_NB] = {
@@ -62,11 +62,9 @@ namespace Stockfish::Eval::NNUE::Features {
        PS_NONE, PS_W_PAWN, PS_W_KNIGHT, PS_W_BISHOP, PS_W_ROOK, PS_W_QUEEN, PS_KING, PS_NONE }
    };
    // Orient a square according to perspective (rotates by 180 for black)
    static Square orient(Color perspective, Square s, Square ksq);
    // 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);
+    template<Color Perspective>
    static IndexType make_index(Square s, Piece pc, Square ksq);
   public:
    // Feature name
@@ -79,15 +77,45 @@ namespace Stockfish::Eval::NNUE::Features {
    static constexpr IndexType Dimensions =
        static_cast<IndexType>(SQUARE_NB) * static_cast<IndexType>(PS_NB) / 2;
-    static constexpr int KingBuckets[64] = {
+#define B(v) (v * PS_NB)
-      -1, -1, -1, -1, 31, 30, 29, 28,
+    static constexpr int KingBuckets[COLOR_NB][SQUARE_NB] = {
-      -1, -1, -1, -1, 27, 26, 25, 24,
+      { B(28), B(29), B(30), B(31), B(31), B(30), B(29), B(28),
-      -1, -1, -1, -1, 23, 22, 21, 20,
+        B(24), B(25), B(26), B(27), B(27), B(26), B(25), B(24),
-      -1, -1, -1, -1, 19, 18, 17, 16,
+        B(20), B(21), B(22), B(23), B(23), B(22), B(21), B(20),
-      -1, -1, -1, -1, 15, 14, 13, 12,
+        B(16), B(17), B(18), B(19), B(19), B(18), B(17), B(16),
-      -1, -1, -1, -1, 11, 10,  9,  8,
+        B(12), B(13), B(14), B(15), B(15), B(14), B(13), B(12),
-      -1, -1, -1, -1,  7,  6,  5,  4,
+        B( 8), B( 9), B(10), B(11), B(11), B(10), B( 9), B( 8),
-      -1, -1, -1, -1,  3,  2,  1,  0
+        B( 4), B( 5), B( 6), B( 7), B( 7), B( 6), B( 5), B( 4),
        B( 0), B( 1), B( 2), B( 3), B( 3), B( 2), B( 1), B( 0) },
      { B( 0), B( 1), B( 2), B( 3), B( 3), B( 2), B( 1), B( 0),
        B( 4), B( 5), B( 6), B( 7), B( 7), B( 6), B( 5), B( 4),
        B( 8), B( 9), B(10), B(11), B(11), B(10), B( 9), B( 8),
        B(12), B(13), B(14), B(15), B(15), B(14), B(13), B(12),
        B(16), B(17), B(18), B(19), B(19), B(18), B(17), B(16),
        B(20), B(21), B(22), B(23), B(23), B(22), B(21), B(20),
        B(24), B(25), B(26), B(27), B(27), B(26), B(25), B(24),
        B(28), B(29), B(30), B(31), B(31), B(30), B(29), B(28) }
    };
 #undef B
    // Orient a square according to perspective (rotates by 180 for black)
    static constexpr int OrientTBL[COLOR_NB][SQUARE_NB] = {
      { SQ_H1, SQ_H1, SQ_H1, SQ_H1, SQ_A1, SQ_A1, SQ_A1, SQ_A1,
        SQ_H1, SQ_H1, SQ_H1, SQ_H1, SQ_A1, SQ_A1, SQ_A1, SQ_A1,
        SQ_H1, SQ_H1, SQ_H1, SQ_H1, SQ_A1, SQ_A1, SQ_A1, SQ_A1,
        SQ_H1, SQ_H1, SQ_H1, SQ_H1, SQ_A1, SQ_A1, SQ_A1, SQ_A1,
        SQ_H1, SQ_H1, SQ_H1, SQ_H1, SQ_A1, SQ_A1, SQ_A1, SQ_A1,
        SQ_H1, SQ_H1, SQ_H1, SQ_H1, SQ_A1, SQ_A1, SQ_A1, SQ_A1,
        SQ_H1, SQ_H1, SQ_H1, SQ_H1, SQ_A1, SQ_A1, SQ_A1, SQ_A1,
        SQ_H1, SQ_H1, SQ_H1, SQ_H1, SQ_A1, SQ_A1, SQ_A1, SQ_A1 },
      { SQ_H8, SQ_H8, SQ_H8, SQ_H8, SQ_A8, SQ_A8, SQ_A8, SQ_A8,
        SQ_H8, SQ_H8, SQ_H8, SQ_H8, SQ_A8, SQ_A8, SQ_A8, SQ_A8,
        SQ_H8, SQ_H8, SQ_H8, SQ_H8, SQ_A8, SQ_A8, SQ_A8, SQ_A8,
        SQ_H8, SQ_H8, SQ_H8, SQ_H8, SQ_A8, SQ_A8, SQ_A8, SQ_A8,
        SQ_H8, SQ_H8, SQ_H8, SQ_H8, SQ_A8, SQ_A8, SQ_A8, SQ_A8,
        SQ_H8, SQ_H8, SQ_H8, SQ_H8, SQ_A8, SQ_A8, SQ_A8, SQ_A8,
        SQ_H8, SQ_H8, SQ_H8, SQ_H8, SQ_A8, SQ_A8, SQ_A8, SQ_A8,
        SQ_H8, SQ_H8, SQ_H8, SQ_H8, SQ_A8, SQ_A8, SQ_A8, SQ_A8 }
    };
    // Maximum number of simultaneously active features.
@@ -95,16 +123,16 @@ namespace Stockfish::Eval::NNUE::Features {
    using IndexList = ValueList<IndexType, MaxActiveDimensions>;
    // Get a list of indices for active features
    template<Color Perspective>
    static void append_active_indices(
      const Position& pos,
      Color perspective,
      IndexList& active);
    // Get a list of indices for recently changed features
    template<Color Perspective>
    static void append_changed_indices(
      Square ksq,
      const DirtyPiece& dp,
      Color perspective,
      IndexList& removed,
      IndexList& added
    );
@@ -25,7 +25,7 @@
 #include <algorithm>
 #include <type_traits>
 #include "../nnue_common.h"
-#include "../../simd.h"
+#include "simd.h"
 /*
  This file contains the definition for a fully connected layer (aka affine transform).
@@ -151,9 +151,15 @@ namespace Stockfish::Eval::NNUE::Layers {
  template <IndexType InDims, IndexType OutDims, typename Enabled = void>
  class AffineTransform;
 #if defined (USE_AVX512)
  constexpr IndexType LargeInputSize = 2 * 64;
 #else
  constexpr IndexType LargeInputSize = std::numeric_limits<IndexType>::max();
 #endif
  // A specialization for large inputs.
  template <IndexType InDims, IndexType OutDims>
-  class AffineTransform<InDims, OutDims, std::enable_if_t<(ceil_to_multiple<IndexType>(InDims, MaxSimdWidth) >= 2*64)>> {
+  class AffineTransform<InDims, OutDims, std::enable_if_t<(ceil_to_multiple<IndexType>(InDims, MaxSimdWidth) >= LargeInputSize)>> {
   public:
    // Input/output type
    using InputType = std::uint8_t;
@@ -170,7 +176,7 @@ namespace Stockfish::Eval::NNUE::Layers {
    using OutputBuffer = OutputType[PaddedOutputDimensions];
-    static_assert(PaddedInputDimensions >= 128, "Something went wrong. This specialization should not have been chosen.");
+    static_assert(PaddedInputDimensions >= LargeInputSize, "Something went wrong. This specialization should not have been chosen.");
 #if defined (USE_AVX512)
    static constexpr const IndexType InputSimdWidth = 64;
@@ -369,7 +375,7 @@ namespace Stockfish::Eval::NNUE::Layers {
  };
  template <IndexType InDims, IndexType OutDims>
-  class AffineTransform<InDims, OutDims, std::enable_if_t<(ceil_to_multiple<IndexType>(InDims, MaxSimdWidth) < 2*64)>> {
+  class AffineTransform<InDims, OutDims, std::enable_if_t<(ceil_to_multiple<IndexType>(InDims, MaxSimdWidth) < LargeInputSize)>> {
   public:
    // Input/output type
    // Input/output type
@@ -387,7 +393,7 @@ namespace Stockfish::Eval::NNUE::Layers {
    using OutputBuffer = OutputType[PaddedOutputDimensions];
-    static_assert(PaddedInputDimensions < 128, "Something went wrong. This specialization should not have been chosen.");
+    static_assert(PaddedInputDimensions < LargeInputSize, "Something went wrong. This specialization should not have been chosen.");
 #if defined (USE_SSSE3)
    static constexpr const IndexType OutputSimdWidth = SimdWidth / 4;
@@ -0,0 +1,120 @@
 /*
  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_SQR_CLIPPED_RELU_H_INCLUDED
 #define NNUE_LAYERS_SQR_CLIPPED_RELU_H_INCLUDED
 #include "../nnue_common.h"
 namespace Stockfish::Eval::NNUE::Layers {
  // Clipped ReLU
  template <IndexType InDims>
  class SqrClippedReLU {
   public:
    // Input/output type
    using InputType = std::int32_t;
    using OutputType = std::uint8_t;
    // Number of input/output dimensions
    static constexpr IndexType InputDimensions = InDims;
    static constexpr IndexType OutputDimensions = InputDimensions;
    static constexpr IndexType PaddedOutputDimensions =
        ceil_to_multiple<IndexType>(OutputDimensions, 32);
    using OutputBuffer = OutputType[PaddedOutputDimensions];
    // Hash value embedded in the evaluation file
    static constexpr std::uint32_t get_hash_value(std::uint32_t prevHash) {
      std::uint32_t hashValue = 0x538D24C7u;
      hashValue += prevHash;
      return hashValue;
    }
    // Read network parameters
    bool read_parameters(std::istream&) {
      return true;
    }
    // Write network parameters
    bool write_parameters(std::ostream&) const {
      return true;
    }
    // Forward propagation
    const OutputType* propagate(
        const InputType* input, OutputType* output) const {
  #if defined(USE_SSE2)
      constexpr IndexType NumChunks = InputDimensions / 16;
  #ifdef USE_SSE41
      const __m128i Zero = _mm_setzero_si128();
  #else
      const __m128i k0x80s = _mm_set1_epi8(-128);
  #endif
      static_assert(WeightScaleBits == 6);
      const auto in = reinterpret_cast<const __m128i*>(input);
      const auto out = reinterpret_cast<__m128i*>(output);
      for (IndexType i = 0; i < NumChunks; ++i) {
        __m128i words0 = _mm_packs_epi32(
            _mm_load_si128(&in[i * 4 + 0]),
            _mm_load_si128(&in[i * 4 + 1]));
        __m128i words1 = _mm_packs_epi32(
            _mm_load_si128(&in[i * 4 + 2]),
            _mm_load_si128(&in[i * 4 + 3]));
        // Not sure if
        words0 = _mm_srli_epi16(_mm_mulhi_epi16(words0, words0), 3);
        words1 = _mm_srli_epi16(_mm_mulhi_epi16(words1, words1), 3);
        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 * 16;
  #else
      constexpr IndexType Start = 0;
  #endif
      for (IndexType i = Start; i < InputDimensions; ++i) {
        output[i] = static_cast<OutputType>(
            // realy should be /127 but we need to make it fast
            // needs to be accounted for in the trainer
            std::max(0ll, std::min(127ll, (((long long)input[i] * input[i]) >> (2 * WeightScaleBits)) / 128)));
      }
      return output;
    }
  };
 }  // namespace Stockfish::Eval::NNUE::Layers
 #endif // NNUE_LAYERS_SQR_CLIPPED_RELU_H_INCLUDED
@@ -29,6 +29,7 @@
 #include "layers/affine_transform.h"
 #include "layers/clipped_relu.h"
 #include "layers/sqr_clipped_relu.h"
 #include "../misc.h"
@@ -48,8 +49,9 @@ struct Network
  static constexpr int FC_1_OUTPUTS = 32;
  Layers::AffineTransform<TransformedFeatureDimensions, FC_0_OUTPUTS + 1> fc_0;
  Layers::SqrClippedReLU<FC_0_OUTPUTS + 1> ac_sqr_0;
  Layers::ClippedReLU<FC_0_OUTPUTS + 1> ac_0;
-  Layers::AffineTransform<FC_0_OUTPUTS, FC_1_OUTPUTS> fc_1;
+  Layers::AffineTransform<FC_0_OUTPUTS * 2, FC_1_OUTPUTS> fc_1;
  Layers::ClippedReLU<FC_1_OUTPUTS> ac_1;
  Layers::AffineTransform<FC_1_OUTPUTS, 1> fc_2;
@@ -93,6 +95,7 @@ struct Network
    struct alignas(CacheLineSize) Buffer
    {
      alignas(CacheLineSize) decltype(fc_0)::OutputBuffer fc_0_out;
      alignas(CacheLineSize) decltype(ac_sqr_0)::OutputType ac_sqr_0_out[ceil_to_multiple<IndexType>(FC_0_OUTPUTS * 2, 32)];
      alignas(CacheLineSize) decltype(ac_0)::OutputBuffer ac_0_out;
      alignas(CacheLineSize) decltype(fc_1)::OutputBuffer fc_1_out;
      alignas(CacheLineSize) decltype(ac_1)::OutputBuffer ac_1_out;
@@ -114,8 +117,10 @@ struct Network
 #endif
    fc_0.propagate(transformedFeatures, buffer.fc_0_out);
    ac_sqr_0.propagate(buffer.fc_0_out, buffer.ac_sqr_0_out);
    ac_0.propagate(buffer.fc_0_out, buffer.ac_0_out);
-    fc_1.propagate(buffer.ac_0_out, buffer.fc_1_out);
+    std::memcpy(buffer.ac_sqr_0_out + FC_0_OUTPUTS, buffer.ac_0_out, FC_0_OUTPUTS * sizeof(decltype(ac_0)::OutputType));
    fc_1.propagate(buffer.ac_sqr_0_out, buffer.fc_1_out);
    ac_1.propagate(buffer.fc_1_out, buffer.ac_1_out);
    fc_2.propagate(buffer.ac_1_out, buffer.fc_2_out);
@@ -120,12 +120,12 @@ namespace Stockfish::Eval::NNUE {
  #define vec_zero() _mm_setzero_si64()
  #define vec_set_16(a) _mm_set1_pi16(a)
  inline vec_t vec_max_16(vec_t a,vec_t b){
-      vec_t comparison = _mm_cmpgt_pi16(a,b);
+    vec_t comparison = _mm_cmpgt_pi16(a,b);
-      return _mm_or_si64(_mm_and_si64(comparison, a), _mm_andnot_si64(comparison, b));
+    return _mm_or_si64(_mm_and_si64(comparison, a), _mm_andnot_si64(comparison, b));
  }
  inline vec_t vec_min_16(vec_t a,vec_t b){
-      vec_t comparison = _mm_cmpgt_pi16(a,b);
+    vec_t comparison = _mm_cmpgt_pi16(a,b);
-      return _mm_or_si64(_mm_and_si64(comparison, b), _mm_andnot_si64(comparison, a));
+    return _mm_or_si64(_mm_and_si64(comparison, b), _mm_andnot_si64(comparison, a));
  }
  #define vec_msb_pack_16(a,b) _mm_packs_pi16(_mm_srli_pi16(a,7),_mm_srli_pi16(b,7))
  #define vec_load_psqt(a) (*(a))
@@ -150,10 +150,10 @@ namespace Stockfish::Eval::NNUE {
  #define vec_max_16(a,b) vmaxq_s16(a,b)
  #define vec_min_16(a,b) vminq_s16(a,b)
  inline vec_t vec_msb_pack_16(vec_t a, vec_t b){
-        const int8x8_t shifta = vshrn_n_s16(a, 7);
+    const int8x8_t shifta = vshrn_n_s16(a, 7);
-        const int8x8_t shiftb = vshrn_n_s16(b, 7);
+    const int8x8_t shiftb = vshrn_n_s16(b, 7);
-	const int8x16_t compacted = vcombine_s8(shifta,shiftb);
+    const int8x16_t compacted = vcombine_s8(shifta,shiftb);
-	return *reinterpret_cast<const vec_t*> (&compacted);
+    return *reinterpret_cast<const vec_t*> (&compacted);
  }
  #define vec_load_psqt(a) (*(a))
  #define vec_store_psqt(a,b) *(a)=(b)
@@ -271,8 +271,8 @@ namespace Stockfish::Eval::NNUE {
    // Convert input features
    std::int32_t transform(const Position& pos, OutputType* output, int bucket) const {
-      update_accumulator(pos, WHITE);
+      update_accumulator<WHITE>(pos);
-      update_accumulator(pos, BLACK);
+      update_accumulator<BLACK>(pos);
      const Color perspectives[2] = {pos.side_to_move(), ~pos.side_to_move()};
      const auto& accumulation = pos.state()->accumulator.accumulation;
@@ -290,7 +290,7 @@ namespace Stockfish::Eval::NNUE {
 #if defined(VECTOR)
-	  constexpr IndexType OutputChunkSize = MaxChunkSize;
+          constexpr IndexType OutputChunkSize = MaxChunkSize;
          static_assert((HalfDimensions / 2) % OutputChunkSize == 0);
          constexpr IndexType NumOutputChunks = HalfDimensions / 2 / OutputChunkSize;
@@ -338,7 +338,8 @@ namespace Stockfish::Eval::NNUE {
   private:
-    void update_accumulator(const Position& pos, const Color perspective) const {
+    template<Color Perspective>
    void update_accumulator(const Position& pos) const {
      // The size must be enough to contain the largest possible update.
      // That might depend on the feature set and generally relies on the
@@ -356,18 +357,18 @@ namespace Stockfish::Eval::NNUE {
      // of the estimated gain in terms of features to be added/subtracted.
      StateInfo *st = pos.state(), *next = nullptr;
      int gain = FeatureSet::refresh_cost(pos);
-      while (st->previous && !st->accumulator.computed[perspective])
+      while (st->previous && !st->accumulator.computed[Perspective])
      {
        // This governs when a full feature refresh is needed and how many
        // updates are better than just one full refresh.
-        if (   FeatureSet::requires_refresh(st, perspective)
+        if (   FeatureSet::requires_refresh(st, Perspective)
            || (gain -= FeatureSet::update_cost(st) + 1) < 0)
          break;
        next = st;
        st = st->previous;
      }
-      if (st->accumulator.computed[perspective])
+      if (st->accumulator.computed[Perspective])
      {
        if (next == nullptr)
          return;
@@ -376,17 +377,17 @@ namespace Stockfish::Eval::NNUE {
        // accumulator. Then, we update the current accumulator (pos.state()).
        // Gather all features to be updated.
-        const Square ksq = pos.square<KING>(perspective);
+        const Square ksq = pos.square<KING>(Perspective);
        FeatureSet::IndexList removed[2], added[2];
-        FeatureSet::append_changed_indices(
+        FeatureSet::append_changed_indices<Perspective>(
-          ksq, next->dirtyPiece, perspective, removed[0], added[0]);
+          ksq, next->dirtyPiece, removed[0], added[0]);
        for (StateInfo *st2 = pos.state(); st2 != next; st2 = st2->previous)
-          FeatureSet::append_changed_indices(
+          FeatureSet::append_changed_indices<Perspective>(
-            ksq, st2->dirtyPiece, perspective, removed[1], added[1]);
+            ksq, st2->dirtyPiece, removed[1], added[1]);
        // Mark the accumulators as computed.
-        next->accumulator.computed[perspective] = true;
+        next->accumulator.computed[Perspective] = true;
-        pos.state()->accumulator.computed[perspective] = true;
+        pos.state()->accumulator.computed[Perspective] = true;
        // Now update the accumulators listed in states_to_update[], where the last element is a sentinel.
        StateInfo *states_to_update[3] =
@@ -396,7 +397,7 @@ namespace Stockfish::Eval::NNUE {
        {
          // Load accumulator
          auto accTile = reinterpret_cast<vec_t*>(
-            &st->accumulator.accumulation[perspective][j * TileHeight]);
+            &st->accumulator.accumulation[Perspective][j * TileHeight]);
          for (IndexType k = 0; k < NumRegs; ++k)
            acc[k] = vec_load(&accTile[k]);
@@ -422,7 +423,7 @@ namespace Stockfish::Eval::NNUE {
            // Store accumulator
            accTile = reinterpret_cast<vec_t*>(
-              &states_to_update[i]->accumulator.accumulation[perspective][j * TileHeight]);
+              &states_to_update[i]->accumulator.accumulation[Perspective][j * TileHeight]);
            for (IndexType k = 0; k < NumRegs; ++k)
              vec_store(&accTile[k], acc[k]);
          }
@@ -432,7 +433,7 @@ namespace Stockfish::Eval::NNUE {
        {
          // Load accumulator
          auto accTilePsqt = reinterpret_cast<psqt_vec_t*>(
-            &st->accumulator.psqtAccumulation[perspective][j * PsqtTileHeight]);
+            &st->accumulator.psqtAccumulation[Perspective][j * PsqtTileHeight]);
          for (std::size_t k = 0; k < NumPsqtRegs; ++k)
            psqt[k] = vec_load_psqt(&accTilePsqt[k]);
@@ -458,7 +459,7 @@ namespace Stockfish::Eval::NNUE {
            // Store accumulator
            accTilePsqt = reinterpret_cast<psqt_vec_t*>(
-              &states_to_update[i]->accumulator.psqtAccumulation[perspective][j * PsqtTileHeight]);
+              &states_to_update[i]->accumulator.psqtAccumulation[Perspective][j * PsqtTileHeight]);
            for (std::size_t k = 0; k < NumPsqtRegs; ++k)
              vec_store_psqt(&accTilePsqt[k], psqt[k]);
          }
@@ -467,12 +468,12 @@ namespace Stockfish::Eval::NNUE {
  #else
        for (IndexType i = 0; states_to_update[i]; ++i)
        {
-          std::memcpy(states_to_update[i]->accumulator.accumulation[perspective],
+          std::memcpy(states_to_update[i]->accumulator.accumulation[Perspective],
-              st->accumulator.accumulation[perspective],
+              st->accumulator.accumulation[Perspective],
              HalfDimensions * sizeof(BiasType));
          for (std::size_t k = 0; k < PSQTBuckets; ++k)
-            states_to_update[i]->accumulator.psqtAccumulation[perspective][k] = st->accumulator.psqtAccumulation[perspective][k];
+            states_to_update[i]->accumulator.psqtAccumulation[Perspective][k] = st->accumulator.psqtAccumulation[Perspective][k];
          st = states_to_update[i];
@@ -482,10 +483,10 @@ namespace Stockfish::Eval::NNUE {
            const IndexType offset = HalfDimensions * index;
            for (IndexType j = 0; j < HalfDimensions; ++j)
-              st->accumulator.accumulation[perspective][j] -= weights[offset + j];
+              st->accumulator.accumulation[Perspective][j] -= weights[offset + j];
            for (std::size_t k = 0; k < PSQTBuckets; ++k)
-              st->accumulator.psqtAccumulation[perspective][k] -= psqtWeights[index * PSQTBuckets + k];
+              st->accumulator.psqtAccumulation[Perspective][k] -= psqtWeights[index * PSQTBuckets + k];
          }
          // Difference calculation for the activated features
@@ -494,10 +495,10 @@ namespace Stockfish::Eval::NNUE {
            const IndexType offset = HalfDimensions * index;
            for (IndexType j = 0; j < HalfDimensions; ++j)
-              st->accumulator.accumulation[perspective][j] += weights[offset + j];
+              st->accumulator.accumulation[Perspective][j] += weights[offset + j];
            for (std::size_t k = 0; k < PSQTBuckets; ++k)
-              st->accumulator.psqtAccumulation[perspective][k] += psqtWeights[index * PSQTBuckets + k];
+              st->accumulator.psqtAccumulation[Perspective][k] += psqtWeights[index * PSQTBuckets + k];
          }
        }
  #endif
@@ -506,9 +507,9 @@ namespace Stockfish::Eval::NNUE {
      {
        // Refresh the accumulator
        auto& accumulator = pos.state()->accumulator;
-        accumulator.computed[perspective] = true;
+        accumulator.computed[Perspective] = true;
        FeatureSet::IndexList active;
-        FeatureSet::append_active_indices(pos, perspective, active);
+        FeatureSet::append_active_indices<Perspective>(pos, active);
  #ifdef VECTOR
        for (IndexType j = 0; j < HalfDimensions / TileHeight; ++j)
@@ -528,7 +529,7 @@ namespace Stockfish::Eval::NNUE {
          }
          auto accTile = reinterpret_cast<vec_t*>(
-              &accumulator.accumulation[perspective][j * TileHeight]);
+              &accumulator.accumulation[Perspective][j * TileHeight]);
          for (unsigned k = 0; k < NumRegs; k++)
            vec_store(&accTile[k], acc[k]);
        }
@@ -548,27 +549,27 @@ namespace Stockfish::Eval::NNUE {
          }
          auto accTilePsqt = reinterpret_cast<psqt_vec_t*>(
-            &accumulator.psqtAccumulation[perspective][j * PsqtTileHeight]);
+            &accumulator.psqtAccumulation[Perspective][j * PsqtTileHeight]);
          for (std::size_t k = 0; k < NumPsqtRegs; ++k)
            vec_store_psqt(&accTilePsqt[k], psqt[k]);
        }
  #else
-        std::memcpy(accumulator.accumulation[perspective], biases,
+        std::memcpy(accumulator.accumulation[Perspective], biases,
            HalfDimensions * sizeof(BiasType));
        for (std::size_t k = 0; k < PSQTBuckets; ++k)
-          accumulator.psqtAccumulation[perspective][k] = 0;
+          accumulator.psqtAccumulation[Perspective][k] = 0;
        for (const auto index : active)
        {
          const IndexType offset = HalfDimensions * index;
          for (IndexType j = 0; j < HalfDimensions; ++j)
-            accumulator.accumulation[perspective][j] += weights[offset + j];
+            accumulator.accumulation[Perspective][j] += weights[offset + j];
          for (std::size_t k = 0; k < PSQTBuckets; ++k)
-            accumulator.psqtAccumulation[perspective][k] += psqtWeights[index * PSQTBuckets + k];
+            accumulator.psqtAccumulation[Perspective][k] += psqtWeights[index * PSQTBuckets + k];
        }
  #endif
      }
@@ -129,7 +129,7 @@ void Position::init() {
  // Prepare the cuckoo tables
  std::memset(cuckoo, 0, sizeof(cuckoo));
  std::memset(cuckooMove, 0, sizeof(cuckooMove));
-  int count = 0;
+  [[maybe_unused]] int count = 0;
  for (Piece pc : Pieces)
      for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
          for (Square s2 = Square(s1 + 1); s2 <= SQ_H8; ++s2)
@@ -1054,7 +1054,10 @@ Key Position::key_after(Move m) const {
  if (captured)
      k ^= Zobrist::psq[captured][to];
-  return k ^ Zobrist::psq[pc][to] ^ Zobrist::psq[pc][from];
+  k ^= Zobrist::psq[pc][to] ^ Zobrist::psq[pc][from];
  return (captured || type_of(pc) == PAWN)
      ? k : adjust_key50<true>(k);
 }
@@ -1099,10 +1102,12 @@ bool Position::see_ge(Move m, Value threshold) const {
      // Don't allow pinned pieces to attack as long as there are
      // pinners on their original square.
      if (pinners(~stm) & occupied)
      {
          stmAttackers &= ~blockers_for_king(stm);
-      if (!stmAttackers)
+          if (!stmAttackers)
-          break;
+              break;
      }
      res ^= 1;
@@ -161,6 +161,7 @@ public:
  bool has_repeated() const;
  int rule50_count() const;
  Score psq_score() const;
  Value psq_eg_stm() const;
  Value non_pawn_material(Color c) const;
  Value non_pawn_material() const;
@@ -184,6 +185,8 @@ private:
  void move_piece(Square from, Square to);
  template<bool Do>
  void do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto);
  template<bool AfterMove>
  Key adjust_key50(Key k) const;
  // Data members
  Piece board[SQUARE_NB];
@@ -326,8 +329,14 @@ inline int Position::pawns_on_same_color_squares(Color c, Square s) const {
 }
 inline Key Position::key() const {
-  return st->rule50 < 14 ? st->key
+  return adjust_key50<false>(st->key);
-                         : st->key ^ make_key((st->rule50 - 14) / 8);
+}
 template<bool AfterMove>
 inline Key Position::adjust_key50(Key k) const
 {
  return st->rule50 < 14 - AfterMove
      ? k : k ^ make_key((st->rule50 - (14 - AfterMove)) / 8);
 }
 inline Key Position::pawn_key() const {
@@ -342,6 +351,10 @@ inline Score Position::psq_score() const {
  return psq;
 }
 inline Value Position::psq_eg_stm() const {
  return (sideToMove == WHITE ? 1 : -1) * eg_value(psq);
 }
 inline Value Position::non_pawn_material(Color c) const {
  return st->nonPawnMaterial[c];
 }
@@ -63,7 +63,7 @@ namespace {
  // Futility margin
  Value futility_margin(Depth d, bool improving) {
-    return Value(168 * (d - improving));
+    return Value(165 * (d - improving));
  }
  // Reductions lookup table, initialized at startup
@@ -71,21 +71,22 @@ namespace {
  Depth reduction(bool i, Depth d, int mn, Value delta, Value rootDelta) {
    int r = Reductions[d] * Reductions[mn];
-    return (r + 1463 - int(delta) * 1024 / int(rootDelta)) / 1024 + (!i && r > 1010);
+    return (r + 1642 - int(delta) * 1024 / int(rootDelta)) / 1024 + (!i && r > 916);
  }
  constexpr int futility_move_count(bool improving, Depth depth) {
-    return (3 + depth * depth) / (2 - improving);
+    return improving ? (3 + depth * depth)
                     : (3 + depth * depth) / 2;
  }
  // History and stats update bonus, based on depth
  int stat_bonus(Depth d) {
-    return std::min((9 * d + 270) * d - 311 , 2145);
+    return std::min((12 * d + 282) * d - 349 , 1594);
  }
  // Add a small random component to draw evaluations to avoid 3-fold blindness
-  Value value_draw(Thread* thisThread) {
+  Value value_draw(const Thread* thisThread) {
-    return VALUE_DRAW + Value(2 * (thisThread->nodes & 1) - 1);
+    return VALUE_DRAW - 1 + Value(thisThread->nodes & 0x2);
  }
  // Skill structure is used to implement strength limit. If we have an uci_elo then
@@ -115,7 +116,7 @@ namespace {
  Value value_to_tt(Value v, int ply);
  Value value_from_tt(Value v, int ply, int r50c);
-  void update_pv(Move* pv, Move move, Move* childPv);
+  void update_pv(Move* pv, Move move, const Move* childPv);
  void update_continuation_histories(Stack* ss, Piece pc, Square to, int bonus);
  void update_quiet_stats(const Position& pos, Stack* ss, Move move, int bonus);
  void update_all_stats(const Position& pos, Stack* ss, Move bestMove, Value bestValue, Value beta, Square prevSq,
@@ -157,7 +158,7 @@ namespace {
 void Search::init() {
  for (int i = 1; i < MAX_MOVES; ++i)
-      Reductions[i] = int((20.81 + std::log(Threads.size()) / 2) * std::log(i));
+      Reductions[i] = int((20.26 + std::log(Threads.size()) / 2) * std::log(i));
 }
@@ -238,9 +239,12 @@ void MainThread::search() {
  bestPreviousScore = bestThread->rootMoves[0].score;
  bestPreviousAverageScore = bestThread->rootMoves[0].averageScore;
  for (Thread* th : Threads)
    th->previousDepth = bestThread->completedDepth;
  // Send again PV info if we have a new best thread
  if (bestThread != this)
-      sync_cout << UCI::pv(bestThread->rootPos, bestThread->completedDepth, -VALUE_INFINITE, VALUE_INFINITE) << sync_endl;
+      sync_cout << UCI::pv(bestThread->rootPos, bestThread->completedDepth) << sync_endl;
  sync_cout << "bestmove " << UCI::move(bestThread->rootMoves[0].pv[0], rootPos.is_chess960());
@@ -303,11 +307,9 @@ void Thread::search() {
  multiPV = std::min(multiPV, rootMoves.size());
-  complexityAverage.set(202, 1);
+  complexityAverage.set(155, 1);
-  trend         = SCORE_ZERO;
+  optimism[us] = optimism[~us] = VALUE_ZERO;
  optimism[ us] = Value(39);
  optimism[~us] = -optimism[us];
  int searchAgainCounter = 0;
@@ -349,16 +351,12 @@ void Thread::search() {
          if (rootDepth >= 4)
          {
              Value prev = rootMoves[pvIdx].averageScore;
-              delta = Value(16) + int(prev) * prev / 19178;
+              delta = Value(10) + int(prev) * prev / 15620;
              alpha = std::max(prev - delta,-VALUE_INFINITE);
              beta  = std::min(prev + delta, VALUE_INFINITE);
-              // Adjust trend and optimism based on root move's previousScore
+              // Adjust optimism based on root move's previousScore
-              int tr = sigmoid(prev, 3, 8, 90, 125, 1);
+              int opt = 118 * prev / (std::abs(prev) + 169);
              trend = (us == WHITE ?  make_score(tr, tr / 2)
                                   : -make_score(tr, tr / 2));
              int opt = sigmoid(prev, 8, 17, 144, 13966, 183);
              optimism[ us] = Value(opt);
              optimism[~us] = -optimism[us];
          }
@@ -369,7 +367,9 @@ void Thread::search() {
          int failedHighCnt = 0;
          while (true)
          {
-              Depth adjustedDepth = std::max(1, rootDepth - failedHighCnt - searchAgainCounter);
+              // Adjust the effective depth searched, but ensuring at least one effective increment for every
              // four searchAgain steps (see issue #2717).
              Depth adjustedDepth = std::max(1, rootDepth - failedHighCnt - 3 * (searchAgainCounter + 1) / 4);
              bestValue = Stockfish::search<Root>(rootPos, ss, alpha, beta, adjustedDepth, false);
              // Bring the best move to the front. It is critical that sorting
@@ -392,7 +392,7 @@ void Thread::search() {
                  && multiPV == 1
                  && (bestValue <= alpha || bestValue >= beta)
                  && Time.elapsed() > 3000)
-                  sync_cout << UCI::pv(rootPos, rootDepth, alpha, beta) << sync_endl;
+                  sync_cout << UCI::pv(rootPos, rootDepth) << sync_endl;
              // In case of failing low/high increase aspiration window and
              // re-search, otherwise exit the loop.
@@ -423,7 +423,7 @@ void Thread::search() {
          if (    mainThread
              && (Threads.stop || pvIdx + 1 == multiPV || Time.elapsed() > 3000))
-              sync_cout << UCI::pv(rootPos, rootDepth, alpha, beta) << sync_endl;
+              sync_cout << UCI::pv(rootPos, rootDepth) << sync_endl;
      }
      if (!Threads.stop)
@@ -459,17 +459,16 @@ void Thread::search() {
          && !Threads.stop
          && !mainThread->stopOnPonderhit)
      {
-          double fallingEval = (69 + 12 * (mainThread->bestPreviousAverageScore - bestValue)
+          double fallingEval = (71 + 12 * (mainThread->bestPreviousAverageScore - bestValue)
-                                    +  6 * (mainThread->iterValue[iterIdx] - bestValue)) / 781.4;
+                                    +  6 * (mainThread->iterValue[iterIdx] - bestValue)) / 656.7;
          fallingEval = std::clamp(fallingEval, 0.5, 1.5);
          // If the bestMove is stable over several iterations, reduce time accordingly
-          timeReduction = lastBestMoveDepth + 10 < completedDepth ? 1.63 : 0.73;
+          timeReduction = lastBestMoveDepth + 9 < completedDepth ? 1.37 : 0.65;
-          double reduction = (1.56 + mainThread->previousTimeReduction) / (2.20 * timeReduction);
+          double reduction = (1.4 + mainThread->previousTimeReduction) / (2.15 * timeReduction);
-          double bestMoveInstability = 1.073 + std::max(1.0, 2.25 - 9.9 / rootDepth)
+          double bestMoveInstability = 1 + 1.7 * totBestMoveChanges / Threads.size();
                                              * totBestMoveChanges / Threads.size();
          int complexity = mainThread->complexityAverage.value();
-          double complexPosition = std::clamp(1.0 + (complexity - 326) / 1618.1, 0.5, 1.5);
+          double complexPosition = std::min(1.0 + (complexity - 261) / 1738.7, 1.5);
          double totalTime = Time.optimum() * fallingEval * reduction * bestMoveInstability * complexPosition;
@@ -490,7 +489,7 @@ void Thread::search() {
          }
          else if (   Threads.increaseDepth
                   && !mainThread->ponder
-                   && Time.elapsed() > totalTime * 0.43)
+                   && Time.elapsed() > totalTime * 0.53)
                   Threads.increaseDepth = false;
          else
                   Threads.increaseDepth = true;
@@ -553,18 +552,17 @@ namespace {
    Move ttMove, move, excludedMove, bestMove;
    Depth extension, newDepth;
    Value bestValue, value, ttValue, eval, maxValue, probCutBeta;
-    bool givesCheck, improving, didLMR, priorCapture;
+    bool givesCheck, improving, priorCapture, singularQuietLMR;
-    bool capture, doFullDepthSearch, moveCountPruning, ttCapture;
+    bool capture, moveCountPruning, ttCapture;
    Piece movedPiece;
-    int moveCount, captureCount, quietCount, bestMoveCount, improvement, complexity;
+    int moveCount, captureCount, quietCount, improvement, complexity;
    // Step 1. Initialize node
    Thread* thisThread = pos.this_thread();
    thisThread->depth  = depth;
    ss->inCheck        = pos.checkers();
    priorCapture       = pos.captured_piece();
    Color us           = pos.side_to_move();
-    moveCount          = bestMoveCount = captureCount = quietCount = ss->moveCount = 0;
+    moveCount          = captureCount = quietCount = ss->moveCount = 0;
    bestValue          = -VALUE_INFINITE;
    maxValue           = VALUE_INFINITE;
@@ -604,8 +602,8 @@ namespace {
    (ss+1)->ttPv         = false;
    (ss+1)->excludedMove = bestMove = MOVE_NONE;
    (ss+2)->killers[0]   = (ss+2)->killers[1] = MOVE_NONE;
    (ss+2)->cutoffCnt    = 0;
    ss->doubleExtensions = (ss-1)->doubleExtensions;
    ss->depth            = depth;
    Square prevSq        = to_sq((ss-1)->currentMove);
    // Initialize statScore to zero for the grandchildren of the current position.
@@ -632,10 +630,9 @@ namespace {
    // At non-PV nodes we check for an early TT cutoff
    if (  !PvNode
        && ss->ttHit
-        && tte->depth() > depth - (thisThread->id() % 2 == 1)
+        && tte->depth() > depth - (tte->bound() == BOUND_EXACT)
        && ttValue != VALUE_NONE // Possible in case of TT access race
-        && (ttValue >= beta ? (tte->bound() & BOUND_LOWER)
+        && (tte->bound() & (ttValue >= beta ? BOUND_LOWER : BOUND_UPPER)))
                            : (tte->bound() & BOUND_UPPER)))
    {
        // If ttMove is quiet, update move sorting heuristics on TT hit (~1 Elo)
        if (ttMove)
@@ -734,11 +731,9 @@ namespace {
        // Never assume anything about values stored in TT
        ss->staticEval = eval = tte->eval();
        if (eval == VALUE_NONE)
-            ss->staticEval = eval = evaluate(pos);
+            ss->staticEval = eval = evaluate(pos, &complexity);
-
+        else // Fall back to (semi)classical complexity for TT hits, the NNUE complexity is lost
-        // Randomize draw evaluation
+            complexity = abs(ss->staticEval - pos.psq_eg_stm());
        if (eval == VALUE_DRAW)
            eval = value_draw(thisThread);
        // ttValue can be used as a better position evaluation (~4 Elo)
        if (    ttValue != VALUE_NONE
@@ -747,17 +742,19 @@ namespace {
    }
    else
    {
-        ss->staticEval = eval = evaluate(pos);
+        ss->staticEval = eval = evaluate(pos, &complexity);
        // Save static evaluation into transposition table
        if (!excludedMove)
            tte->save(posKey, VALUE_NONE, ss->ttPv, BOUND_NONE, DEPTH_NONE, MOVE_NONE, eval);
    }
    thisThread->complexityAverage.update(complexity);
    // Use static evaluation difference to improve quiet move ordering (~3 Elo)
    if (is_ok((ss-1)->currentMove) && !(ss-1)->inCheck && !priorCapture)
    {
-        int bonus = std::clamp(-16 * int((ss-1)->staticEval + ss->staticEval), -2000, 2000);
+        int bonus = std::clamp(-19 * int((ss-1)->staticEval + ss->staticEval), -1914, 1914);
        thisThread->mainHistory[~us][from_to((ss-1)->currentMove)] << bonus;
    }
@@ -767,19 +764,13 @@ namespace {
    // margin and the improving flag are used in various pruning heuristics.
    improvement =   (ss-2)->staticEval != VALUE_NONE ? ss->staticEval - (ss-2)->staticEval
                  : (ss-4)->staticEval != VALUE_NONE ? ss->staticEval - (ss-4)->staticEval
-                  :                                    175;
+                  :                                    168;
    improving = improvement > 0;
    complexity = abs(ss->staticEval - (us == WHITE ? eg_value(pos.psq_score()) : -eg_value(pos.psq_score())));
    thisThread->complexityAverage.update(complexity);
    // Step 7. Razoring.
    // If eval is really low check with qsearch if it can exceed alpha, if it can't,
    // return a fail low.
-    if (   !PvNode
+    if (eval < alpha - 369 - 254 * depth * depth)
        && depth <= 7
        && eval < alpha - 348 - 258 * depth * depth)
    {
        value = qsearch<NonPV>(pos, ss, alpha - 1, alpha);
        if (value < alpha)
@@ -790,18 +781,18 @@ namespace {
    // The depth condition is important for mate finding.
    if (   !ss->ttPv
        &&  depth < 8
-        &&  eval - futility_margin(depth, improving) - (ss-1)->statScore / 256 >= beta
+        &&  eval - futility_margin(depth, improving) - (ss-1)->statScore / 303 >= beta
        &&  eval >= beta
-        &&  eval < 26305) // larger than VALUE_KNOWN_WIN, but smaller than TB wins.
+        &&  eval < 28031) // larger than VALUE_KNOWN_WIN, but smaller than TB wins
        return eval;
    // Step 9. Null move search with verification search (~22 Elo)
    if (   !PvNode
        && (ss-1)->currentMove != MOVE_NULL
-        && (ss-1)->statScore < 14695
+        && (ss-1)->statScore < 17139
        &&  eval >= beta
        &&  eval >= ss->staticEval
-        &&  ss->staticEval >= beta - 15 * depth - improvement / 15 + 198 + complexity / 28
+        &&  ss->staticEval >= beta - 20 * depth - improvement / 13 + 233 + complexity / 25
        && !excludedMove
        &&  pos.non_pawn_material(us)
        && (ss->ply >= thisThread->nmpMinPly || us != thisThread->nmpColor))
@@ -809,7 +800,7 @@ namespace {
        assert(eval - beta >= 0);
        // Null move dynamic reduction based on depth, eval and complexity of position
-        Depth R = std::min(int(eval - beta) / 147, 5) + depth / 3 + 4 - (complexity > 753);
+        Depth R = std::min(int(eval - beta) / 168, 7) + depth / 3 + 4 - (complexity > 861);
        ss->currentMove = MOVE_NULL;
        ss->continuationHistory = &thisThread->continuationHistory[0][0][NO_PIECE][0];
@@ -845,7 +836,7 @@ namespace {
        }
    }
-    probCutBeta = beta + 179 - 46 * improving;
+    probCutBeta = beta + 191 - 54 * improving;
    // Step 10. ProbCut (~4 Elo)
    // If we have a good enough capture and a reduced search returns a value
@@ -864,21 +855,16 @@ namespace {
    {
        assert(probCutBeta < VALUE_INFINITE);
-        MovePicker mp(pos, ttMove, probCutBeta - ss->staticEval, depth - 3, &captureHistory);
+        MovePicker mp(pos, ttMove, probCutBeta - ss->staticEval, &captureHistory);
        bool ttPv = ss->ttPv;
        bool captureOrPromotion;
        ss->ttPv = false;
        while ((move = mp.next_move()) != MOVE_NONE)
            if (move != excludedMove && pos.legal(move))
            {
                assert(pos.capture(move) || promotion_type(move) == QUEEN);
                captureOrPromotion = true;
                ss->currentMove = move;
                ss->continuationHistory = &thisThread->continuationHistory[ss->inCheck]
-                                                                          [captureOrPromotion]
+                                                                          [true]
                                                                          [pos.moved_piece(move)]
                                                                          [to_sq(move)];
@@ -895,34 +881,31 @@ namespace {
                if (value >= probCutBeta)
                {
-                    // if transposition table doesn't have equal or more deep info write probCut data into it
+                    // Save ProbCut data into transposition table
-                    if ( !(ss->ttHit
+                    tte->save(posKey, value_to_tt(value, ss->ply), ss->ttPv, BOUND_LOWER, depth - 3, move, ss->staticEval);
                       && tte->depth() >= depth - 3
                       && ttValue != VALUE_NONE))
                        tte->save(posKey, value_to_tt(value, ss->ply), ttPv,
                            BOUND_LOWER,
                            depth - 3, move, ss->staticEval);
                    return value;
                }
            }
         ss->ttPv = ttPv;
    }
-    // Step 11. If the position is not in TT, decrease depth by 2 or 1 depending on node type (~3 Elo)
+    // Step 11. If the position is not in TT, decrease depth by 3.
-    if (   PvNode
+    // Use qsearch if depth is equal or below zero (~4 Elo)
-        && depth >= 3
+    if (    PvNode
        && !ttMove)
        depth -= 3;
    if (depth <= 0)
        return qsearch<PV>(pos, ss, alpha, beta);
    if (    cutNode
        &&  depth >= 9
        && !ttMove)
        depth -= 2;
    if (   cutNode
        && depth >= 8
        && !ttMove)
        depth--;
 moves_loop: // When in check, search starts here
    // Step 12. A small Probcut idea, when we are in check (~0 Elo)
-    probCutBeta = beta + 481;
+    probCutBeta = beta + 417;
    if (   ss->inCheck
        && !PvNode
        && depth >= 2
@@ -949,7 +932,7 @@ moves_loop: // When in check, search starts here
                                      ss->killers);
    value = bestValue;
-    moveCountPruning = false;
+    moveCountPruning = singularQuietLMR = false;
    // Indicate PvNodes that will probably fail low if the node was searched
    // at a depth equal or greater than the current depth, and the result of this search was a fail low.
@@ -1013,17 +996,16 @@ moves_loop: // When in check, search starts here
              || givesCheck)
          {
              // Futility pruning for captures (~0 Elo)
-              if (   !pos.empty(to_sq(move))
+              if (   !givesCheck
                  && !givesCheck
                  && !PvNode
-                  && lmrDepth < 6
+                  && lmrDepth < 7
                  && !ss->inCheck
-                  && ss->staticEval + 281 + 179 * lmrDepth + PieceValue[EG][pos.piece_on(to_sq(move))]
+                  && ss->staticEval + 180 + 201 * lmrDepth + PieceValue[EG][pos.piece_on(to_sq(move))]
                   + captureHistory[movedPiece][to_sq(move)][type_of(pos.piece_on(to_sq(move)))] / 6 < alpha)
                  continue;
              // SEE based pruning (~9 Elo)
-              if (!pos.see_ge(move, Value(-203) * depth))
+              if (!pos.see_ge(move, Value(-222) * depth))
                  continue;
          }
          else
@@ -1037,16 +1019,16 @@ moves_loop: // When in check, search starts here
                  && history < -3875 * (depth - 1))
                  continue;
-              history += thisThread->mainHistory[us][from_to(move)];
+              history += 2 * thisThread->mainHistory[us][from_to(move)];
              // Futility pruning: parent node (~9 Elo)
              if (   !ss->inCheck
-                  && lmrDepth < 11
+                  && lmrDepth < 13
-                  && ss->staticEval + 122 + 138 * lmrDepth + history / 60 <= alpha)
+                  && ss->staticEval + 106 + 145 * lmrDepth + history / 52 <= alpha)
                  continue;
              // Prune moves with negative SEE (~3 Elo)
-              if (!pos.see_ge(move, Value(-25 * lmrDepth * lmrDepth - 20 * lmrDepth)))
+              if (!pos.see_ge(move, Value(-24 * lmrDepth * lmrDepth - 15 * lmrDepth)))
                  continue;
          }
      }
@@ -1061,7 +1043,7 @@ moves_loop: // When in check, search starts here
          // a reduced search on all the other moves but the ttMove and if the
          // result is lower than ttValue minus a margin, then we will extend the ttMove.
          if (   !rootNode
-              &&  depth >= 4 + 2 * (PvNode && tte->is_pv())
+              &&  depth >= 4 - (thisThread->previousDepth > 24) + 2 * (PvNode && tte->is_pv())
              &&  move == ttMove
              && !excludedMove // Avoid recursive singular search
           /* &&  ttValue != VALUE_NONE Already implicit in the next condition */
@@ -1069,7 +1051,7 @@ moves_loop: // When in check, search starts here
              && (tte->bound() & BOUND_LOWER)
              &&  tte->depth() >= depth - 3)
          {
-              Value singularBeta = ttValue - 3 * depth;
+              Value singularBeta = ttValue - (3 + (ss->ttPv && !PvNode)) * depth;
              Depth singularDepth = (depth - 1) / 2;
              ss->excludedMove = move;
@@ -1079,11 +1061,12 @@ moves_loop: // When in check, search starts here
              if (value < singularBeta)
              {
                  extension = 1;
                  singularQuietLMR = !ttCapture;
                  // Avoid search explosion by limiting the number of double extensions
                  if (  !PvNode
-                      && value < singularBeta - 26
+                      && value < singularBeta - 25
-                      && ss->doubleExtensions <= 8)
+                      && ss->doubleExtensions <= 9)
                      extension = 2;
              }
@@ -1098,19 +1081,23 @@ moves_loop: // When in check, search starts here
              // If the eval of ttMove is greater than beta, we reduce it (negative extension)
              else if (ttValue >= beta)
                  extension = -2;
              // If the eval of ttMove is less than alpha and value, we reduce it (negative extension)
              else if (ttValue <= alpha && ttValue <= value)
                  extension = -1;
          }
          // Check extensions (~1 Elo)
          else if (   givesCheck
                   && depth > 9
-                   && abs(ss->staticEval) > 71)
+                   && abs(ss->staticEval) > 82)
              extension = 1;
          // Quiet ttMove extensions (~0 Elo)
          else if (   PvNode
                   && move == ttMove
                   && move == ss->killers[0]
-                   && (*contHist[0])[movedPiece][to_sq(move)] >= 5491)
+                   && (*contHist[0])[movedPiece][to_sq(move)] >= 5177)
              extension = 1;
      }
@@ -1131,8 +1118,6 @@ moves_loop: // When in check, search starts here
      // Step 16. Make the move
      pos.do_move(move, st, givesCheck);
      bool doDeeperSearch = false;
      // Step 17. Late moves reduction / extension (LMR, ~98 Elo)
      // We use various heuristics for the sons of a node after the first son has
      // been searched. In general we would like to reduce them, but there are many
@@ -1145,11 +1130,6 @@ moves_loop: // When in check, search starts here
      {
          Depth r = reduction(improving, depth, moveCount, delta, thisThread->rootDelta);
          // Decrease reduction at some PvNodes (~2 Elo)
          if (   PvNode
              && bestMoveCount <= 3)
              r--;
          // Decrease reduction if position is or has been on the PV
          // and node is not likely to fail low. (~3 Elo)
          if (   ss->ttPv
@@ -1161,63 +1141,59 @@ moves_loop: // When in check, search starts here
              r--;
          // Increase reduction for cut nodes (~3 Elo)
-          if (cutNode && move != ss->killers[0])
+          if (cutNode)
              r += 2;
          // Increase reduction if ttMove is a capture (~3 Elo)
          if (ttCapture)
              r++;
-          // Decrease reduction at PvNodes if bestvalue
+          // Decrease reduction for PvNodes based on depth
-          // is vastly different from static evaluation
+          if (PvNode)
-          if (PvNode && !ss->inCheck && abs(ss->staticEval - bestValue) > 250)
+              r -= 1 + 11 / (3 + depth);
          // Decrease reduction if ttMove has been singularly extended (~1 Elo)
          if (singularQuietLMR)
              r--;
-          // Increase depth based reduction if PvNode
+          // Decrease reduction if we move a threatened piece (~1 Elo)
-          if (PvNode)
+          if (   depth > 9
-              r -= 15 / ( 3 + depth );
+              && (mp.threatenedPieces & from_sq(move)))
              r--;
-          ss->statScore =  thisThread->mainHistory[us][from_to(move)]
+          // Increase reduction if next ply has a lot of fail high
          if ((ss+1)->cutoffCnt > 3)
              r++;
          ss->statScore =  2 * thisThread->mainHistory[us][from_to(move)]
                         + (*contHist[0])[movedPiece][to_sq(move)]
                         + (*contHist[1])[movedPiece][to_sq(move)]
                         + (*contHist[3])[movedPiece][to_sq(move)]
-                         - 4334;
+                         - 4433;
          // Decrease/increase reduction for moves with a good/bad history (~30 Elo)
-          r -= ss->statScore / 15914;
+          r -= ss->statScore / (13628 + 4000 * (depth > 7 && depth < 19));
-          // In general we want to cap the LMR depth search at newDepth. But if reductions
+          // In general we want to cap the LMR depth search at newDepth, but when
-          // are really negative and movecount is low, we allow this move to be searched
+          // reduction is negative, we allow this move a limited search extension
-          // deeper than the first move (this may lead to hidden double extensions).
+          // beyond the first move depth. This may lead to hidden double extensions.
-          int deeper =   r >= -1                   ? 0
+          Depth d = std::clamp(newDepth - r, 1, newDepth + 1);
                       : moveCount <= 4            ? 2
                       : PvNode && depth > 4       ? 1
                       : cutNode && moveCount <= 8 ? 1
                       :                             0;
          Depth d = std::clamp(newDepth - r, 1, newDepth + deeper);
          value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, true);
-          // If the son is reduced and fails high it will be re-searched at full depth
+          // Do full depth search when reduced LMR search fails high
-          doFullDepthSearch = value > alpha && d < newDepth;
+          if (value > alpha && d < newDepth)
          doDeeperSearch = value > (alpha + 78 + 11 * (newDepth - d));
          didLMR = true;
      }
      else
      {
          doFullDepthSearch = !PvNode || moveCount > 1;
          didLMR = false;
      }
      // Step 18. Full depth search when LMR is skipped or fails high
      if (doFullDepthSearch)
      {
          value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth + doDeeperSearch, !cutNode);
          // If the move passed LMR update its stats
          if (didLMR)
          {
              // Adjust full depth search based on LMR results - if result
              // was good enough search deeper, if it was bad enough search shallower
              const bool doDeeperSearch = value > (alpha + 64 + 11 * (newDepth - d));
              const bool doShallowerSearch = value < bestValue + newDepth;
              newDepth += doDeeperSearch - doShallowerSearch;
              if (newDepth > d)
                  value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, !cutNode);
              int bonus = value > alpha ?  stat_bonus(newDepth)
                                        : -stat_bonus(newDepth);
@@ -1228,6 +1204,12 @@ moves_loop: // When in check, search starts here
          }
      }
      // Step 18. Full depth search when LMR is skipped
      else if (!PvNode || moveCount > 1)
      {
              value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, !cutNode);
      }
      // For PV nodes only, do a full PV search on the first move or after a fail
      // high (in the latter case search only if value < beta), otherwise let the
      // parent node fail low with value <= alpha and try another move.
@@ -1264,6 +1246,8 @@ moves_loop: // When in check, search starts here
          {
              rm.score = value;
              rm.selDepth = thisThread->selDepth;
              rm.scoreLowerbound = value >= beta;
              rm.scoreUpperbound = value <= alpha;
              rm.pv.resize(1);
              assert((ss+1)->pv);
@@ -1299,16 +1283,26 @@ moves_loop: // When in check, search starts here
              if (PvNode && value < beta) // Update alpha! Always alpha < beta
              {
                  alpha = value;
-                  bestMoveCount++;
+
                  // Reduce other moves if we have found at least one score improvement
                  if (   depth > 1
                      && depth < 6
                      && beta  <  VALUE_KNOWN_WIN
                      && alpha > -VALUE_KNOWN_WIN)
                     depth -= 1;
                  assert(depth > 0);
              }
              else
              {
                  ss->cutoffCnt++;
                  assert(value >= beta); // Fail high
                  break;
              }
          }
      }
      // If the move is worse than some previously searched move, remember it to update its stats later
      if (move != bestMove)
      {
@@ -1346,14 +1340,14 @@ moves_loop: // When in check, search starts here
                         quietsSearched, quietCount, capturesSearched, captureCount, depth);
    // Bonus for prior countermove that caused the fail low
-    else if (   (depth >= 4 || PvNode)
+    else if (   (depth >= 5 || PvNode)
             && !priorCapture)
    {
        //Assign extra bonus if current node is PvNode or cutNode
        //or fail low was really bad
        bool extraBonus =    PvNode
                          || cutNode
-                          || bestValue < alpha - 70 * depth;
+                          || bestValue < alpha - 62 * depth;
        update_continuation_histories(ss-1, pos.piece_on(prevSq), prevSq, stat_bonus(depth) * (1 + extraBonus));
    }
@@ -1381,6 +1375,7 @@ moves_loop: // When in check, search starts here
  // qsearch() is the quiescence search function, which is called by the main search
  // function with zero depth, or recursively with further decreasing depth per call.
  // (~155 elo)
  template <NodeType nodeType>
  Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth) {
@@ -1437,8 +1432,7 @@ moves_loop: // When in check, search starts here
        && ss->ttHit
        && tte->depth() >= ttDepth
        && ttValue != VALUE_NONE // Only in case of TT access race
-        && (ttValue >= beta ? (tte->bound() & BOUND_LOWER)
+        && (tte->bound() & (ttValue >= beta ? BOUND_LOWER : BOUND_UPPER)))
                            : (tte->bound() & BOUND_UPPER)))
        return ttValue;
    // Evaluate the position statically
@@ -1480,7 +1474,7 @@ moves_loop: // When in check, search starts here
        if (PvNode && bestValue > alpha)
            alpha = bestValue;
-        futilityBase = bestValue + 118;
+        futilityBase = bestValue + 153;
    }
    const PieceToHistory* contHist[] = { (ss-1)->continuationHistory, (ss-2)->continuationHistory,
@@ -1554,18 +1548,17 @@ moves_loop: // When in check, search starts here
                                                                [to_sq(move)];
      // Continuation history based pruning (~2 Elo)
-      if (  !capture
+      if (   !capture
          && bestValue > VALUE_TB_LOSS_IN_MAX_PLY
-          && (*contHist[0])[pos.moved_piece(move)][to_sq(move)] < CounterMovePruneThreshold
+          && (*contHist[0])[pos.moved_piece(move)][to_sq(move)] < 0
-          && (*contHist[1])[pos.moved_piece(move)][to_sq(move)] < CounterMovePruneThreshold)
+          && (*contHist[1])[pos.moved_piece(move)][to_sq(move)] < 0)
          continue;
-      // movecount pruning for quiet check evasions
+      // We prune after 2nd quiet check evasion where being 'in check' is implicitly checked through the counter
-      if (  bestValue > VALUE_TB_LOSS_IN_MAX_PLY
+      // and being a 'quiet' apart from being a tt move is assumed after an increment because captures are pushed ahead.
-          && quietCheckEvasions > 1
+      if (   bestValue > VALUE_TB_LOSS_IN_MAX_PLY
-          && !capture
+          && quietCheckEvasions > 1)
-          && ss->inCheck)
+          break;
          continue;
      quietCheckEvasions += !capture && ss->inCheck;
@@ -1662,7 +1655,7 @@ moves_loop: // When in check, search starts here
  // update_pv() adds current move and appends child pv[]
-  void update_pv(Move* pv, Move move, Move* childPv) {
+  void update_pv(Move* pv, Move move, const Move* childPv) {
    for (*pv++ = move; childPv && *childPv != MOVE_NONE; )
        *pv++ = *childPv++;
@@ -1675,19 +1668,18 @@ moves_loop: // When in check, search starts here
  void update_all_stats(const Position& pos, Stack* ss, Move bestMove, Value bestValue, Value beta, Square prevSq,
                        Move* quietsSearched, int quietCount, Move* capturesSearched, int captureCount, Depth depth) {
    int bonus1, bonus2;
    Color us = pos.side_to_move();
    Thread* thisThread = pos.this_thread();
    CapturePieceToHistory& captureHistory = thisThread->captureHistory;
    Piece moved_piece = pos.moved_piece(bestMove);
    PieceType captured = type_of(pos.piece_on(to_sq(bestMove)));
-
+    int bonus1 = stat_bonus(depth + 1);
    bonus1 = stat_bonus(depth + 1);
    bonus2 = bestValue > beta + PawnValueMg ? bonus1               // larger bonus
                                            : stat_bonus(depth);   // smaller bonus
    if (!pos.capture(bestMove))
    {
        int bonus2 = bestValue > beta + 137 ? bonus1               // larger bonus
                                            : stat_bonus(depth);   // smaller bonus
        // Increase stats for the best move in case it was a quiet move
        update_quiet_stats(pos, ss, bestMove, bonus2);
@@ -1830,7 +1822,7 @@ void MainThread::check_time() {
 /// UCI::pv() formats PV information according to the UCI protocol. UCI requires
 /// that all (if any) unsearched PV lines are sent using a previous search score.
-string UCI::pv(const Position& pos, Depth depth, Value alpha, Value beta) {
+string UCI::pv(const Position& pos, Depth depth) {
  std::stringstream ss;
  TimePoint elapsed = Time.elapsed() + 1;
@@ -1868,16 +1860,13 @@ string UCI::pv(const Position& pos, Depth depth, Value alpha, Value beta) {
      if (Options["UCI_ShowWDL"])
          ss << UCI::wdl(v, pos.game_ply());
-      if (!tb && i == pvIdx)
+      if (i == pvIdx && !tb && updated) // tablebase- and previous-scores are exact
-          ss << (v >= beta ? " lowerbound" : v <= alpha ? " upperbound" : "");
+         ss << (rootMoves[i].scoreLowerbound ? " lowerbound" : (rootMoves[i].scoreUpperbound ? " upperbound" : ""));
      ss << " nodes "    << nodesSearched
-         << " nps "      << nodesSearched * 1000 / elapsed;
+         << " nps "      << nodesSearched * 1000 / elapsed
-
+         << " hashfull " << TT.hashfull()
-      if (elapsed > 1000) // Earlier makes little sense
+         << " tbhits "   << tbHits
          ss << " hashfull " << TT.hashfull();
      ss << " tbhits "   << tbHits
         << " time "     << elapsed
         << " pv";
@@ -31,9 +31,6 @@ class Position;
 namespace Search {
 /// Threshold used for countermoves based pruning
 constexpr int CounterMovePruneThreshold = 0;
 /// Stack struct keeps track of the information we need to remember from nodes
 /// shallower and deeper in the tree during the search. Each search thread has
@@ -47,13 +44,13 @@ struct Stack {
  Move excludedMove;
  Move killers[2];
  Value staticEval;
  Depth depth;
  int statScore;
  int moveCount;
  bool inCheck;
  bool ttPv;
  bool ttHit;
  int doubleExtensions;
  int cutoffCnt;
 };
@@ -74,6 +71,8 @@ struct RootMove {
  Value score = -VALUE_INFINITE;
  Value previousScore = -VALUE_INFINITE;
  Value averageScore = -VALUE_INFINITE;
  bool scoreLowerbound = false;
  bool scoreUpperbound = false;
  int selDepth = 0;
  int tbRank = 0;
  Value tbScore;
@@ -59,6 +59,7 @@ namespace Stockfish {
 namespace {
 constexpr int TBPIECES = 7; // Max number of supported pieces
 constexpr int MAX_DTZ = 1 << 18; // Max DTZ supported, large enough to deal with the syzygy TB limit.
 enum { BigEndian, LittleEndian };
 enum TBType { WDL, DTZ }; // Used as template parameter
@@ -1290,7 +1291,7 @@ void Tablebases::init(const std::string& paths) {
    for (auto s : diagonal)
        MapA1D1D4[s] = code++;
-    // MapKK[] encodes all the 461 possible legal positions of two kings where
+    // MapKK[] encodes all the 462 possible legal positions of two kings where
    // the first is in the a1-d1-d4 triangle. If the first king is on the a1-d4
    // diagonal, the other one shall not to be above the a1-h8 diagonal.
    std::vector<std::pair<int, Square>> bothOnDiagonal;
@@ -1522,7 +1523,7 @@ bool Tablebases::root_probe(Position& pos, Search::RootMoves& rootMoves) {
    // Check whether a position was repeated since the last zeroing move.
    bool rep = pos.has_repeated();
-    int dtz, bound = Options["Syzygy50MoveRule"] ? 900 : 1;
+    int dtz, bound = Options["Syzygy50MoveRule"] ? (MAX_DTZ - 100) : 1;
    // Probe and rank each move
    for (auto& m : rootMoves)
@@ -1565,8 +1566,8 @@ bool Tablebases::root_probe(Position& pos, Search::RootMoves& rootMoves) {
        // Better moves are ranked higher. Certain wins are ranked equally.
        // Losing moves are ranked equally unless a 50-move draw is in sight.
-        int r =  dtz > 0 ? (dtz + cnt50 <= 99 && !rep ? 1000 : 1000 - (dtz + cnt50))
+        int r =  dtz > 0 ? (dtz + cnt50 <= 99 && !rep ? MAX_DTZ : MAX_DTZ - (dtz + cnt50))
-               : dtz < 0 ? (-dtz * 2 + cnt50 < 100 ? -1000 : -1000 + (-dtz + cnt50))
+               : dtz < 0 ? (-dtz * 2 + cnt50 < 100 ? -MAX_DTZ : -MAX_DTZ + (-dtz + cnt50))
               : 0;
        m.tbRank = r;
@@ -1574,9 +1575,9 @@ bool Tablebases::root_probe(Position& pos, Search::RootMoves& rootMoves) {
        // 1 cp to cursed wins and let it grow to 49 cp as the positions gets
        // closer to a real win.
        m.tbScore =  r >= bound ? VALUE_MATE - MAX_PLY - 1
-                   : r >  0     ? Value((std::max( 3, r - 800) * int(PawnValueEg)) / 200)
+                   : r >  0     ? Value((std::max( 3, r - (MAX_DTZ - 200)) * int(PawnValueEg)) / 200)
                   : r == 0     ? VALUE_DRAW
-                   : r > -bound ? Value((std::min(-3, r + 800) * int(PawnValueEg)) / 200)
+                   : r > -bound ? Value((std::min(-3, r + (MAX_DTZ - 200)) * int(PawnValueEg)) / 200)
                   :             -VALUE_MATE + MAX_PLY + 1;
    }
@@ -1590,7 +1591,7 @@ bool Tablebases::root_probe(Position& pos, Search::RootMoves& rootMoves) {
 // A return value false indicates that not all probes were successful.
 bool Tablebases::root_probe_wdl(Position& pos, Search::RootMoves& rootMoves) {
-    static const int WDL_to_rank[] = { -1000, -899, 0, 899, 1000 };
+    static const int WDL_to_rank[] = { -MAX_DTZ, -MAX_DTZ + 101, 0, MAX_DTZ - 101, MAX_DTZ };
    ProbeState result;
    StateInfo st;
@@ -31,8 +31,6 @@ enum WDLScore {
    WDLDraw        =  0, // Draw
    WDLCursedWin   =  1, // Win, but draw under 50-move rule
    WDLWin         =  2, // Win
    WDLScoreNone  = -1000
 };
 // Possible states after a probing operation
@@ -60,15 +60,13 @@ void Thread::clear() {
  counterMoves.fill(MOVE_NONE);
  mainHistory.fill(0);
  captureHistory.fill(0);
  previousDepth = 0;
  for (bool inCheck : { false, true })
      for (StatsType c : { NoCaptures, Captures })
      {
          for (auto& to : continuationHistory[inCheck][c])
-                for (auto& h : to)
+              for (auto& h : to)
-                      h->fill(-71);
+                  h->fill(-71);
          continuationHistory[inCheck][c][NO_PIECE][0]->fill(Search::CounterMovePruneThreshold - 1);
      }
 }
@@ -223,11 +221,14 @@ Thread* ThreadPool::get_best_thread() const {
        minScore = std::min(minScore, th->rootMoves[0].score);
    // Vote according to score and depth, and select the best thread
-    for (Thread* th : *this)
+    auto thread_value = [minScore](Thread* th) {
-    {
+            return (th->rootMoves[0].score - minScore + 14) * int(th->completedDepth);
-        votes[th->rootMoves[0].pv[0]] +=
+        };
            (th->rootMoves[0].score - minScore + 14) * int(th->completedDepth);
    for (Thread* th : *this)
        votes[th->rootMoves[0].pv[0]] += thread_value(th);
    for (Thread* th : *this)
        if (abs(bestThread->rootMoves[0].score) >= VALUE_TB_WIN_IN_MAX_PLY)
        {
            // Make sure we pick the shortest mate / TB conversion or stave off mate the longest
@@ -236,9 +237,10 @@ Thread* ThreadPool::get_best_thread() const {
        }
        else if (   th->rootMoves[0].score >= VALUE_TB_WIN_IN_MAX_PLY
                 || (   th->rootMoves[0].score > VALUE_TB_LOSS_IN_MAX_PLY
-                     && votes[th->rootMoves[0].pv[0]] > votes[bestThread->rootMoves[0].pv[0]]))
+                     && (   votes[th->rootMoves[0].pv[0]] > votes[bestThread->rootMoves[0].pv[0]]
                         || (   votes[th->rootMoves[0].pv[0]] == votes[bestThread->rootMoves[0].pv[0]]
                             && thread_value(th) > thread_value(bestThread)))))
            bestThread = th;
    }
    return bestThread;
 }
@@ -69,13 +69,12 @@ public:
  Position rootPos;
  StateInfo rootState;
  Search::RootMoves rootMoves;
-  Depth rootDepth, completedDepth, depth;
+  Depth rootDepth, completedDepth, previousDepth;
  Value rootDelta;
  CounterMoveHistory counterMoves;
  ButterflyHistory mainHistory;
  CapturePieceToHistory captureHistory;
  ContinuationHistory continuationHistory[2][2];
  Score trend;
 };
@@ -80,7 +80,7 @@ void TimeManagement::init(Search::LimitsType& limits, Color us, int ply) {
  // game time for the current move, so also cap to 20% of available game time.
  if (limits.movestogo == 0)
  {
-      optScale = std::min(0.0084 + std::pow(ply + 3.0, 0.5) * 0.0042,
+      optScale = std::min(0.0120 + std::pow(ply + 3.0, 0.45) * 0.0039,
                           0.2 * limits.time[us] / double(timeLeft))
                 * optExtra;
      maxScale = std::min(7.0, 4.0 + ply / 12.0);
@@ -450,7 +450,7 @@ constexpr Square to_sq(Move m) {
 }
 constexpr int from_to(Move m) {
- return m & 0xFFF;
+  return m & 0xFFF;
 }
 constexpr MoveType type_of(Move m) {
@@ -40,14 +40,14 @@ extern vector<string> setup_bench(const Position&, istream&);
 namespace {
-  // FEN string of the initial position, normal chess
+  // FEN string for the initial position in standard chess
  const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
-  // position() is called when engine receives the "position" UCI command.
+  // position() is called when the engine receives the "position" UCI command.
-  // The function sets up the position described in the given FEN string ("fen")
+  // It sets up the position that is described in the given FEN string ("fen") or
-  // or the starting position ("startpos") and then makes the moves given in the
+  // the initial position ("startpos") and then makes the moves given in the following
-  // following move list ("moves").
+  // move list ("moves").
  void position(Position& pos, istringstream& is, StateListPtr& states) {
@@ -59,7 +59,7 @@ namespace {
    if (token == "startpos")
    {
        fen = StartFEN;
-        is >> token; // Consume "moves" token if any
+        is >> token; // Consume the "moves" token, if any
    }
    else if (token == "fen")
        while (is >> token && token != "moves")
@@ -67,10 +67,10 @@ namespace {
    else
        return;
-    states = StateListPtr(new std::deque<StateInfo>(1)); // Drop old and create a new one
+    states = StateListPtr(new std::deque<StateInfo>(1)); // Drop the old state and create a new one
    pos.set(fen, Options["UCI_Chess960"], &states->back(), Threads.main());
-    // Parse move list (if any)
+    // Parse the move list, if any
    while (is >> token && (m = UCI::to_move(pos, token)) != MOVE_NONE)
    {
        states->emplace_back();
@@ -78,8 +78,8 @@ namespace {
    }
  }
-  // trace_eval() prints the evaluation for the current position, consistent with the UCI
+  // trace_eval() prints the evaluation of the current position, consistent with
-  // options set so far.
+  // the UCI options set so far.
  void trace_eval(Position& pos) {
@@ -93,20 +93,20 @@ namespace {
  }
-  // setoption() is called when engine receives the "setoption" UCI command. The
+  // setoption() is called when the engine receives the "setoption" UCI command.
-  // function updates the UCI option ("name") to the given value ("value").
+  // The function updates the UCI option ("name") to the given value ("value").
  void setoption(istringstream& is) {
    string token, name, value;
-    is >> token; // Consume "name" token
+    is >> token; // Consume the "name" token
-    // Read option name (can contain spaces)
+    // Read the option name (can contain spaces)
    while (is >> token && token != "value")
        name += (name.empty() ? "" : " ") + token;
-    // Read option value (can contain spaces)
+    // Read the option value (can contain spaces)
    while (is >> token)
        value += (value.empty() ? "" : " ") + token;
@@ -117,9 +117,9 @@ namespace {
  }
-  // go() is called when engine receives the "go" UCI command. The function sets
+  // go() is called when the engine receives the "go" UCI command. The function
-  // the thinking time and other parameters from the input string, then starts
+  // sets the thinking time and other parameters from the input string, then starts
-  // the search.
+  // with a search.
  void go(Position& pos, istringstream& is, StateListPtr& states) {
@@ -127,7 +127,7 @@ namespace {
    string token;
    bool ponderMode = false;
-    limits.startTime = now(); // As early as possible!
+    limits.startTime = now(); // The search starts as early as possible
    while (is >> token)
        if (token == "searchmoves") // Needs to be the last command on the line
@@ -151,9 +151,9 @@ namespace {
  }
-  // bench() is called when engine receives the "bench" command. Firstly
+  // bench() is called when the engine receives the "bench" command.
-  // a list of UCI commands is setup according to bench parameters, then
+  // Firstly, a list of UCI commands is set up according to the bench
-  // it is run one by one printing a summary at the end.
+  // parameters, then it is run one by one, printing a summary at the end.
  void bench(Position& pos, istream& args, StateListPtr& states) {
@@ -184,12 +184,12 @@ namespace {
        }
        else if (token == "setoption")  setoption(is);
        else if (token == "position")   position(pos, is, states);
-        else if (token == "ucinewgame") { Search::clear(); elapsed = now(); } // Search::clear() may take some while
+        else if (token == "ucinewgame") { Search::clear(); elapsed = now(); } // Search::clear() may take a while
    }
    elapsed = now() - elapsed + 1; // Ensure positivity to avoid a 'divide by zero'
-    dbg_print(); // Just before exiting
+    dbg_print();
    cerr << "\n==========================="
         << "\nTotal time (ms) : " << elapsed
@@ -197,36 +197,40 @@ namespace {
         << "\nNodes/second    : " << 1000 * nodes / elapsed << endl;
  }
-  // The win rate model returns the probability (per mille) of winning given an eval
+  // The win rate model returns the probability of winning (in per mille units) given an
-  // and a game-ply. The model fits rather accurately the LTC fishtest statistics.
+  // eval and a game ply. It fits the LTC fishtest statistics rather accurately.
  int win_rate_model(Value v, int ply) {
-     // The model captures only up to 240 plies, so limit input (and rescale)
+     // The model only captures up to 240 plies, so limit the input and then rescale
     double m = std::min(240, ply) / 64.0;
-     // Coefficients of a 3rd order polynomial fit based on fishtest data
+     // The coefficients of a third-order polynomial fit is based on the fishtest data
-     // for two parameters needed to transform eval to the argument of a
+     // for two parameters that need to transform eval to the argument of a logistic
-     // logistic function.
+     // function.
-     double as[] = {-1.17202460e-01, 5.94729104e-01, 1.12065546e+01, 1.22606222e+02};
+     constexpr double as[] = {  -0.58270499,    2.68512549,   15.24638015,  344.49745382};
-     double bs[] = {-1.79066759,  11.30759193, -17.43677612,  36.47147479};
+     constexpr double bs[] = {  -2.65734562,   15.96509799,  -20.69040836,   73.61029937 };
     // Enforce that NormalizeToPawnValue corresponds to a 50% win rate at ply 64
     static_assert(UCI::NormalizeToPawnValue == int(as[0] + as[1] + as[2] + as[3]));
     double a = (((as[0] * m + as[1]) * m + as[2]) * m) + as[3];
     double b = (((bs[0] * m + bs[1]) * m + bs[2]) * m) + bs[3];
-     // Transform eval to centipawns with limited range
+     // Transform the eval to centipawns with limited range
-     double x = std::clamp(double(100 * v) / PawnValueEg, -2000.0, 2000.0);
+     double x = std::clamp(double(v), -4000.0, 4000.0);
-     // Return win rate in per mille (rounded to nearest)
+     // Return the win rate in per mille units rounded to the nearest value
     return int(0.5 + 1000 / (1 + std::exp((a - x) / b)));
  }
 } // namespace
-/// UCI::loop() waits for a command from stdin, parses it and calls the appropriate
+/// UCI::loop() waits for a command from the stdin, parses it and then calls the appropriate
-/// function. Also intercepts EOF from stdin to ensure gracefully exiting if the
+/// function. It also intercepts an end-of-file (EOF) indication from the stdin to ensure a
-/// GUI dies unexpectedly. When called with some command line arguments, e.g. to
+/// graceful exit if the GUI dies unexpectedly. When called with some command-line arguments,
-/// run 'bench', once the command is executed the function returns immediately.
+/// like running 'bench', the function returns immediately after the command is executed.
-/// In addition to the UCI ones, also some additional debug commands are supported.
+/// In addition to the UCI ones, some additional debug commands are also supported.
 void UCI::loop(int argc, char* argv[]) {
@@ -240,24 +244,24 @@ void UCI::loop(int argc, char* argv[]) {
      cmd += std::string(argv[i]) + " ";
  do {
-      if (argc == 1 && !getline(cin, cmd)) // Block here waiting for input or EOF
+      if (argc == 1 && !getline(cin, cmd)) // Wait for an input or an end-of-file (EOF) indication
          cmd = "quit";
      istringstream is(cmd);
-      token.clear(); // Avoid a stale if getline() returns empty or blank line
+      token.clear(); // Avoid a stale if getline() returns nothing or a blank line
      is >> skipws >> token;
      if (    token == "quit"
          ||  token == "stop")
          Threads.stop = true;
-      // The GUI sends 'ponderhit' to tell us the user has played the expected move.
+      // The GUI sends 'ponderhit' to tell that the user has played the expected move.
-      // So 'ponderhit' will be sent if we were told to ponder on the same move the
+      // So, 'ponderhit' is sent if pondering was done on the same move that the user
-      // user has played. We should continue searching but switch from pondering to
+      // has played. The search should continue, but should also switch from pondering
-      // normal search.
+      // to the normal search.
      else if (token == "ponderhit")
-          Threads.main()->ponder = false; // Switch to normal search
+          Threads.main()->ponder = false; // Switch to the normal search
      else if (token == "uci")
          sync_cout << "id name " << engine_info(true)
@@ -270,8 +274,8 @@ void UCI::loop(int argc, char* argv[]) {
      else if (token == "ucinewgame") Search::clear();
      else if (token == "isready")    sync_cout << "readyok" << sync_endl;
-      // Additional custom non-UCI commands, mainly for debugging.
+      // Add custom non-UCI commands, mainly for debugging purposes.
-      // Do not use these commands during a search!
+      // These commands must not be used during a search!
      else if (token == "flip")     pos.flip();
      else if (token == "bench")    bench(pos, is, states);
      else if (token == "d")        sync_cout << pos << sync_endl;
@@ -285,19 +289,25 @@ void UCI::loop(int argc, char* argv[]) {
              filename = f;
          Eval::NNUE::save_eval(filename);
      }
      else if (token == "--help" || token == "help" || token == "--license" || token == "license")
          sync_cout << "\nStockfish is a powerful chess engine for playing and analyzing."
                       "\nIt is released as free software licensed under the GNU GPLv3 License."
                       "\nStockfish is normally used with a graphical user interface (GUI) and implements"
                       "\nthe Universal Chess Interface (UCI) protocol to communicate with a GUI, an API, etc."
                       "\nFor any further information, visit https://github.com/official-stockfish/Stockfish#readme"
                       "\nor read the corresponding README.md and Copying.txt files distributed along with this program.\n" << sync_endl;
      else if (!token.empty() && token[0] != '#')
-          sync_cout << "Unknown command: " << cmd << sync_endl;
+          sync_cout << "Unknown command: '" << cmd << "'. Type help for more information." << sync_endl;
-  } while (token != "quit" && argc == 1); // Command line args are one-shot
+  } while (token != "quit" && argc == 1); // The command-line arguments are one-shot
 }
-/// UCI::value() converts a Value to a string suitable for use with the UCI
+/// UCI::value() converts a Value to a string by adhering to the UCI protocol specification:
 /// protocol specification:
 ///
 /// cp <x>    The score from the engine's point of view in centipawns.
-/// mate <y>  Mate in y moves, not plies. If the engine is getting mated
+/// mate <y>  Mate in 'y' moves (not plies). If the engine is getting mated,
-///           use negative values for y.
+///           uses negative values for 'y'.
 string UCI::value(Value v) {
@@ -306,7 +316,7 @@ string UCI::value(Value v) {
  stringstream ss;
  if (abs(v) < VALUE_MATE_IN_MAX_PLY)
-      ss << "cp " << v * 100 / PawnValueEg;
+      ss << "cp " << v * 100 / NormalizeToPawnValue;
  else
      ss << "mate " << (v > 0 ? VALUE_MATE - v + 1 : -VALUE_MATE - v) / 2;
@@ -314,8 +324,8 @@ string UCI::value(Value v) {
 }
-/// UCI::wdl() report WDL statistics given an evaluation and a game ply, based on
+/// UCI::wdl() reports the win-draw-loss (WDL) statistics given an evaluation
-/// data gathered for fishtest LTC games.
+/// and a game ply based on the data gathered for fishtest LTC games.
 string UCI::wdl(Value v, int ply) {
@@ -338,9 +348,9 @@ std::string UCI::square(Square s) {
 /// UCI::move() converts a Move to a string in coordinate notation (g1f3, a7a8q).
-/// The only special case is castling, where we print in the e1g1 notation in
+/// The only special case is castling where the e1g1 notation is printed in
-/// normal chess mode, and in e1h1 notation in chess960 mode. Internally all
+/// standard chess mode and in e1h1 notation it is printed in Chess960 mode.
-/// castling moves are always encoded as 'king captures rook'.
+/// Internally, all castling moves are always encoded as 'king captures rook'.
 string UCI::move(Move m, bool chess960) {
@@ -370,8 +380,8 @@ string UCI::move(Move m, bool chess960) {
 Move UCI::to_move(const Position& pos, string& str) {
-  if (str.length() == 5) // Junior could send promotion piece in uppercase
+  if (str.length() == 5)
-      str[4] = char(tolower(str[4]));
+      str[4] = char(tolower(str[4])); // The promotion piece character must be lowercased
  for (const auto& m : MoveList<LEGAL>(pos))
      if (str == UCI::move(m, pos.is_chess960()))
@@ -30,17 +30,24 @@ class Position;
 namespace UCI {
 // Normalizes the internal value as reported by evaluate or search
 // to the UCI centipawn result used in output. This value is derived from
 // the win_rate_model() such that Stockfish outputs an advantage of
 // "100 centipawns" for a position if the engine has a 50% probability to win
 // from this position in selfplay at fishtest LTC time control.
 const int NormalizeToPawnValue = 361;
 class Option;
-/// Custom comparator because UCI options should be case insensitive
+/// Define a custom comparator, because the UCI options should be case-insensitive
 struct CaseInsensitiveLess {
  bool operator() (const std::string&, const std::string&) const;
 };
-/// Our options container is actually a std::map
+/// The options container is defined as a std::map
 typedef std::map<std::string, Option, CaseInsensitiveLess> OptionsMap;
-/// Option class implements an option as defined by UCI protocol
+/// The Option class implements each option as specified by the UCI protocol
 class Option {
  typedef void (*OnChange)(const Option&);
@@ -72,7 +79,7 @@ void loop(int argc, char* argv[]);
 std::string value(Value v);
 std::string square(Square s);
 std::string move(Move m, bool chess960);
-std::string pv(const Position& pos, Depth depth, Value alpha, Value beta);
+std::string pv(const Position& pos, Depth depth);
 std::string wdl(Value v, int ply);
 Move to_move(const Position& pos, std::string& str);
@@ -61,7 +61,7 @@ void init(OptionsMap& o) {
  constexpr int MaxHashMB = Is64Bit ? 33554432 : 2048;
  o["Debug Log File"]        << Option("", on_logger);
-  o["Threads"]               << Option(1, 1, 512, on_threads);
+  o["Threads"]               << Option(1, 1, 1024, on_threads);
  o["Hash"]                  << Option(16, 1, MaxHashMB, on_hash_size);
  o["Clear Hash"]            << Option(on_clear_hash);
  o["Ponder"]                << Option(false);