v6.26.0

Fix arm64 builds (attempt number 2)

.codespellrc

@@ -0,0 +1,3 @@
+[codespell]
+skip = ./src/3rdparty,./src/crypto/ghostrider,./src/crypto/randomx/blake2,./src/crypto/cn/sse2neon.h,./src/backend/opencl/cl/cn/groestl256.cl,./src/backend/opencl/cl/cn/jh.cl
+ignore-words-list = Carmel,vor

.gitignore

@@ -4,3 +4,5 @@ scripts/deps
 /CMakeLists.txt.user
 /.idea
 /src/backend/opencl/cl/cn/cryptonight_gen.cl
+.vscode
+/.qtcreator

CHANGELOG.md

@@ -1,3 +1,41 @@
+# v6.26.0
+- [#3769](https://github.com/xmrig/xmrig/pull/3769), [#3772](https://github.com/xmrig/xmrig/pull/3772), [#3774](https://github.com/xmrig/xmrig/pull/3774), [#3775](https://github.com/xmrig/xmrig/pull/3775), [#3776](https://github.com/xmrig/xmrig/pull/3776), [#3782](https://github.com/xmrig/xmrig/pull/3782), [#3783](https://github.com/xmrig/xmrig/pull/3783) **Added support for RandomX v2.**
+- [#3746](https://github.com/xmrig/xmrig/pull/3746) RISC-V: vectorized RandomX main loop.
+- [#3748](https://github.com/xmrig/xmrig/pull/3748) RISC-V: auto-detect and use vector code for all RandomX AES functions.
+- [#3749](https://github.com/xmrig/xmrig/pull/3749) RISC-V: detect and use hardware AES.
+- [#3750](https://github.com/xmrig/xmrig/pull/3750) RISC-V: use vector hardware AES instead of scalar.
+- [#3757](https://github.com/xmrig/xmrig/pull/3757) RISC-V: Fixed scratchpad prefetch, removed an unnecessary instruction.
+- [#3758](https://github.com/xmrig/xmrig/pull/3758) RandomX: added VAES-512 support for Zen5.
+- [#3759](https://github.com/xmrig/xmrig/pull/3759) RandomX: Optimized VAES code.
+- [#3762](https://github.com/xmrig/xmrig/pull/3762) Fixed keepalive timer logic.
+- [#3778](https://github.com/xmrig/xmrig/pull/3778) RandomX: ARM64 fixes.
+- [#3784](https://github.com/xmrig/xmrig/pull/3784) Fixed OpenCL address-space mismatch in `keccak_f800_round`.
+- [#3785](https://github.com/xmrig/xmrig/pull/3785) Don't reset nonce during donation rounds.
+
+# v6.25.0
+- [#3680](https://github.com/xmrig/xmrig/pull/3680) Added `armv8l` to the list of 32-bit ARM targets.
+- [#3708](https://github.com/xmrig/xmrig/pull/3708) Minor Aarch64 JIT changes (better instruction selection, don't emit instructions that add 0, etc).
+- [#3718](https://github.com/xmrig/xmrig/pull/3718) Solo mining: added support for FCMP++ hardfork.
+- [#3722](https://github.com/xmrig/xmrig/pull/3722) Added Zen4 (Hawk Point) CPUs detection.
+- [#3725](https://github.com/xmrig/xmrig/pull/3725) Added **RISC-V** support with JIT compiler.
+- [#3731](https://github.com/xmrig/xmrig/pull/3731) Added initial Haiku OS support.
+- [#3733](https://github.com/xmrig/xmrig/pull/3733) Added detection for MSVC/2026.
+- [#3736](https://github.com/xmrig/xmrig/pull/3736) RISC-V: added vectorized dataset init.
+- [#3740](https://github.com/xmrig/xmrig/pull/3740) RISC-V: added vectorized soft AES.
+- [#3743](https://github.com/xmrig/xmrig/pull/3743) Linux: added support for transparent huge pages.
+- Improved LibreSSL support.
+- Improved compatibility for automatically enabling huge pages on Linux systems without NUMA support.
+
+# v6.24.0
+- [#3671](https://github.com/xmrig/xmrig/pull/3671) Fixed detection of L2 cache size for some complex NUMA topologies.
+- [#3674](https://github.com/xmrig/xmrig/pull/3674) Fixed ARMv7 build.
+- [#3677](https://github.com/xmrig/xmrig/pull/3677) Fixed auto-config for AMD CPUs with less than 2 MB L3 cache per thread.
+- [#3678](https://github.com/xmrig/xmrig/pull/3678) Improved IPv6 support: the new default settings use IPv6 equally with IPv4.
+
+# v6.23.0
+- [#3668](https://github.com/xmrig/xmrig/issues/3668) Added support for Windows ARM64.
+- [#3665](https://github.com/xmrig/xmrig/pull/3665) Tweaked auto-config for AMD CPUs with < 2 MB L3 cache per thread.
+
 # v6.22.3
 - [#3605](https://github.com/xmrig/xmrig/pull/3605) CUDA backend: added missing RandomX dataset update.
 - [#3646](https://github.com/xmrig/xmrig/pull/3646) Optimized auto-config for AMD CPUs with less than 2 MB L3 cache per thread.
@@ -136,7 +174,7 @@
 # v6.16.2
 - [#2751](https://github.com/xmrig/xmrig/pull/2751) Fixed crash on CPUs supporting VAES and running GCC-compiled xmrig.
 - [#2761](https://github.com/xmrig/xmrig/pull/2761) Fixed broken auto-tuning in GCC Windows build.
-- [#2771](https://github.com/xmrig/xmrig/issues/2771) Fixed environment variables support for GhostRider and KawPow. 
+- [#2771](https://github.com/xmrig/xmrig/issues/2771) Fixed environment variables support for GhostRider and KawPow.
 - [#2769](https://github.com/xmrig/xmrig/pull/2769) Performance fixes:
   - Fixed several performance bottlenecks introduced in v6.16.1.
   - Fixed overall GCC-compiled build performance, it's the same speed as MSVC build now.
@@ -444,7 +482,7 @@
 - Compiler for Windows gcc builds updated to v10.1.
 
 # v5.11.1
-- [#1652](https://github.com/xmrig/xmrig/pull/1652) Up to 1% RandomX perfomance improvement on recent AMD CPUs.
+- [#1652](https://github.com/xmrig/xmrig/pull/1652) Up to 1% RandomX performance improvement on recent AMD CPUs.
 - [#1306](https://github.com/xmrig/xmrig/issues/1306) Fixed possible double connection to a pool.
 - [#1654](https://github.com/xmrig/xmrig/issues/1654) Fixed build with LibreSSL.
 
@@ -550,9 +588,9 @@
   - Added automatic huge pages configuration on Linux if use the miner with root privileges.
 - **Added [automatic Intel prefetchers configuration](https://xmrig.com/docs/miner/randomx-optimization-guide#intel-specific-optimizations) on Linux.**
    - Added new option `wrmsr` in `randomx` object with command line equivalent `--randomx-wrmsr=6`.
-- [#1396](https://github.com/xmrig/xmrig/pull/1396) [#1401](https://github.com/xmrig/xmrig/pull/1401) New performance optimizations for Ryzen CPUs. 
-- [#1385](https://github.com/xmrig/xmrig/issues/1385) Added `max-threads-hint` option support for RandomX dataset initialization threads.  
-- [#1386](https://github.com/xmrig/xmrig/issues/1386) Added `priority` option support for RandomX dataset initialization threads. 
+- [#1396](https://github.com/xmrig/xmrig/pull/1396) [#1401](https://github.com/xmrig/xmrig/pull/1401) New performance optimizations for Ryzen CPUs.
+- [#1385](https://github.com/xmrig/xmrig/issues/1385) Added `max-threads-hint` option support for RandomX dataset initialization threads.
+- [#1386](https://github.com/xmrig/xmrig/issues/1386) Added `priority` option support for RandomX dataset initialization threads.
 - For official builds all dependencies (libuv, hwloc, openssl) updated to recent versions.
 - Windows `msvc` builds now use Visual Studio 2019 instead of 2017.
 
@@ -598,7 +636,7 @@ This release based on 4.x.x series and include all features from v4.6.2-beta, ch
 - Removed command line option `--http-enabled`, HTTP API enabled automatically if any other `--http-*` option provided.
 - [#1172](https://github.com/xmrig/xmrig/issues/1172) **Added OpenCL mining backend.**
   - [#268](https://github.com/xmrig/xmrig-amd/pull/268) [#270](https://github.com/xmrig/xmrig-amd/pull/270) [#271](https://github.com/xmrig/xmrig-amd/pull/271) [#273](https://github.com/xmrig/xmrig-amd/pull/273) [#274](https://github.com/xmrig/xmrig-amd/pull/274) [#1171](https://github.com/xmrig/xmrig/pull/1171) Added RandomX support for OpenCL, thanks [@SChernykh](https://github.com/SChernykh).
-- Algorithm `cn/wow` removed, as no longer alive. 
+- Algorithm `cn/wow` removed, as no longer alive.
 
 # Previous versions
 [doc/CHANGELOG_OLD.md](doc/CHANGELOG_OLD.md)

CMakeLists.txt

@@ -95,7 +95,7 @@ set(HEADERS_CRYPTO
     src/crypto/common/VirtualMemory.h
    )
 
-if (XMRIG_ARM)
+if (XMRIG_ARM OR XMRIG_RISCV)
     set(HEADERS_CRYPTO "${HEADERS_CRYPTO}" src/crypto/cn/CryptoNight_arm.h)
 else()
     set(HEADERS_CRYPTO "${HEADERS_CRYPTO}" src/crypto/cn/CryptoNight_x86.h)

README.md

@@ -10,7 +10,7 @@
 XMRig is a high performance, open source, cross platform RandomX, KawPow, CryptoNight and [GhostRider](https://github.com/xmrig/xmrig/tree/master/src/crypto/ghostrider#readme) unified CPU/GPU miner and [RandomX benchmark](https://xmrig.com/benchmark). Official binaries are available for Windows, Linux, macOS and FreeBSD.
 
 ## Mining backends
-- **CPU** (x86/x64/ARMv7/ARMv8)
+- **CPU** (x86/x64/ARMv7/ARMv8/RISC-V)
 - **OpenCL** for AMD GPUs.
 - **CUDA** for NVIDIA GPUs via external [CUDA plugin](https://github.com/xmrig/xmrig-cuda).
 

cmake/asm.cmake

@@ -1,4 +1,4 @@
-if (WITH_ASM AND NOT XMRIG_ARM AND CMAKE_SIZEOF_VOID_P EQUAL 8)
+if (WITH_ASM AND NOT XMRIG_ARM AND NOT XMRIG_RISCV AND CMAKE_SIZEOF_VOID_P EQUAL 8)
     set(XMRIG_ASM_LIBRARY "xmrig-asm")
 
     if (CMAKE_C_COMPILER_ID MATCHES MSVC)

cmake/cpu.cmake

@@ -21,6 +21,19 @@ if (NOT VAES_SUPPORTED)
     set(WITH_VAES OFF)
 endif()
 
+# Detect RISC-V architecture early (before it's used below)
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(riscv64|riscv|rv64)$")
+    set(RISCV_TARGET 64)
+    set(XMRIG_RISCV ON)
+    add_definitions(-DXMRIG_RISCV)
+    message(STATUS "Detected RISC-V 64-bit architecture (${CMAKE_SYSTEM_PROCESSOR})")
+elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "^(riscv32|rv32)$")
+    set(RISCV_TARGET 32)
+    set(XMRIG_RISCV ON)
+    add_definitions(-DXMRIG_RISCV)
+    message(STATUS "Detected RISC-V 32-bit architecture (${CMAKE_SYSTEM_PROCESSOR})")
+endif()
+
 if (XMRIG_64_BIT AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64)$")
     add_definitions(-DRAPIDJSON_SSE2)
 else()
@@ -29,6 +42,120 @@ else()
     set(WITH_VAES OFF)
 endif()
 
+# Disable x86-specific features for RISC-V
+if (XMRIG_RISCV)
+    set(WITH_SSE4_1 OFF)
+    set(WITH_AVX2 OFF)
+    set(WITH_VAES OFF)
+
+    # default build uses the RV64GC baseline
+    set(RVARCH "rv64gc")
+
+    enable_language(ASM)
+
+    try_run(RANDOMX_VECTOR_RUN_FAIL
+        RANDOMX_VECTOR_COMPILE_OK
+        ${CMAKE_CURRENT_BINARY_DIR}/
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/crypto/randomx/tests/riscv64_vector.s
+        COMPILE_DEFINITIONS "-march=rv64gcv")
+
+    if (RANDOMX_VECTOR_COMPILE_OK AND NOT RANDOMX_VECTOR_RUN_FAIL)
+        set(RVARCH_V ON)
+        message(STATUS "RISC-V vector extension detected")
+    else()
+        set(RVARCH_V OFF)
+    endif()
+
+    try_run(RANDOMX_ZICBOP_RUN_FAIL
+        RANDOMX_ZICBOP_COMPILE_OK
+        ${CMAKE_CURRENT_BINARY_DIR}/
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/crypto/randomx/tests/riscv64_zicbop.s
+        COMPILE_DEFINITIONS "-march=rv64gc_zicbop")
+
+    if (RANDOMX_ZICBOP_COMPILE_OK AND NOT RANDOMX_ZICBOP_RUN_FAIL)
+        set(RVARCH_ZICBOP ON)
+        message(STATUS "RISC-V zicbop extension detected")
+    else()
+        set(RVARCH_ZICBOP OFF)
+    endif()
+
+    try_run(RANDOMX_ZBA_RUN_FAIL
+        RANDOMX_ZBA_COMPILE_OK
+        ${CMAKE_CURRENT_BINARY_DIR}/
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/crypto/randomx/tests/riscv64_zba.s
+        COMPILE_DEFINITIONS "-march=rv64gc_zba")
+
+    if (RANDOMX_ZBA_COMPILE_OK AND NOT RANDOMX_ZBA_RUN_FAIL)
+        set(RVARCH_ZBA ON)
+        message(STATUS "RISC-V zba extension detected")
+    else()
+        set(RVARCH_ZBA OFF)
+    endif()
+
+    try_run(RANDOMX_ZBB_RUN_FAIL
+        RANDOMX_ZBB_COMPILE_OK
+        ${CMAKE_CURRENT_BINARY_DIR}/
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/crypto/randomx/tests/riscv64_zbb.s
+        COMPILE_DEFINITIONS "-march=rv64gc_zbb")
+
+    if (RANDOMX_ZBB_COMPILE_OK AND NOT RANDOMX_ZBB_RUN_FAIL)
+        set(RVARCH_ZBB ON)
+        message(STATUS "RISC-V zbb extension detected")
+    else()
+        set(RVARCH_ZBB OFF)
+    endif()
+
+    try_run(RANDOMX_ZVKB_RUN_FAIL
+        RANDOMX_ZVKB_COMPILE_OK
+        ${CMAKE_CURRENT_BINARY_DIR}/
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/crypto/randomx/tests/riscv64_zvkb.s
+        COMPILE_DEFINITIONS "-march=rv64gcv_zvkb")
+
+    if (RANDOMX_ZVKB_COMPILE_OK AND NOT RANDOMX_ZVKB_RUN_FAIL)
+        set(RVARCH_ZVKB ON)
+        message(STATUS "RISC-V zvkb extension detected")
+    else()
+        set(RVARCH_ZVKB OFF)
+    endif()
+
+    try_run(RANDOMX_ZVKNED_RUN_FAIL
+        RANDOMX_ZVKNED_COMPILE_OK
+        ${CMAKE_CURRENT_BINARY_DIR}/
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/crypto/randomx/tests/riscv64_zvkned.s
+        COMPILE_DEFINITIONS "-march=rv64gcv_zvkned")
+
+    if (RANDOMX_ZVKNED_COMPILE_OK AND NOT RANDOMX_ZVKNED_RUN_FAIL)
+        set(RVARCH_ZVKNED ON)
+        message(STATUS "RISC-V zvkned extension detected")
+    else()
+        set(RVARCH_ZVKNED OFF)
+    endif()
+
+    # for native builds, enable Zba and Zbb if supported by the CPU
+    if (ARCH STREQUAL "native")
+        if (RVARCH_V)
+            set(RVARCH "${RVARCH}v")
+        endif()
+        if (RVARCH_ZICBOP)
+            set(RVARCH "${RVARCH}_zicbop")
+        endif()
+        if (RVARCH_ZBA)
+            set(RVARCH "${RVARCH}_zba")
+        endif()
+        if (RVARCH_ZBB)
+            set(RVARCH "${RVARCH}_zbb")
+        endif()
+        if (RVARCH_ZVKB)
+            set(RVARCH "${RVARCH}_zvkb")
+        endif()
+        if (RVARCH_ZVKNED)
+            set(RVARCH "${RVARCH}_zvkned")
+        endif()
+    endif()
+
+    message(STATUS "Using -march=${RVARCH}")
+endif()
+
 add_definitions(-DRAPIDJSON_WRITE_DEFAULT_FLAGS=6) # rapidjson::kWriteNanAndInfFlag | rapidjson::kWriteNanAndInfNullFlag
 
 if (ARM_V8)
@@ -40,7 +167,7 @@ endif()
 if (NOT ARM_TARGET)
     if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64|armv8-a)$")
         set(ARM_TARGET 8)
-    elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "^(armv7|armv7f|armv7s|armv7k|armv7-a|armv7l|armv7ve)$")
+    elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "^(armv7|armv7f|armv7s|armv7k|armv7-a|armv7l|armv7ve|armv8l)$")
         set(ARM_TARGET 7)
     endif()
 endif()
@@ -51,7 +178,7 @@ if (ARM_TARGET AND ARM_TARGET GREATER 6)
 
     message(STATUS "Use ARM_TARGET=${ARM_TARGET} (${CMAKE_SYSTEM_PROCESSOR})")
 
-    if (ARM_TARGET EQUAL 8)
+    if (ARM_TARGET EQUAL 8 AND (CMAKE_CXX_COMPILER_ID MATCHES GNU OR CMAKE_CXX_COMPILER_ID MATCHES Clang))
         CHECK_CXX_COMPILER_FLAG(-march=armv8-a+crypto XMRIG_ARM_CRYPTO)
 
         if (XMRIG_ARM_CRYPTO)

cmake/flags.cmake

@@ -26,8 +26,13 @@ if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARM8_CXX_FLAGS}")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ARM8_CXX_FLAGS} -flax-vector-conversions")
     elseif (ARM_TARGET EQUAL 7)
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv7-a -mfpu=neon")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv7-a -mfpu=neon -flax-vector-conversions")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv7-a -mfpu=neon -flax-vector-conversions")
+    elseif (XMRIG_RISCV)
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=${RVARCH}")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=${RVARCH}")
+        
+        add_definitions(-DHAVE_ROTR)
     else()
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maes")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maes")
@@ -41,6 +46,8 @@ if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
         else()
             set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static -Wl,--large-address-aware")
         endif()
+    elseif(CMAKE_SYSTEM_NAME STREQUAL "Haiku")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc")
     else()
         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++")
     endif()
@@ -63,10 +70,10 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
 elseif (CMAKE_CXX_COMPILER_ID MATCHES Clang)
 
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -Ofast -funroll-loops -fmerge-all-constants")
+    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -funroll-loops -fmerge-all-constants")
 
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -fexceptions -fno-rtti -Wno-missing-braces")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Ofast -funroll-loops -fmerge-all-constants")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -fexceptions -fno-rtti")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -funroll-loops -fmerge-all-constants")
 
     if (ARM_TARGET EQUAL 8)
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARM8_CXX_FLAGS}")
@@ -74,6 +81,11 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES Clang)
     elseif (ARM_TARGET EQUAL 7)
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=neon -march=${CMAKE_SYSTEM_PROCESSOR}")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=neon -march=${CMAKE_SYSTEM_PROCESSOR}")
+    elseif (XMRIG_RISCV)
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=${RVARCH}")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=${RVARCH}")
+        
+        add_definitions(-DHAVE_ROTR)
     else()
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maes")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maes")
@@ -84,10 +96,9 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES Clang)
         endif()
     endif()
 
-    if (BUILD_STATIC OR WIN32)
+    if ((WIN32 AND ARM_TARGET) OR BUILD_STATIC)
         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")
     endif()
-
 endif()
 
 if (NOT WIN32)

cmake/os.cmake

@@ -17,6 +17,10 @@ else()
         set(XMRIG_OS_LINUX ON)
     elseif(CMAKE_SYSTEM_NAME STREQUAL FreeBSD OR CMAKE_SYSTEM_NAME STREQUAL DragonFly)
         set(XMRIG_OS_FREEBSD ON)
+    elseif(CMAKE_SYSTEM_NAME STREQUAL OpenBSD)
+        set(XMRIG_OS_OPENBSD ON)
+    elseif(CMAKE_SYSTEM_NAME STREQUAL "Haiku")
+        set(XMRIG_OS_HAIKU ON)
     endif()
 endif()
 
@@ -43,6 +47,10 @@ elseif(XMRIG_OS_UNIX)
         add_definitions(-DXMRIG_OS_LINUX)
     elseif (XMRIG_OS_FREEBSD)
         add_definitions(-DXMRIG_OS_FREEBSD)
+    elseif (XMRIG_OS_OPENBSD)
+        add_definitions(-DXMRIG_OS_OPENBSD)
+    elseif (XMRIG_OS_HAIKU)
+        add_definitions(-DXMRIG_OS_HAIKU)
     endif()
 endif()
 

cmake/randomx.cmake

@@ -1,4 +1,18 @@
 if (WITH_RANDOMX)
+    include(CheckSymbolExists)
+
+    if (WIN32)
+        check_symbol_exists(_aligned_malloc "stdlib.h" HAVE_ALIGNED_MALLOC)
+        if (HAVE_ALIGNED_MALLOC)
+            add_compile_definitions(HAVE_ALIGNED_MALLOC)
+        endif()
+    else()
+        check_symbol_exists(posix_memalign "stdlib.h" HAVE_POSIX_MEMALIGN)
+        if (HAVE_POSIX_MEMALIGN)
+            add_compile_definitions(HAVE_POSIX_MEMALIGN)
+        endif()
+    endif()
+
     add_definitions(/DXMRIG_ALGO_RANDOMX)
     set(WITH_ARGON2 ON)
 
@@ -48,7 +62,7 @@ if (WITH_RANDOMX)
              src/crypto/randomx/jit_compiler_x86_static.asm
              src/crypto/randomx/jit_compiler_x86.cpp
             )
-    elseif (WITH_ASM AND NOT XMRIG_ARM AND CMAKE_SIZEOF_VOID_P EQUAL 8)
+    elseif (WITH_ASM AND NOT XMRIG_ARM AND NOT XMRIG_RISCV AND CMAKE_SIZEOF_VOID_P EQUAL 8)
         list(APPEND SOURCES_CRYPTO
              src/crypto/randomx/jit_compiler_x86_static.S
              src/crypto/randomx/jit_compiler_x86.cpp
@@ -66,6 +80,39 @@ if (WITH_RANDOMX)
         else()
             set_property(SOURCE src/crypto/randomx/jit_compiler_a64_static.S PROPERTY LANGUAGE C)
         endif()
+    elseif (XMRIG_RISCV AND CMAKE_SIZEOF_VOID_P EQUAL 8)
+        list(APPEND SOURCES_CRYPTO
+             src/crypto/randomx/jit_compiler_rv64_static.S
+             src/crypto/randomx/jit_compiler_rv64_vector_static.S
+             src/crypto/randomx/jit_compiler_rv64.cpp
+             src/crypto/randomx/jit_compiler_rv64_vector.cpp
+             src/crypto/randomx/aes_hash_rv64_vector.cpp
+             src/crypto/randomx/aes_hash_rv64_zvkned.cpp
+            )
+        # cheat because cmake and ccache hate each other
+        set_property(SOURCE src/crypto/randomx/jit_compiler_rv64_static.S PROPERTY LANGUAGE C)
+        set_property(SOURCE src/crypto/randomx/jit_compiler_rv64_vector_static.S PROPERTY LANGUAGE C)
+
+        set(RV64_VECTOR_FILE_ARCH "rv64gcv")
+
+        if (ARCH STREQUAL "native")
+            if (RVARCH_ZICBOP)
+                set(RV64_VECTOR_FILE_ARCH "${RV64_VECTOR_FILE_ARCH}_zicbop")
+            endif()
+            if (RVARCH_ZBA)
+                set(RV64_VECTOR_FILE_ARCH "${RV64_VECTOR_FILE_ARCH}_zba")
+            endif()
+            if (RVARCH_ZBB)
+                set(RV64_VECTOR_FILE_ARCH "${RV64_VECTOR_FILE_ARCH}_zbb")
+            endif()
+            if (RVARCH_ZVKB)
+                set(RV64_VECTOR_FILE_ARCH "${RV64_VECTOR_FILE_ARCH}_zvkb")
+            endif()
+        endif()
+
+        set_source_files_properties(src/crypto/randomx/jit_compiler_rv64_vector_static.S PROPERTIES COMPILE_FLAGS "-march=${RV64_VECTOR_FILE_ARCH}_zvkned")
+        set_source_files_properties(src/crypto/randomx/aes_hash_rv64_vector.cpp PROPERTIES COMPILE_FLAGS "-O3 -march=${RV64_VECTOR_FILE_ARCH}")
+        set_source_files_properties(src/crypto/randomx/aes_hash_rv64_zvkned.cpp PROPERTIES COMPILE_FLAGS "-O3 -march=${RV64_VECTOR_FILE_ARCH}_zvkned")
     else()
         list(APPEND SOURCES_CRYPTO
              src/crypto/randomx/jit_compiler_fallback.cpp
@@ -102,7 +149,7 @@ if (WITH_RANDOMX)
             )
     endif()
 
-    if (WITH_MSR AND NOT XMRIG_ARM AND CMAKE_SIZEOF_VOID_P EQUAL 8 AND (XMRIG_OS_WIN OR XMRIG_OS_LINUX))
+    if (WITH_MSR AND NOT XMRIG_ARM AND NOT XMRIG_RISCV AND CMAKE_SIZEOF_VOID_P EQUAL 8 AND (XMRIG_OS_WIN OR XMRIG_OS_LINUX))
         add_definitions(/DXMRIG_FEATURE_MSR)
         add_definitions(/DXMRIG_FIX_RYZEN)
         message("-- WITH_MSR=ON")
@@ -143,6 +190,15 @@ if (WITH_RANDOMX)
         list(APPEND HEADERS_CRYPTO src/crypto/rx/Profiler.h)
         list(APPEND SOURCES_CRYPTO src/crypto/rx/Profiler.cpp)
     endif()
+
+    if (WITH_VAES)
+        set(SOURCES_CRYPTO "${SOURCES_CRYPTO}" src/crypto/randomx/aes_hash_vaes512.cpp)
+        if (CMAKE_C_COMPILER_ID MATCHES MSVC)
+            set_source_files_properties(src/crypto/randomx/aes_hash_vaes512.cpp PROPERTIES COMPILE_FLAGS "/arch:AVX512")
+        elseif (CMAKE_C_COMPILER_ID MATCHES GNU OR CMAKE_C_COMPILER_ID MATCHES Clang)
+            set_source_files_properties(src/crypto/randomx/aes_hash_vaes512.cpp PROPERTIES COMPILE_FLAGS "-mavx512f -mvaes")
+        endif()
+    endif()
 else()
     remove_definitions(/DXMRIG_ALGO_RANDOMX)
 endif()

doc/API.md

@@ -1,8 +1,8 @@
 # HTTP API
 
-If you want use HTTP API you need enable it (`"enabled": true,`) then choice `port` and optionaly `host`. API not available if miner built without HTTP support (`-DWITH_HTTP=OFF`).
+If you want use HTTP API you need enable it (`"enabled": true,`) then choice `port` and optionally `host`. API not available if miner built without HTTP support (`-DWITH_HTTP=OFF`).
 
-Offical HTTP client for API: http://workers.xmrig.info/
+Official HTTP client for API: http://workers.xmrig.info/
 
 Example configuration:
 

doc/BENCHMARK.md

@@ -17,7 +17,7 @@ Double check that you see `Huge pages 100%` both for dataset and for all threads
 
 ### Benchmark with custom config
 
-You can run benchmark with any configuration you want. Just start without command line parameteres, use regular config.json and add `"benchmark":"1M",` on the next line after pool url. 
+You can run benchmark with any configuration you want. Just start without command line parameters, use regular config.json and add `"benchmark":"1M",` on the next line after pool url.
 
 # Stress test
 
@@ -26,4 +26,4 @@ You can also run continuous stress-test that is as close to the real RandomX min
 xmrig --stress
 xmrig --stress -a rx/wow
 ```
-This will require Internet connection and will run indefinitely.
+This will require Internet connection and will run indefinitely.

doc/CHANGELOG_OLD.md

@@ -57,7 +57,7 @@
 # v4.0.0-beta
 - [#1172](https://github.com/xmrig/xmrig/issues/1172) **Added OpenCL mining backend.**
   - [#268](https://github.com/xmrig/xmrig-amd/pull/268) [#270](https://github.com/xmrig/xmrig-amd/pull/270) [#271](https://github.com/xmrig/xmrig-amd/pull/271) [#273](https://github.com/xmrig/xmrig-amd/pull/273) [#274](https://github.com/xmrig/xmrig-amd/pull/274) [#1171](https://github.com/xmrig/xmrig/pull/1171) Added RandomX support for OpenCL, thanks [@SChernykh](https://github.com/SChernykh).
-- Algorithm `cn/wow` removed, as no longer alive. 
+- Algorithm `cn/wow` removed, as no longer alive.
 
 # v3.2.0
 - Added per pool option `coin` with single possible value `monero` for pools without algorithm negotiation, for upcoming Monero fork.
@@ -103,7 +103,7 @@
 - [#1105](https://github.com/xmrig/xmrig/issues/1105) Improved auto configuration for `cn-pico` algorithm.
 - Added commands `pause` and `resume` via JSON RPC 2.0 API (`POST /json_rpc`).
 - Added command line option `--export-topology` for export hwloc topology to a XML file.
-- Breaked backward compatibility with previous configs and command line, `variant` option replaced to `algo`, global option `algo` removed, all CPU related settings moved to `cpu` object.
+- Broken backward compatibility with previous configs and command line, `variant` option replaced to `algo`, global option `algo` removed, all CPU related settings moved to `cpu` object.
 - Options `av`, `safe` and `max-cpu-usage` removed.
 - Algorithm `cn/msr` renamed to `cn/fast`.
 - Algorithm `cn/xtl` removed.
@@ -122,7 +122,7 @@
 - [#1092](https://github.com/xmrig/xmrig/issues/1092) Fixed crash if wrong CPU affinity used.
 - [#1103](https://github.com/xmrig/xmrig/issues/1103) Improved auto configuration for RandomX for CPUs where L2 cache is limiting factor.
 - [#1105](https://github.com/xmrig/xmrig/issues/1105) Improved auto configuration for `cn-pico` algorithm.
-- [#1106](https://github.com/xmrig/xmrig/issues/1106) Fixed `hugepages` field in summary API. 
+- [#1106](https://github.com/xmrig/xmrig/issues/1106) Fixed `hugepages` field in summary API.
 - Added alternative short format for CPU threads.
 - Changed format for CPU threads with intensity above 1.
 - Name for reference RandomX configuration changed to `rx/test` to avoid potential conflicts in future.
@@ -150,7 +150,7 @@
 - [#1050](https://github.com/xmrig/xmrig/pull/1050) Added RandomXL algorithm for [Loki](https://loki.network/), algorithm name used by miner is `randomx/loki` or `rx/loki`.
 - Added [flexible](https://github.com/xmrig/xmrig/blob/evo/doc/CPU.md) multi algorithm configuration.
 - Added unlimited switching between incompatible algorithms, all mining options can be changed in runtime.
-- Breaked backward compatibility with previous configs and command line, `variant` option replaced to `algo`, global option `algo` removed, all CPU related settings moved to `cpu` object.
+- Broken backward compatibility with previous configs and command line, `variant` option replaced to `algo`, global option `algo` removed, all CPU related settings moved to `cpu` object.
 - Options `av`, `safe` and `max-cpu-usage` removed.
 - Algorithm `cn/msr` renamed to `cn/fast`.
 - Algorithm `cn/xtl` removed.
@@ -183,7 +183,7 @@
 - [#314](https://github.com/xmrig/xmrig-proxy/issues/314) Added donate over proxy feature.
   - Added new option `donate-over-proxy`.
   - Added real graceful exit.
-  
+
 # v2.14.4
 - [#992](https://github.com/xmrig/xmrig/pull/992)  Fixed compilation with Clang 3.5.
 - [#1012](https://github.com/xmrig/xmrig/pull/1012) Fixed compilation with Clang 9.0.
@@ -250,7 +250,7 @@
 # v2.8.1
 - [#768](https://github.com/xmrig/xmrig/issues/768) Fixed build with Visual Studio 2015.
 - [#769](https://github.com/xmrig/xmrig/issues/769) Fixed regression, some ANSI escape sequences was in log with disabled colors.
-- [#777](https://github.com/xmrig/xmrig/issues/777) Better report about pool connection issues. 
+- [#777](https://github.com/xmrig/xmrig/issues/777) Better report about pool connection issues.
 - Simplified checks for ASM auto detection, only AES support necessary.
 - Added missing options to `--help` output.
 
@@ -259,7 +259,7 @@
   - Added global and per thread option `"asm"` and command line equivalent.
 - **[#758](https://github.com/xmrig/xmrig/issues/758) Added SSL/TLS support for secure connections to pools.**
   - Added per pool options `"tls"` and `"tls-fingerprint"` and command line equivalents.
-- [#767](https://github.com/xmrig/xmrig/issues/767) Added config autosave feature, same with GPU miners.  
+- [#767](https://github.com/xmrig/xmrig/issues/767) Added config autosave feature, same with GPU miners.
 - [#245](https://github.com/xmrig/xmrig-proxy/issues/245) Fixed API ID collision when run multiple miners on same machine.
 - [#757](https://github.com/xmrig/xmrig/issues/757) Fixed send buffer overflow.
 
@@ -346,7 +346,7 @@
 
 # v2.4.4
  - Added libmicrohttpd version to --version output.
- - Fixed bug in singal handler, in some cases miner wasn't shutdown properly.
+ - Fixed bug in signal handler, in some cases miner wasn't shutdown properly.
  - Fixed recent MSVC 2017 version detection.
  - [#279](https://github.com/xmrig/xmrig/pull/279) Fixed build on some macOS versions.
 
@@ -359,7 +359,7 @@
 # v2.4.2
  - [#60](https://github.com/xmrig/xmrig/issues/60) Added FreeBSD support, thanks [vcambur](https://github.com/vcambur).
  - [#153](https://github.com/xmrig/xmrig/issues/153) Fixed issues with dwarfpool.com.
- 
+
 # v2.4.1
   - [#147](https://github.com/xmrig/xmrig/issues/147) Fixed comparability with monero-stratum.
 
@@ -371,7 +371,7 @@
  - [#101](https://github.com/xmrig/xmrig/issues/101) Fixed MSVC 2017 (15.3) compile time version detection.
  - [#108](https://github.com/xmrig/xmrig/issues/108) Silently ignore invalid values for `donate-level` option.
  - [#111](https://github.com/xmrig/xmrig/issues/111) Fixed build without AEON support.
- 
+
 # v2.3.1
 - [#68](https://github.com/xmrig/xmrig/issues/68) Fixed compatibility with Docker containers, was nothing print on console.
 
@@ -398,7 +398,7 @@
 # v2.1.0
 - [#40](https://github.com/xmrig/xmrig/issues/40)
 Improved miner shutdown, fixed crash on exit for Linux and OS X.
-- Fixed, login request was contain malformed JSON if username or password has some special characters for example `\`. 
+- Fixed, login request was contain malformed JSON if username or password has some special characters for example `\`.
 - [#220](https://github.com/fireice-uk/xmr-stak-cpu/pull/220) Better support for Round Robin DNS, IP address now always chosen randomly instead of stuck on first one.
 - Changed donation address, new [xmrig-proxy](https://github.com/xmrig/xmrig-proxy) is coming soon.
 
@@ -418,16 +418,16 @@ Improved miner shutdown, fixed crash on exit for Linux and OS X.
  - Fixed Windows XP support.
  - Fixed regression, option `--no-color` was not fully disable colored output.
  - Show resolved pool IP address in miner output.
- 
+
 # v1.0.1
 - Fix broken software AES implementation, app has crashed if CPU not support AES-NI, only version 1.0.0 affected.
 
 # v1.0.0
 - Miner complete rewritten in C++ with libuv.
-- This version should be fully compatible (except config file) with previos versions, many new nice features will come in next versions.
-- This is still beta. If you found regression, stability or perfomance issues or have an idea for new feature please fell free to open new [issue](https://github.com/xmrig/xmrig/issues/new).
+- This version should be fully compatible (except config file) with previous versions, many new nice features will come in next versions.
+- This is still beta. If you found regression, stability or performance issues or have an idea for new feature please fell free to open new [issue](https://github.com/xmrig/xmrig/issues/new).
 - Added new option `--print-time=N`, print hashrate report every N seconds.
-- New hashrate reports, by default every 60 secons.
+- New hashrate reports, by default every 60 seconds.
 - Added Microsoft Visual C++ 2015 and 2017 support.
 - Removed dependency on libcurl.
 - To compile this version from source please switch to [dev](https://github.com/xmrig/xmrig/tree/dev) branch.
@@ -440,7 +440,7 @@ Improved miner shutdown, fixed crash on exit for Linux and OS X.
 - Fixed gcc 7.1 support.
 
 # v0.8.1
-- Added nicehash support, detects automaticaly by pool URL, for example `cryptonight.eu.nicehash.com:3355` or manually via option `--nicehash`.
+- Added nicehash support, detects automatically by pool URL, for example `cryptonight.eu.nicehash.com:3355` or manually via option `--nicehash`.
 
 # v0.8.0
 - Added double hash mode, also known as lower power mode. `--av=2` and `--av=4`.

doc/CPU.md

@@ -124,7 +124,7 @@ Force enable (`true`) or disable (`false`) hardware AES support. Default value `
 Mining threads priority, value from `1` (lowest priority) to `5` (highest possible priority). Default value `null` means miner don't change threads priority at all. Setting priority higher than 2 can make your PC unresponsive.
 
 #### `memory-pool` (since v4.3.0)
-Use continuous, persistent memory block for mining threads, useful for preserve huge pages allocation while algorithm switching. Possible values `false` (feature disabled, by default) or `true` or specific count of 2 MB huge pages. It helps to avoid loosing huge pages for scratchpads when RandomX dataset is updated and mining threads restart after a 2-3 days of mining.
+Use continuous, persistent memory block for mining threads, useful for preserve huge pages allocation while algorithm switching. Possible values `false` (feature disabled, by default) or `true` or specific count of 2 MB huge pages. It helps to avoid losing huge pages for scratchpads when RandomX dataset is updated and mining threads restart after a 2-3 days of mining.
 
 #### `yield` (since v5.1.1)
 Prefer system better system response/stability `true` (default value) or maximum hashrate `false`.
@@ -133,7 +133,7 @@ Prefer system better system response/stability `true` (default value) or maximum
 Enable/configure or disable ASM optimizations. Possible values: `true`, `false`, `"intel"`, `"ryzen"`, `"bulldozer"`.
 
 #### `argon2-impl` (since v3.1.0)
-Allow override automatically detected Argon2 implementation, this option added mostly for debug purposes, default value `null` means autodetect. This is used in RandomX dataset initialization and also in some other mining algorithms. Other possible values: `"x86_64"`, `"SSE2"`, `"SSSE3"`, `"XOP"`, `"AVX2"`, `"AVX-512F"`. Manual selection has no safe guards - if your CPU doesn't support required instuctions, miner will crash.
+Allow override automatically detected Argon2 implementation, this option added mostly for debug purposes, default value `null` means autodetect. This is used in RandomX dataset initialization and also in some other mining algorithms. Other possible values: `"x86_64"`, `"SSE2"`, `"SSSE3"`, `"XOP"`, `"AVX2"`, `"AVX-512F"`. Manual selection has no safe guards - if your CPU doesn't support required instructions, miner will crash.
 
 #### `astrobwt-max-size`
 AstroBWT algorithm: skip hashes with large stage 2 size, default: `550`, min: `400`, max: `1200`. Optimal value depends on your CPU/GPU

doc/RISCV_PERF_TUNING.md

@@ -0,0 +1,365 @@
+# RISC-V Performance Optimization Guide
+
+This guide provides comprehensive instructions for optimizing XMRig on RISC-V architectures.
+
+## Build Optimizations
+
+### Compiler Flags Applied Automatically
+
+The CMake build now applies aggressive RISC-V-specific optimizations:
+
+```cmake
+# RISC-V ISA with extensions
+-march=rv64gcv_zba_zbb_zbc_zbs
+
+# Aggressive compiler optimizations
+-funroll-loops              # Unroll loops for ILP (instruction-level parallelism)
+-fomit-frame-pointer        # Free up frame pointer register (RISC-V has limited registers)
+-fno-common                 # Better code generation for global variables
+-finline-functions          # Inline more functions for better cache locality
+-ffast-math                 # Relaxed FP semantics (safe for mining)
+-flto                       # Link-time optimization for cross-module inlining
+
+# Release build additions
+-minline-atomics            # Inline atomic operations for faster synchronization
+```
+
+### Optimal Build Command
+
+```bash
+mkdir build && cd build
+cmake -DCMAKE_BUILD_TYPE=Release ..
+make -j$(nproc)
+```
+
+**Expected build time**: 5-15 minutes depending on CPU
+
+## Runtime Optimizations
+
+### 1. Memory Configuration (Most Important)
+
+Enable huge pages to reduce TLB misses and fragmentation:
+
+#### Enable 2MB Huge Pages
+```bash
+# Calculate required huge pages (1 page = 2MB)
+# For 2 GB dataset: 1024 pages
+# For cache + dataset: 1536 pages minimum
+sudo sysctl -w vm.nr_hugepages=2048
+```
+
+Verify:
+```bash
+grep HugePages /proc/meminfo
+# Expected: HugePages_Free should be close to nr_hugepages
+```
+
+#### Enable 1GB Huge Pages (Optional but Recommended)
+
+```bash
+# Run provided helper script
+sudo ./scripts/enable_1gb_pages.sh
+
+# Verify 1GB pages are available
+cat /sys/kernel/mm/hugepages/hugepages-1048576kB/nr_hugepages
+# Should be: >= 1 (one 1GB page)
+```
+
+Update config.json:
+```json
+{
+    "cpu": {
+        "huge-pages": true
+    },
+    "randomx": {
+        "1gb-pages": true
+    }
+}
+```
+
+### 2. RandomX Mode Selection
+
+| Mode | Memory | Init Time | Throughput | Recommendation |
+|------|--------|-----------|-----------|-----------------|
+| **light** | 256 MB | 10 sec | Low | Testing, resource-constrained |
+| **fast** | 2 GB | 2-5 min* | High | Production (with huge pages) |
+| **auto** | 2 GB | Varies | High | Default (uses fast if possible) |
+
+*With optimizations; can be 30+ minutes without huge pages
+
+**For RISC-V, use fast mode with huge pages enabled.**
+
+### 3. Dataset Initialization Threads
+
+Optimal thread count = 60-75% of CPU cores (leaves headroom for OS/other tasks)
+
+```json
+{
+    "randomx": {
+        "init": 4
+    }
+}
+```
+
+Or auto-detect (rewritten for RISC-V):
+```json
+{
+    "randomx": {
+        "init": -1
+    }
+}
+```
+
+### 4. CPU Affinity (Optional)
+
+Pin threads to specific cores for better cache locality:
+
+```json
+{
+    "cpu": {
+        "rx/0": [
+            { "threads": 1, "affinity": 0 },
+            { "threads": 1, "affinity": 1 },
+            { "threads": 1, "affinity": 2 },
+            { "threads": 1, "affinity": 3 }
+        ]
+    }
+}
+```
+
+### 5. CPU Governor (Linux)
+
+Set to performance mode for maximum throughput:
+
+```bash
+# Check current governor
+cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
+
+# Set to performance (requires root)
+echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
+
+# Verify
+cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
+# Should output: performance
+```
+
+## Configuration Examples
+
+### Minimum (Testing)
+```json
+{
+    "randomx": {
+        "mode": "light"
+    },
+    "cpu": {
+        "huge-pages": false
+    }
+}
+```
+
+### Recommended (Balanced)
+```json
+{
+    "randomx": {
+        "mode": "auto",
+        "init": 4,
+        "1gb-pages": true
+    },
+    "cpu": {
+        "huge-pages": true,
+        "priority": 2
+    }
+}
+```
+
+### Maximum Performance (Production)
+```json
+{
+    "randomx": {
+        "mode": "fast",
+        "init": -1,
+        "1gb-pages": true,
+        "scratchpad_prefetch_mode": 1
+    },
+    "cpu": {
+        "huge-pages": true,
+        "priority": 3,
+        "yield": false
+    }
+}
+```
+
+## CLI Equivalents
+
+```bash
+# Light mode
+./xmrig --randomx-mode=light
+
+# Fast mode with 4 init threads
+./xmrig --randomx-mode=fast --randomx-init=4
+
+# Benchmark
+./xmrig --bench=1M --algo=rx/0
+
+# Benchmark Wownero variant (1 MB scratchpad)
+./xmrig --bench=1M --algo=rx/wow
+
+# Mine to pool
+./xmrig -o pool.example.com:3333 -u YOUR_WALLET -p x
+```
+
+## Performance Diagnostics
+
+### Check if Vector Extensions are Detected
+
+Look for `FEATURES:` line in output:
+```
+ * CPU:       ky,x60 (uarch ky,x1)
+ * FEATURES:  rv64imafdcv zba zbb zbc zbs
+```
+
+- `v`: Vector extension (RVV) ✓
+- `zba`, `zbb`, `zbc`, `zbs`: Bit manipulation ✓
+- If missing, make sure build used `-march=rv64gcv_zba_zbb_zbc_zbs`
+
+### Verify Huge Pages at Runtime
+
+```bash
+# Run xmrig with --bench=1M and check output
+./xmrig --bench=1M
+
+# Look for line like:
+# HUGE PAGES   100%  1 / 1 (1024 MB)
+```
+
+- Should show 100% for dataset AND threads
+- If less, increase `vm.nr_hugepages` and reboot
+
+### Monitor Performance
+
+```bash
+# Run benchmark multiple times to find stable hashrate
+./xmrig --bench=1M --algo=rx/0
+./xmrig --bench=10M --algo=rx/0
+./xmrig --bench=100M --algo=rx/0
+
+# Check system load and memory during mining
+while true; do free -h; grep HugePages /proc/meminfo; sleep 2; done
+```
+
+## Expected Performance
+
+### Hardware: Orange Pi RV2 (Ky X1, 8 cores @ ~1.5 GHz)
+
+| Config | Mode | Hashrate | Init Time |
+|--------|------|----------|-----------|
+| Scalar (baseline) | fast | 30 H/s | 10 min |
+| Scalar + huge pages | fast | 33 H/s | 2 min |
+| RVV (if enabled) | fast | 70-100 H/s | 3 min |
+
+*Actual results depend on CPU frequency, memory speed, and load*
+
+## Troubleshooting
+
+### Long Initialization Times (30+ minutes)
+
+**Cause**: Huge pages not enabled, system using swap
+**Solution**:
+1. Enable huge pages: `sudo sysctl -w vm.nr_hugepages=2048`
+2. Reboot: `sudo reboot`
+3. Reduce mining threads to free memory
+4. Check available memory: `free -h`
+
+### Low Hashrate (50% of expected)
+
+**Cause**: CPU governor set to power-save, no huge pages, high contention
+**Solution**:
+1. Set governor to performance: `echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor`
+2. Enable huge pages
+3. Reduce number of mining threads
+4. Check system load: `top` or `htop`
+
+### Dataset Init Crashes or Hangs
+
+**Cause**: Insufficient memory, corrupted huge pages
+**Solution**:
+1. Disable huge pages temporarily: set `huge-pages: false` in config
+2. Reduce mining threads
+3. Reboot and re-enable huge pages
+4. Try light mode: `--randomx-mode=light`
+
+### Out of Memory During Benchmark
+
+**Cause**: Not enough RAM for dataset + cache + threads
+**Solution**:
+1. Use light mode: `--randomx-mode=light`
+2. Reduce mining threads: `--threads=1`
+3. Increase available memory (kill other processes)
+4. Check: `free -h` before mining
+
+## Advanced Tuning
+
+### Vector Length (VLEN) Detection
+
+RISC-V vector extension variable length (VLEN) affects performance:
+
+```bash
+# Check VLEN on your CPU
+cat /proc/cpuinfo | grep vlen
+
+# Expected values:
+# - 128 bits (16 bytes) = minimum
+# - 256 bits (32 bytes) = common
+# - 512 bits (64 bytes) = high performance
+```
+
+Larger VLEN generally means better performance for vectorized operations.
+
+### Prefetch Optimization
+
+The code automatically optimizes memory prefetching for RISC-V:
+
+```
+scratchpad_prefetch_mode: 0 = disabled (slowest)
+scratchpad_prefetch_mode: 1 = prefetch.r (default, recommended)
+scratchpad_prefetch_mode: 2 = prefetch.w (experimental)
+```
+
+### Memory Bandwidth Saturation
+
+If experiencing memory bandwidth saturation (high latency):
+
+1. Reduce mining threads
+2. Increase L2/L3 cache by mining fewer threads per core
+3. Enable cache QoS (AMD Ryzen): `cache_qos: true`
+
+## Building with Custom Flags
+
+To build with custom RISC-V flags:
+
+```bash
+mkdir build && cd build
+cmake -DCMAKE_BUILD_TYPE=Release \
+      -DCMAKE_C_FLAGS="-march=rv64gcv_zba_zbb_zbc_zbs -O3 -funroll-loops -fomit-frame-pointer" \
+      ..
+make -j$(nproc)
+```
+
+## Future Optimizations
+
+- [ ] Zbk* (crypto) support detection and usage
+- [ ] Optimal VLEN-aware algorithm selection
+- [ ] Per-core memory affinity (NUMA support)
+- [ ] Dynamic thread count adjustment based on thermals
+- [ ] Cross-compile optimizations for various RISC-V cores
+
+## References
+
+- [RISC-V Vector Extension Spec](https://github.com/riscv/riscv-v-spec)
+- [RISC-V Bit Manipulation Spec](https://github.com/riscv/riscv-bitmanip)
+- [RISC-V Crypto Spec](https://github.com/riscv/riscv-crypto)
+- [XMRig Documentation](https://xmrig.com/docs)
+
+---
+
+For further optimization, enable RVV intrinsics by replacing `sse2rvv.h` with `sse2rvv_optimized.h` in the build.

scripts/randomx_boost.sh

@@ -12,7 +12,7 @@ if grep -E 'AMD Ryzen|AMD EPYC|AuthenticAMD' /proc/cpuinfo > /dev/null;
 	then
 	if grep "cpu family[[:space:]]\{1,\}:[[:space:]]25" /proc/cpuinfo > /dev/null;
 		then
-			if grep "model[[:space:]]\{1,\}:[[:space:]]97" /proc/cpuinfo > /dev/null;
+			if grep "model[[:space:]]\{1,\}:[[:space:]]\(97\|117\)" /proc/cpuinfo > /dev/null;
 				then
 					echo "Detected Zen4 CPU"
 					wrmsr -a 0xc0011020 0x4400000000000

src/3rdparty/argon2/CMakeLists.txt

@@ -35,7 +35,7 @@ if (CMAKE_C_COMPILER_ID MATCHES MSVC)
     add_feature_impl(xop     ""              HAVE_XOP)
     add_feature_impl(avx2    "/arch:AVX2"    HAVE_AVX2)
     add_feature_impl(avx512f "/arch:AVX512F" HAVE_AVX512F)
-elseif (NOT XMRIG_ARM AND CMAKE_SIZEOF_VOID_P EQUAL 8)
+elseif (NOT XMRIG_ARM AND NOT XMRIG_RISCV AND CMAKE_SIZEOF_VOID_P EQUAL 8)
     function(add_feature_impl FEATURE GCC_FLAG DEF)
         add_library(argon2-${FEATURE} STATIC arch/x86_64/lib/argon2-${FEATURE}.c)
         target_include_directories(argon2-${FEATURE} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../)

src/3rdparty/hwloc/NEWS

@@ -1,5 +1,5 @@
 Copyright © 2009 CNRS
-Copyright © 2009-2024 Inria.  All rights reserved.
+Copyright © 2009-2025 Inria.  All rights reserved.
 Copyright © 2009-2013 Université Bordeaux
 Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
 Copyright © 2020 Hewlett Packard Enterprise.  All rights reserved.
@@ -17,6 +17,52 @@ bug fixes (and other actions) for each version of hwloc since version
 0.9.
 
 
+Version 2.12.1
+--------------
+* Add hwloc-calc's --default-nodes option to hwloc-bind and hwloc-info.
+* Improve the --best-memattr "default" fallback, try to use "default"
+  memory nodes, and add verbose messages and warnings if some
+  performance info are incomplete or missing.
+  Thanks to Antoine Morvan for the report.
+* Fix CPU and memory binding on different locations,
+  thanks to Antoine Morvan for the report.
+* Add HWLOC_LOCAL_NUMANODE_FLAG_INTERSECT_LOCALITY and enable it by
+  default in hwloc-calc --local-memory for finding local NUMA nodes
+  that do not exactly match input locations.
+  Thanks to Antoine Morvan for the report.
+* Fix a possible crash in the x86 backend when Qemu is configured to
+  expose multicore/thread CPUs that are actually single-core/thread.
+  Thanks to Georg Pfuetzenreuter.
+
+
+Version 2.12.0
+--------------
+* Add hwloc_topology_get_default_nodeset() for the set of default
+  NUMA nodes.
+  - hwloc-calc now has --default-nodes option.
+* Rework oneAPI LevelZero support to use zesInit() and avoid the need
+  to set ZES_ENABLE_SYSMAN=1 in the environment.
+  - zesDriverGetDeviceByUuidExp() is now required in the L0 runtime.
+  - ZES/Sysman variants were added in hwloc/levelzero.h to specifically
+    handle ZES/Sysman device handles.
+* Fix the locality of AMD GPU partitions, thanks to Edgar Leon for
+  reporting and debugging the issue.
+* Better detect Cray Slingshot NICs, thanks to Edgar Leon.
+* Add support for Die objects and Module groups on Windows.
+* Only filter-out Dies that are identical to their Packages
+  when it applies to all Dies.
+* Improve hwloc-calc to handle CPU-less NUMA nodes or platforms with
+  heterogeneous memory without requiring --nodeset-output.
+* hwloc-calc now accepts counting/listing cpukinds and memory tiers
+  with -N and -I cpukind/memorytier.
+* The systemd-dbus-api output of hwloc-calc has changed, and
+  --nodeset-output-format was added, to support NUMA node outputs.
+  Thanks to Pierre Neyron.
+* Update NVLink bandwidth and CUDA capabilities up to NVIDIA Blackwell.
+* Fix some NUMA syscalls on Linux for platforms with old libc headers.
+* Some minor fixes in distances.
+
+
 Version 2.11.2
 --------------
 * Add missing CPU info attrs on aarch64 on Linux.

src/3rdparty/hwloc/VERSION

@@ -8,8 +8,8 @@
 # Please update HWLOC_VERSION* in contrib/windows/hwloc_config.h too.
 
 major=2
-minor=11
-release=2
+minor=12
+release=1
 
 # greek is used for alpha or beta release tags.  If it is non-empty,
 # it will be appended to the version number.  It does not have to be
@@ -22,7 +22,7 @@ greek=
 
 # The date when this release was created
 
-date="Sep 26, 2024"
+date="May 12, 2025"
 
 # If snapshot=1, then use the value from snapshot_version as the
 # entire hwloc version (i.e., ignore major, minor, release, and
@@ -41,6 +41,6 @@ snapshot_version=${major}.${minor}.${release}${greek}-git
 # 2. Version numbers are described in the Libtool current:revision:age
 # format.
 
-libhwloc_so_version=23:1:8
+libhwloc_so_version=25:0:10
 
 # Please also update the <TargetName> lines in contrib/windows/libhwloc.vcxproj

src/3rdparty/hwloc/include/hwloc.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2024 Inria.  All rights reserved.
+ * Copyright © 2009-2025 Inria.  All rights reserved.
  * Copyright © 2009-2012 Université Bordeaux
  * Copyright © 2009-2020 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -112,7 +112,7 @@ extern "C" {
  * Two stable releases of the same series usually have the same ::HWLOC_API_VERSION
  * even if their HWLOC_VERSION are different.
  */
-#define HWLOC_API_VERSION 0x00020b00
+#define HWLOC_API_VERSION 0x00020c00
 
 /** \brief Indicate at runtime which hwloc API version was used at build time.
  *
@@ -346,9 +346,10 @@ typedef enum {
 			 *
 			 * Some operating systems (e.g. Linux) may expose a single die per package
 			 * even if the hardware does not support dies at all. To avoid showing
-			 * such non-existing dies, the corresponding hwloc backend may filter them out.
+			 * such non-existing dies, hwloc will filter them out if all of them are
+                         * identical to packages.
 			 * This is functionally equivalent to ::HWLOC_TYPE_FILTER_KEEP_STRUCTURE
-			 * being enforced.
+			 * being enforced for Dies versus Packages.
 			 */
 
   HWLOC_OBJ_TYPE_MAX    /**< \private Sentinel value */
@@ -1047,7 +1048,7 @@ HWLOC_DECLSPEC const char * hwloc_obj_type_string (hwloc_obj_type_t type) __hwlo
  * If \p size is 0, \p string may safely be \c NULL.
  *
  * \return the number of characters that were actually written if not truncating,
- * or that would have been written (not including the ending \\0).
+ * or that would have been written (not including the ending \c \0).
  */
 HWLOC_DECLSPEC int hwloc_obj_type_snprintf(char * __hwloc_restrict string, size_t size,
 					   hwloc_obj_t obj,
@@ -1062,7 +1063,7 @@ HWLOC_DECLSPEC int hwloc_obj_type_snprintf(char * __hwloc_restrict string, size_
  * If \p size is 0, \p string may safely be \c NULL.
  *
  * \return the number of characters that were actually written if not truncating,
- * or that would have been written (not including the ending \\0).
+ * or that would have been written (not including the ending \c \0).
  */
 HWLOC_DECLSPEC int hwloc_obj_attr_snprintf(char * __hwloc_restrict string, size_t size,
 					   hwloc_obj_t obj, const char * __hwloc_restrict separator,
@@ -2002,7 +2003,7 @@ HWLOC_DECLSPEC int hwloc_topology_set_xml(hwloc_topology_t __hwloc_restrict topo
  * a file, as with hwloc_topology_set_xml()).
  *
  * Gather topology information from the XML memory buffer given at
- * \p buffer and of length \p size (including an ending \0).
+ * \p buffer and of length \p size (including an ending \c \0).
  * This buffer may have been filled earlier with
  * hwloc_topology_export_xmlbuffer() in hwloc/export.h.
  *

src/3rdparty/hwloc/include/hwloc/autogen/config.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2024 Inria.  All rights reserved.
+ * Copyright © 2009-2025 Inria.  All rights reserved.
  * Copyright © 2009-2012 Université Bordeaux
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -11,10 +11,10 @@
 #ifndef HWLOC_CONFIG_H
 #define HWLOC_CONFIG_H
 
-#define HWLOC_VERSION "2.11.2"
+#define HWLOC_VERSION "2.12.1"
 #define HWLOC_VERSION_MAJOR 2
-#define HWLOC_VERSION_MINOR 11
-#define HWLOC_VERSION_RELEASE 2
+#define HWLOC_VERSION_MINOR 12
+#define HWLOC_VERSION_RELEASE 1
 #define HWLOC_VERSION_GREEK ""
 
 #define __hwloc_restrict

src/3rdparty/hwloc/include/hwloc/bitmap.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2023 Inria.  All rights reserved.
+ * Copyright © 2009-2024 Inria.  All rights reserved.
  * Copyright © 2009-2012 Université Bordeaux
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -113,51 +113,88 @@ HWLOC_DECLSPEC int hwloc_bitmap_copy(hwloc_bitmap_t dst, hwloc_const_bitmap_t sr
  * Bitmap/String Conversion
  */
 
-/** \brief Stringify a bitmap.
+/** \brief Stringify a bitmap in the default hwloc format.
+ *
+ * <b>Note that if the bitmap is a CPU or nodeset, it contains physical indexes.</b>
+ *
+ * Print the bits set inside a bitmap as a comma-separated list of hexadecimal 32-bit blocks.
+ * A bitmap containing bits 1, 33, 34, and all from 64 to 95 is printed as <tt>"0xffffffff,0x00000006,0x00000002"</tt>.
  *
  * Up to \p buflen characters may be written in buffer \p buf.
  *
  * If \p buflen is 0, \p buf may safely be \c NULL.
  *
  * \return the number of characters that were actually written if not truncating,
- * or that would have been written (not including the ending \\0).
+ * or that would have been written (not including the ending \c \0).
+ * \return -1 on error.
  */
 HWLOC_DECLSPEC int hwloc_bitmap_snprintf(char * __hwloc_restrict buf, size_t buflen, hwloc_const_bitmap_t bitmap);
 
-/** \brief Stringify a bitmap into a newly allocated string.
+/** \brief Stringify a bitmap into a newly allocated string in the default hwloc format.
  *
- * \return 0 on success, -1 on error.
+ * <b>Note that if the bitmap is a CPU or nodeset, it contains physical indexes.</b>
+ *
+ * Print the bits set inside a bitmap as a comma-separated list of hexadecimal 32-bit blocks.
+ * A bitmap containing bits 1, 33, 34, and all from 64 to 95 is printed as <tt>"0xffffffff,0x00000006,0x00000002"</tt>.
+ *
+ * \return the number of characters that were written (not including the ending \c \0).
+ * \return -1 on error, for instance with \p errno set to \c ENOMEM on failure to allocate the output string.
  */
 HWLOC_DECLSPEC int hwloc_bitmap_asprintf(char ** strp, hwloc_const_bitmap_t bitmap);
 
-/** \brief Parse a bitmap string and stores it in bitmap \p bitmap.
+/** \brief Parse a bitmap string as the default hwloc format and stores it in bitmap \p bitmap.
+ *
+ * <b>Note that if the bitmap is a CPU or nodeset, the input string must contain physical indexes.</b>
+ *
+ * The input string should be a comma-separared list of hexadecimal 32-bit blocks.
+ * String <tt>"0xffffffff,0x6,0x2"</tt> is parsed as a bitmap containing all bits between 64 and 95,
+ * and bits 33, 34 and 1.
  *
  * \return 0 on success, -1 on error.
  */
 HWLOC_DECLSPEC int hwloc_bitmap_sscanf(hwloc_bitmap_t bitmap, const char * __hwloc_restrict string);
 
 /** \brief Stringify a bitmap in the list format.
+ *
+ * <b>Note that if the bitmap is a CPU or nodeset, it contains physical indexes.</b>
  *
  * Lists are comma-separated indexes or ranges.
  * Ranges are dash separated indexes.
- * The last range may not have an ending indexes if the bitmap is infinitely set.
+ * A bitmap containing bits 1, 33, 34, and all from 64 to 95 is printed as <tt>"1,33-34,64-95"</tt>.
+ * The last range may not have an ending index if the bitmap is infinitely set.
  *
  * Up to \p buflen characters may be written in buffer \p buf.
  *
  * If \p buflen is 0, \p buf may safely be \c NULL.
  *
  * \return the number of characters that were actually written if not truncating,
- * or that would have been written (not including the ending \\0).
+ * or that would have been written (not including the ending \c \0).
+ * \return -1 on error.
  */
 HWLOC_DECLSPEC int hwloc_bitmap_list_snprintf(char * __hwloc_restrict buf, size_t buflen, hwloc_const_bitmap_t bitmap);
 
 /** \brief Stringify a bitmap into a newly allocated list string.
  *
- * \return 0 on success, -1 on error.
+ * <b>Note that if the bitmap is a CPU or nodeset, it contains physical indexes.</b>
+ *
+ * Lists are comma-separated indexes or ranges.
+ * Ranges are dash separated indexes.
+ * A bitmap containing bits 1, 33, 34, and all from 64 to 95 is printed as <tt>"1,33-34,64-95"</tt>.
+ * The last range may not have an ending index if the bitmap is infinitely set.
+ *
+ * \return the number of characters that were written (not including the ending \c \0).
+ * \return -1 on error, for instance with \p errno set to \c ENOMEM on failure to allocate the output string.
  */
 HWLOC_DECLSPEC int hwloc_bitmap_list_asprintf(char ** strp, hwloc_const_bitmap_t bitmap);
 
 /** \brief Parse a list string and stores it in bitmap \p bitmap.
+ *
+ * <b>Note that if the bitmap is a CPU or nodeset, the input string must contain physical indexes.</b>
+ *
+ * Lists are comma-separated indexes or ranges.
+ * Ranges are dash separated indexes.
+ * String <tt>"1,33-34,64-95"</tt> is parsed as a bitmap containing bits 1, 33, 34, and all from 64 to 95.
+ * The last range may not have an ending index if the bitmap is infinitely set.
  *
  * \return 0 on success, -1 on error.
  */
@@ -165,25 +202,43 @@ HWLOC_DECLSPEC int hwloc_bitmap_list_sscanf(hwloc_bitmap_t bitmap, const char *
 
 /** \brief Stringify a bitmap in the taskset-specific format.
  *
- * The taskset command manipulates bitmap strings that contain a single
+ * <b>Note that if the bitmap is a CPU or nodeset, it contains physical indexes.</b>
+ *
+ * The taskset program manipulates bitmap strings that contain a single
  * (possible very long) hexadecimal number starting with 0x.
+ * A bitmap containing bits 1, 33, 34, and all from 64 to 95 is printed as </tt>"0xffffffff0000000600000002"</tt>.
  *
  * Up to \p buflen characters may be written in buffer \p buf.
  *
  * If \p buflen is 0, \p buf may safely be \c NULL.
  *
  * \return the number of characters that were actually written if not truncating,
- * or that would have been written (not including the ending \\0).
+ * or that would have been written (not including the ending \c \0).
+ * \return -1 on error.
  */
 HWLOC_DECLSPEC int hwloc_bitmap_taskset_snprintf(char * __hwloc_restrict buf, size_t buflen, hwloc_const_bitmap_t bitmap);
 
 /** \brief Stringify a bitmap into a newly allocated taskset-specific string.
  *
- * \return 0 on success, -1 on error.
+ * <b>Note that if the bitmap is a CPU or nodeset, it contains physical indexes.</b>
+ *
+ * The taskset program manipulates bitmap strings that contain a single
+ * (possible very long) hexadecimal number starting with 0x.
+ * A bitmap containing bits 1, 33, 34, and all from 64 to 95 is printed as <tt>"0xffffffff0000000600000002"</tt>.
+ *
+ * \return the number of characters that were written (not including the ending \c \0).
+ * \return -1 on error, for instance with \p errno set to \c ENOMEM on failure to allocate the output string.
  */
 HWLOC_DECLSPEC int hwloc_bitmap_taskset_asprintf(char ** strp, hwloc_const_bitmap_t bitmap);
 
 /** \brief Parse a taskset-specific bitmap string and stores it in bitmap \p bitmap.
+ *
+ * <b>Note that if the bitmap is a CPU or nodeset, the input string must contain physical indexes.</b>
+ *
+ * The taskset program manipulates bitmap strings that contain a single
+ * (possible very long) hexadecimal number starting with 0x.
+ * String <tt>"0xffffffff0000000600000002"</tt> is parsed as a bitmap containing all bits between 64 and 95,
+ * and bits 33, 34 and 1.
  *
  * \return 0 on success, -1 on error.
  */

src/3rdparty/hwloc/include/hwloc/diff.h

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013-2023 Inria.  All rights reserved.
+ * Copyright © 2013-2024 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -258,7 +258,7 @@ HWLOC_DECLSPEC int hwloc_topology_diff_export_xml(hwloc_topology_diff_t diff, co
 /** \brief Load a list of topology differences from a XML buffer.
  *
  * Build a list of differences from the XML memory buffer given
- * at \p xmlbuffer and of length \p buflen (including an ending \0).
+ * at \p xmlbuffer and of length \p buflen (including an ending \c \0).
  * This buffer may have been filled earlier with
  * hwloc_topology_diff_export_xmlbuffer().
  *
@@ -284,7 +284,7 @@ HWLOC_DECLSPEC int hwloc_topology_diff_load_xmlbuffer(const char *xmlbuffer, int
  * that contains the reference topology.
  * This attribute is given back when reading the diff from XML.
  *
- * The returned buffer ends with a \0 that is included in the returned
+ * The returned buffer ends with a \c \0 that is included in the returned
  * length.
  *
  * \return 0 on success, -1 on error.

src/3rdparty/hwloc/include/hwloc/distances.h

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2010-2024 Inria.  All rights reserved.
+ * Copyright © 2010-2025 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -227,17 +227,24 @@ enum hwloc_distances_transform_e {
   HWLOC_DISTANCES_TRANSFORM_LINKS = 1,
 
   /** \brief Merge switches with multiple ports into a single object.
-   * This currently only applies to NVSwitches where GPUs seem connected to different
-   * separate switch ports in the NVLinkBandwidth matrix. This transformation will
-   * replace all of them with the same port connected to all GPUs.
-   * Other ports are removed by applying ::HWLOC_DISTANCES_TRANSFORM_REMOVE_NULL internally.
+   *
+   * This currently only applies to NVSwitches where GPUs seem connected
+   * to different switch ports. Switch ports must be objects with subtype
+   * "NVSwitch" as in the NVLinkBandwidth matrix.
+   *
+   * This transformation will replace all ports with only the first one,
+   * now connected to all GPUs. Other ports are removed by applying
+   * ::HWLOC_DISTANCES_TRANSFORM_REMOVE_NULL internally.
    * \hideinitializer
    */
   HWLOC_DISTANCES_TRANSFORM_MERGE_SWITCH_PORTS = 2,
 
   /** \brief Apply a transitive closure to the matrix to connect objects across switches.
-   * This currently only applies to GPUs and NVSwitches in the NVLinkBandwidth matrix.
-   * All pairs of GPUs will be reported as directly connected.
+   *
+   * All pairs of GPUs will be reported as directly connected instead GPUs being
+   * only connected to switches.
+   *
+   * Switch ports must be objects with subtype "NVSwitch" as in the NVLinkBandwidth matrix.
    * \hideinitializer
    */
   HWLOC_DISTANCES_TRANSFORM_TRANSITIVE_CLOSURE = 3

src/3rdparty/hwloc/include/hwloc/levelzero.h

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2021-2023 Inria.  All rights reserved.
+ * Copyright © 2021-2024 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -32,7 +32,8 @@ extern "C" {
 /** \defgroup hwlocality_levelzero Interoperability with the oneAPI Level Zero interface.
  *
  * This interface offers ways to retrieve topology information about
- * devices managed by the Level Zero API.
+ * devices managed by the Level Zero API, both for main Core devices (ZE API)
+ * and the Sysman devices (ZES API).
  *
  * @{
  */
@@ -44,9 +45,68 @@ extern "C" {
  * the Level Zero device \p device.
  *
  * Topology \p topology and device \p device must match the local machine.
+ * The Level Zero library must have been initialized with zeInit().
+ * I/O devices detection and the Level Zero component are not needed in the
+ * topology.
+ *
+ * The function only returns the locality of the device.
+ * If more information about the device is needed, OS objects should
+ * be used instead, see hwloc_levelzero_get_device_osdev().
+ *
+ * This function is currently only implemented in a meaningful way for
+ * Linux; other systems will simply get a full cpuset.
+ *
+ * \return 0 on success.
+ * \return -1 on error, for instance if device information could not be found.
+ *
+ * \note zeDevicePciGetPropertiesExt() must be supported, or the entire machine
+ * locality will be returned.
+ */
+static __hwloc_inline int
+hwloc_levelzero_get_device_cpuset(hwloc_topology_t topology __hwloc_attribute_unused,
+                                  ze_device_handle_t device, hwloc_cpuset_t set)
+{
+#ifdef HWLOC_LINUX_SYS
+  /* If we're on Linux, use the sysfs mechanism to get the local cpus */
+#define HWLOC_LEVELZERO_DEVICE_SYSFS_PATH_MAX 128
+  char path[HWLOC_LEVELZERO_DEVICE_SYSFS_PATH_MAX];
+  ze_pci_ext_properties_t pci;
+  ze_result_t res;
+
+  if (!hwloc_topology_is_thissystem(topology)) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  pci.stype =  ZE_STRUCTURE_TYPE_PCI_EXT_PROPERTIES;
+  pci.pNext = NULL;
+  res = zeDevicePciGetPropertiesExt(device, &pci);
+  if (res != ZE_RESULT_SUCCESS) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  sprintf(path, "/sys/bus/pci/devices/%04x:%02x:%02x.%01x/local_cpus",
+          pci.address.domain, pci.address.bus, pci.address.device, pci.address.function);
+  if (hwloc_linux_read_path_as_cpumask(path, set) < 0
+      || hwloc_bitmap_iszero(set))
+    hwloc_bitmap_copy(set, hwloc_topology_get_complete_cpuset(topology));
+#else
+  /* Non-Linux systems simply get a full cpuset */
+  hwloc_bitmap_copy(set, hwloc_topology_get_complete_cpuset(topology));
+#endif
+  return 0;
+}
+
+/** \brief Get the CPU set of logical processors that are physically
+ * close to the Level Zero Sysman device \p device
+ *
+ * Store in \p set the CPU-set describing the locality of
+ * the Level Zero device \p device.
+ *
+ * Topology \p topology and device \p device must match the local machine.
  * The Level Zero library must have been initialized with Sysman enabled
- * (by calling zesInit(0) if supported,
- *  or by setting ZES_ENABLE_SYSMAN=1 in the environment).
+ * with zesInit().
  * I/O devices detection and the Level Zero component are not needed in the
  * topology.
  *
@@ -61,15 +121,14 @@ extern "C" {
  * \return -1 on error, for instance if device information could not be found.
  */
 static __hwloc_inline int
-hwloc_levelzero_get_device_cpuset(hwloc_topology_t topology __hwloc_attribute_unused,
-                                  ze_device_handle_t device, hwloc_cpuset_t set)
+hwloc_levelzero_get_sysman_device_cpuset(hwloc_topology_t topology __hwloc_attribute_unused,
+                                         zes_device_handle_t device, hwloc_cpuset_t set)
 {
 #ifdef HWLOC_LINUX_SYS
   /* If we're on Linux, use the sysfs mechanism to get the local cpus */
 #define HWLOC_LEVELZERO_DEVICE_SYSFS_PATH_MAX 128
   char path[HWLOC_LEVELZERO_DEVICE_SYSFS_PATH_MAX];
   zes_pci_properties_t pci;
-  zes_device_handle_t sdevice = device;
   ze_result_t res;
 
   if (!hwloc_topology_is_thissystem(topology)) {
@@ -77,7 +136,7 @@ hwloc_levelzero_get_device_cpuset(hwloc_topology_t topology __hwloc_attribute_un
     return -1;
   }
 
-  res = zesDevicePciGetProperties(sdevice, &pci);
+  res = zesDevicePciGetProperties(device, &pci);
   if (res != ZE_RESULT_SUCCESS) {
     errno = EINVAL;
     return -1;
@@ -102,17 +161,90 @@ hwloc_levelzero_get_device_cpuset(hwloc_topology_t topology __hwloc_attribute_un
  * \return \c NULL if none could be found.
  *
  * Topology \p topology and device \p dv_ind must match the local machine.
+ * The Level Zero library must have been initialized with zeInit().
  * I/O devices detection and the Level Zero component must be enabled in the
  * topology. If not, the locality of the object may still be found using
  * hwloc_levelzero_get_device_cpuset().
  *
+ * \note If the input ZE device is actually a subdevice, then its parent
+ * (root device) is actually translated, i.e. the main hwloc OS device
+ * is returned instead of one of its children.
+ *
+ * \note The corresponding hwloc PCI device may be found by looking
+ * at the result parent pointer (unless PCI devices are filtered out).
+ *
+ * \note zeDevicePciGetPropertiesExt() must be supported.
+ */
+static __hwloc_inline hwloc_obj_t
+hwloc_levelzero_get_device_osdev(hwloc_topology_t topology, ze_device_handle_t device)
+{
+  ze_pci_ext_properties_t pci;
+  ze_result_t res;
+  hwloc_obj_t osdev;
+
+  if (!hwloc_topology_is_thissystem(topology)) {
+    errno = EINVAL;
+    return NULL;
+  }
+
+  pci.stype = ZE_STRUCTURE_TYPE_PCI_EXT_PROPERTIES;
+  pci.pNext = NULL;
+  res = zeDevicePciGetPropertiesExt(device, &pci);
+  if (res != ZE_RESULT_SUCCESS) {
+    errno = EINVAL;
+    return NULL;
+  }
+
+  osdev = NULL;
+  while ((osdev = hwloc_get_next_osdev(topology, osdev)) != NULL) {
+    hwloc_obj_t pcidev;
+
+    if (strncmp(osdev->name, "ze", 2))
+      continue;
+
+    pcidev = osdev;
+    while (pcidev && pcidev->type != HWLOC_OBJ_PCI_DEVICE)
+      pcidev = pcidev->parent;
+    if (!pcidev)
+      continue;
+
+    if (pcidev
+      && pcidev->type == HWLOC_OBJ_PCI_DEVICE
+      && pcidev->attr->pcidev.domain == pci.address.domain
+      && pcidev->attr->pcidev.bus == pci.address.bus
+      && pcidev->attr->pcidev.dev == pci.address.device
+      && pcidev->attr->pcidev.func == pci.address.function)
+      return osdev;
+
+    /* FIXME: when we'll have serialnumber, try it in case PCI is filtered-out */
+  }
+
+  return NULL;
+}
+
+/** \brief Get the hwloc OS device object corresponding to Level Zero Sysman device
+ * \p device.
+ *
+ * \return The hwloc OS device object that describes the given Level Zero device \p device.
+ * \return \c NULL if none could be found.
+ *
+ * Topology \p topology and device \p dv_ind must match the local machine.
+ * The Level Zero library must have been initialized with Sysman enabled
+ * with zesInit().
+ * I/O devices detection and the Level Zero component must be enabled in the
+ * topology. If not, the locality of the object may still be found using
+ * hwloc_levelzero_get_device_cpuset().
+ *
+ * \note If the input ZES device is actually a subdevice, then its parent
+ * (root device) is actually translated, i.e. the main hwloc OS device
+ * is returned instead of one of its children.
+ *
  * \note The corresponding hwloc PCI device may be found by looking
  * at the result parent pointer (unless PCI devices are filtered out).
  */
 static __hwloc_inline hwloc_obj_t
-hwloc_levelzero_get_device_osdev(hwloc_topology_t topology, ze_device_handle_t device)
+hwloc_levelzero_get_sysman_device_osdev(hwloc_topology_t topology, zes_device_handle_t device)
 {
-  zes_device_handle_t sdevice = device;
   zes_pci_properties_t pci;
   ze_result_t res;
   hwloc_obj_t osdev;
@@ -122,20 +254,25 @@ hwloc_levelzero_get_device_osdev(hwloc_topology_t topology, ze_device_handle_t d
     return NULL;
   }
 
-  res = zesDevicePciGetProperties(sdevice, &pci);
+  res = zesDevicePciGetProperties(device, &pci);
   if (res != ZE_RESULT_SUCCESS) {
-    /* L0 was likely initialized without sysman, don't bother */
     errno = EINVAL;
     return NULL;
   }
 
   osdev = NULL;
   while ((osdev = hwloc_get_next_osdev(topology, osdev)) != NULL) {
-    hwloc_obj_t pcidev = osdev->parent;
+    hwloc_obj_t pcidev;
 
     if (strncmp(osdev->name, "ze", 2))
       continue;
 
+    pcidev = osdev;
+    while (pcidev && pcidev->type != HWLOC_OBJ_PCI_DEVICE)
+      pcidev = pcidev->parent;
+    if (!pcidev)
+      continue;
+
     if (pcidev
       && pcidev->type == HWLOC_OBJ_PCI_DEVICE
       && pcidev->attr->pcidev.domain == pci.address.domain

src/3rdparty/hwloc/include/hwloc/memattrs.h

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2019-2024 Inria.  All rights reserved.
+ * Copyright © 2019-2025 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -58,6 +58,11 @@ extern "C" {
  * an easy way to distinguish NUMA nodes of different kinds, as explained
  * in \ref heteromem.
  *
+ * Beside tiers, hwloc defines a set of "default" nodes where normal memory
+ * allocations should be made from (see hwloc_topology_get_default_nodeset()).
+ * This is also useful for dividing the machine into a set of non-overlapping
+ * NUMA domains, for instance for binding tasks per domain.
+ *
  * \sa An example is available in doc/examples/memory-attributes.c in the source tree.
  *
  * \note The API also supports specific objects as initiator,
@@ -245,6 +250,16 @@ enum hwloc_local_numanode_flag_e {
    */
   HWLOC_LOCAL_NUMANODE_FLAG_SMALLER_LOCALITY = (1UL<<1),
 
+  /** \breif Select NUMA nodes whose locality intersects the given cpuset.
+   * This includes larger and smaller localities as well as localities
+   * that are partially included.
+   * For instance, if the locality is one core of both packages, a NUMA node
+   * local to one package is neither larger nor smaller than this locality,
+   * but it intersects it.
+   * \hideinitializer
+   */
+  HWLOC_LOCAL_NUMANODE_FLAG_INTERSECT_LOCALITY = (1UL<<3),
+
   /** \brief Select all NUMA nodes in the topology.
    * The initiator \p initiator is ignored.
    * \hideinitializer
@@ -290,7 +305,57 @@ hwloc_get_local_numanode_objs(hwloc_topology_t topology,
                               hwloc_obj_t *nodes,
                               unsigned long flags);
 
-
+/** \brief Return the set of default NUMA nodes
+ *
+ * In machines with heterogeneous memory, some NUMA nodes are considered
+ * the default ones, i.e. where basic allocations should be made from.
+ * These are usually DRAM nodes.
+ *
+ * Other nodes may be reserved for specific use (I/O device memory, e.g. GPU memory),
+ * small but high performance (HBM), large but slow memory (NVM), etc.
+ * Buffers should usually not be allocated from there unless explicitly required.
+ *
+ * This function fills \p nodeset with the bits of NUMA nodes considered default.
+ *
+ * It is guaranteed that these nodes have non-intersecting CPU sets,
+ * i.e. cores may not have multiple local NUMA nodes anymore.
+ * Hence this may be used to iterate over the platform divided into separate
+ * NUMA localities, for instance for binding one task per NUMA domain.
+ *
+ * Any core that had some local NUMA node(s) in the initial topology should
+ * still have one in the default nodeset. Corner cases where this would be
+ * wrong consist in asymmetric platforms with missing DRAM nodes, or topologies
+ * that were already restricted to less NUMA nodes.
+ *
+ * The returned nodeset may be passed to hwloc_topology_restrict() with
+ * ::HWLOC_RESTRICT_FLAG_BYNODESET to remove all non-default nodes from
+ * the topology. The resulting topology will be easier to use when iterating
+ * over (now homogeneous) NUMA nodes.
+ *
+ * The heuristics for finding default nodes relies on memory tiers and subtypes
+ * (see \ref heteromem) as well as the assumption that hardware vendors list
+ * default nodes first in hardware tables.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * \return 0 on success.
+ * \return -1 on error.
+ *
+ * \note The returned nodeset usually contains all nodes from a single memory
+ * tier, likely the DRAM one.
+ *
+ * \note The returned nodeset is included in the list of available nodes
+ * returned by hwloc_topology_get_topology_nodeset(). It is strictly smaller
+ * if the machine has heterogeneous memory.
+ *
+ * \note The heuristics may return a suboptimal set of nodes if hwloc could
+ * not guess memory types and/or if some default nodes were removed earlier
+ * from the topology (e.g. with hwloc_topology_restrict()).
+ */
+HWLOC_DECLSPEC int
+hwloc_topology_get_default_nodeset(hwloc_topology_t topology,
+                                   hwloc_nodeset_t nodeset,
+                                   unsigned long flags);
 
 /** \brief Return an attribute value for a specific target NUMA node.
  *

src/3rdparty/hwloc/include/hwloc/plugins.h

@@ -26,7 +26,7 @@ struct hwloc_backend;
 
 
 
-/** \defgroup hwlocality_disc_components Components and Plugins: Discovery components
+/** \defgroup hwlocality_disc_components Components and Plugins: Discovery components and backends
  *
  * \note These structures and functions may change when ::HWLOC_COMPONENT_ABI is modified.
  *
@@ -90,18 +90,6 @@ struct hwloc_disc_component {
   struct hwloc_disc_component * next;
 };
 
-/** @} */
-
-
-
-
-/** \defgroup hwlocality_disc_backends Components and Plugins: Discovery backends
- *
- * \note These structures and functions may change when ::HWLOC_COMPONENT_ABI is modified.
- *
- * @{
- */
-
 /** \brief Discovery phase */
 typedef enum hwloc_disc_phase_e {
   /** \brief xml or synthetic, platform-specific components such as bgq.
@@ -313,6 +301,64 @@ struct hwloc_component {
   void * data;
 };
 
+/** \brief Make sure that plugins can lookup core symbols.
+ *
+ * This is a sanity check to avoid lazy-lookup failures when libhwloc
+ * is loaded within a plugin, and later tries to load its own plugins.
+ * This may fail (and abort the program) if libhwloc symbols are in a
+ * private namespace.
+ *
+ * \return 0 on success.
+ * \return -1 if the plugin cannot be successfully loaded. The caller
+ * plugin init() callback should return a negative error code as well.
+ *
+ * Plugins should call this function in their init() callback to avoid
+ * later crashes if lazy symbol resolution is used by the upper layer that
+ * loaded hwloc (e.g. OpenCL implementations using dlopen with RTLD_LAZY).
+ *
+ * \note The build system must define HWLOC_INSIDE_PLUGIN if and only if
+ * building the caller as a plugin.
+ *
+ * \note This function should remain inline so plugins can call it even
+ * when they cannot find libhwloc symbols.
+ */
+static __hwloc_inline int
+hwloc_plugin_check_namespace(const char *pluginname __hwloc_attribute_unused, const char *symbol __hwloc_attribute_unused)
+{
+#ifdef HWLOC_INSIDE_PLUGIN
+  void *sym;
+#ifdef HWLOC_HAVE_LTDL
+  lt_dlhandle handle = lt_dlopen(NULL);
+#else
+  void *handle = dlopen(NULL, RTLD_NOW|RTLD_LOCAL);
+#endif
+  if (!handle)
+    /* cannot check, assume things will work */
+    return 0;
+#ifdef HWLOC_HAVE_LTDL
+  sym = lt_dlsym(handle, symbol);
+  lt_dlclose(handle);
+#else
+  sym = dlsym(handle, symbol);
+  dlclose(handle);
+#endif
+  if (!sym) {
+    static int verboseenv_checked = 0;
+    static int verboseenv_value = 0;
+    if (!verboseenv_checked) {
+      const char *verboseenv = getenv("HWLOC_PLUGINS_VERBOSE");
+      verboseenv_value = verboseenv ? atoi(verboseenv) : 0;
+      verboseenv_checked = 1;
+    }
+    if (verboseenv_value)
+      fprintf(stderr, "Plugin `%s' disabling itself because it cannot find the `%s' core symbol.\n",
+	      pluginname, symbol);
+    return -1;
+  }
+#endif /* HWLOC_INSIDE_PLUGIN */
+  return 0;
+}
+
 /** @} */
 
 
@@ -422,64 +468,6 @@ HWLOC_DECLSPEC int hwloc_obj_add_children_sets(hwloc_obj_t obj);
  */
 HWLOC_DECLSPEC int hwloc_topology_reconnect(hwloc_topology_t topology, unsigned long flags __hwloc_attribute_unused);
 
-/** \brief Make sure that plugins can lookup core symbols.
- *
- * This is a sanity check to avoid lazy-lookup failures when libhwloc
- * is loaded within a plugin, and later tries to load its own plugins.
- * This may fail (and abort the program) if libhwloc symbols are in a
- * private namespace.
- *
- * \return 0 on success.
- * \return -1 if the plugin cannot be successfully loaded. The caller
- * plugin init() callback should return a negative error code as well.
- *
- * Plugins should call this function in their init() callback to avoid
- * later crashes if lazy symbol resolution is used by the upper layer that
- * loaded hwloc (e.g. OpenCL implementations using dlopen with RTLD_LAZY).
- *
- * \note The build system must define HWLOC_INSIDE_PLUGIN if and only if
- * building the caller as a plugin.
- *
- * \note This function should remain inline so plugins can call it even
- * when they cannot find libhwloc symbols.
- */
-static __hwloc_inline int
-hwloc_plugin_check_namespace(const char *pluginname __hwloc_attribute_unused, const char *symbol __hwloc_attribute_unused)
-{
-#ifdef HWLOC_INSIDE_PLUGIN
-  void *sym;
-#ifdef HWLOC_HAVE_LTDL
-  lt_dlhandle handle = lt_dlopen(NULL);
-#else
-  void *handle = dlopen(NULL, RTLD_NOW|RTLD_LOCAL);
-#endif
-  if (!handle)
-    /* cannot check, assume things will work */
-    return 0;
-#ifdef HWLOC_HAVE_LTDL
-  sym = lt_dlsym(handle, symbol);
-  lt_dlclose(handle);
-#else
-  sym = dlsym(handle, symbol);
-  dlclose(handle);
-#endif
-  if (!sym) {
-    static int verboseenv_checked = 0;
-    static int verboseenv_value = 0;
-    if (!verboseenv_checked) {
-      const char *verboseenv = getenv("HWLOC_PLUGINS_VERBOSE");
-      verboseenv_value = verboseenv ? atoi(verboseenv) : 0;
-      verboseenv_checked = 1;
-    }
-    if (verboseenv_value)
-      fprintf(stderr, "Plugin `%s' disabling itself because it cannot find the `%s' core symbol.\n",
-	      pluginname, symbol);
-    return -1;
-  }
-#endif /* HWLOC_INSIDE_PLUGIN */
-  return 0;
-}
-
 /** @} */
 
 

src/3rdparty/hwloc/include/hwloc/rename.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
- * Copyright © 2010-2024 Inria.  All rights reserved.
+ * Copyright © 2010-2025 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -409,8 +409,10 @@ extern "C" {
 #define hwloc_local_numanode_flag_e HWLOC_NAME(local_numanode_flag_e)
 #define HWLOC_LOCAL_NUMANODE_FLAG_LARGER_LOCALITY HWLOC_NAME_CAPS(LOCAL_NUMANODE_FLAG_LARGER_LOCALITY)
 #define HWLOC_LOCAL_NUMANODE_FLAG_SMALLER_LOCALITY HWLOC_NAME_CAPS(LOCAL_NUMANODE_FLAG_SMALLER_LOCALITY)
+#define HWLOC_LOCAL_NUMANODE_FLAG_INTERSECT_LOCALITY HWLOC_NAME_CAPS(LOCAL_NUMANODE_FLAG_INTERSECT_LOCALITY)
 #define HWLOC_LOCAL_NUMANODE_FLAG_ALL HWLOC_NAME_CAPS(LOCAL_NUMANODE_FLAG_ALL)
 #define hwloc_get_local_numanode_objs HWLOC_NAME(get_local_numanode_objs)
+#define hwloc_topology_get_default_nodeset HWLOC_NAME(topology_get_default_nodeset)
 
 #define hwloc_memattr_get_name HWLOC_NAME(memattr_get_name)
 #define hwloc_memattr_get_flags HWLOC_NAME(memattr_get_flags)
@@ -599,7 +601,9 @@ extern "C" {
 /* levelzero.h */
 
 #define hwloc_levelzero_get_device_cpuset HWLOC_NAME(levelzero_get_device_cpuset)
+#define hwloc_levelzero_get_sysman_device_cpuset HWLOC_NAME(levelzero_get_sysman_device_cpuset)
 #define hwloc_levelzero_get_device_osdev HWLOC_NAME(levelzero_get_device_osdev)
+#define hwloc_levelzero_get_sysman_device_osdev HWLOC_NAME(levelzero_get_sysman_device_osdev)
 
 /* gl.h */
 
@@ -813,6 +817,8 @@ extern "C" {
 #define hwloc_topology_setup_defaults HWLOC_NAME(topology_setup_defaults)
 #define hwloc_topology_clear HWLOC_NAME(topology_clear)
 
+#define hwloc__reconnect HWLOC_NAME(_reconnect)
+
 #define hwloc__attach_memory_object HWLOC_NAME(insert_memory_object)
 
 #define hwloc_get_obj_by_type_and_gp_index HWLOC_NAME(get_obj_by_type_and_gp_index)

src/3rdparty/hwloc/include/private/autogen/config.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009, 2011, 2012 CNRS.  All rights reserved.
- * Copyright © 2009-2020 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * Copyright © 2009, 2011, 2012, 2015 Université Bordeaux.  All rights reserved.
  * Copyright © 2009-2020 Cisco Systems, Inc.  All rights reserved.
  * $COPYRIGHT$
@@ -17,10 +17,6 @@
 
 #define HWLOC_HAVE_MSVC_CPUIDEX 1
 
-/* #undef HAVE_MKSTEMP */
-
-#define HWLOC_HAVE_X86_CPUID 1
-
 /* Define to 1 if the system has the type `CACHE_DESCRIPTOR'. */
 #define HAVE_CACHE_DESCRIPTOR 0
 
@@ -132,7 +128,8 @@
 #define HAVE_DECL__SC_PAGE_SIZE 0
 
 /* Define to 1 if you have the <dirent.h> header file. */
-/* #undef HAVE_DIRENT_H */
+/* #define HAVE_DIRENT_H 1 */
+#undef HAVE_DIRENT_H
 
 /* Define to 1 if you have the <dlfcn.h> header file. */
 /* #undef HAVE_DLFCN_H */
@@ -285,7 +282,7 @@
 #define HAVE_STRING_H 1
 
 /* Define to 1 if you have the `strncasecmp' function. */
-/* #undef HAVE_STRNCASECMP */
+#define HAVE_STRNCASECMP 1
 
 /* Define to '1' if sysctl is present and usable */
 /* #undef HAVE_SYSCTL */
@@ -326,7 +323,8 @@
 /* #undef HAVE_UNAME */
 
 /* Define to 1 if you have the <unistd.h> header file. */
-/* #undef HAVE_UNISTD_H */
+/* #define HAVE_UNISTD_H 1 */
+#undef HAVE_UNISTD_H
 
 /* Define to 1 if you have the `uselocale' function. */
 /* #undef HAVE_USELOCALE */
@@ -661,7 +659,7 @@
 #define hwloc_pid_t HANDLE
 
 /* Define this to either strncasecmp or strncmp */
-/* #undef hwloc_strncasecmp */
+#define hwloc_strncasecmp strncasecmp
 
 /* Define this to the thread ID type */
 #define hwloc_thread_t HANDLE

src/3rdparty/hwloc/include/private/misc.h

@@ -186,7 +186,7 @@ hwloc_ffsl_from_ffs32(unsigned long x)
 /**
  * flsl helpers.
  */
-#ifdef __GNUC_____
+#ifdef __GNUC__
 
 #  if (__GNUC__ >= 4) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))
 #    define hwloc_flsl(x) ((x) ? (8*sizeof(long) - __builtin_clzl(x)) : 0)

src/3rdparty/hwloc/include/private/private.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009      CNRS
- * Copyright © 2009-2023 Inria.  All rights reserved.
+ * Copyright © 2009-2025 Inria.  All rights reserved.
  * Copyright © 2009-2012, 2020 Université Bordeaux
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
  *
@@ -302,6 +302,9 @@ extern void hwloc__reorder_children(hwloc_obj_t parent);
 extern void hwloc_topology_setup_defaults(struct hwloc_topology *topology);
 extern void hwloc_topology_clear(struct hwloc_topology *topology);
 
+#define _HWLOC_RECONNECT_FLAG_KEEPSTRUCTURE (1UL<<0)
+extern int hwloc__reconnect(struct hwloc_topology *topology, unsigned long flags);
+
 /* insert memory object as memory child of normal parent */
 extern struct hwloc_obj * hwloc__attach_memory_object(struct hwloc_topology *topology, hwloc_obj_t parent,
                                                       hwloc_obj_t obj, const char *reason);

src/3rdparty/hwloc/src/distances.c

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2010-2024 Inria.  All rights reserved.
+ * Copyright © 2010-2025 Inria.  All rights reserved.
  * Copyright © 2011-2012 Université Bordeaux
  * Copyright © 2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -699,7 +699,7 @@ hwloc_distances_add_commit(hwloc_topology_t topology,
   }
 
   /* in case we added some groups, see if we need to reconnect */
-  hwloc_topology_reconnect(topology, 0);
+  hwloc__reconnect(topology, 0);
 
   return 0;
 
@@ -1387,19 +1387,12 @@ static __hwloc_inline int is_nvswitch(hwloc_obj_t obj)
 }
 
 static int
-hwloc__distances_transform_merge_switch_ports(hwloc_topology_t topology,
-                                              struct hwloc_distances_s *distances)
+hwloc__distances_transform_merge_switch_ports(struct hwloc_distances_s *distances)
 {
-  struct hwloc_internal_distances_s *dist = hwloc__internal_distances_from_public(topology, distances);
   hwloc_obj_t *objs = distances->objs;
   hwloc_uint64_t *values = distances->values;
   unsigned first, i, j, nbobjs = distances->nbobjs;
 
-  if (strcmp(dist->name, "NVLinkBandwidth")) {
-    errno = EINVAL;
-    return -1;
-  }
-
   /* find the first port */
   first = (unsigned) -1;
   for(i=0; i<nbobjs; i++)
@@ -1435,20 +1428,13 @@ hwloc__distances_transform_merge_switch_ports(hwloc_topology_t topology,
 }
 
 static int
-hwloc__distances_transform_transitive_closure(hwloc_topology_t topology,
-                                              struct hwloc_distances_s *distances)
+hwloc__distances_transform_transitive_closure(struct hwloc_distances_s *distances)
 {
-  struct hwloc_internal_distances_s *dist = hwloc__internal_distances_from_public(topology, distances);
   hwloc_obj_t *objs = distances->objs;
   hwloc_uint64_t *values = distances->values;
   unsigned nbobjs = distances->nbobjs;
   unsigned i, j, k;
 
-  if (strcmp(dist->name, "NVLinkBandwidth")) {
-    errno = EINVAL;
-    return -1;
-  }
-
   for(i=0; i<nbobjs; i++) {
     hwloc_uint64_t bw_i2sw = 0;
     if (is_nvswitch(objs[i]))
@@ -1467,8 +1453,8 @@ hwloc__distances_transform_transitive_closure(hwloc_topology_t topology,
         if (is_nvswitch(objs[k]))
           bw_sw2j += values[k*nbobjs+j];
 
-      /* bandwidth from i to j is now min(i2sw,sw2j) */
-      values[i*nbobjs+j] = bw_i2sw > bw_sw2j ? bw_sw2j : bw_i2sw;
+      /* bandwidth from i to j now gets indirect bandwidth too, min(i2sw,sw2j) */
+      values[i*nbobjs+j] += bw_i2sw > bw_sw2j ? bw_sw2j : bw_i2sw;
     }
   }
 
@@ -1476,7 +1462,7 @@ hwloc__distances_transform_transitive_closure(hwloc_topology_t topology,
 }
 
 int
-hwloc_distances_transform(hwloc_topology_t topology,
+hwloc_distances_transform(hwloc_topology_t topology __hwloc_attribute_unused,
                           struct hwloc_distances_s *distances,
                           enum hwloc_distances_transform_e transform,
                           void *transform_attr,
@@ -1495,13 +1481,13 @@ hwloc_distances_transform(hwloc_topology_t topology,
   case HWLOC_DISTANCES_TRANSFORM_MERGE_SWITCH_PORTS:
   {
     int err;
-    err = hwloc__distances_transform_merge_switch_ports(topology, distances);
+    err = hwloc__distances_transform_merge_switch_ports(distances);
     if (!err)
       err = hwloc__distances_transform_remove_null(distances);
     return err;
   }
   case HWLOC_DISTANCES_TRANSFORM_TRANSITIVE_CLOSURE:
-    return hwloc__distances_transform_transitive_closure(topology, distances);
+    return hwloc__distances_transform_transitive_closure(distances);
   default:
     errno = EINVAL;
     return -1;

src/3rdparty/hwloc/src/memattrs.c

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2020-2024 Inria.  All rights reserved.
+ * Copyright © 2020-2025 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -1158,6 +1158,8 @@ match_local_obj_cpuset(hwloc_obj_t node, hwloc_cpuset_t cpuset, unsigned long fl
 {
   if (flags & HWLOC_LOCAL_NUMANODE_FLAG_ALL)
     return 1;
+  if (flags & HWLOC_LOCAL_NUMANODE_FLAG_INTERSECT_LOCALITY)
+    return hwloc_bitmap_intersects(node->cpuset, cpuset);
   if ((flags & HWLOC_LOCAL_NUMANODE_FLAG_LARGER_LOCALITY)
       && hwloc_bitmap_isincluded(cpuset, node->cpuset))
     return 1;
@@ -1180,6 +1182,7 @@ hwloc_get_local_numanode_objs(hwloc_topology_t topology,
 
   if (flags & ~(HWLOC_LOCAL_NUMANODE_FLAG_SMALLER_LOCALITY
                 |HWLOC_LOCAL_NUMANODE_FLAG_LARGER_LOCALITY
+                |HWLOC_LOCAL_NUMANODE_FLAG_INTERSECT_LOCALITY
                 | HWLOC_LOCAL_NUMANODE_FLAG_ALL)) {
     errno = EINVAL;
     return -1;
@@ -1226,6 +1229,93 @@ hwloc_get_local_numanode_objs(hwloc_topology_t topology,
   return 0;
 }
 
+static int compare_nodes_by_os_index(const void *_a, const void *_b)
+{
+  const hwloc_obj_t * a = _a, * b = _b;
+  return (*a)->os_index - (*b)->os_index;
+}
+
+int
+hwloc_topology_get_default_nodeset(hwloc_topology_t topology,
+                                   hwloc_nodeset_t nodeset,
+                                   unsigned long flags)
+{
+  hwloc_obj_t *nodes;
+  hwloc_bitmap_t remainingcpuset;
+  unsigned nrnodes, i;
+  const char *first_subtype;
+
+  if (flags) {
+    errno = EINVAL;
+    goto out;
+  }
+
+  remainingcpuset = hwloc_bitmap_dup(topology->levels[0][0]->cpuset);
+  if (!remainingcpuset)
+    goto out;
+
+  nrnodes = topology->slevels[HWLOC_SLEVEL_NUMANODE].nbobjs;
+  nodes = malloc(nrnodes * sizeof(*nodes));
+  if (!nodes)
+    goto out_with_remainingcpuset;
+
+  memcpy(nodes, topology->slevels[HWLOC_SLEVEL_NUMANODE].objs, nrnodes * sizeof(*nodes));
+  qsort(nodes, nrnodes, sizeof(*nodes), compare_nodes_by_os_index);
+
+  hwloc_bitmap_zero(nodeset);
+
+  /* always take the first node (FIXME: except if unexpected subtype?) */
+  first_subtype = nodes[0]->subtype;
+  hwloc_bitmap_set(nodeset, nodes[0]->os_index);
+  hwloc_bitmap_andnot(remainingcpuset, remainingcpuset, nodes[0]->cpuset);
+
+  /* use all non-intersecting nodes with same subtype */
+  for(i=1; i<nrnodes; i++) {
+    /* check same or no subtype */
+    if (first_subtype) {
+      if (!nodes[i]->subtype || strcmp(first_subtype, nodes[i]->subtype))
+        continue;
+    } else if (nodes[i]->subtype) {
+      continue;
+    }
+    /* take non-overlapping nodes */
+    if (hwloc_bitmap_isincluded(nodes[i]->cpuset, remainingcpuset) /* can be empty */) {
+      hwloc_bitmap_set(nodeset, nodes[i]->os_index);
+      hwloc_bitmap_andnot(remainingcpuset, remainingcpuset, nodes[i]->cpuset);
+    }
+    /* more needed? */
+    if (hwloc_bitmap_iszero(remainingcpuset))
+      goto done;
+  }
+
+  /* find more nodes to cover the entire topology cpuset.
+   * only take what's necessary: first nodes, non-empty */
+  for(i=1; i<nrnodes; i++) {
+    /* already taken? */
+    if (hwloc_bitmap_isset(nodeset, i))
+      continue;
+    /* take non-overlapping nodes, except empty  */
+    if (hwloc_bitmap_isincluded(nodes[i]->cpuset, remainingcpuset)
+        && !hwloc_bitmap_iszero(nodes[i]->cpuset)) {
+      hwloc_bitmap_set(nodeset, nodes[i]->os_index);
+      hwloc_bitmap_andnot(remainingcpuset, remainingcpuset, nodes[i]->cpuset);
+    }
+    /* more needed? */
+    if (hwloc_bitmap_iszero(remainingcpuset))
+      goto done;
+  }
+
+ done:
+  free(nodes);
+  hwloc_bitmap_free(remainingcpuset);
+  return 0;
+
+ out_with_remainingcpuset:
+  hwloc_bitmap_free(remainingcpuset);
+ out:
+  return -1;
+}
+
 
 /**************************************
  * Using memattrs to identify HBM/DRAM
@@ -1433,10 +1523,15 @@ hwloc__group_memory_tiers(hwloc_topology_t topology,
     }
   }
 
-  /* Sort nodes.
-   * We could also sort by the existing subtype.
-   * KNL is the only case where subtypes are set in backends, but we set memattrs as well there.
-   * Also HWLOC_MEMTIERS_REFRESH would be a special value to ignore existing subtypes.
+  /* Sort nodes by tier type and bandwidth.
+   *
+   * We could also use the existing subtype but it's not clear it'd be better.
+   * For NVIDIA GPU, "GPUMemory" is set in the Linux backend, and used above to set tier type anyway.
+   * For KNL, the Linux backend sets subtypes and memattrs, sorting by memattrs already works fine.
+   * Existing subtypes could have been imported from XML, usually mostly OK except maybe SPM (fallback for I don't know)?
+   * An envvar (or HWLOC_MEMTIERS_REFRESH special value?) could be passed to ignore existing subtypes,
+   * but "GPUMemory" wouldn't be available anymore, we'd have to use something else like "PCIBusId",
+   * but that one might not always be specific to GPU-backed NUMA nodes?
    */
   hwloc_debug("Sorting memory node infos...\n");
   qsort(nodeinfos, n, sizeof(*nodeinfos), compare_node_infos_by_type_and_bw);

src/3rdparty/hwloc/src/topology-windows.c

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2024 Inria.  All rights reserved.
+ * Copyright © 2009-2025 Inria.  All rights reserved.
  * Copyright © 2009-2012, 2020 Université Bordeaux
  * Copyright © 2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -56,6 +56,9 @@ typedef enum _LOGICAL_PROCESSOR_RELATIONSHIP {
   RelationCache,
   RelationProcessorPackage,
   RelationGroup,
+  RelationProcessorDie,
+  RelationNumaNodeEx, /* only used to *request* extended numa info only, but included in RelationAll, never returned on output */
+  RelationProcessorModule,
   RelationAll = 0xffff
 } LOGICAL_PROCESSOR_RELATIONSHIP;
 #else /* HAVE_LOGICAL_PROCESSOR_RELATIONSHIP */
@@ -64,6 +67,11 @@ typedef enum _LOGICAL_PROCESSOR_RELATIONSHIP {
 #    define RelationGroup 4
 #    define RelationAll 0xffff
 #  endif /* HAVE_RELATIONPROCESSORPACKAGE */
+#  ifndef HAVE_RELATIONPROCESSORDIE
+#    define RelationProcessorDie 5
+#    define RelationNumaNodeEx 6
+#    define RelationProcessorModule 7
+#  endif
 #endif /* HAVE_LOGICAL_PROCESSOR_RELATIONSHIP */
 
 #ifndef HAVE_GROUP_AFFINITY
@@ -366,7 +374,7 @@ hwloc_win_get_processor_groups(void)
   hwloc_debug("found %lu windows processor groups\n", nr_processor_groups);
 
   if (nr_processor_groups > 1 && SIZEOF_VOID_P == 4) {
-    if (HWLOC_SHOW_ALL_ERRORS())
+    if (HWLOC_SHOW_CRITICAL_ERRORS())
       fprintf(stderr, "hwloc/windows: multiple processor groups found on 32bits Windows, topology may be invalid/incomplete.\n");
   }
 
@@ -1068,6 +1076,7 @@ hwloc_look_windows(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
 
 	id = HWLOC_UNKNOWN_INDEX;
 	switch (procInfo->Relationship) {
+          case RelationNumaNodeEx: /* only used on input anyway */
 	  case RelationNumaNode:
 	    type = HWLOC_OBJ_NUMANODE;
             /* Starting with Windows 11 and Server 2022, the GroupCount field is valid and >=1
@@ -1087,9 +1096,19 @@ hwloc_look_windows(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
 	    break;
 	  case RelationProcessorPackage:
 	    type = HWLOC_OBJ_PACKAGE;
+	    num = procInfo->Processor.GroupCount;
+	    GroupMask = procInfo->Processor.GroupMask;
+	    break;
+	  case RelationProcessorDie:
+            type = HWLOC_OBJ_DIE;
             num = procInfo->Processor.GroupCount;
             GroupMask = procInfo->Processor.GroupMask;
-	    break;
+            break;
+	  case RelationProcessorModule:
+            type = HWLOC_OBJ_GROUP;
+            num = procInfo->Processor.GroupCount;
+            GroupMask = procInfo->Processor.GroupMask;
+            break;
 	  case RelationCache:
 	    type = (procInfo->Cache.Type == CacheInstruction ? HWLOC_OBJ_L1ICACHE : HWLOC_OBJ_L1CACHE) + procInfo->Cache.Level - 1;
             /* GroupCount added approximately with NumaNode.GroupCount above */
@@ -1211,6 +1230,19 @@ hwloc_look_windows(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
 		continue;
 	    }
 	    break;
+          case HWLOC_OBJ_GROUP:
+            switch (procInfo->Relationship) {
+            case RelationGroup:
+              obj->attr->group.kind = HWLOC_GROUP_KIND_WINDOWS_PROCESSOR_GROUP;
+              break;
+            case RelationProcessorModule:
+              obj->attr->group.kind = HWLOC_GROUP_KIND_INTEL_MODULE;
+              obj->subtype = strdup("Module");
+              break;
+            default:
+              obj->attr->group.kind = HWLOC_GROUP_KIND_WINDOWS_RELATIONSHIP_UNKNOWN;
+            }
+            break;
 	  default:
 	    break;
 	}

src/3rdparty/hwloc/src/topology-x86.c

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2010-2024 Inria.  All rights reserved.
+ * Copyright © 2010-2025 Inria.  All rights reserved.
  * Copyright © 2010-2013 Université Bordeaux
  * Copyright © 2010-2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -653,7 +653,13 @@ static void look_proc(struct hwloc_backend *backend, struct procinfo *infos, uns
   cpuid_or_from_dump(&eax, &ebx, &ecx, &edx, src_cpuiddump);
   infos->apicid = ebx >> 24;
   if (edx & (1 << 28)) {
-    legacy_max_log_proc = 1 << hwloc_flsl(((ebx >> 16) & 0xff) - 1);
+    unsigned ebx_16_23 = (ebx >> 16) & 0xff;
+    if (ebx_16_23) {
+      legacy_max_log_proc = 1 << hwloc_flsl(ebx_16_23 - 1);
+    } else {
+      hwloc_debug("HTT bit set in CPUID 0x01.edx, but legacy_max_proc = 0 in ebx, assuming legacy_max_log_proc = 1\n");
+      legacy_max_log_proc = 1;
+    }
   } else {
     hwloc_debug("HTT bit not set in CPUID 0x01.edx, assuming legacy_max_log_proc = 1\n");
     legacy_max_log_proc = 1;
@@ -1742,7 +1748,7 @@ hwloc_x86_discover(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
 
   if (topology->levels[0][0]->cpuset) {
     /* somebody else discovered things, reconnect levels so that we can look at them */
-    hwloc_topology_reconnect(topology, 0);
+    hwloc__reconnect(topology, 0);
     if (topology->nb_levels == 2 && topology->level_nbobjects[1] == data->nbprocs) {
       /* only PUs were discovered, as much as we would, complete the topology with everything else */
       alreadypus = 1;

src/3rdparty/hwloc/src/topology-xml.c

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2024 Inria.  All rights reserved.
+ * Copyright © 2009-2025 Inria.  All rights reserved.
  * Copyright © 2009-2011, 2020 Université Bordeaux
  * Copyright © 2009-2018 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -415,6 +415,20 @@ hwloc__xml_import_object_attr(struct hwloc_topology *topology,
     }
   }
 
+  else if (!strcmp(name, "numanode_type")) {
+    switch (obj->type) {
+    case HWLOC_OBJ_NUMANODE: {
+      /* ignored for now, here for possible forward compat */
+      break;
+    }
+    default:
+      if (hwloc__xml_verbose())
+	fprintf(stderr, "%s: ignoring numanode_type attribute for non-NUMA object\n",
+		state->global->msgprefix);
+      break;
+    }
+  }
+
   else if (data->version_major < 2) {
     /************************
      * deprecated from 1.x
@@ -876,14 +890,19 @@ hwloc__xml_import_object(hwloc_topology_t topology,
 	  /* deal with possible future type */
 	  obj->type = HWLOC_OBJ_GROUP;
 	  obj->attr->group.kind = HWLOC_GROUP_KIND_LINUX_CLUSTER;
-	} else if (!strcasecmp(attrvalue, "MemCache")) {
+	}
+#if 0
+        /* reenable if there's ever a future type that should be ignored without being an error */
+        else if (!strcasecmp(attrvalue, "MemCache")) {
 	  /* ignore possible future type */
 	  obj->type = _HWLOC_OBJ_FUTURE;
 	  ignored = 1;
 	  if (hwloc__xml_verbose())
 	    fprintf(stderr, "%s: %s object not-supported, will be ignored\n",
 		    state->global->msgprefix, attrvalue);
-	} else {
+	}
+#endif
+        else {
 	  if (hwloc__xml_verbose())
 	    fprintf(stderr, "%s: unrecognized object type string %s\n",
 		    state->global->msgprefix, attrvalue);
@@ -958,22 +977,22 @@ hwloc__xml_import_object(hwloc_topology_t topology,
     if (hwloc__obj_type_is_normal(obj->type)) {
       if (!hwloc__obj_type_is_normal(parent->type)) {
 	if (hwloc__xml_verbose())
-	  fprintf(stderr, "normal object %s cannot be child of non-normal parent %s\n",
-		  hwloc_obj_type_string(obj->type), hwloc_obj_type_string(parent->type));
+	  fprintf(stderr, "%s: normal object %s cannot be child of non-normal parent %s\n",
+		  state->global->msgprefix, hwloc_obj_type_string(obj->type), hwloc_obj_type_string(parent->type));
 	goto error_with_object;
       }
     } else if (hwloc__obj_type_is_memory(obj->type)) {
       if (hwloc__obj_type_is_io(parent->type) || HWLOC_OBJ_MISC == parent->type) {
 	if (hwloc__xml_verbose())
-	  fprintf(stderr, "Memory object %s cannot be child of non-normal-or-memory parent %s\n",
-		  hwloc_obj_type_string(obj->type), hwloc_obj_type_string(parent->type));
+	  fprintf(stderr, "%s: Memory object %s cannot be child of non-normal-or-memory parent %s\n",
+		  state->global->msgprefix, hwloc_obj_type_string(obj->type), hwloc_obj_type_string(parent->type));
 	goto error_with_object;
       }
     } else if (hwloc__obj_type_is_io(obj->type)) {
       if (hwloc__obj_type_is_memory(parent->type) || HWLOC_OBJ_MISC == parent->type) {
 	if (hwloc__xml_verbose())
-	  fprintf(stderr, "I/O object %s cannot be child of non-normal-or-I/O parent %s\n",
-		  hwloc_obj_type_string(obj->type), hwloc_obj_type_string(parent->type));
+	  fprintf(stderr, "%s: I/O object %s cannot be child of non-normal-or-I/O parent %s\n",
+		  state->global->msgprefix, hwloc_obj_type_string(obj->type), hwloc_obj_type_string(parent->type));
 	goto error_with_object;
       }
     }

src/3rdparty/hwloc/src/topology.c

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2023 Inria.  All rights reserved.
+ * Copyright © 2009-2025 Inria.  All rights reserved.
  * Copyright © 2009-2012, 2020 Université Bordeaux
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
  * Copyright © 2022 IBM Corporation.  All rights reserved.
@@ -54,56 +54,6 @@
 #endif
 
 
-#ifdef HWLOC_HAVE_LEVELZERO
-/*
- * Define ZES_ENABLE_SYSMAN=1 early so that the LevelZero backend gets Sysman enabled.
- *
- * Only if the levelzero was enabled in this build so that we don't enable sysman
- * for external levelzero users when hwloc doesn't need it. If somebody ever loads
- * an external levelzero plugin in a hwloc library built without levelzero (unlikely),
- * he may have to manually set ZES_ENABLE_SYSMAN=1.
- *
- * Use the constructor if supported and/or the Windows DllMain callback.
- * Do it in the main hwloc library instead of the levelzero component because
- * the latter could be loaded later as a plugin.
- *
- * L0 seems to be using getenv() to check this variable on Windows
- * (at least in the Intel Compute-Runtime of March 2021),
- * but setenv() doesn't seem to exist on Windows, hence use putenv() to set the variable.
- *
- * For the record, Get/SetEnvironmentVariable() is not exactly the same as getenv/putenv():
- * - getenv() doesn't see what was set with SetEnvironmentVariable()
- * - GetEnvironmentVariable() doesn't see putenv() in cygwin (while it does in MSVC and MinGW).
- * Hence, if L0 ever switches from getenv() to GetEnvironmentVariable(),
- * it will break in cygwin, we'll have to use both putenv() and SetEnvironmentVariable().
- * Hopefully L0 will provide a way to enable Sysman without env vars before it happens.
- */
-#if HWLOC_HAVE_ATTRIBUTE_CONSTRUCTOR
-static void hwloc_constructor(void) __attribute__((constructor));
-static void hwloc_constructor(void)
-{
-  if (!getenv("ZES_ENABLE_SYSMAN"))
-#ifdef HWLOC_WIN_SYS
-    putenv("ZES_ENABLE_SYSMAN=1");
-#else
-    setenv("ZES_ENABLE_SYSMAN", "1", 1);
-#endif
-}
-#endif
-#ifdef HWLOC_WIN_SYS
-BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
-{
-  if (fdwReason == DLL_PROCESS_ATTACH) {
-    if (!getenv("ZES_ENABLE_SYSMAN"))
-      /* Windows does not have a setenv, so use putenv. */
-      putenv((char *) "ZES_ENABLE_SYSMAN=1");
-  }
-  return TRUE;
-}
-#endif
-#endif /* HWLOC_HAVE_LEVELZERO */
-
-
 unsigned hwloc_get_api_version(void)
 {
   return HWLOC_API_VERSION;
@@ -179,7 +129,7 @@ static void report_insert_error(hwloc_obj_t new, hwloc_obj_t old, const char *ms
     report_insert_error_format_obj(oldstr, sizeof(oldstr), old);
 
     fprintf(stderr, "****************************************************************************\n");
-    fprintf(stderr, "* hwloc %s received invalid information from the operating system.\n", HWLOC_VERSION);
+    fprintf(stderr, "* hwloc %s received invalid information.\n", HWLOC_VERSION);
     fprintf(stderr, "*\n");
     fprintf(stderr, "* Failed with error: %s\n", msg);
     fprintf(stderr, "* while inserting %s\n", newstr);
@@ -1966,6 +1916,51 @@ static void hwloc_set_group_depth(hwloc_topology_t topology);
 static void hwloc_connect_children(hwloc_obj_t parent);
 static int hwloc_connect_levels(hwloc_topology_t topology);
 static int hwloc_connect_special_levels(hwloc_topology_t topology);
+static int hwloc_filter_levels_keep_structure(hwloc_topology_t topology);
+
+/* reconnect children and levels,
+ * and optionnally merged identical levels while keeping structure.
+ */
+int
+hwloc__reconnect(struct hwloc_topology *topology, unsigned long flags)
+{
+  int merged_levels = 0;
+
+  if (topology->modified) {
+    hwloc_connect_children(topology->levels[0][0]);
+
+    if (hwloc_connect_levels(topology) < 0)
+      return -1;
+  }
+
+  if (flags & _HWLOC_RECONNECT_FLAG_KEEPSTRUCTURE) {
+    merged_levels = hwloc_filter_levels_keep_structure(topology);
+    /* If > 0, we merged some levels,
+     * some child+parent special children list may have been merged,
+     * hence specials level might need reordering,
+     * So reconnect special levels only here at the end.
+     */
+  }
+
+  if (topology->modified || merged_levels) {
+    if (hwloc_connect_special_levels(topology) < 0)
+      return -1;
+  }
+
+  topology->modified = 0;
+  return 0;
+}
+
+int
+hwloc_topology_reconnect(struct hwloc_topology *topology, unsigned long flags)
+{
+  if (flags) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  return hwloc__reconnect(topology, 0);
+}
 
 hwloc_obj_t
 hwloc_topology_insert_group_object(struct hwloc_topology *topology, hwloc_obj_t obj)
@@ -2058,7 +2053,10 @@ hwloc_topology_insert_group_object(struct hwloc_topology *topology, hwloc_obj_t
 
   /* properly inserted */
   hwloc_obj_add_children_sets(res);
-  if (hwloc_topology_reconnect(topology, 0) < 0)
+  /* reconnect levels.
+   * no need to filter levels keep_structure because groups are either auto-merged
+   * or have the dont_merge attribute */
+  if (hwloc__reconnect(topology, 0) < 0)
     return NULL;
 
   /* Compute group total_memory. */
@@ -2550,26 +2548,13 @@ hwloc_compare_levels_structure(hwloc_topology_t topology, unsigned i)
   return 0;
 }
 
-/* return > 0 if any level was removed.
- * performs its own reconnect internally if needed
- */
+/* return > 0 if any level was removed. */
 static int
 hwloc_filter_levels_keep_structure(hwloc_topology_t topology)
 {
   unsigned i, j;
   int res = 0;
 
-  if (topology->modified) {
-    /* WARNING: hwloc_topology_reconnect() is duplicated partially here
-     * and at the end of this function:
-     * - we need normal levels before merging.
-     * - and we'll need to update special levels after merging.
-     */
-    hwloc_connect_children(topology->levels[0][0]);
-    if (hwloc_connect_levels(topology) < 0)
-      return -1;
-  }
-
   /* start from the bottom since we'll remove intermediate levels */
   for(i=topology->nb_levels-1; i>0; i--) {
     int replacechild = 0, replaceparent = 0;
@@ -2591,9 +2576,15 @@ hwloc_filter_levels_keep_structure(hwloc_topology_t topology)
       if (type1 == HWLOC_OBJ_GROUP && hwloc_dont_merge_group_level(topology, i))
 	replacechild = 0;
     }
-    if (!replacechild && !replaceparent)
+    if (!replacechild && !replaceparent) {
+      /* always merge Die into Package when levels are identical */
+      if (type1 == HWLOC_OBJ_PACKAGE && type2 == HWLOC_OBJ_DIE)
+        replacechild = 1;
+    }
+    if (!replacechild && !replaceparent) {
       /* no ignoring */
       continue;
+    }
     /* Decide which one to actually replace */
     if (replaceparent && replacechild) {
       /* If both may be replaced, look at obj_type_priority */
@@ -2736,20 +2727,6 @@ hwloc_filter_levels_keep_structure(hwloc_topology_t topology)
     }
   }
 
-
-  if (res > 0 || topology-> modified) {
-    /* WARNING: hwloc_topology_reconnect() is duplicated partially here
-     * and at the beginning of this function.
-     * If we merged some levels, some child+parent special children lisst
-     * may have been merged, hence specials level might need reordering,
-     * So reconnect special levels only here at the end
-     * (it's not needed at the beginning of this function).
-     */
-    if (hwloc_connect_special_levels(topology) < 0)
-      return -1;
-    topology->modified = 0;
-  }
-
   return 0;
 }
 
@@ -3278,33 +3255,6 @@ hwloc_connect_levels(hwloc_topology_t topology)
   return 0;
 }
 
-int
-hwloc_topology_reconnect(struct hwloc_topology *topology, unsigned long flags)
-{
-  /* WARNING: when updating this function, the replicated code must
-   * also be updated inside hwloc_filter_levels_keep_structure()
-   */
-
-  if (flags) {
-    errno = EINVAL;
-    return -1;
-  }
-  if (!topology->modified)
-    return 0;
-
-  hwloc_connect_children(topology->levels[0][0]);
-
-  if (hwloc_connect_levels(topology) < 0)
-    return -1;
-
-  if (hwloc_connect_special_levels(topology) < 0)
-    return -1;
-
-  topology->modified = 0;
-
-  return 0;
-}
-
 /* for regression testing, make sure the order of io devices
  * doesn't change with the dentry order in the filesystem
  *
@@ -3561,32 +3511,13 @@ hwloc_discover(struct hwloc_topology *topology,
     hwloc_debug_print_objects(0, topology->levels[0][0]);
   }
 
-  /* see if we should ignore the root now that we know how many children it has */
-  if (!hwloc_filter_check_keep_object(topology, topology->levels[0][0])
-      && topology->levels[0][0]->first_child && !topology->levels[0][0]->first_child->next_sibling) {
-    hwloc_obj_t oldroot = topology->levels[0][0];
-    hwloc_obj_t newroot = oldroot->first_child;
-    /* switch to the new root */
-    newroot->parent = NULL;
-    topology->levels[0][0] = newroot;
-    /* move oldroot memory/io/misc children before newroot children */
-    if (oldroot->memory_first_child)
-      prepend_siblings_list(&newroot->memory_first_child, oldroot->memory_first_child, newroot);
-    if (oldroot->io_first_child)
-      prepend_siblings_list(&newroot->io_first_child, oldroot->io_first_child, newroot);
-    if (oldroot->misc_first_child)
-      prepend_siblings_list(&newroot->misc_first_child, oldroot->misc_first_child, newroot);
-    /* destroy oldroot and use the new one */
-    hwloc_free_unlinked_object(oldroot);
-  }
-
   /*
    * All object cpusets and nodesets are properly set now.
    */
 
   /* Now connect handy pointers to make remaining discovery easier. */
   hwloc_debug("%s", "\nOk, finished tweaking, now connect\n");
-  if (hwloc_topology_reconnect(topology, 0) < 0)
+  if (hwloc__reconnect(topology, 0) < 0)
     return -1;
   hwloc_debug_print_objects(0, topology->levels[0][0]);
 
@@ -3642,12 +3573,12 @@ hwloc_discover(struct hwloc_topology *topology,
   }
   hwloc_debug_print_objects(0, topology->levels[0][0]);
 
+  /* reconnect all (new groups might have appears, IO added, etc),
+   * and (now that everything was added) remove identical levels while keeping structure
+   */
   hwloc_debug("%s", "\nRemoving levels with HWLOC_TYPE_FILTER_KEEP_STRUCTURE\n");
-  if (hwloc_filter_levels_keep_structure(topology) < 0)
+  if (hwloc__reconnect(topology, _HWLOC_RECONNECT_FLAG_KEEPSTRUCTURE) < 0)
     return -1;
-  /* takes care of reconnecting children/levels internally,
-   * because it needs normal levels.
-   * and it's often needed below because of Groups inserted for I/Os anyway */
   hwloc_debug_print_objects(0, topology->levels[0][0]);
 
   /* accumulate children memory in total_memory fields (only once parent is set) */
@@ -4494,7 +4425,7 @@ hwloc_topology_restrict(struct hwloc_topology *topology, hwloc_const_bitmap_t se
   hwloc_bitmap_free(droppedcpuset);
   hwloc_bitmap_free(droppednodeset);
 
-  if (hwloc_filter_levels_keep_structure(topology) < 0) /* takes care of reconnecting internally */
+  if (hwloc__reconnect(topology, _HWLOC_RECONNECT_FLAG_KEEPSTRUCTURE) < 0)
     goto out;
 
   /* some objects may have disappeared and sets were modified,
@@ -5116,6 +5047,8 @@ hwloc_topology_check(struct hwloc_topology *topology)
   unsigned i;
   int j, depth;
 
+  assert(!topology->modified);
+
   /* make sure we can use ranges to check types */
 
   /* hwloc__obj_type_is_{,d,i}cache() want cache types to be ordered like this */

src/3rdparty/libethash/endian.h

@@ -31,7 +31,7 @@
 #include <libkern/OSByteOrder.h>
 #define ethash_swap_u32(input_) OSSwapInt32(input_)
 #define ethash_swap_u64(input_) OSSwapInt64(input_)
-#elif defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__)
+#elif defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__HAIKU__)
 #define ethash_swap_u32(input_) bswap32(input_)
 #define ethash_swap_u64(input_) bswap64(input_)
 #elif defined(__OpenBSD__)

src/Summary.cpp

@@ -89,11 +89,16 @@ static void print_cpu(const Config *)
 {
     const auto info = Cpu::info();
 
-    Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s%s (%zu)") " %s %sAES%s",
+    Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s%s (%zu)") " %s %s%sAES%s",
                "CPU",
                info->brand(),
                info->packages(),
                ICpuInfo::is64bit()    ? GREEN_BOLD("64-bit") : RED_BOLD("32-bit"),
+#ifdef XMRIG_RISCV
+               info->hasRISCV_Vector() ? GREEN_BOLD_S "RVV " : RED_BOLD_S "-RVV ",
+#else
+               "",
+#endif
                info->hasAES()         ? GREEN_BOLD_S : RED_BOLD_S "-",
                info->isVM()           ? RED_BOLD_S " VM" : ""
                );

src/backend/common/benchmark/BenchState_test.h

@@ -48,6 +48,24 @@ static const std::map<int, std::map<uint32_t, uint64_t> > hashCheck = {
         {  9000000U, 0x323935102AB6B45CULL },
         { 10000000U, 0xB5231262E2792B26ULL }
     }},
+    { Algorithm::RX_V2, {
+#       ifndef NDEBUG
+        {    10000U, 0x57d2051d099613a4ULL },
+        {    20000U, 0x0bae0155cc797f01ULL },
+#       endif
+        {   250000U, 0x18cf741a71484072ULL },
+        {   500000U, 0xcd8c3e6ec31b2faeULL },
+        {  1000000U, 0x88d6b8fb70cd479dULL },
+        {  2000000U, 0x0e16828d236a1a63ULL },
+        {  3000000U, 0x2739bdd0f25b83a6ULL },
+        {  4000000U, 0x32f42d9006d2d34bULL },
+        {  5000000U, 0x16d9c6286cb82251ULL },
+        {  6000000U, 0x1f916ae19d6bcf07ULL },
+        {  7000000U, 0x1f474f99a873948fULL },
+        {  8000000U, 0x8d67e0ddf05476bbULL },
+        {  9000000U, 0x3ebf37dcd5c4a215ULL },
+        { 10000000U, 0x7efbddff3f30fb74ULL }
+    }},
     { Algorithm::RX_WOW, {
 #       ifndef NDEBUG
         {    10000U, 0x6B0918757100B338ULL },
@@ -88,6 +106,24 @@ static const std::map<int, std::map<uint32_t, uint64_t> > hashCheck1T = {
         {  9000000U, 0xC6D39EF59213A07CULL },
         { 10000000U, 0x95E6BAE68DD779CDULL }
     }},
+    { Algorithm::RX_V2, {
+#       ifndef NDEBUG
+        {    10000, 0x90eb7c07cd9e0d90ULL },
+        {    20000, 0x6523a3658d7d9930ULL },
+#       endif
+        {   250000, 0xf83b6d9d355ee5b1ULL },
+        {   500000, 0xbea3c1bf1465e9abULL },
+        {  1000000, 0x9e16f7cb56b366e1ULL },
+        {  2000000, 0x3b5e671f47e15e55ULL },
+        {  3000000, 0xec5819c180df03e2ULL },
+        {  4000000, 0x19d31b498f86aad4ULL },
+        {  5000000, 0x2487626c75cd12ccULL },
+        {  6000000, 0xa323a25a5286c39aULL },
+        {  7000000, 0xa123b100f3104dfcULL },
+        {  8000000, 0x602db9d83bfa0ddcULL },
+        {  9000000, 0x98da909e579765ddULL },
+        { 10000000, 0x3a45b7247cec9895ULL }
+    }},
     { Algorithm::RX_WOW, {
 #       ifndef NDEBUG
         {    10000U, 0x9EC1B9B8C8C7F082ULL },

src/backend/cpu/CpuWorker.cpp

@@ -87,14 +87,14 @@ xmrig::CpuWorker<N>::CpuWorker(size_t id, const CpuLaunchData &data) :
         if (!cn_heavyZen3Memory) {
             // Round up number of threads to the multiple of 8
             const size_t num_threads = ((m_threads + 7) / 8) * 8;
-            cn_heavyZen3Memory = new VirtualMemory(m_algorithm.l3() * num_threads, data.hugePages, false, false, node());
+            cn_heavyZen3Memory = new VirtualMemory(m_algorithm.l3() * num_threads, data.hugePages, false, false, node(), VirtualMemory::kDefaultHugePageSize);
         }
         m_memory = cn_heavyZen3Memory;
     }
     else
 #   endif
     {
-        m_memory = new VirtualMemory(m_algorithm.l3() * N, data.hugePages, false, true, node());
+        m_memory = new VirtualMemory(m_algorithm.l3() * N, data.hugePages, false, true, node(), VirtualMemory::kDefaultHugePageSize);
     }
 
 #   ifdef XMRIG_ALGO_GHOSTRIDER
@@ -256,7 +256,10 @@ void xmrig::CpuWorker<N>::start()
 
 #       ifdef XMRIG_ALGO_RANDOMX
         bool first = true;
-        alignas(16) uint64_t tempHash[8] = {};
+        alignas(64) uint64_t tempHash[8] = {};
+
+        size_t prev_job_size = 0;
+        alignas(64) uint8_t prev_job[Job::kMaxBlobSize] = {};
 #       endif
 
         while (!Nonce::isOutdated(Nonce::CPU, m_job.sequence())) {
@@ -297,6 +300,11 @@ void xmrig::CpuWorker<N>::start()
                         job.generateMinerSignature(m_job.blob(), job.size(), miner_signature_ptr);
                     }
                     randomx_calculate_hash_first(m_vm, tempHash, m_job.blob(), job.size());
+
+                    if (RandomX_CurrentConfig.Tweak_V2_COMMITMENT) {
+                        prev_job_size = job.size();
+                        memcpy(prev_job, m_job.blob(), prev_job_size);
+                    }
                 }
 
                 if (!nextRound()) {
@@ -307,7 +315,15 @@ void xmrig::CpuWorker<N>::start()
                     memcpy(miner_signature_saved, miner_signature_ptr, sizeof(miner_signature_saved));
                     job.generateMinerSignature(m_job.blob(), job.size(), miner_signature_ptr);
                 }
+
                 randomx_calculate_hash_next(m_vm, tempHash, m_job.blob(), job.size(), m_hash);
+
+                if (RandomX_CurrentConfig.Tweak_V2_COMMITMENT) {
+                    memcpy(m_commitment, m_hash, RANDOMX_HASH_SIZE);
+                    randomx_calculate_commitment(prev_job, prev_job_size, m_hash, m_hash);
+                    prev_job_size = job.size();
+                    memcpy(prev_job, m_job.blob(), prev_job_size);
+                }
             }
             else
 #           endif
@@ -347,8 +363,20 @@ void xmrig::CpuWorker<N>::start()
                     }
                     else
 #                   endif
+
                     if (value < job.target()) {
-                        JobResults::submit(job, current_job_nonces[i], m_hash + (i * 32), job.hasMinerSignature() ? miner_signature_saved : nullptr);
+                        uint8_t* extra_data = nullptr;
+
+                        if (job.algorithm().family() == Algorithm::RANDOM_X) {
+                            if (RandomX_CurrentConfig.Tweak_V2_COMMITMENT) {
+                                extra_data = m_commitment;
+                            }
+                            else if (job.hasMinerSignature()) {
+                                extra_data = miner_signature_saved;
+                            }
+                        }
+
+                        JobResults::submit(job, current_job_nonces[i], m_hash + (i * 32), extra_data);
                     }
                 }
                 m_count += N;

src/backend/cpu/CpuWorker.h

@@ -83,6 +83,7 @@ private:
     void allocateCnCtx();
     void consumeJob();
 
+    alignas(8) uint8_t m_commitment[N * 32]{ 0 };
     alignas(8) uint8_t m_hash[N * 32]{ 0 };
     const Algorithm m_algorithm;
     const Assembly m_assembly;

src/backend/cpu/cpu.cmake

@@ -46,7 +46,12 @@ else()
     set(CPUID_LIB "")
 endif()
 
-if (XMRIG_ARM)
+if (XMRIG_RISCV)
+    list(APPEND SOURCES_BACKEND_CPU
+        src/backend/cpu/platform/lscpu_riscv.cpp
+        src/backend/cpu/platform/BasicCpuInfo_riscv.cpp
+    )
+elseif (XMRIG_ARM)
     list(APPEND SOURCES_BACKEND_CPU src/backend/cpu/platform/BasicCpuInfo_arm.cpp)
 
     if (XMRIG_OS_WIN)

src/backend/cpu/interfaces/ICpuInfo.h

@@ -85,13 +85,14 @@ public:
         FLAG_POPCNT,
         FLAG_CAT_L3,
         FLAG_VM,
+        FLAG_RISCV_VECTOR,
         FLAG_MAX
     };
 
     ICpuInfo()          = default;
     virtual ~ICpuInfo() = default;
 
-#   if defined(__x86_64__) || defined(_M_AMD64) || defined (__arm64__) || defined (__aarch64__)
+#   if defined(__x86_64__) || defined(_M_AMD64) || defined (__arm64__) || defined (__aarch64__) || defined(__riscv) && (__riscv_xlen == 64)
     inline constexpr static bool is64bit() { return true; }
 #   else
     inline constexpr static bool is64bit() { return false; }
@@ -109,6 +110,7 @@ public:
     virtual bool hasOneGbPages() const                                              = 0;
     virtual bool hasXOP() const                                                     = 0;
     virtual bool isVM() const                                                       = 0;
+    virtual bool hasRISCV_Vector() const                                            = 0;
     virtual bool jccErratum() const                                                 = 0;
     virtual const char *backend() const                                             = 0;
     virtual const char *brand() const                                               = 0;

src/backend/cpu/platform/BasicCpuInfo.cpp

@@ -58,8 +58,8 @@
 namespace xmrig {
 
 
-constexpr size_t kCpuFlagsSize                                  = 15;
-static const std::array<const char *, kCpuFlagsSize> flagNames  = { "aes", "vaes", "avx", "avx2", "avx512f", "bmi2", "osxsave", "pdpe1gb", "sse2", "ssse3", "sse4.1", "xop", "popcnt", "cat_l3", "vm" };
+constexpr size_t kCpuFlagsSize                                  = 16;
+static const std::array<const char *, kCpuFlagsSize> flagNames  = { "aes", "vaes", "avx", "avx2", "avx512f", "bmi2", "osxsave", "pdpe1gb", "sse2", "ssse3", "sse4.1", "xop", "popcnt", "cat_l3", "vm", "rvv" };
 static_assert(kCpuFlagsSize == ICpuInfo::FLAG_MAX, "kCpuFlagsSize and FLAG_MAX mismatch");
 
 
@@ -250,7 +250,7 @@ xmrig::BasicCpuInfo::BasicCpuInfo() :
                     break;
 
                 case 0x19:
-                    if (m_model == 0x61) {
+                    if ((m_model == 0x61) || (m_model == 0x75)) {
                         m_arch = ARCH_ZEN4;
                         m_msrMod = MSR_MOD_RYZEN_19H_ZEN4;
                     }

src/backend/cpu/platform/BasicCpuInfo.h

@@ -52,6 +52,7 @@ protected:
     inline bool hasOneGbPages() const override                  { return has(FLAG_PDPE1GB); }
     inline bool hasXOP() const override                         { return has(FLAG_XOP); }
     inline bool isVM() const override                           { return has(FLAG_VM); }
+    inline bool hasRISCV_Vector() const override                { return has(FLAG_RISCV_VECTOR); }
     inline bool jccErratum() const override                     { return m_jccErratum; }
     inline const char *brand() const override                   { return m_brand; }
     inline const std::vector<int32_t> &units() const override   { return m_units; }
@@ -65,7 +66,7 @@ protected:
     inline Vendor vendor() const override                       { return m_vendor; }
     inline uint32_t model() const override
     {
-#   ifndef XMRIG_ARM
+#   if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
         return m_model;
 #   else
         return 0;
@@ -80,7 +81,7 @@ protected:
     Vendor m_vendor         = VENDOR_UNKNOWN;
 
 private:
-#   ifndef XMRIG_ARM
+#   if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
     uint32_t m_procInfo     = 0;
     uint32_t m_family       = 0;
     uint32_t m_model        = 0;

src/backend/cpu/platform/BasicCpuInfo_arm_win.cpp

@@ -18,10 +18,15 @@
 
 #include "backend/cpu/platform/BasicCpuInfo.h"
 
+#include <Windows.h>
+
 
 void xmrig::BasicCpuInfo::init_arm()
 {
-#   if __ARM_FEATURE_CRYPTO
-    m_flags.set(FLAG_AES, true); // FIXME
-#   endif
+    DWORD size         = sizeof(m_brand) - 1;
+    const char *subkey = "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0";
+
+    RegGetValueA(HKEY_LOCAL_MACHINE, subkey, "ProcessorNameString", RRF_RT_REG_SZ, nullptr, m_brand, &size);
+
+    m_flags.set(FLAG_AES, IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE));
 }

src/backend/cpu/platform/BasicCpuInfo_riscv.cpp

@@ -0,0 +1,119 @@
+/* XMRig
+ * Copyright (c) 2025      Slayingripper <https://github.com/Slayingripper>
+ * Copyright (c) 2018-2025 SChernykh     <https://github.com/SChernykh>
+ * Copyright (c) 2017-2019 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright (c) 2016-2025 XMRig         <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <array>
+#include <cstring>
+#include <fstream>
+#include <thread>
+
+
+#include "backend/cpu/platform/BasicCpuInfo.h"
+#include "base/tools/String.h"
+#include "3rdparty/rapidjson/document.h"
+
+
+namespace xmrig {
+
+
+extern String cpu_name_riscv();
+extern bool has_riscv_vector();
+extern bool has_riscv_aes();
+
+
+} // namespace xmrig
+
+
+xmrig::BasicCpuInfo::BasicCpuInfo() :
+    m_threads(std::thread::hardware_concurrency())
+{
+    m_units.resize(m_threads);
+    for (int32_t i = 0; i < static_cast<int32_t>(m_threads); ++i) {
+        m_units[i] = i;
+    }
+
+    memcpy(m_brand, "RISC-V", 6);
+
+    auto name = cpu_name_riscv();
+    if (!name.isNull()) {
+        strncpy(m_brand, name.data(), sizeof(m_brand) - 1);
+    }
+    
+    // Check for vector extensions
+    m_flags.set(FLAG_RISCV_VECTOR, has_riscv_vector());
+
+    // Check for AES extensions (Zknd/Zkne)
+    m_flags.set(FLAG_AES, has_riscv_aes());
+    
+    // RISC-V typically supports 1GB huge pages
+    m_flags.set(FLAG_PDPE1GB, std::ifstream("/sys/kernel/mm/hugepages/hugepages-1048576kB/nr_hugepages").good());
+}
+
+
+const char *xmrig::BasicCpuInfo::backend() const
+{
+    return "basic/1";
+}
+
+
+xmrig::CpuThreads xmrig::BasicCpuInfo::threads(const Algorithm &algorithm, uint32_t) const
+{
+#   ifdef XMRIG_ALGO_GHOSTRIDER
+    if (algorithm.family() == Algorithm::GHOSTRIDER) {
+        return CpuThreads(threads(), 8);
+    }
+#   endif
+
+    return CpuThreads(threads());
+}
+
+
+rapidjson::Value xmrig::BasicCpuInfo::toJSON(rapidjson::Document &doc) const
+{
+    using namespace rapidjson;
+    auto &allocator = doc.GetAllocator();
+
+    Value out(kObjectType);
+
+    out.AddMember("brand",      StringRef(brand()), allocator);
+    out.AddMember("aes",        hasAES(), allocator);
+    out.AddMember("avx2",       false, allocator);
+    out.AddMember("x64",        is64bit(), allocator); // DEPRECATED will be removed in the next major release.
+    out.AddMember("64_bit",     is64bit(), allocator);
+    out.AddMember("l2",         static_cast<uint64_t>(L2()), allocator);
+    out.AddMember("l3",         static_cast<uint64_t>(L3()), allocator);
+    out.AddMember("cores",      static_cast<uint64_t>(cores()), allocator);
+    out.AddMember("threads",    static_cast<uint64_t>(threads()), allocator);
+    out.AddMember("packages",   static_cast<uint64_t>(packages()), allocator);
+    out.AddMember("nodes",      static_cast<uint64_t>(nodes()), allocator);
+    out.AddMember("backend",    StringRef(backend()), allocator);
+    out.AddMember("msr",        "none", allocator);
+    out.AddMember("assembly",   "none", allocator);
+    out.AddMember("arch",       "riscv64", allocator);
+
+    Value flags(kArrayType);
+
+    if (hasAES()) {
+        flags.PushBack("aes", allocator);
+    }
+
+    out.AddMember("flags", flags, allocator);
+
+    return out;
+}

src/backend/cpu/platform/HwlocCpuInfo.cpp

@@ -87,7 +87,7 @@ static inline size_t countByType(hwloc_topology_t topology, hwloc_obj_type_t typ
 }
 
 
-#ifndef XMRIG_ARM
+#if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
 static inline std::vector<hwloc_obj_t> findByType(hwloc_obj_t obj, hwloc_obj_type_t type)
 {
     std::vector<hwloc_obj_t> out;
@@ -207,7 +207,7 @@ bool xmrig::HwlocCpuInfo::membind(hwloc_const_bitmap_t nodeset)
 
 xmrig::CpuThreads xmrig::HwlocCpuInfo::threads(const Algorithm &algorithm, uint32_t limit) const
 {
-#   ifndef XMRIG_ARM
+#   if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
     if (L2() == 0 && L3() == 0) {
         return BasicCpuInfo::threads(algorithm, limit);
     }
@@ -277,7 +277,7 @@ xmrig::CpuThreads xmrig::HwlocCpuInfo::allThreads(const Algorithm &algorithm, ui
 
 void xmrig::HwlocCpuInfo::processTopLevelCache(hwloc_obj_t cache, const Algorithm &algorithm, CpuThreads &threads, size_t limit) const
 {
-#   ifndef XMRIG_ARM
+#   if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
     constexpr size_t oneMiB = 1024U * 1024U;
 
     size_t PUs = countByType(cache, HWLOC_OBJ_PU);
@@ -311,17 +311,17 @@ void xmrig::HwlocCpuInfo::processTopLevelCache(hwloc_obj_t cache, const Algorith
     uint32_t intensity      = algorithm.maxIntensity() == 1 ? 0 : 1;
 
     if (cache->attr->cache.depth == 3) {
-        for (size_t i = 0; i < cache->arity; ++i) {
-            hwloc_obj_t l2 = cache->children[i];
+        auto process_L2 = [&L2, &L2_associativity, L3_exclusive, this, &extra, scratchpad](hwloc_obj_t l2) {
             if (!hwloc_obj_type_is_cache(l2->type) || l2->attr == nullptr) {
-                continue;
+                return;
             }
 
             L2 += l2->attr->cache.size;
             L2_associativity = l2->attr->cache.associativity;
 
             if (L3_exclusive) {
-                if (vendor() == VENDOR_AMD) {
+                if ((vendor() == VENDOR_AMD) && ((arch() == ARCH_ZEN4) || (arch() == ARCH_ZEN5))) {
+                    // Use extra L2 only on newer CPUs because older CPUs (Zen 3 and older) don't benefit from it.
                     // For some reason, AMD CPUs can use only half of the exclusive L2/L3 cache combo efficiently
                     extra += std::min<size_t>(l2->attr->cache.size / 2, scratchpad);
                 }
@@ -329,6 +329,18 @@ void xmrig::HwlocCpuInfo::processTopLevelCache(hwloc_obj_t cache, const Algorith
                     extra += scratchpad;
                 }
             }
+        };
+
+        for (size_t i = 0; i < cache->arity; ++i) {
+            hwloc_obj_t ch = cache->children[i];
+            if (ch->type == HWLOC_OBJ_GROUP) {
+                for (size_t j = 0; j < ch->arity; ++j) {
+                    process_L2(ch->children[j]);
+                }
+            }
+            else {
+                process_L2(ch);
+            }
         }
     }
 

src/backend/cpu/platform/lscpu_arm.cpp

@@ -1,7 +1,7 @@
 /* XMRig
  * Copyright (c) 2018      Riku Voipio <riku.voipio@iki.fi>
- * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2023 XMRig       <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -98,8 +98,11 @@ static const id_part arm_part[] = {
     { 0xd0e, "Cortex-A76AE" },
     { 0xd13, "Cortex-R52" },
     { 0xd15, "Cortex-R82" },
+    { 0xd16, "Cortex-R52+" },
     { 0xd20, "Cortex-M23" },
     { 0xd21, "Cortex-M33" },
+    { 0xd22, "Cortex-M55" },
+    { 0xd23, "Cortex-M85" },
     { 0xd40, "Neoverse-V1" },
     { 0xd41, "Cortex-A78" },
     { 0xd42, "Cortex-A78AE" },
@@ -115,6 +118,17 @@ static const id_part arm_part[] = {
     { 0xd4d, "Cortex-A715" },
     { 0xd4e, "Cortex-X3" },
     { 0xd4f, "Neoverse-V2" },
+    { 0xd80, "Cortex-A520" },
+    { 0xd81, "Cortex-A720" },
+    { 0xd82, "Cortex-X4" },
+    { 0xd83, "Neoverse-V3AE" },
+    { 0xd84, "Neoverse-V3" },
+    { 0xd85, "Cortex-X925" },
+    { 0xd87, "Cortex-A725" },
+    { 0xd88, "Cortex-A520AE" },
+    { 0xd89, "Cortex-A720AE" },
+    { 0xd8e, "Neoverse-N3" },
+    { 0xd8f, "Cortex-A320" },
     { -1, nullptr }
 };
 
@@ -154,6 +168,7 @@ static const id_part apm_part[] = {
 };
 
 static const id_part qcom_part[] = {
+    { 0x001, "Oryon" },
     { 0x00f, "Scorpion" },
     { 0x02d, "Scorpion" },
     { 0x04d, "Krait" },
@@ -194,6 +209,22 @@ static const id_part marvell_part[] = {
     { -1, nullptr }
 };
 
+static const id_part apple_part[] = {
+    { 0x022, "M1" },
+    { 0x023, "M1" },
+    { 0x024, "M1-Pro" },
+    { 0x025, "M1-Pro" },
+    { 0x028, "M1-Max" },
+    { 0x029, "M1-Max" },
+    { 0x032, "M2" },
+    { 0x033, "M2" },
+    { 0x034, "M2-Pro" },
+    { 0x035, "M2-Pro" },
+    { 0x038, "M2-Max" },
+    { 0x039, "M2-Max" },
+    { -1, nullptr }
+};
+
 static const id_part faraday_part[] = {
     { 0x526, "FA526" },
     { 0x626, "FA626" },
@@ -227,47 +258,40 @@ static const id_part intel_part[] = {
 
 static const struct id_part fujitsu_part[] = {
     { 0x001, "A64FX" },
+    { 0x003, "MONAKA" },
     { -1, nullptr }
 };
 
 static const id_part hisi_part[] = {
-    { 0xd01, "Kunpeng-920" },	/* aka tsv110 */
-    { 0xd40, "Cortex-A76" },	/* HiSilicon uses this ID though advertises A76 */
+    { 0xd01, "TaiShan-v110" }, /* used in Kunpeng-920 SoC */
+    { 0xd02, "TaiShan-v120" }, /* used in Kirin 990A and 9000S SoCs */
+    { 0xd40, "Cortex-A76" },   /* HiSilicon uses this ID though advertises A76 */
+    { 0xd41, "Cortex-A77" },   /* HiSilicon uses this ID though advertises A77 */
     { -1, nullptr }
 };
 
-static const id_part apple_part[] = {
-    { 0x022, "M1" },
-    { 0x023, "M1" },
-    { 0x024, "M1-Pro" },
-    { 0x025, "M1-Pro" },
-    { 0x028, "M1-Max" },
-    { 0x029, "M1-Max" },
-    { 0x032, "M2" },
-    { 0x033, "M2" },
-    { 0x034, "M2-Pro" },
-    { 0x035, "M2-Pro" },
-    { 0x038, "M2-Max" },
-    { 0x039, "M2-Max" },
-    { -1, nullptr }
-};
-
-
-static const struct id_part ft_part[] = {
-    { 0x660, "FTC660" },
-    { 0x661, "FTC661" },
-    { 0x662, "FTC662" },
-    { 0x663, "FTC663" },
-    { -1, nullptr }
-};
-
-
 static const struct id_part ampere_part[] = {
     { 0xac3, "Ampere-1" },
     { 0xac4, "Ampere-1a" },
     { -1, nullptr }
 };
 
+static const struct id_part ft_part[] = {
+    { 0x303, "FTC310" },
+    { 0x660, "FTC660" },
+    { 0x661, "FTC661" },
+    { 0x662, "FTC662" },
+    { 0x663, "FTC663" },
+    { 0x664, "FTC664" },
+    { 0x862, "FTC862" },
+    { -1, nullptr }
+};
+
+static const struct id_part ms_part[] = {
+    { 0xd49, "Azure-Cobalt-100" },
+    { -1, nullptr }
+};
+
 
 static const hw_impl hw_implementer[] = {
     { 0x41, arm_part,     "ARM" },
@@ -276,7 +300,7 @@ static const hw_impl hw_implementer[] = {
     { 0x44, dec_part,     "DEC" },
     { 0x46, fujitsu_part, "FUJITSU" },
     { 0x48, hisi_part,    "HiSilicon" },
-    { 0x4e, nvidia_part,  "Nvidia" },
+    { 0x4e, nvidia_part,  "NVIDIA" },
     { 0x50, apm_part,     "APM" },
     { 0x51, qcom_part,    "Qualcomm" },
     { 0x53, samsung_part, "Samsung" },
@@ -284,6 +308,7 @@ static const hw_impl hw_implementer[] = {
     { 0x61, apple_part,   "Apple" },
     { 0x66, faraday_part, "Faraday" },
     { 0x69, intel_part,   "Intel" },
+    { 0x6d, ms_part,      "Microsoft" },
     { 0x70, ft_part,      "Phytium" },
     { 0xc0, ampere_part,  "Ampere" }
 };

src/backend/cpu/platform/lscpu_riscv.cpp

@@ -0,0 +1,150 @@
+/* XMRig
+ * Copyright (c) 2025      Slayingripper <https://github.com/Slayingripper>
+ * Copyright (c) 2018-2025 SChernykh     <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig         <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "base/tools/String.h"
+#include "3rdparty/fmt/core.h"
+
+#include <cstdio>
+#include <cstring>
+#include <string>
+
+namespace xmrig {
+
+struct riscv_cpu_desc
+{
+    String model;
+    String isa;
+    String uarch;
+    bool has_vector = false;
+    bool has_aes = false;
+    
+    inline bool isReady() const { return !isa.isNull(); }
+};
+
+static bool lookup_riscv(char *line, const char *pattern, String &value)
+{
+    char *p = strstr(line, pattern);
+    if (!p) {
+        return false;
+    }
+
+    p += strlen(pattern);
+    while (isspace(*p)) {
+        ++p;
+    }
+
+    if (*p == ':') {
+        ++p;
+    }
+
+    while (isspace(*p)) {
+        ++p;
+    }
+
+    // Remove trailing newline
+    size_t len = strlen(p);
+    if (len > 0 && p[len - 1] == '\n') {
+        p[len - 1] = '\0';
+    }
+
+    // Ensure we call the const char* assignment (which performs a copy)
+    // instead of the char* overload (which would take ownership of the pointer)
+    value = (const char*)p;
+    return true;
+}
+
+static bool read_riscv_cpuinfo(riscv_cpu_desc *desc)
+{
+    auto fp = fopen("/proc/cpuinfo", "r");
+    if (!fp) {
+        return false;
+    }
+
+    char buf[2048]; // Larger buffer for long ISA strings
+    while (fgets(buf, sizeof(buf), fp) != nullptr) {
+        lookup_riscv(buf, "model name", desc->model);
+        
+        if (lookup_riscv(buf, "isa", desc->isa)) {
+            desc->isa.toLower();
+
+            for (const String& s : desc->isa.split('_')) {
+                const char* p = s.data();
+                const size_t n = s.size();
+
+                if ((s.size() > 4) && (memcmp(p, "rv64", 4) == 0)) {
+                    for (size_t i = 4; i < n; ++i) {
+                        if (p[i] == 'v') {
+                            desc->has_vector = true;
+                            break;
+                        }
+                    }
+                }
+                else if (s == "zve64d") {
+                    desc->has_vector = true;
+                }
+                else if ((s == "zvkn") || (s == "zvknc") || (s == "zvkned") || (s == "zvkng")){
+                    desc->has_aes = true;
+                }
+            }
+        }
+        
+        lookup_riscv(buf, "uarch", desc->uarch);
+
+        if (desc->isReady()) {
+            break;
+        }
+    }
+
+    fclose(fp);
+
+    return desc->isReady();
+}
+
+String cpu_name_riscv()
+{
+    riscv_cpu_desc desc;
+    if (read_riscv_cpuinfo(&desc)) {
+        if (!desc.uarch.isNull()) {
+            return fmt::format("{} ({})", desc.model, desc.uarch).c_str();
+        }
+        return desc.model;
+    }
+
+    return "RISC-V";
+}
+
+bool has_riscv_vector()
+{
+    riscv_cpu_desc desc;
+    if (read_riscv_cpuinfo(&desc)) {
+        return desc.has_vector;
+    }
+    return false;
+}
+
+bool has_riscv_aes()
+{
+    riscv_cpu_desc desc;
+    if (read_riscv_cpuinfo(&desc)) {
+        return desc.has_aes;
+    }
+    return false;
+}
+
+} // namespace xmrig

src/backend/opencl/cl/cn/algorithm.cl

@@ -19,6 +19,7 @@
 #define ALGO_CN_PICO_TLO    0x63120274
 #define ALGO_CN_UPX2        0x63110200
 #define ALGO_RX_0           0x72151200
+#define ALGO_RX_V2          0x72151202
 #define ALGO_RX_WOW         0x72141177
 #define ALGO_RX_ARQMA       0x72121061
 #define ALGO_RX_SFX         0x72151273

src/backend/opencl/cl/cn/cryptonight.cl

@@ -706,7 +706,7 @@ __kernel void cn2(__global uint4 *Scratchpad, __global ulong *states, __global u
     }
 
 #   if (ALGO_FAMILY == FAMILY_CN_HEAVY)
-    /* Also left over threads performe this loop.
+    /* Also left over threads perform this loop.
      * The left over thread results will be ignored
      */
     #pragma unroll 16
@@ -1005,7 +1005,7 @@ __kernel void Groestl(__global ulong *states, __global uint *BranchBuf, __global
         ulong State[8] = { 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0x0001000000000000UL };
         ulong H[8], M[8];
 
-        // BUG: AMD driver 19.7.X crashs if this is written as loop
+        // BUG: AMD driver 19.7.X crashes if this is written as loop
         // Thx AMD for so bad software
         {
             ((ulong8 *)M)[0] = vload8(0, states);

src/backend/opencl/cl/cn/wolf-skein.cl

@@ -10,7 +10,7 @@
 #else
 #   define STATIC
 /* taken from https://www.khronos.org/registry/OpenCL/extensions/amd/cl_amd_media_ops.txt
- * Build-in Function
+ * Built-in Function
  *     uintn  amd_bitalign (uintn src0, uintn src1, uintn src2)
  *   Description
  *     dst.s0 =  (uint) (((((long)src0.s0) << 32) | (long)src1.s0) >> (src2.s0 & 31))

src/backend/opencl/cl/kawpow/kawpow.cl

@@ -74,10 +74,10 @@ void keccak_f800_round(uint32_t st[25], const int r)
 // Keccak - implemented as a variant of SHAKE
 // The width is 800, with a bitrate of 576, a capacity of 224, and no padding
 // Only need 64 bits of output for mining
-void keccak_f800(uint32_t* st)
+void keccak_f800(uint32_t st[25])
 {
     // Complete all 22 rounds as a separate impl to
-    // evaluate only first 8 words is wasteful of regsters
+    // evaluate only first 8 words is wasteful of registers
     for (int r = 0; r < 22; r++) {
         keccak_f800_round(st, r);
     }
@@ -181,7 +181,7 @@ __kernel void progpow_search(__global dag_t const* g_dag, __global uint* job_blo
         for (int i = 10; i < 25; i++)
             state[i] = ravencoin_rndc[i-10];
 
-        // Run intial keccak round
+        // Run initial keccak round
         keccak_f800(state);
 
         for (int i = 0; i < 8; i++)

src/backend/opencl/cl/kawpow/kawpow_cl.h

@@ -2,7 +2,7 @@
 
 namespace xmrig {
 
-static const char kawpow_cl[5944] = {
+static const char kawpow_cl[5947] = {
     0x23,0x69,0x66,0x64,0x65,0x66,0x20,0x63,0x6c,0x5f,0x63,0x6c,0x61,0x6e,0x67,0x5f,0x73,0x74,0x6f,0x72,0x61,0x67,0x65,0x5f,0x63,0x6c,0x61,0x73,0x73,0x5f,0x73,0x70,
     0x65,0x63,0x69,0x66,0x69,0x65,0x72,0x73,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x4f,0x50,0x45,0x4e,0x43,0x4c,0x20,0x45,0x58,0x54,0x45,0x4e,0x53,0x49,0x4f,
     0x4e,0x20,0x63,0x6c,0x5f,0x63,0x6c,0x61,0x6e,0x67,0x5f,0x73,0x74,0x6f,0x72,0x61,0x67,0x65,0x5f,0x63,0x6c,0x61,0x73,0x73,0x5f,0x73,0x70,0x65,0x63,0x69,0x66,0x69,
@@ -77,118 +77,118 @@ static const char kawpow_cl[5944] = {
     0x29,0x0a,0x73,0x74,0x5b,0x6a,0x2b,0x69,0x5d,0x20,0x5e,0x3d,0x20,0x28,0x7e,0x62,0x63,0x5b,0x28,0x69,0x2b,0x31,0x29,0x20,0x25,0x20,0x35,0x5d,0x29,0x26,0x62,0x63,
     0x5b,0x28,0x69,0x2b,0x32,0x29,0x20,0x25,0x20,0x35,0x5d,0x3b,0x0a,0x7d,0x0a,0x73,0x74,0x5b,0x30,0x5d,0x20,0x5e,0x3d,0x20,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x5f,
     0x72,0x6e,0x64,0x63,0x5b,0x72,0x5d,0x3b,0x0a,0x7d,0x0a,0x76,0x6f,0x69,0x64,0x20,0x6b,0x65,0x63,0x63,0x61,0x6b,0x5f,0x66,0x38,0x30,0x30,0x28,0x75,0x69,0x6e,0x74,
-    0x33,0x32,0x5f,0x74,0x2a,0x20,0x73,0x74,0x29,0x0a,0x7b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x72,0x3d,0x30,0x3b,0x20,0x72,0x3c,0x32,0x32,0x3b,0x20,
-    0x72,0x2b,0x2b,0x29,0x20,0x7b,0x0a,0x6b,0x65,0x63,0x63,0x61,0x6b,0x5f,0x66,0x38,0x30,0x30,0x5f,0x72,0x6f,0x75,0x6e,0x64,0x28,0x73,0x74,0x2c,0x72,0x29,0x3b,0x0a,
-    0x7d,0x0a,0x7d,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x66,0x6e,0x76,0x31,0x61,0x28,0x68,0x2c,0x20,0x64,0x29,0x20,0x28,0x68,0x20,0x3d,0x20,0x28,0x68,0x20,
-    0x5e,0x20,0x64,0x29,0x20,0x2a,0x20,0x46,0x4e,0x56,0x5f,0x50,0x52,0x49,0x4d,0x45,0x29,0x0a,0x74,0x79,0x70,0x65,0x64,0x65,0x66,0x20,0x73,0x74,0x72,0x75,0x63,0x74,
-    0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x7a,0x2c,0x77,0x2c,0x6a,0x73,0x72,0x2c,0x6a,0x63,0x6f,0x6e,0x67,0x3b,0x0a,0x7d,0x20,0x6b,0x69,0x73,
-    0x73,0x39,0x39,0x5f,0x74,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6b,0x69,0x73,0x73,0x39,0x39,0x28,0x6b,0x69,0x73,0x73,0x39,0x39,0x5f,0x74,0x2a,
-    0x20,0x73,0x74,0x29,0x0a,0x7b,0x0a,0x73,0x74,0x2d,0x3e,0x7a,0x3d,0x33,0x36,0x39,0x36,0x39,0x2a,0x28,0x73,0x74,0x2d,0x3e,0x7a,0x26,0x36,0x35,0x35,0x33,0x35,0x29,
-    0x2b,0x28,0x73,0x74,0x2d,0x3e,0x7a,0x3e,0x3e,0x31,0x36,0x29,0x3b,0x0a,0x73,0x74,0x2d,0x3e,0x77,0x3d,0x31,0x38,0x30,0x30,0x30,0x2a,0x28,0x73,0x74,0x2d,0x3e,0x77,
-    0x26,0x36,0x35,0x35,0x33,0x35,0x29,0x2b,0x28,0x73,0x74,0x2d,0x3e,0x77,0x3e,0x3e,0x31,0x36,0x29,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x4d,0x57,
-    0x43,0x3d,0x28,0x28,0x73,0x74,0x2d,0x3e,0x7a,0x3c,0x3c,0x31,0x36,0x29,0x2b,0x73,0x74,0x2d,0x3e,0x77,0x29,0x3b,0x0a,0x73,0x74,0x2d,0x3e,0x6a,0x73,0x72,0x20,0x5e,
-    0x3d,0x20,0x28,0x73,0x74,0x2d,0x3e,0x6a,0x73,0x72,0x3c,0x3c,0x31,0x37,0x29,0x3b,0x0a,0x73,0x74,0x2d,0x3e,0x6a,0x73,0x72,0x20,0x5e,0x3d,0x20,0x28,0x73,0x74,0x2d,
-    0x3e,0x6a,0x73,0x72,0x3e,0x3e,0x31,0x33,0x29,0x3b,0x0a,0x73,0x74,0x2d,0x3e,0x6a,0x73,0x72,0x20,0x5e,0x3d,0x20,0x28,0x73,0x74,0x2d,0x3e,0x6a,0x73,0x72,0x3c,0x3c,
-    0x35,0x29,0x3b,0x0a,0x73,0x74,0x2d,0x3e,0x6a,0x63,0x6f,0x6e,0x67,0x3d,0x36,0x39,0x30,0x36,0x39,0x2a,0x73,0x74,0x2d,0x3e,0x6a,0x63,0x6f,0x6e,0x67,0x2b,0x31,0x32,
-    0x33,0x34,0x35,0x36,0x37,0x3b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x28,0x28,0x4d,0x57,0x43,0x5e,0x73,0x74,0x2d,0x3e,0x6a,0x63,0x6f,0x6e,0x67,0x29,0x2b,0x73,
-    0x74,0x2d,0x3e,0x6a,0x73,0x72,0x29,0x3b,0x0a,0x7d,0x0a,0x76,0x6f,0x69,0x64,0x20,0x66,0x69,0x6c,0x6c,0x5f,0x6d,0x69,0x78,0x28,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,
-    0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x2a,0x20,0x73,0x65,0x65,0x64,0x2c,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x2c,0x75,
-    0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x2a,0x20,0x6d,0x69,0x78,0x29,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x66,0x6e,0x76,0x5f,0x68,0x61,0x73,
-    0x68,0x3d,0x46,0x4e,0x56,0x5f,0x4f,0x46,0x46,0x53,0x45,0x54,0x5f,0x42,0x41,0x53,0x49,0x53,0x3b,0x0a,0x6b,0x69,0x73,0x73,0x39,0x39,0x5f,0x74,0x20,0x73,0x74,0x3b,
-    0x0a,0x73,0x74,0x2e,0x7a,0x3d,0x66,0x6e,0x76,0x31,0x61,0x28,0x66,0x6e,0x76,0x5f,0x68,0x61,0x73,0x68,0x2c,0x73,0x65,0x65,0x64,0x5b,0x30,0x5d,0x29,0x3b,0x0a,0x73,
-    0x74,0x2e,0x77,0x3d,0x66,0x6e,0x76,0x31,0x61,0x28,0x66,0x6e,0x76,0x5f,0x68,0x61,0x73,0x68,0x2c,0x73,0x65,0x65,0x64,0x5b,0x31,0x5d,0x29,0x3b,0x0a,0x73,0x74,0x2e,
-    0x6a,0x73,0x72,0x3d,0x66,0x6e,0x76,0x31,0x61,0x28,0x66,0x6e,0x76,0x5f,0x68,0x61,0x73,0x68,0x2c,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x29,0x3b,0x0a,0x73,0x74,0x2e,
-    0x6a,0x63,0x6f,0x6e,0x67,0x3d,0x66,0x6e,0x76,0x31,0x61,0x28,0x66,0x6e,0x76,0x5f,0x68,0x61,0x73,0x68,0x2c,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x29,0x3b,0x0a,0x23,
-    0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x50,0x52,
-    0x4f,0x47,0x50,0x4f,0x57,0x5f,0x52,0x45,0x47,0x53,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x6d,0x69,0x78,0x5b,0x69,0x5d,0x3d,0x6b,0x69,0x73,0x73,0x39,0x39,0x28,0x26,
-    0x73,0x74,0x29,0x3b,0x0a,0x7d,0x0a,0x74,0x79,0x70,0x65,0x64,0x65,0x66,0x20,0x73,0x74,0x72,0x75,0x63,0x74,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,
-    0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,0x45,0x53,0x5d,0x3b,0x0a,0x7d,0x20,0x73,0x68,0x75,0x66,0x66,
-    0x6c,0x65,0x5f,0x74,0x3b,0x0a,0x74,0x79,0x70,0x65,0x64,0x65,0x66,0x20,0x73,0x74,0x72,0x75,0x63,0x74,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,
-    0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x33,0x32,0x2f,0x73,0x69,0x7a,0x65,0x6f,0x66,0x28,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x29,0x5d,0x3b,0x0a,0x7d,0x20,
-    0x68,0x61,0x73,0x68,0x33,0x32,0x5f,0x74,0x3b,0x0a,0x23,0x69,0x66,0x20,0x50,0x4c,0x41,0x54,0x46,0x4f,0x52,0x4d,0x20,0x21,0x3d,0x20,0x4f,0x50,0x45,0x4e,0x43,0x4c,
-    0x5f,0x50,0x4c,0x41,0x54,0x46,0x4f,0x52,0x4d,0x5f,0x4e,0x56,0x49,0x44,0x49,0x41,0x20,0x0a,0x5f,0x5f,0x61,0x74,0x74,0x72,0x69,0x62,0x75,0x74,0x65,0x5f,0x5f,0x28,
-    0x28,0x72,0x65,0x71,0x64,0x5f,0x77,0x6f,0x72,0x6b,0x5f,0x67,0x72,0x6f,0x75,0x70,0x5f,0x73,0x69,0x7a,0x65,0x28,0x47,0x52,0x4f,0x55,0x50,0x5f,0x53,0x49,0x5a,0x45,
-    0x2c,0x31,0x2c,0x31,0x29,0x29,0x29,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x5f,0x5f,0x6b,0x65,0x72,0x6e,0x65,0x6c,0x20,0x76,0x6f,0x69,0x64,0x20,0x70,0x72,0x6f,
-    0x67,0x70,0x6f,0x77,0x5f,0x73,0x65,0x61,0x72,0x63,0x68,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x64,0x61,0x67,0x5f,0x74,0x20,0x63,0x6f,0x6e,0x73,0x74,
-    0x2a,0x20,0x67,0x5f,0x64,0x61,0x67,0x2c,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x2a,0x20,0x6a,0x6f,0x62,0x5f,0x62,0x6c,0x6f,0x62,0x2c,
-    0x75,0x6c,0x6f,0x6e,0x67,0x20,0x74,0x61,0x72,0x67,0x65,0x74,0x2c,0x75,0x69,0x6e,0x74,0x20,0x68,0x61,0x63,0x6b,0x5f,0x66,0x61,0x6c,0x73,0x65,0x2c,0x76,0x6f,0x6c,
-    0x61,0x74,0x69,0x6c,0x65,0x20,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x2a,0x20,0x72,0x65,0x73,0x75,0x6c,0x74,0x73,0x2c,0x76,0x6f,0x6c,
-    0x61,0x74,0x69,0x6c,0x65,0x20,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x2a,0x20,0x73,0x74,0x6f,0x70,0x29,0x0a,0x7b,0x0a,0x63,0x6f,0x6e,
-    0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6c,0x69,0x64,0x3d,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x3b,
-    0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x67,0x69,0x64,0x3d,0x67,0x65,0x74,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x5f,0x69,
-    0x64,0x28,0x30,0x29,0x3b,0x0a,0x69,0x66,0x28,0x73,0x74,0x6f,0x70,0x5b,0x30,0x5d,0x29,0x20,0x7b,0x0a,0x69,0x66,0x28,0x6c,0x69,0x64,0x3d,0x3d,0x30,0x29,0x20,0x7b,
-    0x0a,0x61,0x74,0x6f,0x6d,0x69,0x63,0x5f,0x69,0x6e,0x63,0x28,0x73,0x74,0x6f,0x70,0x2b,0x31,0x29,0x3b,0x0a,0x7d,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x3b,0x0a,0x7d,
-    0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x73,0x68,0x75,0x66,0x66,0x6c,0x65,0x5f,0x74,0x20,0x73,0x68,0x61,0x72,0x65,0x5b,0x48,0x41,0x53,0x48,0x45,0x53,0x5f,
-    0x50,0x45,0x52,0x5f,0x47,0x52,0x4f,0x55,0x50,0x5d,0x3b,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x63,0x5f,0x64,
-    0x61,0x67,0x5b,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x43,0x41,0x43,0x48,0x45,0x5f,0x57,0x4f,0x52,0x44,0x53,0x5d,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,
-    0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x3d,0x6c,0x69,0x64,0x26,0x28,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,
-    0x45,0x53,0x2d,0x31,0x29,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x3d,0x6c,
-    0x69,0x64,0x2f,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,0x45,0x53,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,
-    0x77,0x6f,0x72,0x64,0x3d,0x6c,0x69,0x64,0x2a,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x44,0x41,0x47,0x5f,0x4c,0x4f,0x41,0x44,0x53,0x3b,0x20,0x77,0x6f,0x72,0x64,
-    0x3c,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x43,0x41,0x43,0x48,0x45,0x5f,0x57,0x4f,0x52,0x44,0x53,0x3b,0x20,0x77,0x6f,0x72,0x64,0x2b,0x3d,0x47,0x52,0x4f,0x55,
-    0x50,0x5f,0x53,0x49,0x5a,0x45,0x2a,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x44,0x41,0x47,0x5f,0x4c,0x4f,0x41,0x44,0x53,0x29,0x0a,0x7b,0x0a,0x64,0x61,0x67,0x5f,
-    0x74,0x20,0x6c,0x6f,0x61,0x64,0x3d,0x67,0x5f,0x64,0x61,0x67,0x5b,0x77,0x6f,0x72,0x64,0x2f,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x44,0x41,0x47,0x5f,0x4c,0x4f,
-    0x41,0x44,0x53,0x5d,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x44,0x41,
-    0x47,0x5f,0x4c,0x4f,0x41,0x44,0x53,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x63,0x5f,0x64,0x61,0x67,0x5b,0x77,0x6f,0x72,0x64,0x2b,0x69,0x5d,0x3d,0x6c,0x6f,0x61,0x64,
-    0x2e,0x73,0x5b,0x69,0x5d,0x3b,0x0a,0x7d,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x68,0x61,0x73,0x68,0x5f,0x73,0x65,0x65,0x64,0x5b,0x32,0x5d,0x3b,0x20,
-    0x0a,0x68,0x61,0x73,0x68,0x33,0x32,0x5f,0x74,0x20,0x64,0x69,0x67,0x65,0x73,0x74,0x3b,0x20,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x73,0x74,0x61,0x74,
-    0x65,0x32,0x5b,0x38,0x5d,0x3b,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x73,0x74,0x61,0x74,0x65,0x5b,0x32,0x35,0x5d,0x3b,0x20,0x0a,0x66,0x6f,
-    0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x31,0x30,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x73,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3d,
-    0x6a,0x6f,0x62,0x5f,0x62,0x6c,0x6f,0x62,0x5b,0x69,0x5d,0x3b,0x0a,0x73,0x74,0x61,0x74,0x65,0x5b,0x38,0x5d,0x3d,0x67,0x69,0x64,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,
-    0x69,0x6e,0x74,0x20,0x69,0x3d,0x31,0x30,0x3b,0x20,0x69,0x3c,0x32,0x35,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x73,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3d,0x72,0x61,
-    0x76,0x65,0x6e,0x63,0x6f,0x69,0x6e,0x5f,0x72,0x6e,0x64,0x63,0x5b,0x69,0x2d,0x31,0x30,0x5d,0x3b,0x0a,0x6b,0x65,0x63,0x63,0x61,0x6b,0x5f,0x66,0x38,0x30,0x30,0x28,
-    0x73,0x74,0x61,0x74,0x65,0x29,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x38,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,
-    0x73,0x74,0x61,0x74,0x65,0x32,0x5b,0x69,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3b,0x0a,0x7d,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,
-    0x72,0x6f,0x6c,0x6c,0x20,0x31,0x0a,0x66,0x6f,0x72,0x20,0x28,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x68,0x3d,0x30,0x3b,0x20,0x68,0x3c,0x50,0x52,0x4f,0x47,
-    0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,0x45,0x53,0x3b,0x20,0x68,0x2b,0x2b,0x29,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6d,0x69,0x78,0x5b,0x50,
-    0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x52,0x45,0x47,0x53,0x5d,0x3b,0x0a,0x69,0x66,0x28,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x3d,0x3d,0x68,0x29,0x20,0x7b,0x0a,0x73,
-    0x68,0x61,0x72,0x65,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x30,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x32,
-    0x5b,0x30,0x5d,0x3b,0x0a,0x73,0x68,0x61,0x72,0x65,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x31,0x5d,0x3d,
-    0x73,0x74,0x61,0x74,0x65,0x32,0x5b,0x31,0x5d,0x3b,0x0a,0x7d,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,
-    0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x66,0x69,0x6c,0x6c,0x5f,0x6d,0x69,0x78,0x28,0x73,0x68,0x61,0x72,0x65,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,
-    0x69,0x64,0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x2c,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x2c,0x6d,0x69,0x78,0x29,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,
-    0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x32,0x0a,0x66,0x6f,0x72,0x20,0x28,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6c,0x6f,0x6f,0x70,0x3d,0x30,0x3b,
-    0x20,0x6c,0x6f,0x6f,0x70,0x3c,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x43,0x4e,0x54,0x5f,0x44,0x41,0x47,0x3b,0x20,0x2b,0x2b,0x6c,0x6f,0x6f,0x70,0x29,0x0a,0x7b,
-    0x0a,0x69,0x66,0x28,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x3d,0x3d,0x28,0x6c,0x6f,0x6f,0x70,0x20,0x25,0x20,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,
-    0x45,0x53,0x29,0x29,0x0a,0x73,0x68,0x61,0x72,0x65,0x5b,0x30,0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x5d,0x3d,
-    0x6d,0x69,0x78,0x5b,0x30,0x5d,0x3b,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,
-    0x4e,0x43,0x45,0x29,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6f,0x66,0x66,0x73,0x65,0x74,0x3d,0x73,0x68,0x61,0x72,0x65,0x5b,0x30,0x5d,0x2e,0x75,
-    0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x5d,0x3b,0x0a,0x6f,0x66,0x66,0x73,0x65,0x74,0x20,0x25,0x3d,0x20,0x50,0x52,0x4f,0x47,
-    0x50,0x4f,0x57,0x5f,0x44,0x41,0x47,0x5f,0x45,0x4c,0x45,0x4d,0x45,0x4e,0x54,0x53,0x3b,0x0a,0x6f,0x66,0x66,0x73,0x65,0x74,0x3d,0x6f,0x66,0x66,0x73,0x65,0x74,0x2a,
-    0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,0x45,0x53,0x2b,0x28,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x5e,0x6c,0x6f,0x6f,0x70,0x29,0x20,0x25,0x20,0x50,
-    0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,0x45,0x53,0x3b,0x0a,0x64,0x61,0x67,0x5f,0x74,0x20,0x64,0x61,0x74,0x61,0x5f,0x64,0x61,0x67,0x3d,0x67,0x5f,0x64,
-    0x61,0x67,0x5b,0x6f,0x66,0x66,0x73,0x65,0x74,0x5d,0x3b,0x0a,0x69,0x66,0x28,0x68,0x61,0x63,0x6b,0x5f,0x66,0x61,0x6c,0x73,0x65,0x29,0x20,0x62,0x61,0x72,0x72,0x69,
-    0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,
-    0x74,0x20,0x64,0x61,0x74,0x61,0x3b,0x0a,0x58,0x4d,0x52,0x49,0x47,0x5f,0x49,0x4e,0x43,0x4c,0x55,0x44,0x45,0x5f,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x52,0x41,
-    0x4e,0x44,0x4f,0x4d,0x5f,0x4d,0x41,0x54,0x48,0x0a,0x69,0x66,0x28,0x68,0x61,0x63,0x6b,0x5f,0x66,0x61,0x6c,0x73,0x65,0x29,0x20,0x62,0x61,0x72,0x72,0x69,0x65,0x72,
-    0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x58,0x4d,0x52,0x49,0x47,0x5f,0x49,0x4e,0x43,
-    0x4c,0x55,0x44,0x45,0x5f,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x44,0x41,0x54,0x41,0x5f,0x4c,0x4f,0x41,0x44,0x53,0x0a,0x7d,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,
-    0x5f,0x74,0x20,0x6d,0x69,0x78,0x5f,0x68,0x61,0x73,0x68,0x3d,0x46,0x4e,0x56,0x5f,0x4f,0x46,0x46,0x53,0x45,0x54,0x5f,0x42,0x41,0x53,0x49,0x53,0x3b,0x0a,0x23,0x70,
-    0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x50,0x52,0x4f,
-    0x47,0x50,0x4f,0x57,0x5f,0x52,0x45,0x47,0x53,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x66,0x6e,0x76,0x31,0x61,0x28,0x6d,0x69,0x78,0x5f,0x68,0x61,0x73,0x68,0x2c,0x6d,
-    0x69,0x78,0x5b,0x69,0x5d,0x29,0x3b,0x0a,0x68,0x61,0x73,0x68,0x33,0x32,0x5f,0x74,0x20,0x64,0x69,0x67,0x65,0x73,0x74,0x5f,0x74,0x65,0x6d,0x70,0x3b,0x0a,0x66,0x6f,
-    0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x38,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x64,0x69,0x67,0x65,0x73,0x74,0x5f,0x74,0x65,0x6d,
-    0x70,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x69,0x5d,0x3d,0x46,0x4e,0x56,0x5f,0x4f,0x46,0x46,0x53,0x45,0x54,0x5f,0x42,0x41,0x53,0x49,0x53,0x3b,0x0a,0x73,
-    0x68,0x61,0x72,0x65,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x5d,0x3d,
-    0x6d,0x69,0x78,0x5f,0x68,0x61,0x73,0x68,0x3b,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,
-    0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,
-    0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,0x45,0x53,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x66,0x6e,0x76,0x31,0x61,
-    0x28,0x64,0x69,0x67,0x65,0x73,0x74,0x5f,0x74,0x65,0x6d,0x70,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x69,0x20,0x25,0x20,0x38,0x5d,0x2c,0x73,0x68,0x61,0x72,
-    0x65,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x69,0x5d,0x29,0x3b,0x0a,0x69,0x66,0x28,0x68,0x3d,0x3d,0x6c,
-    0x61,0x6e,0x65,0x5f,0x69,0x64,0x29,0x0a,0x64,0x69,0x67,0x65,0x73,0x74,0x3d,0x64,0x69,0x67,0x65,0x73,0x74,0x5f,0x74,0x65,0x6d,0x70,0x3b,0x0a,0x7d,0x0a,0x75,0x69,
-    0x6e,0x74,0x36,0x34,0x5f,0x74,0x20,0x72,0x65,0x73,0x75,0x6c,0x74,0x3b,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x73,0x74,0x61,0x74,0x65,0x5b,
-    0x32,0x35,0x5d,0x3d,0x7b,0x30,0x78,0x30,0x7d,0x3b,0x20,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x38,0x3b,0x20,0x69,
-    0x2b,0x2b,0x29,0x0a,0x73,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x32,0x5b,0x69,0x5d,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,
-    0x20,0x69,0x3d,0x38,0x3b,0x20,0x69,0x3c,0x31,0x36,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x73,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3d,0x64,0x69,0x67,0x65,0x73,0x74,
-    0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x69,0x2d,0x38,0x5d,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x31,0x36,0x3b,0x20,0x69,0x3c,
-    0x32,0x35,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x73,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3d,0x72,0x61,0x76,0x65,0x6e,0x63,0x6f,0x69,0x6e,0x5f,0x72,0x6e,0x64,0x63,
-    0x5b,0x69,0x2d,0x31,0x36,0x5d,0x3b,0x0a,0x6b,0x65,0x63,0x63,0x61,0x6b,0x5f,0x66,0x38,0x30,0x30,0x28,0x73,0x74,0x61,0x74,0x65,0x29,0x3b,0x0a,0x75,0x69,0x6e,0x74,
-    0x36,0x34,0x5f,0x74,0x20,0x72,0x65,0x73,0x3d,0x28,0x75,0x69,0x6e,0x74,0x36,0x34,0x5f,0x74,0x29,0x73,0x74,0x61,0x74,0x65,0x5b,0x31,0x5d,0x3c,0x3c,0x33,0x32,0x7c,
-    0x73,0x74,0x61,0x74,0x65,0x5b,0x30,0x5d,0x3b,0x0a,0x72,0x65,0x73,0x75,0x6c,0x74,0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x28,0x61,0x73,0x5f,0x75,0x63,0x68,
-    0x61,0x72,0x38,0x28,0x72,0x65,0x73,0x29,0x2e,0x73,0x37,0x36,0x35,0x34,0x33,0x32,0x31,0x30,0x29,0x3b,0x0a,0x7d,0x0a,0x69,0x66,0x28,0x72,0x65,0x73,0x75,0x6c,0x74,
-    0x3c,0x3d,0x74,0x61,0x72,0x67,0x65,0x74,0x29,0x0a,0x7b,0x0a,0x2a,0x73,0x74,0x6f,0x70,0x3d,0x31,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,
-    0x6b,0x3d,0x61,0x74,0x6f,0x6d,0x69,0x63,0x5f,0x69,0x6e,0x63,0x28,0x72,0x65,0x73,0x75,0x6c,0x74,0x73,0x29,0x2b,0x31,0x3b,0x0a,0x69,0x66,0x28,0x6b,0x3c,0x3d,0x31,
-    0x35,0x29,0x0a,0x72,0x65,0x73,0x75,0x6c,0x74,0x73,0x5b,0x6b,0x5d,0x3d,0x67,0x69,0x64,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,0x00
+    0x33,0x32,0x5f,0x74,0x20,0x73,0x74,0x5b,0x32,0x35,0x5d,0x29,0x0a,0x7b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x72,0x3d,0x30,0x3b,0x20,0x72,0x3c,0x32,
+    0x32,0x3b,0x20,0x72,0x2b,0x2b,0x29,0x20,0x7b,0x0a,0x6b,0x65,0x63,0x63,0x61,0x6b,0x5f,0x66,0x38,0x30,0x30,0x5f,0x72,0x6f,0x75,0x6e,0x64,0x28,0x73,0x74,0x2c,0x72,
+    0x29,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x66,0x6e,0x76,0x31,0x61,0x28,0x68,0x2c,0x20,0x64,0x29,0x20,0x28,0x68,0x20,0x3d,0x20,
+    0x28,0x68,0x20,0x5e,0x20,0x64,0x29,0x20,0x2a,0x20,0x46,0x4e,0x56,0x5f,0x50,0x52,0x49,0x4d,0x45,0x29,0x0a,0x74,0x79,0x70,0x65,0x64,0x65,0x66,0x20,0x73,0x74,0x72,
+    0x75,0x63,0x74,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x7a,0x2c,0x77,0x2c,0x6a,0x73,0x72,0x2c,0x6a,0x63,0x6f,0x6e,0x67,0x3b,0x0a,0x7d,0x20,
+    0x6b,0x69,0x73,0x73,0x39,0x39,0x5f,0x74,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6b,0x69,0x73,0x73,0x39,0x39,0x28,0x6b,0x69,0x73,0x73,0x39,0x39,
+    0x5f,0x74,0x2a,0x20,0x73,0x74,0x29,0x0a,0x7b,0x0a,0x73,0x74,0x2d,0x3e,0x7a,0x3d,0x33,0x36,0x39,0x36,0x39,0x2a,0x28,0x73,0x74,0x2d,0x3e,0x7a,0x26,0x36,0x35,0x35,
+    0x33,0x35,0x29,0x2b,0x28,0x73,0x74,0x2d,0x3e,0x7a,0x3e,0x3e,0x31,0x36,0x29,0x3b,0x0a,0x73,0x74,0x2d,0x3e,0x77,0x3d,0x31,0x38,0x30,0x30,0x30,0x2a,0x28,0x73,0x74,
+    0x2d,0x3e,0x77,0x26,0x36,0x35,0x35,0x33,0x35,0x29,0x2b,0x28,0x73,0x74,0x2d,0x3e,0x77,0x3e,0x3e,0x31,0x36,0x29,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,
+    0x20,0x4d,0x57,0x43,0x3d,0x28,0x28,0x73,0x74,0x2d,0x3e,0x7a,0x3c,0x3c,0x31,0x36,0x29,0x2b,0x73,0x74,0x2d,0x3e,0x77,0x29,0x3b,0x0a,0x73,0x74,0x2d,0x3e,0x6a,0x73,
+    0x72,0x20,0x5e,0x3d,0x20,0x28,0x73,0x74,0x2d,0x3e,0x6a,0x73,0x72,0x3c,0x3c,0x31,0x37,0x29,0x3b,0x0a,0x73,0x74,0x2d,0x3e,0x6a,0x73,0x72,0x20,0x5e,0x3d,0x20,0x28,
+    0x73,0x74,0x2d,0x3e,0x6a,0x73,0x72,0x3e,0x3e,0x31,0x33,0x29,0x3b,0x0a,0x73,0x74,0x2d,0x3e,0x6a,0x73,0x72,0x20,0x5e,0x3d,0x20,0x28,0x73,0x74,0x2d,0x3e,0x6a,0x73,
+    0x72,0x3c,0x3c,0x35,0x29,0x3b,0x0a,0x73,0x74,0x2d,0x3e,0x6a,0x63,0x6f,0x6e,0x67,0x3d,0x36,0x39,0x30,0x36,0x39,0x2a,0x73,0x74,0x2d,0x3e,0x6a,0x63,0x6f,0x6e,0x67,
+    0x2b,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x3b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x28,0x28,0x4d,0x57,0x43,0x5e,0x73,0x74,0x2d,0x3e,0x6a,0x63,0x6f,0x6e,0x67,
+    0x29,0x2b,0x73,0x74,0x2d,0x3e,0x6a,0x73,0x72,0x29,0x3b,0x0a,0x7d,0x0a,0x76,0x6f,0x69,0x64,0x20,0x66,0x69,0x6c,0x6c,0x5f,0x6d,0x69,0x78,0x28,0x6c,0x6f,0x63,0x61,
+    0x6c,0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x2a,0x20,0x73,0x65,0x65,0x64,0x2c,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6c,0x61,0x6e,0x65,0x5f,0x69,
+    0x64,0x2c,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x2a,0x20,0x6d,0x69,0x78,0x29,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x66,0x6e,0x76,0x5f,
+    0x68,0x61,0x73,0x68,0x3d,0x46,0x4e,0x56,0x5f,0x4f,0x46,0x46,0x53,0x45,0x54,0x5f,0x42,0x41,0x53,0x49,0x53,0x3b,0x0a,0x6b,0x69,0x73,0x73,0x39,0x39,0x5f,0x74,0x20,
+    0x73,0x74,0x3b,0x0a,0x73,0x74,0x2e,0x7a,0x3d,0x66,0x6e,0x76,0x31,0x61,0x28,0x66,0x6e,0x76,0x5f,0x68,0x61,0x73,0x68,0x2c,0x73,0x65,0x65,0x64,0x5b,0x30,0x5d,0x29,
+    0x3b,0x0a,0x73,0x74,0x2e,0x77,0x3d,0x66,0x6e,0x76,0x31,0x61,0x28,0x66,0x6e,0x76,0x5f,0x68,0x61,0x73,0x68,0x2c,0x73,0x65,0x65,0x64,0x5b,0x31,0x5d,0x29,0x3b,0x0a,
+    0x73,0x74,0x2e,0x6a,0x73,0x72,0x3d,0x66,0x6e,0x76,0x31,0x61,0x28,0x66,0x6e,0x76,0x5f,0x68,0x61,0x73,0x68,0x2c,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x29,0x3b,0x0a,
+    0x73,0x74,0x2e,0x6a,0x63,0x6f,0x6e,0x67,0x3d,0x66,0x6e,0x76,0x31,0x61,0x28,0x66,0x6e,0x76,0x5f,0x68,0x61,0x73,0x68,0x2c,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x29,
+    0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,
+    0x3c,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x52,0x45,0x47,0x53,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x6d,0x69,0x78,0x5b,0x69,0x5d,0x3d,0x6b,0x69,0x73,0x73,0x39,
+    0x39,0x28,0x26,0x73,0x74,0x29,0x3b,0x0a,0x7d,0x0a,0x74,0x79,0x70,0x65,0x64,0x65,0x66,0x20,0x73,0x74,0x72,0x75,0x63,0x74,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,
+    0x32,0x5f,0x74,0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,0x45,0x53,0x5d,0x3b,0x0a,0x7d,0x20,0x73,0x68,
+    0x75,0x66,0x66,0x6c,0x65,0x5f,0x74,0x3b,0x0a,0x74,0x79,0x70,0x65,0x64,0x65,0x66,0x20,0x73,0x74,0x72,0x75,0x63,0x74,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,
+    0x5f,0x74,0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x33,0x32,0x2f,0x73,0x69,0x7a,0x65,0x6f,0x66,0x28,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x29,0x5d,0x3b,
+    0x0a,0x7d,0x20,0x68,0x61,0x73,0x68,0x33,0x32,0x5f,0x74,0x3b,0x0a,0x23,0x69,0x66,0x20,0x50,0x4c,0x41,0x54,0x46,0x4f,0x52,0x4d,0x20,0x21,0x3d,0x20,0x4f,0x50,0x45,
+    0x4e,0x43,0x4c,0x5f,0x50,0x4c,0x41,0x54,0x46,0x4f,0x52,0x4d,0x5f,0x4e,0x56,0x49,0x44,0x49,0x41,0x20,0x0a,0x5f,0x5f,0x61,0x74,0x74,0x72,0x69,0x62,0x75,0x74,0x65,
+    0x5f,0x5f,0x28,0x28,0x72,0x65,0x71,0x64,0x5f,0x77,0x6f,0x72,0x6b,0x5f,0x67,0x72,0x6f,0x75,0x70,0x5f,0x73,0x69,0x7a,0x65,0x28,0x47,0x52,0x4f,0x55,0x50,0x5f,0x53,
+    0x49,0x5a,0x45,0x2c,0x31,0x2c,0x31,0x29,0x29,0x29,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x5f,0x5f,0x6b,0x65,0x72,0x6e,0x65,0x6c,0x20,0x76,0x6f,0x69,0x64,0x20,
+    0x70,0x72,0x6f,0x67,0x70,0x6f,0x77,0x5f,0x73,0x65,0x61,0x72,0x63,0x68,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x64,0x61,0x67,0x5f,0x74,0x20,0x63,0x6f,
+    0x6e,0x73,0x74,0x2a,0x20,0x67,0x5f,0x64,0x61,0x67,0x2c,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x2a,0x20,0x6a,0x6f,0x62,0x5f,0x62,0x6c,
+    0x6f,0x62,0x2c,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x74,0x61,0x72,0x67,0x65,0x74,0x2c,0x75,0x69,0x6e,0x74,0x20,0x68,0x61,0x63,0x6b,0x5f,0x66,0x61,0x6c,0x73,0x65,0x2c,
+    0x76,0x6f,0x6c,0x61,0x74,0x69,0x6c,0x65,0x20,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x2a,0x20,0x72,0x65,0x73,0x75,0x6c,0x74,0x73,0x2c,
+    0x76,0x6f,0x6c,0x61,0x74,0x69,0x6c,0x65,0x20,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x2a,0x20,0x73,0x74,0x6f,0x70,0x29,0x0a,0x7b,0x0a,
+    0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6c,0x69,0x64,0x3d,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,
+    0x30,0x29,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x67,0x69,0x64,0x3d,0x67,0x65,0x74,0x5f,0x67,0x6c,0x6f,0x62,0x61,
+    0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x3b,0x0a,0x69,0x66,0x28,0x73,0x74,0x6f,0x70,0x5b,0x30,0x5d,0x29,0x20,0x7b,0x0a,0x69,0x66,0x28,0x6c,0x69,0x64,0x3d,0x3d,0x30,
+    0x29,0x20,0x7b,0x0a,0x61,0x74,0x6f,0x6d,0x69,0x63,0x5f,0x69,0x6e,0x63,0x28,0x73,0x74,0x6f,0x70,0x2b,0x31,0x29,0x3b,0x0a,0x7d,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,
+    0x3b,0x0a,0x7d,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x73,0x68,0x75,0x66,0x66,0x6c,0x65,0x5f,0x74,0x20,0x73,0x68,0x61,0x72,0x65,0x5b,0x48,0x41,0x53,0x48,
+    0x45,0x53,0x5f,0x50,0x45,0x52,0x5f,0x47,0x52,0x4f,0x55,0x50,0x5d,0x3b,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,
+    0x63,0x5f,0x64,0x61,0x67,0x5b,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x43,0x41,0x43,0x48,0x45,0x5f,0x57,0x4f,0x52,0x44,0x53,0x5d,0x3b,0x0a,0x63,0x6f,0x6e,0x73,
+    0x74,0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x3d,0x6c,0x69,0x64,0x26,0x28,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,
+    0x4c,0x41,0x4e,0x45,0x53,0x2d,0x31,0x29,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,
+    0x64,0x3d,0x6c,0x69,0x64,0x2f,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,0x45,0x53,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x75,0x69,0x6e,0x74,0x33,0x32,
+    0x5f,0x74,0x20,0x77,0x6f,0x72,0x64,0x3d,0x6c,0x69,0x64,0x2a,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x44,0x41,0x47,0x5f,0x4c,0x4f,0x41,0x44,0x53,0x3b,0x20,0x77,
+    0x6f,0x72,0x64,0x3c,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x43,0x41,0x43,0x48,0x45,0x5f,0x57,0x4f,0x52,0x44,0x53,0x3b,0x20,0x77,0x6f,0x72,0x64,0x2b,0x3d,0x47,
+    0x52,0x4f,0x55,0x50,0x5f,0x53,0x49,0x5a,0x45,0x2a,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x44,0x41,0x47,0x5f,0x4c,0x4f,0x41,0x44,0x53,0x29,0x0a,0x7b,0x0a,0x64,
+    0x61,0x67,0x5f,0x74,0x20,0x6c,0x6f,0x61,0x64,0x3d,0x67,0x5f,0x64,0x61,0x67,0x5b,0x77,0x6f,0x72,0x64,0x2f,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x44,0x41,0x47,
+    0x5f,0x4c,0x4f,0x41,0x44,0x53,0x5d,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,
+    0x5f,0x44,0x41,0x47,0x5f,0x4c,0x4f,0x41,0x44,0x53,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x63,0x5f,0x64,0x61,0x67,0x5b,0x77,0x6f,0x72,0x64,0x2b,0x69,0x5d,0x3d,0x6c,
+    0x6f,0x61,0x64,0x2e,0x73,0x5b,0x69,0x5d,0x3b,0x0a,0x7d,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x68,0x61,0x73,0x68,0x5f,0x73,0x65,0x65,0x64,0x5b,0x32,
+    0x5d,0x3b,0x20,0x0a,0x68,0x61,0x73,0x68,0x33,0x32,0x5f,0x74,0x20,0x64,0x69,0x67,0x65,0x73,0x74,0x3b,0x20,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x73,
+    0x74,0x61,0x74,0x65,0x32,0x5b,0x38,0x5d,0x3b,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x73,0x74,0x61,0x74,0x65,0x5b,0x32,0x35,0x5d,0x3b,0x20,
+    0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x31,0x30,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x73,0x74,0x61,0x74,0x65,0x5b,
+    0x69,0x5d,0x3d,0x6a,0x6f,0x62,0x5f,0x62,0x6c,0x6f,0x62,0x5b,0x69,0x5d,0x3b,0x0a,0x73,0x74,0x61,0x74,0x65,0x5b,0x38,0x5d,0x3d,0x67,0x69,0x64,0x3b,0x0a,0x66,0x6f,
+    0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x31,0x30,0x3b,0x20,0x69,0x3c,0x32,0x35,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x73,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,
+    0x3d,0x72,0x61,0x76,0x65,0x6e,0x63,0x6f,0x69,0x6e,0x5f,0x72,0x6e,0x64,0x63,0x5b,0x69,0x2d,0x31,0x30,0x5d,0x3b,0x0a,0x6b,0x65,0x63,0x63,0x61,0x6b,0x5f,0x66,0x38,
+    0x30,0x30,0x28,0x73,0x74,0x61,0x74,0x65,0x29,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x38,0x3b,0x20,0x69,0x2b,
+    0x2b,0x29,0x0a,0x73,0x74,0x61,0x74,0x65,0x32,0x5b,0x69,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3b,0x0a,0x7d,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,
+    0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x31,0x0a,0x66,0x6f,0x72,0x20,0x28,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x68,0x3d,0x30,0x3b,0x20,0x68,0x3c,0x50,
+    0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,0x45,0x53,0x3b,0x20,0x68,0x2b,0x2b,0x29,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6d,0x69,
+    0x78,0x5b,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x52,0x45,0x47,0x53,0x5d,0x3b,0x0a,0x69,0x66,0x28,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x3d,0x3d,0x68,0x29,0x20,
+    0x7b,0x0a,0x73,0x68,0x61,0x72,0x65,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x30,0x5d,0x3d,0x73,0x74,0x61,
+    0x74,0x65,0x32,0x5b,0x30,0x5d,0x3b,0x0a,0x73,0x68,0x61,0x72,0x65,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,
+    0x31,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x32,0x5b,0x31,0x5d,0x3b,0x0a,0x7d,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,
+    0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x66,0x69,0x6c,0x6c,0x5f,0x6d,0x69,0x78,0x28,0x73,0x68,0x61,0x72,0x65,0x5b,0x67,0x72,0x6f,
+    0x75,0x70,0x5f,0x69,0x64,0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x2c,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x2c,0x6d,0x69,0x78,0x29,0x3b,0x0a,0x23,0x70,0x72,
+    0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x32,0x0a,0x66,0x6f,0x72,0x20,0x28,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6c,0x6f,0x6f,0x70,
+    0x3d,0x30,0x3b,0x20,0x6c,0x6f,0x6f,0x70,0x3c,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x43,0x4e,0x54,0x5f,0x44,0x41,0x47,0x3b,0x20,0x2b,0x2b,0x6c,0x6f,0x6f,0x70,
+    0x29,0x0a,0x7b,0x0a,0x69,0x66,0x28,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x3d,0x3d,0x28,0x6c,0x6f,0x6f,0x70,0x20,0x25,0x20,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,
+    0x4c,0x41,0x4e,0x45,0x53,0x29,0x29,0x0a,0x73,0x68,0x61,0x72,0x65,0x5b,0x30,0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,
+    0x64,0x5d,0x3d,0x6d,0x69,0x78,0x5b,0x30,0x5d,0x3b,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,
+    0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x6f,0x66,0x66,0x73,0x65,0x74,0x3d,0x73,0x68,0x61,0x72,0x65,0x5b,0x30,
+    0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x5d,0x3b,0x0a,0x6f,0x66,0x66,0x73,0x65,0x74,0x20,0x25,0x3d,0x20,0x50,
+    0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x44,0x41,0x47,0x5f,0x45,0x4c,0x45,0x4d,0x45,0x4e,0x54,0x53,0x3b,0x0a,0x6f,0x66,0x66,0x73,0x65,0x74,0x3d,0x6f,0x66,0x66,0x73,
+    0x65,0x74,0x2a,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,0x45,0x53,0x2b,0x28,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x5e,0x6c,0x6f,0x6f,0x70,0x29,0x20,
+    0x25,0x20,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,0x45,0x53,0x3b,0x0a,0x64,0x61,0x67,0x5f,0x74,0x20,0x64,0x61,0x74,0x61,0x5f,0x64,0x61,0x67,0x3d,
+    0x67,0x5f,0x64,0x61,0x67,0x5b,0x6f,0x66,0x66,0x73,0x65,0x74,0x5d,0x3b,0x0a,0x69,0x66,0x28,0x68,0x61,0x63,0x6b,0x5f,0x66,0x61,0x6c,0x73,0x65,0x29,0x20,0x62,0x61,
+    0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x75,0x69,0x6e,0x74,
+    0x33,0x32,0x5f,0x74,0x20,0x64,0x61,0x74,0x61,0x3b,0x0a,0x58,0x4d,0x52,0x49,0x47,0x5f,0x49,0x4e,0x43,0x4c,0x55,0x44,0x45,0x5f,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,
+    0x5f,0x52,0x41,0x4e,0x44,0x4f,0x4d,0x5f,0x4d,0x41,0x54,0x48,0x0a,0x69,0x66,0x28,0x68,0x61,0x63,0x6b,0x5f,0x66,0x61,0x6c,0x73,0x65,0x29,0x20,0x62,0x61,0x72,0x72,
+    0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x58,0x4d,0x52,0x49,0x47,0x5f,
+    0x49,0x4e,0x43,0x4c,0x55,0x44,0x45,0x5f,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x44,0x41,0x54,0x41,0x5f,0x4c,0x4f,0x41,0x44,0x53,0x0a,0x7d,0x0a,0x75,0x69,0x6e,
+    0x74,0x33,0x32,0x5f,0x74,0x20,0x6d,0x69,0x78,0x5f,0x68,0x61,0x73,0x68,0x3d,0x46,0x4e,0x56,0x5f,0x4f,0x46,0x46,0x53,0x45,0x54,0x5f,0x42,0x41,0x53,0x49,0x53,0x3b,
+    0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,
+    0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x52,0x45,0x47,0x53,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x66,0x6e,0x76,0x31,0x61,0x28,0x6d,0x69,0x78,0x5f,0x68,0x61,0x73,
+    0x68,0x2c,0x6d,0x69,0x78,0x5b,0x69,0x5d,0x29,0x3b,0x0a,0x68,0x61,0x73,0x68,0x33,0x32,0x5f,0x74,0x20,0x64,0x69,0x67,0x65,0x73,0x74,0x5f,0x74,0x65,0x6d,0x70,0x3b,
+    0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x38,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x64,0x69,0x67,0x65,0x73,0x74,0x5f,
+    0x74,0x65,0x6d,0x70,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x69,0x5d,0x3d,0x46,0x4e,0x56,0x5f,0x4f,0x46,0x46,0x53,0x45,0x54,0x5f,0x42,0x41,0x53,0x49,0x53,
+    0x3b,0x0a,0x73,0x68,0x61,0x72,0x65,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x6c,0x61,0x6e,0x65,0x5f,0x69,
+    0x64,0x5d,0x3d,0x6d,0x69,0x78,0x5f,0x68,0x61,0x73,0x68,0x3b,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,
+    0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,
+    0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x50,0x52,0x4f,0x47,0x50,0x4f,0x57,0x5f,0x4c,0x41,0x4e,0x45,0x53,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x66,0x6e,
+    0x76,0x31,0x61,0x28,0x64,0x69,0x67,0x65,0x73,0x74,0x5f,0x74,0x65,0x6d,0x70,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x69,0x20,0x25,0x20,0x38,0x5d,0x2c,0x73,
+    0x68,0x61,0x72,0x65,0x5b,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x5d,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x69,0x5d,0x29,0x3b,0x0a,0x69,0x66,0x28,0x68,
+    0x3d,0x3d,0x6c,0x61,0x6e,0x65,0x5f,0x69,0x64,0x29,0x0a,0x64,0x69,0x67,0x65,0x73,0x74,0x3d,0x64,0x69,0x67,0x65,0x73,0x74,0x5f,0x74,0x65,0x6d,0x70,0x3b,0x0a,0x7d,
+    0x0a,0x75,0x69,0x6e,0x74,0x36,0x34,0x5f,0x74,0x20,0x72,0x65,0x73,0x75,0x6c,0x74,0x3b,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x33,0x32,0x5f,0x74,0x20,0x73,0x74,0x61,
+    0x74,0x65,0x5b,0x32,0x35,0x5d,0x3d,0x7b,0x30,0x78,0x30,0x7d,0x3b,0x20,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x38,
+    0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x73,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x32,0x5b,0x69,0x5d,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,
+    0x69,0x6e,0x74,0x20,0x69,0x3d,0x38,0x3b,0x20,0x69,0x3c,0x31,0x36,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x73,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3d,0x64,0x69,0x67,
+    0x65,0x73,0x74,0x2e,0x75,0x69,0x6e,0x74,0x33,0x32,0x73,0x5b,0x69,0x2d,0x38,0x5d,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x31,0x36,0x3b,
+    0x20,0x69,0x3c,0x32,0x35,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x73,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3d,0x72,0x61,0x76,0x65,0x6e,0x63,0x6f,0x69,0x6e,0x5f,0x72,
+    0x6e,0x64,0x63,0x5b,0x69,0x2d,0x31,0x36,0x5d,0x3b,0x0a,0x6b,0x65,0x63,0x63,0x61,0x6b,0x5f,0x66,0x38,0x30,0x30,0x28,0x73,0x74,0x61,0x74,0x65,0x29,0x3b,0x0a,0x75,
+    0x69,0x6e,0x74,0x36,0x34,0x5f,0x74,0x20,0x72,0x65,0x73,0x3d,0x28,0x75,0x69,0x6e,0x74,0x36,0x34,0x5f,0x74,0x29,0x73,0x74,0x61,0x74,0x65,0x5b,0x31,0x5d,0x3c,0x3c,
+    0x33,0x32,0x7c,0x73,0x74,0x61,0x74,0x65,0x5b,0x30,0x5d,0x3b,0x0a,0x72,0x65,0x73,0x75,0x6c,0x74,0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x28,0x61,0x73,0x5f,
+    0x75,0x63,0x68,0x61,0x72,0x38,0x28,0x72,0x65,0x73,0x29,0x2e,0x73,0x37,0x36,0x35,0x34,0x33,0x32,0x31,0x30,0x29,0x3b,0x0a,0x7d,0x0a,0x69,0x66,0x28,0x72,0x65,0x73,
+    0x75,0x6c,0x74,0x3c,0x3d,0x74,0x61,0x72,0x67,0x65,0x74,0x29,0x0a,0x7b,0x0a,0x2a,0x73,0x74,0x6f,0x70,0x3d,0x31,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,
+    0x6e,0x74,0x20,0x6b,0x3d,0x61,0x74,0x6f,0x6d,0x69,0x63,0x5f,0x69,0x6e,0x63,0x28,0x72,0x65,0x73,0x75,0x6c,0x74,0x73,0x29,0x2b,0x31,0x3b,0x0a,0x69,0x66,0x28,0x6b,
+    0x3c,0x3d,0x31,0x35,0x29,0x0a,0x72,0x65,0x73,0x75,0x6c,0x74,0x73,0x5b,0x6b,0x5d,0x3d,0x67,0x69,0x64,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,0x00
 };
 
 } // namespace xmrig

src/base/crypto/Algorithm.cpp

@@ -77,6 +77,7 @@ const char *Algorithm::kCN_UPX2         = "cn/upx2";
 #ifdef XMRIG_ALGO_RANDOMX
 const char *Algorithm::kRX              = "rx";
 const char *Algorithm::kRX_0            = "rx/0";
+const char *Algorithm::kRX_V2           = "rx/2";
 const char *Algorithm::kRX_WOW          = "rx/wow";
 const char *Algorithm::kRX_ARQ          = "rx/arq";
 const char *Algorithm::kRX_GRAFT        = "rx/graft";
@@ -143,6 +144,7 @@ static const std::map<uint32_t, const char *> kAlgorithmNames = {
 
 #   ifdef XMRIG_ALGO_RANDOMX
     ALGO_NAME(RX_0),
+    ALGO_NAME(RX_V2),
     ALGO_NAME(RX_WOW),
     ALGO_NAME(RX_ARQ),
     ALGO_NAME(RX_GRAFT),
@@ -253,6 +255,8 @@ static const std::map<const char *, Algorithm::Id, aliasCompare> kAlgorithmAlias
                                     ALGO_ALIAS(RX_0,            "rx/test"),
                                     ALGO_ALIAS(RX_0,            "randomx"),
                                     ALGO_ALIAS(RX_0,            "rx"),
+    ALGO_ALIAS_AUTO(RX_V2),         ALGO_ALIAS(RX_V2,           "randomx/v2"),
+                                    ALGO_ALIAS(RX_V2,           "rx/v2"),
     ALGO_ALIAS_AUTO(RX_WOW),        ALGO_ALIAS(RX_WOW,          "randomx/wow"),
                                     ALGO_ALIAS(RX_WOW,          "randomwow"),
     ALGO_ALIAS_AUTO(RX_ARQ),        ALGO_ALIAS(RX_ARQ,          "randomx/arq"),
@@ -350,7 +354,7 @@ std::vector<xmrig::Algorithm> xmrig::Algorithm::all(const std::function<bool(con
         CN_HEAVY_0, CN_HEAVY_TUBE, CN_HEAVY_XHV,
         CN_PICO_0, CN_PICO_TLO,
         CN_UPX2,
-        RX_0, RX_WOW, RX_ARQ, RX_GRAFT, RX_SFX, RX_YADA,
+        RX_0, RX_V2, RX_WOW, RX_ARQ, RX_GRAFT, RX_SFX, RX_YADA,
         AR2_CHUKWA, AR2_CHUKWA_V2, AR2_WRKZ,
         KAWPOW_RVN,
         GHOSTRIDER_RTM

src/base/crypto/Algorithm.h

@@ -73,6 +73,7 @@ public:
         CN_GR_5         = 0x63120105,   // "cn/turtle-lite"   GhostRider
         GHOSTRIDER_RTM  = 0x6c150000,   // "ghostrider"       GhostRider
         RX_0            = 0x72151200,   // "rx/0"             RandomX (reference configuration).
+        RX_V2           = 0x72151202,   // "rx/2"             RandomX (Monero v2).
         RX_WOW          = 0x72141177,   // "rx/wow"           RandomWOW (Wownero).
         RX_ARQ          = 0x72121061,   // "rx/arq"           RandomARQ (Arqma).
         RX_GRAFT        = 0x72151267,   // "rx/graft"         RandomGRAFT (Graft).
@@ -139,6 +140,7 @@ public:
 #   ifdef XMRIG_ALGO_RANDOMX
     static const char *kRX;
     static const char *kRX_0;
+    static const char* kRX_V2;
     static const char *kRX_WOW;
     static const char *kRX_ARQ;
     static const char *kRX_GRAFT;

src/base/crypto/sha3.cpp

@@ -48,7 +48,7 @@
 #define KECCAK_ROUNDS 24
 
 
-/* *************************** Public Inteface ************************ */
+/* *************************** Public Interface ************************ */
 
 /* For Init or Reset call these: */
 sha3_return_t

src/base/io/json/Json_win.cpp

@@ -39,7 +39,7 @@
 namespace xmrig {
 
 
-#if defined(_MSC_VER) || (defined(__GNUC__) && !defined(__clang__))
+#if defined(_MSC_VER) || defined(__GNUC__)
 static std::wstring toUtf16(const char *str)
 {
     const int size = static_cast<int>(strlen(str));
@@ -56,13 +56,13 @@ static std::wstring toUtf16(const char *str)
 #endif
 
 
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) || defined(_LIBCPP_HAS_OPEN_WITH_WCHAR)
 #   define OPEN_IFS(name)                                                               \
-    std::ifstream ifs(toUtf16(name), std::ios_base::in | std::ios_base::binary);        \
+    std::ifstream ifs(toUtf16(name).c_str(), std::ios_base::in | std::ios_base::binary);\
     if (!ifs.is_open()) {                                                               \
         return false;                                                                   \
     }
-#elif defined(__GNUC__) && !defined(__clang__)
+#elif defined(__GNUC__)
 #   define OPEN_IFS(name)                                                               \
     const int fd = _wopen(toUtf16(name).c_str(), _O_RDONLY | _O_BINARY);                \
     if (fd == -1) {                                                                     \
@@ -98,12 +98,12 @@ bool xmrig::Json::save(const char *fileName, const rapidjson::Document &doc)
     using namespace rapidjson;
     constexpr const std::ios_base::openmode mode = std::ios_base::out | std::ios_base::binary | std::ios_base::trunc;
 
-#   if defined(_MSC_VER)
-    std::ofstream ofs(toUtf16(fileName), mode);
+#   if defined(_MSC_VER) || defined(_LIBCPP_HAS_OPEN_WITH_WCHAR)
+    std::ofstream ofs(toUtf16(fileName).c_str(), mode);
     if (!ofs.is_open()) {
         return false;
     }
-#   elif defined(__GNUC__) && !defined(__clang__)
+#   elif defined(__GNUC__)
     const int fd = _wopen(toUtf16(fileName).c_str(), _O_WRONLY | _O_BINARY | _O_CREAT | _O_TRUNC, _S_IWRITE);
     if (fd == -1) {
         return false;

src/base/kernel/Platform_unix.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -71,11 +71,11 @@ char *xmrig::Platform::createUserAgent()
 
 
 #ifndef XMRIG_FEATURE_HWLOC
-#ifdef __DragonFly__
+#if defined(__DragonFly__) || defined(XMRIG_OS_OPENBSD) || defined(XMRIG_OS_HAIKU)
 
 bool xmrig::Platform::setThreadAffinity(uint64_t cpu_id)
 {
-    return true;
+    return false;
 }
 
 #else

src/base/kernel/Platform_win.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2023 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -53,13 +53,21 @@ char *xmrig::Platform::createUserAgent()
     char *buf = new char[max]();
     int length = snprintf(buf, max, "%s/%s (Windows NT %lu.%lu", APP_NAME, APP_VERSION, osver.dwMajorVersion, osver.dwMinorVersion);
 
-#   if defined(__x86_64__) || defined(_M_AMD64)
-    length += snprintf(buf + length, max - length, "; Win64; x64) libuv/%s", uv_version_string());
+#   if defined(XMRIG_64_BIT)
+    length += snprintf(buf + length, max - length, "; Win64; "
+#   if defined(XMRIG_ARM)
+    "arm64"
+#   else
+    "x64"
+#   endif
+    ") libuv/%s", uv_version_string());
 #   else
     length += snprintf(buf + length, max - length, ") libuv/%s", uv_version_string());
 #   endif
 
-#   ifdef __GNUC__
+#   ifdef __clang__
+    snprintf(buf + length, max - length, " clang/%d.%d.%d", __clang_major__, __clang_minor__, __clang_patchlevel__);
+#   elif defined(__GNUC__)
     snprintf(buf + length, max - length, " gcc/%d.%d.%d", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
 #   elif _MSC_VER
     snprintf(buf + length, max - length, " msvc/%d", MSVC_VERSION);

src/base/kernel/config/BaseTransform.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -18,14 +18,12 @@
 
 #include <cstdio>
 
-
 #ifdef _MSC_VER
 #   include "getopt/getopt.h"
 #else
 #   include <getopt.h>
 #endif
 
-
 #include "base/kernel/config/BaseTransform.h"
 #include "base/io/json/JsonChain.h"
 #include "base/io/log/Log.h"
@@ -37,7 +35,6 @@
 #include "base/net/stratum/Pools.h"
 #include "core/config/Config_platform.h"
 
-
 #ifdef XMRIG_FEATURE_TLS
 #   include "base/net/tls/TlsConfig.h"
 #endif
@@ -47,9 +44,9 @@ void xmrig::BaseTransform::load(JsonChain &chain, Process *process, IConfigTrans
 {
     using namespace rapidjson;
 
-    int key     = 0;
-    int argc    = process->arguments().argc();
-    char **argv = process->arguments().argv();
+    int key        = 0;
+    const int argc = process->arguments().argc();
+    char **argv    = process->arguments().argv();
 
     Document doc(kObjectType);
 
@@ -262,7 +259,8 @@ void xmrig::BaseTransform::transform(rapidjson::Document &doc, int key, const ch
     case IConfig::DaemonKey:      /* --daemon */
     case IConfig::SubmitToOriginKey: /* --submit-to-origin */
     case IConfig::VerboseKey:     /* --verbose */
-    case IConfig::DnsIPv6Key:     /* --dns-ipv6 */
+    case IConfig::DnsIPv4Key:     /* --ipv4 */
+    case IConfig::DnsIPv6Key:     /* --ipv6 */
         return transformBoolean(doc, key, true);
 
     case IConfig::ColorKey:          /* --no-color */
@@ -323,8 +321,11 @@ void xmrig::BaseTransform::transformBoolean(rapidjson::Document &doc, int key, b
     case IConfig::NoTitleKey: /* --no-title */
         return set(doc, BaseConfig::kTitle, enable);
 
-    case IConfig::DnsIPv6Key: /* --dns-ipv6 */
-        return set(doc, DnsConfig::kField, DnsConfig::kIPv6, enable);
+    case IConfig::DnsIPv4Key: /* --ipv4 */
+        return set(doc, DnsConfig::kField, DnsConfig::kIPv, 4);
+
+    case IConfig::DnsIPv6Key: /* --ipv6 */
+        return set(doc, DnsConfig::kField, DnsConfig::kIPv, 6);
 
     default:
         break;

src/base/kernel/interfaces/IConfig.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,9 +16,7 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef XMRIG_ICONFIG_H
-#define XMRIG_ICONFIG_H
-
+#pragma once
 
 #include "3rdparty/rapidjson/fwd.h"
 
@@ -82,7 +80,8 @@ public:
         HugePageSizeKey      = 1050,
         PauseOnActiveKey     = 1051,
         SubmitToOriginKey    = 1052,
-        DnsIPv6Key           = 1053,
+        DnsIPv4Key           = '4',
+        DnsIPv6Key           = '6',
         DnsTtlKey            = 1054,
         SpendSecretKey       = 1055,
         DaemonZMQPortKey     = 1056,
@@ -177,7 +176,4 @@ public:
 };
 
 
-} /* namespace xmrig */
-
-
-#endif // XMRIG_ICONFIG_H
+} // namespace xmrig

src/base/kernel/interfaces/IDnsBackend.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,21 +16,16 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef XMRIG_IDNSBACKEND_H
-#define XMRIG_IDNSBACKEND_H
-
+#pragma once
 
 #include "base/tools/Object.h"
 
 
-#include <memory>
-
-
 namespace xmrig {
 
 
+class DnsConfig;
 class DnsRecords;
-class DnsRequest;
 class IDnsListener;
 class String;
 
@@ -43,12 +38,8 @@ public:
     IDnsBackend()           = default;
     virtual ~IDnsBackend()  = default;
 
-    virtual const DnsRecords &records() const                                                               = 0;
-    virtual std::shared_ptr<DnsRequest> resolve(const String &host, IDnsListener *listener, uint64_t ttl)   = 0;
+    virtual void resolve(const String &host, const std::weak_ptr<IDnsListener> &listener, const DnsConfig &config)  = 0;
 };
 
 
-} /* namespace xmrig */
-
-
-#endif // XMRIG_IDNSBACKEND_H
+} // namespace xmrig

src/base/net/dns/Dns.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -18,6 +18,7 @@
 
 
 #include "base/net/dns/Dns.h"
+#include "base/net/dns/DnsRequest.h"
 #include "base/net/dns/DnsUvBackend.h"
 
 
@@ -25,17 +26,21 @@ namespace xmrig {
 
 
 DnsConfig Dns::m_config;
-std::map<String, std::shared_ptr<IDnsBackend> > Dns::m_backends;
+std::map<String, std::shared_ptr<IDnsBackend>> Dns::m_backends;
 
 
 } // namespace xmrig
 
 
-std::shared_ptr<xmrig::DnsRequest> xmrig::Dns::resolve(const String &host, IDnsListener *listener, uint64_t ttl)
+std::shared_ptr<xmrig::DnsRequest> xmrig::Dns::resolve(const String &host, IDnsListener *listener)
 {
+    auto req = std::make_shared<DnsRequest>(listener);
+
     if (m_backends.find(host) == m_backends.end()) {
         m_backends.insert({ host, std::make_shared<DnsUvBackend>() });
     }
 
-    return m_backends.at(host)->resolve(host, listener, ttl == 0 ? m_config.ttl() : ttl);
+    m_backends.at(host)->resolve(host, req, m_config);
+
+    return req;
 }

src/base/net/dns/Dns.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -43,7 +43,7 @@ public:
     inline static const DnsConfig &config()             { return m_config; }
     inline static void set(const DnsConfig &config)     { m_config = config; }
 
-    static std::shared_ptr<DnsRequest> resolve(const String &host, IDnsListener *listener, uint64_t ttl = 0);
+    static std::shared_ptr<DnsRequest> resolve(const String &host, IDnsListener *listener);
 
 private:
     static DnsConfig m_config;

src/base/net/dns/DnsConfig.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -20,15 +20,15 @@
 #include "3rdparty/rapidjson/document.h"
 #include "base/io/json/Json.h"
 
-
 #include <algorithm>
+#include <uv.h>
 
 
 namespace xmrig {
 
 
 const char *DnsConfig::kField   = "dns";
-const char *DnsConfig::kIPv6    = "ipv6";
+const char *DnsConfig::kIPv     = "ip_version";
 const char *DnsConfig::kTTL     = "ttl";
 
 
@@ -37,8 +37,26 @@ const char *DnsConfig::kTTL     = "ttl";
 
 xmrig::DnsConfig::DnsConfig(const rapidjson::Value &value)
 {
-    m_ipv6  = Json::getBool(value, kIPv6, m_ipv6);
-    m_ttl   = std::max(Json::getUint(value, kTTL, m_ttl), 1U);
+    const uint32_t ipv = Json::getUint(value, kIPv, m_ipv);
+    if (ipv == 0 || ipv == 4 || ipv == 6) {
+        m_ipv = ipv;
+    }
+
+    m_ttl = std::max(Json::getUint(value, kTTL, m_ttl), 1U);
+}
+
+
+int xmrig::DnsConfig::ai_family() const
+{
+    if (m_ipv == 4) {
+        return AF_INET;
+    }
+
+    if (m_ipv == 6) {
+        return AF_INET6;
+    }
+
+    return AF_UNSPEC;
 }
 
 
@@ -49,8 +67,8 @@ rapidjson::Value xmrig::DnsConfig::toJSON(rapidjson::Document &doc) const
     auto &allocator = doc.GetAllocator();
     Value obj(kObjectType);
 
-    obj.AddMember(StringRef(kIPv6), m_ipv6, allocator);
-    obj.AddMember(StringRef(kTTL),  m_ttl, allocator);
+    obj.AddMember(StringRef(kIPv), m_ipv, allocator);
+    obj.AddMember(StringRef(kTTL), m_ttl, allocator);
 
     return obj;
 }

src/base/net/dns/DnsConfig.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,9 +16,7 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef XMRIG_DNSCONFIG_H
-#define XMRIG_DNSCONFIG_H
-
+#pragma once
 
 #include "3rdparty/rapidjson/fwd.h"
 
@@ -30,25 +28,22 @@ class DnsConfig
 {
 public:
     static const char *kField;
-    static const char *kIPv6;
+    static const char *kIPv;
     static const char *kTTL;
 
     DnsConfig() = default;
     DnsConfig(const rapidjson::Value &value);
 
-    inline bool isIPv6() const  { return m_ipv6; }
+    inline uint32_t ipv() const { return m_ipv; }
     inline uint32_t ttl() const { return m_ttl * 1000U; }
 
+    int ai_family() const;
     rapidjson::Value toJSON(rapidjson::Document &doc) const;
 
-
 private:
-    bool m_ipv6     = false;
-    uint32_t m_ttl  = 30U;
+    uint32_t m_ttl = 30U;
+    uint32_t m_ipv = 0U;
 };
 
 
-} /* namespace xmrig */
-
-
-#endif /* XMRIG_DNSCONFIG_H */
+} // namespace xmrig

src/base/net/dns/DnsRecord.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2023 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,19 +16,16 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <uv.h>
 
-
 #include "base/net/dns/DnsRecord.h"
 
 
-xmrig::DnsRecord::DnsRecord(const addrinfo *addr) :
-    m_type(addr->ai_family == AF_INET6 ? AAAA : (addr->ai_family == AF_INET ? A : Unknown))
+xmrig::DnsRecord::DnsRecord(const addrinfo *addr)
 {
     static_assert(sizeof(m_data) >= sizeof(sockaddr_in6), "Not enough storage for IPv6 address.");
 
-    memcpy(m_data, addr->ai_addr, m_type == AAAA ? sizeof(sockaddr_in6) : sizeof(sockaddr_in));
+    memcpy(m_data, addr->ai_addr, addr->ai_family == AF_INET6 ? sizeof(sockaddr_in6) : sizeof(sockaddr_in));
 }
 
 
@@ -44,7 +41,7 @@ xmrig::String xmrig::DnsRecord::ip() const
 {
     char *buf = nullptr;
 
-    if (m_type == AAAA) {
+    if (reinterpret_cast<const sockaddr &>(m_data).sa_family == AF_INET6) {
         buf = new char[45]();
         uv_ip6_name(reinterpret_cast<const sockaddr_in6*>(m_data), buf, 45);
     }

src/base/net/dns/DnsRecord.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,14 +16,11 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef XMRIG_DNSRECORD_H
-#define XMRIG_DNSRECORD_H
-
+#pragma once
 
 struct addrinfo;
 struct sockaddr;
 
-
 #include "base/tools/String.h"
 
 
@@ -33,28 +30,15 @@ namespace xmrig {
 class DnsRecord
 {
 public:
-    enum Type : uint32_t {
-        Unknown,
-        A,
-        AAAA
-    };
-
     DnsRecord() {}
     DnsRecord(const addrinfo *addr);
 
     const sockaddr *addr(uint16_t port = 0) const;
     String ip() const;
 
-    inline bool isValid() const     { return m_type != Unknown; }
-    inline Type type() const        { return m_type; }
-
 private:
     mutable uint8_t m_data[28]{};
-    const Type m_type = Unknown;
 };
 
 
-} /* namespace xmrig */
-
-
-#endif /* XMRIG_DNSRECORD_H */
+} // namespace xmrig

src/base/net/dns/DnsRecords.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -18,90 +18,96 @@
 
 #include <uv.h>
 
-
 #include "base/net/dns/DnsRecords.h"
-#include "base/net/dns/Dns.h"
 
 
-const xmrig::DnsRecord &xmrig::DnsRecords::get(DnsRecord::Type prefered) const
+namespace {
+
+
+static size_t dns_records_count(const addrinfo *res, int &ai_family)
+{
+    size_t ipv4 = 0;
+    size_t ipv6 = 0;
+
+    while (res != nullptr) {
+        if (res->ai_family == AF_INET) {
+            ++ipv4;
+        }
+
+        if (res->ai_family == AF_INET6) {
+            ++ipv6;
+        }
+
+        res = res->ai_next;
+    }
+
+    if (ai_family == AF_INET6 && !ipv6) {
+        ai_family = AF_INET;
+    }
+
+    switch (ai_family) {
+    case AF_UNSPEC:
+        return ipv4 + ipv6;
+
+    case AF_INET:
+        return ipv4;
+
+    case AF_INET6:
+        return ipv6;
+
+    default:
+        break;
+    }
+
+    return 0;
+}
+
+
+} // namespace
+
+
+xmrig::DnsRecords::DnsRecords(const addrinfo *res, int ai_family)
+{
+    size_t size = dns_records_count(res, ai_family);
+    if (!size) {
+        return;
+    }
+
+    m_records.reserve(size);
+
+    if (ai_family == AF_UNSPEC) {
+        while (res != nullptr) {
+            if (res->ai_family == AF_INET || res->ai_family == AF_INET6) {
+                m_records.emplace_back(res);
+            }
+
+            res = res->ai_next;
+        };
+    } else {
+        while (res != nullptr) {
+            if (res->ai_family == ai_family) {
+                m_records.emplace_back(res);
+            }
+
+            res = res->ai_next;
+        };
+    }
+
+    size = m_records.size();
+    if (size > 1) {
+        m_index = static_cast<size_t>(rand()) % size; // NOLINT(concurrency-mt-unsafe, cert-msc30-c, cert-msc50-cpp)
+    }
+}
+
+
+const xmrig::DnsRecord &xmrig::DnsRecords::get() const
 {
     static const DnsRecord defaultRecord;
 
-    if (isEmpty()) {
-        return defaultRecord;
-    }
-
-    const size_t ipv4 = m_ipv4.size();
-    const size_t ipv6 = m_ipv6.size();
-
-    if (ipv6 && (prefered == DnsRecord::AAAA || Dns::config().isIPv6() || !ipv4)) {
-        return m_ipv6[ipv6 == 1 ? 0 : static_cast<size_t>(rand()) % ipv6]; // NOLINT(concurrency-mt-unsafe, cert-msc30-c, cert-msc50-cpp)
-    }
-
-    if (ipv4) {
-        return m_ipv4[ipv4 == 1 ? 0 : static_cast<size_t>(rand()) % ipv4]; // NOLINT(concurrency-mt-unsafe, cert-msc30-c, cert-msc50-cpp)
+    const size_t size = m_records.size();
+    if (size > 0) {
+        return m_records[m_index++ % size];
     }
 
     return defaultRecord;
 }
-
-
-size_t xmrig::DnsRecords::count(DnsRecord::Type type) const
-{
-    if (type == DnsRecord::A) {
-        return m_ipv4.size();
-    }
-
-    if (type == DnsRecord::AAAA) {
-        return m_ipv6.size();
-    }
-
-    return m_ipv4.size() + m_ipv6.size();
-}
-
-
-void xmrig::DnsRecords::clear()
-{
-    m_ipv4.clear();
-    m_ipv6.clear();
-}
-
-
-void xmrig::DnsRecords::parse(addrinfo *res)
-{
-    clear();
-
-    addrinfo *ptr = res;
-    size_t ipv4   = 0;
-    size_t ipv6   = 0;
-
-    while (ptr != nullptr) {
-        if (ptr->ai_family == AF_INET) {
-            ++ipv4;
-        }
-        else if (ptr->ai_family == AF_INET6) {
-            ++ipv6;
-        }
-
-        ptr = ptr->ai_next;
-    }
-
-    if (ipv4 == 0 && ipv6 == 0) {
-        return;
-    }
-
-    m_ipv4.reserve(ipv4);
-    m_ipv6.reserve(ipv6);
-
-    ptr = res;
-    while (ptr != nullptr) {
-        if (ptr->ai_family == AF_INET) {
-            m_ipv4.emplace_back(ptr);
-        }
-        else if (ptr->ai_family == AF_INET6) {
-            m_ipv6.emplace_back(ptr);
-        }
-
-        ptr = ptr->ai_next;
-    }
-}

src/base/net/dns/DnsRecords.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,9 +16,7 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef XMRIG_DNSRECORDS_H
-#define XMRIG_DNSRECORDS_H
-
+#pragma once
 
 #include "base/net/dns/DnsRecord.h"
 
@@ -29,20 +27,19 @@ namespace xmrig {
 class DnsRecords
 {
 public:
-    inline bool isEmpty() const       { return m_ipv4.empty() && m_ipv6.empty(); }
+    DnsRecords() = default;
+    DnsRecords(const addrinfo *res, int ai_family);
 
-    const DnsRecord &get(DnsRecord::Type prefered = DnsRecord::Unknown) const;
-    size_t count(DnsRecord::Type type = DnsRecord::Unknown) const;
-    void clear();
-    void parse(addrinfo *res);
+    inline bool isEmpty() const                             { return m_records.empty(); }
+    inline const std::vector<DnsRecord> &records() const    { return m_records; }
+    inline size_t size() const                              { return m_records.size(); }
+
+    const DnsRecord &get() const;
 
 private:
-    std::vector<DnsRecord> m_ipv4;
-    std::vector<DnsRecord> m_ipv6;
+    mutable size_t m_index = 0;
+    std::vector<DnsRecord> m_records;
 };
 
 
-} /* namespace xmrig */
-
-
-#endif /* XMRIG_DNSRECORDS_H */
+} // namespace xmrig

src/base/net/dns/DnsRequest.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,35 +16,30 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef XMRIG_DNSREQUEST_H
-#define XMRIG_DNSREQUEST_H
+#pragma once
 
-
-#include "base/tools/Object.h"
-
-
-#include <cstdint>
+#include "base/kernel/interfaces/IDnsListener.h"
 
 
 namespace xmrig {
 
 
-class IDnsListener;
-
-
-class DnsRequest
+class DnsRequest : public IDnsListener
 {
 public:
     XMRIG_DISABLE_COPY_MOVE_DEFAULT(DnsRequest)
 
-    DnsRequest(IDnsListener *listener) : listener(listener) {}
-    ~DnsRequest() = default;
+    inline DnsRequest(IDnsListener *listener) : m_listener(listener) {}
+    ~DnsRequest() override = default;
 
-    IDnsListener *listener;
+protected:
+    inline void onResolved(const DnsRecords &records, int status, const char *error) override {
+        m_listener->onResolved(records, status, error);
+    }
+
+private:
+    IDnsListener *m_listener;
 };
 
 
-} /* namespace xmrig */
-
-
-#endif /* XMRIG_DNSREQUEST_H */
+} // namespace xmrig

src/base/net/dns/DnsUvBackend.cpp

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2023 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,13 +16,11 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include <uv.h>
 
-
 #include "base/net/dns/DnsUvBackend.h"
 #include "base/kernel/interfaces/IDnsListener.h"
-#include "base/net/dns/DnsRequest.h"
+#include "base/net/dns/DnsConfig.h"
 #include "base/tools/Chrono.h"
 
 
@@ -73,21 +71,23 @@ xmrig::DnsUvBackend::~DnsUvBackend()
 }
 
 
-std::shared_ptr<xmrig::DnsRequest> xmrig::DnsUvBackend::resolve(const String &host, IDnsListener *listener, uint64_t ttl)
+void xmrig::DnsUvBackend::resolve(const String &host, const std::weak_ptr<IDnsListener> &listener, const DnsConfig &config)
 {
-    auto req = std::make_shared<DnsRequest>(listener);
+    m_queue.emplace_back(listener);
 
-    if (Chrono::currentMSecsSinceEpoch() - m_ts <= ttl && !m_records.isEmpty()) {
-        req->listener->onResolved(m_records, 0, nullptr);
-    } else {
-        m_queue.emplace(req);
+    if (Chrono::currentMSecsSinceEpoch() - m_ts <= config.ttl()) {
+        return notify();
     }
 
-    if (m_queue.size() == 1 && !resolve(host)) {
-        done();
+    if (m_req) {
+        return;
     }
 
-    return req;
+    m_ai_family = config.ai_family();
+
+    if (!resolve(host)) {
+        notify();
+    }
 }
 
 
@@ -102,44 +102,46 @@ bool xmrig::DnsUvBackend::resolve(const String &host)
 }
 
 
-void xmrig::DnsUvBackend::done()
+void xmrig::DnsUvBackend::notify()
 {
     const char *error = m_status < 0 ? uv_strerror(m_status) : nullptr;
 
-    while (!m_queue.empty()) {
-        auto req = std::move(m_queue.front()).lock();
-        if (req) {
-            req->listener->onResolved(m_records, m_status, error);
+    for (const auto &l : m_queue) {
+        auto listener = l.lock();
+        if (listener) {
+            listener->onResolved(m_records, m_status, error);
         }
-
-        m_queue.pop();
     }
 
+    m_queue.clear();
     m_req.reset();
 }
 
 
 void xmrig::DnsUvBackend::onResolved(int status, addrinfo *res)
 {
-    m_ts = Chrono::currentMSecsSinceEpoch();
+    m_status = status;
+    m_ts     = Chrono::currentMSecsSinceEpoch();
 
-    if ((m_status = status) < 0) {
-        return done();
+    if (m_status < 0) {
+        m_records = {};
+
+        return notify();
     }
 
-    m_records.parse(res);
+    m_records = { res, m_ai_family };
 
     if (m_records.isEmpty()) {
         m_status = UV_EAI_NONAME;
     }
 
-    done();
+    notify();
 }
 
 
 void xmrig::DnsUvBackend::onResolved(uv_getaddrinfo_t *req, int status, addrinfo *res)
 {
-    auto backend = getStorage().get(req->data);
+    auto *backend = getStorage().get(req->data);
     if (backend) {
         backend->onResolved(status, res);
     }

src/base/net/dns/DnsUvBackend.h

@@ -1,6 +1,6 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,16 +16,13 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef XMRIG_DNSUVBACKEND_H
-#define XMRIG_DNSUVBACKEND_H
-
+#pragma once
 
 #include "base/kernel/interfaces/IDnsBackend.h"
 #include "base/net/dns/DnsRecords.h"
 #include "base/net/tools/Storage.h"
 
-
-#include <queue>
+#include <deque>
 
 
 using uv_getaddrinfo_t = struct uv_getaddrinfo_s;
@@ -43,20 +40,19 @@ public:
     ~DnsUvBackend() override;
 
 protected:
-    inline const DnsRecords &records() const override   { return m_records; }
-
-    std::shared_ptr<DnsRequest> resolve(const String &host, IDnsListener *listener, uint64_t ttl) override;
+    void resolve(const String &host, const std::weak_ptr<IDnsListener> &listener, const DnsConfig &config) override;
 
 private:
     bool resolve(const String &host);
-    void done();
+    void notify();
     void onResolved(int status, addrinfo *res);
 
     static void onResolved(uv_getaddrinfo_t *req, int status, addrinfo *res);
 
     DnsRecords m_records;
+    int m_ai_family         = 0;
     int m_status            = 0;
-    std::queue<std::weak_ptr<DnsRequest> > m_queue;
+    std::deque<std::weak_ptr<IDnsListener>> m_queue;
     std::shared_ptr<uv_getaddrinfo_t> m_req;
     uint64_t m_ts           = 0;
     uintptr_t m_key;
@@ -66,7 +62,4 @@ private:
 };
 
 
-} /* namespace xmrig */
-
-
-#endif /* XMRIG_DNSUVBACKEND_H */
+} // namespace xmrig

src/base/net/stratum/Client.cpp

@@ -81,7 +81,7 @@ xmrig::Client::Client(int id, const char *agent, IClientListener *listener) :
     BaseClient(id, listener),
     m_agent(agent),
     m_sendBuf(1024),
-    m_tempBuf(256)
+    m_tempBuf(320)
 {
     m_reader.setListener(this);
     m_key = m_storage.add(this);
@@ -199,6 +199,7 @@ int64_t xmrig::Client::submit(const JobResult &result)
     char *nonce = m_tempBuf.data();
     char *data  = m_tempBuf.data() + 16;
     char *signature = m_tempBuf.data() + 88;
+    char *commitment = m_tempBuf.data() + 224;
 
     Cvt::toHex(nonce, sizeof(uint32_t) * 2 + 1, reinterpret_cast<const uint8_t *>(&result.nonce), sizeof(uint32_t));
     Cvt::toHex(data, 65, result.result(), 32);
@@ -206,6 +207,10 @@ int64_t xmrig::Client::submit(const JobResult &result)
     if (result.minerSignature()) {
         Cvt::toHex(signature, 129, result.minerSignature(), 64);
     }
+
+    if (result.commitment()) {
+        Cvt::toHex(commitment, 65, result.commitment(), 32);
+    }
 #   endif
 
     Document doc(kObjectType);
@@ -227,6 +232,16 @@ int64_t xmrig::Client::submit(const JobResult &result)
     }
 #   endif
 
+#   ifndef XMRIG_PROXY_PROJECT
+    if (result.commitment()) {
+        params.AddMember("commitment", StringRef(commitment), allocator);
+    }
+#   else
+    if (result.commitment) {
+        params.AddMember("commitment", StringRef(result.commitment), allocator);
+    }
+#   endif
+
     if (has<EXT_ALGO>() && result.algorithm.isValid()) {
         params.AddMember("algo", StringRef(result.algorithm.name()), allocator);
     }
@@ -554,6 +569,7 @@ int64_t xmrig::Client::send(size_t size)
     }
 
     m_expire = Chrono::steadyMSecs() + kResponseTimeout;
+    startTimeout();
     return m_sequence++;
 }
 
@@ -661,8 +677,6 @@ void xmrig::Client::onClose()
 
 void xmrig::Client::parse(char *line, size_t len)
 {
-    startTimeout();
-
     LOG_DEBUG("[%s] received (%d bytes): \"%.*s\"", url(), len, static_cast<int>(len), line);
 
     if (len < 22 || line[0] != '{') {
@@ -857,8 +871,6 @@ void xmrig::Client::parseResponse(int64_t id, const rapidjson::Value &result, co
 void xmrig::Client::ping()
 {
     send(snprintf(m_sendBuf.data(), m_sendBuf.size(), "{\"id\":%" PRId64 ",\"jsonrpc\":\"2.0\",\"method\":\"keepalived\",\"params\":{\"id\":\"%s\"}}\n", m_sequence, m_rpcId.data()));
-
-    m_keepAlive = 0;
 }
 
 

src/base/net/stratum/DaemonClient.cpp

@@ -410,6 +410,7 @@ bool xmrig::DaemonClient::parseJob(const rapidjson::Value &params, int *code)
         m_blocktemplate.offset(BlockTemplate::TX_EXTRA_NONCE_OFFSET) - k,
         m_blocktemplate.txExtraNonce().size(),
         m_blocktemplate.minerTxMerkleTreeBranch(),
+        m_blocktemplate.minerTxMerkleTreePath(),
         m_blocktemplate.outputType() == 3
     );
 #   endif

src/base/net/stratum/Job.cpp

@@ -269,6 +269,7 @@ void xmrig::Job::copy(const Job &other)
     m_minerTxExtraNonceOffset = other.m_minerTxExtraNonceOffset;
     m_minerTxExtraNonceSize = other.m_minerTxExtraNonceSize;
     m_minerTxMerkleTreeBranch = other.m_minerTxMerkleTreeBranch;
+    m_minerTxMerkleTreePath = other.m_minerTxMerkleTreePath;
     m_hasViewTag = other.m_hasViewTag;
 #   else
     memcpy(m_ephPublicKey, other.m_ephPublicKey, sizeof(m_ephPublicKey));
@@ -325,6 +326,7 @@ void xmrig::Job::move(Job &&other)
     m_minerTxExtraNonceOffset   = other.m_minerTxExtraNonceOffset;
     m_minerTxExtraNonceSize     = other.m_minerTxExtraNonceSize;
     m_minerTxMerkleTreeBranch   = std::move(other.m_minerTxMerkleTreeBranch);
+    m_minerTxMerkleTreePath     = other.m_minerTxMerkleTreePath;
     m_hasViewTag                = other.m_hasViewTag;
 #   else
     memcpy(m_ephPublicKey, other.m_ephPublicKey, sizeof(m_ephPublicKey));
@@ -349,7 +351,7 @@ void xmrig::Job::setSpendSecretKey(const uint8_t *key)
 }
 
 
-void xmrig::Job::setMinerTx(const uint8_t *begin, const uint8_t *end, size_t minerTxEphPubKeyOffset, size_t minerTxPubKeyOffset, size_t minerTxExtraNonceOffset, size_t minerTxExtraNonceSize, const Buffer &minerTxMerkleTreeBranch, bool hasViewTag)
+void xmrig::Job::setMinerTx(const uint8_t *begin, const uint8_t *end, size_t minerTxEphPubKeyOffset, size_t minerTxPubKeyOffset, size_t minerTxExtraNonceOffset, size_t minerTxExtraNonceSize, const Buffer &minerTxMerkleTreeBranch, uint32_t minerTxMerkleTreePath, bool hasViewTag)
 {
     m_minerTxPrefix.assign(begin, end);
     m_minerTxEphPubKeyOffset    = minerTxEphPubKeyOffset;
@@ -357,6 +359,7 @@ void xmrig::Job::setMinerTx(const uint8_t *begin, const uint8_t *end, size_t min
     m_minerTxExtraNonceOffset   = minerTxExtraNonceOffset;
     m_minerTxExtraNonceSize     = minerTxExtraNonceSize;
     m_minerTxMerkleTreeBranch   = minerTxMerkleTreeBranch;
+    m_minerTxMerkleTreePath     = minerTxMerkleTreePath;
     m_hasViewTag                = hasViewTag;
 }
 
@@ -401,7 +404,7 @@ void xmrig::Job::generateHashingBlob(String &blob) const
 {
     uint8_t root_hash[32];
     const uint8_t* p = m_minerTxPrefix.data();
-    BlockTemplate::calculateRootHash(p, p + m_minerTxPrefix.size(), m_minerTxMerkleTreeBranch, root_hash);
+    BlockTemplate::calculateRootHash(p, p + m_minerTxPrefix.size(), m_minerTxMerkleTreeBranch, m_minerTxMerkleTreePath, root_hash);
 
     uint64_t root_hash_offset = nonceOffset() + nonceSize();
 

src/base/net/stratum/Job.h

@@ -121,7 +121,7 @@ public:
     inline bool hasViewTag() const                      { return m_hasViewTag; }
 
     void setSpendSecretKey(const uint8_t* key);
-    void setMinerTx(const uint8_t* begin, const uint8_t* end, size_t minerTxEphPubKeyOffset, size_t minerTxPubKeyOffset, size_t minerTxExtraNonceOffset, size_t minerTxExtraNonceSize, const Buffer& minerTxMerkleTreeBranch, bool hasViewTag);
+    void setMinerTx(const uint8_t* begin, const uint8_t* end, size_t minerTxEphPubKeyOffset, size_t minerTxPubKeyOffset, size_t minerTxExtraNonceOffset, size_t minerTxExtraNonceSize, const Buffer& minerTxMerkleTreeBranch, uint32_t minerTxMerkleTreePath, bool hasViewTag);
     void setViewTagInMinerTx(uint8_t view_tag);
     void setExtraNonceInMinerTx(uint32_t extra_nonce);
     void generateSignatureData(String& signatureData, uint8_t& view_tag) const;
@@ -179,6 +179,7 @@ private:
     size_t m_minerTxExtraNonceOffset = 0;
     size_t m_minerTxExtraNonceSize = 0;
     Buffer m_minerTxMerkleTreeBranch;
+    uint32_t m_minerTxMerkleTreePath = 0;
     bool m_hasViewTag = false;
 #   else
     // Miner signatures

src/base/net/tls/TlsContext.cpp

@@ -1,7 +1,7 @@
 /* XMRig
  * Copyright (c) 2018      Lee Clagett <https://github.com/vtnerd>
- * Copyright (c) 2018-2023 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2023 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -45,7 +45,7 @@ namespace xmrig {
 
 
 // https://wiki.openssl.org/index.php/Diffie-Hellman_parameters
-#if OPENSSL_VERSION_NUMBER < 0x30000000L || defined(LIBRESSL_VERSION_NUMBER)
+#if OPENSSL_VERSION_NUMBER < 0x30000000L || (defined(LIBRESSL_VERSION_NUMBER) && !defined(LIBRESSL_HAS_TLS1_3))
 static DH *get_dh2048()
 {
     static unsigned char dhp_2048[] = {
@@ -152,7 +152,7 @@ bool xmrig::TlsContext::load(const TlsConfig &config)
     SSL_CTX_set_options(m_ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
     SSL_CTX_set_options(m_ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);
 
-#   if OPENSSL_VERSION_NUMBER >= 0x1010100fL && !defined(LIBRESSL_VERSION_NUMBER)
+#   if OPENSSL_VERSION_NUMBER >= 0x1010100fL || defined(LIBRESSL_HAS_TLS1_3)
     SSL_CTX_set_max_early_data(m_ctx, 0);
 #   endif
 
@@ -180,7 +180,7 @@ bool xmrig::TlsContext::setCipherSuites(const char *ciphersuites)
         return true;
     }
 
-#   if OPENSSL_VERSION_NUMBER >= 0x1010100fL && !defined(LIBRESSL_VERSION_NUMBER)
+#   if OPENSSL_VERSION_NUMBER >= 0x1010100fL || defined(LIBRESSL_HAS_TLS1_3)
     if (SSL_CTX_set_ciphersuites(m_ctx, ciphersuites) == 1) {
         return true;
     }
@@ -194,7 +194,7 @@ bool xmrig::TlsContext::setCipherSuites(const char *ciphersuites)
 
 bool xmrig::TlsContext::setDH(const char *dhparam)
 {
-#   if OPENSSL_VERSION_NUMBER < 0x30000000L || defined(LIBRESSL_VERSION_NUMBER)
+#   if OPENSSL_VERSION_NUMBER < 0x30000000L || (defined(LIBRESSL_VERSION_NUMBER) && !defined(LIBRESSL_HAS_TLS1_3))
     DH *dh = nullptr;
 
     if (dhparam != nullptr) {

src/base/tools/cryptonote/BlockTemplate.cpp

@@ -48,69 +48,98 @@ void xmrig::BlockTemplate::calculateMinerTxHash(const uint8_t *prefix_begin, con
 }
 
 
-void xmrig::BlockTemplate::calculateRootHash(const uint8_t *prefix_begin, const uint8_t *prefix_end, const Buffer &miner_tx_merkle_tree_branch, uint8_t *root_hash)
+void xmrig::BlockTemplate::calculateRootHash(const uint8_t *prefix_begin, const uint8_t *prefix_end, const Buffer &miner_tx_merkle_tree_branch, uint32_t miner_tx_merkle_tree_path, uint8_t *root_hash)
 {
     calculateMinerTxHash(prefix_begin, prefix_end, root_hash);
 
-    for (size_t i = 0; i < miner_tx_merkle_tree_branch.size(); i += kHashSize) {
+    const size_t depth = miner_tx_merkle_tree_branch.size() / kHashSize;
+
+    for (size_t d = 0; d < depth; ++d) {
         uint8_t h[kHashSize * 2];
 
-        memcpy(h, root_hash, kHashSize);
-        memcpy(h + kHashSize, miner_tx_merkle_tree_branch.data() + i, kHashSize);
+        const uint32_t t = (miner_tx_merkle_tree_path >> (depth - d - 1)) & 1;
+
+        memcpy(h + kHashSize * t, root_hash, kHashSize);
+        memcpy(h + kHashSize * (t ^ 1), miner_tx_merkle_tree_branch.data() + d * kHashSize, kHashSize);
 
         keccak(h, kHashSize * 2, root_hash, kHashSize);
     }
 }
 
 
-void xmrig::BlockTemplate::calculateMerkleTreeHash()
+void xmrig::BlockTemplate::calculateMerkleTreeHash(uint32_t index)
 {
     m_minerTxMerkleTreeBranch.clear();
+	m_minerTxMerkleTreePath = 0;
 
-    const uint64_t count = m_numHashes + 1;
+    const size_t count = m_hashes.size() / kHashSize;
     const uint8_t *h = m_hashes.data();
 
-    if (count == 1) {
+	if (count == 1) {
         memcpy(m_rootHash, h, kHashSize);
-    }
-    else if (count == 2) {
-        m_minerTxMerkleTreeBranch.insert(m_minerTxMerkleTreeBranch.end(), h + kHashSize, h + kHashSize * 2);
+	}
+	else if (count == 2) {
         keccak(h, kHashSize * 2, m_rootHash, kHashSize);
-    }
-    else {
-        size_t i    = 0;
-        size_t j    = 0;
-        size_t cnt  = 0;
 
-        for (i = 0, cnt = 1; cnt <= count; ++i, cnt <<= 1) {}
+		m_minerTxMerkleTreeBranch.reserve(1);
+        m_minerTxMerkleTreeBranch.insert(m_minerTxMerkleTreeBranch.end(), h + kHashSize * (index ^ 1), h + kHashSize * ((index ^ 1) + 1));
+		m_minerTxMerkleTreePath = static_cast<uint32_t>(index);
+	}
+	else {
+		uint8_t h2[kHashSize];
+        memcpy(h2, h + kHashSize * index, kHashSize);
 
-        cnt >>= 1;
+		size_t cnt = 1, proof_max_size = 0;
+		do {
+			cnt <<= 1;
+			++proof_max_size;
+		} while (cnt <= count);
+		cnt >>= 1;
 
-        m_minerTxMerkleTreeBranch.reserve(kHashSize * (i - 1));
+		m_minerTxMerkleTreeBranch.reserve(proof_max_size);
 
         Buffer ints(cnt * kHashSize);
-        memcpy(ints.data(), h, (cnt * 2 - count) * kHashSize);
 
-        for (i = cnt * 2 - count, j = cnt * 2 - count; j < cnt; i += 2, ++j) {
-            if (i == 0) {
-                m_minerTxMerkleTreeBranch.insert(m_minerTxMerkleTreeBranch.end(), h + kHashSize, h + kHashSize * 2);
-            }
-            keccak(h + i * kHashSize, kHashSize * 2, ints.data() + j * kHashSize, kHashSize);
-        }
+		const size_t k = cnt * 2 - count;
+		memcpy(ints.data(), h, k * kHashSize);
 
-        while (cnt > 2) {
-            cnt >>= 1;
-            for (i = 0, j = 0; j < cnt; i += 2, ++j) {
-                if (i == 0) {
-                    m_minerTxMerkleTreeBranch.insert(m_minerTxMerkleTreeBranch.end(), ints.data() + kHashSize, ints.data() + kHashSize * 2);
-                }
-                keccak(ints.data() + i * kHashSize, kHashSize * 2, ints.data() + j * kHashSize, kHashSize);
-            }
-        }
+		for (size_t i = k, j = k; j < cnt; i += 2, ++j) {
+			keccak(h + i * kHashSize, kHashSize * 2, ints.data() + j * kHashSize, kHashSize);
 
-        m_minerTxMerkleTreeBranch.insert(m_minerTxMerkleTreeBranch.end(), ints.data() + kHashSize, ints.data() + kHashSize * 2);
-        keccak(ints.data(), kHashSize * 2, m_rootHash, kHashSize);
-    }
+			if (memcmp(h + i * kHashSize, h2, kHashSize) == 0) {
+                m_minerTxMerkleTreeBranch.insert(m_minerTxMerkleTreeBranch.end(), h + kHashSize * (i + 1), h + kHashSize * (i + 2));
+                memcpy(h2, ints.data() + j * kHashSize, kHashSize);
+			}
+			else if (memcmp(h + (i + 1) * kHashSize, h2, kHashSize) == 0) {
+                m_minerTxMerkleTreeBranch.insert(m_minerTxMerkleTreeBranch.end(), h + kHashSize * i, h + kHashSize * (i + 1));
+                memcpy(h2, ints.data() + j * kHashSize, kHashSize);
+				m_minerTxMerkleTreePath = 1;
+			}
+		}
+
+		while (cnt >= 2) {
+			cnt >>= 1;
+			for (size_t i = 0, j = 0; j < cnt; i += 2, ++j) {
+                uint8_t tmp[kHashSize];
+				keccak(ints.data() + i * kHashSize, kHashSize * 2, tmp, kHashSize);
+
+                if (memcmp(ints.data() + i * kHashSize, h2, kHashSize) == 0) {
+                    m_minerTxMerkleTreeBranch.insert(m_minerTxMerkleTreeBranch.end(), ints.data() + kHashSize * (i + 1), ints.data() + kHashSize * (i + 2));
+					memcpy(h2, tmp, kHashSize);
+					m_minerTxMerkleTreePath <<= 1;
+				}
+                else if (memcmp(ints.data() + (i + 1) * kHashSize, h2, kHashSize) == 0) {
+                    m_minerTxMerkleTreeBranch.insert(m_minerTxMerkleTreeBranch.end(), ints.data() + kHashSize * i, ints.data() + kHashSize * (i + 1));
+					memcpy(h2, tmp, kHashSize);
+					m_minerTxMerkleTreePath = (m_minerTxMerkleTreePath << 1) | 1;
+				}
+
+				memcpy(ints.data() + j * kHashSize, tmp, kHashSize);
+			}
+		}
+
+		memcpy(m_rootHash, ints.data(), kHashSize);
+	}
 }
 
 
@@ -241,8 +270,13 @@ bool xmrig::BlockTemplate::parse(bool hashes)
     ar(m_amount);
     ar(m_outputType);
 
-    // output type must be txout_to_key (2) or txout_to_tagged_key (3)
-    if ((m_outputType != 2) && (m_outputType != 3)) {
+    const bool is_fcmp_pp = (m_coin == Coin::MONERO) && (m_version.first >= 17);
+
+    // output type must be txout_to_key (2) or txout_to_tagged_key (3) for versions < 17, and txout_to_carrot_v1 (0) for version FCMP++
+    if (is_fcmp_pp && (m_outputType == 0)) {
+        // all good
+    }
+    else if ((m_outputType != 2) && (m_outputType != 3)) {
         return false;
     }
 
@@ -250,6 +284,11 @@ bool xmrig::BlockTemplate::parse(bool hashes)
 
     ar(m_ephPublicKey, kKeySize);
 
+    if (is_fcmp_pp) {
+        ar(m_carrotViewTag);
+        ar(m_janusAnchor);
+    }
+
     if (m_coin == Coin::ZEPHYR) {
         if (m_outputType != 2) {
             return false;
@@ -365,16 +404,42 @@ bool xmrig::BlockTemplate::parse(bool hashes)
     ar(m_numHashes);
 
     if (hashes) {
-        m_hashes.resize((m_numHashes + 1) * kHashSize);
-        calculateMinerTxHash(blob(MINER_TX_PREFIX_OFFSET), blob(MINER_TX_PREFIX_END_OFFSET), m_hashes.data());
+        // FCMP++ layout:
+        //
+        // index 0  fcmp_pp_n_tree_layers + 31 zero bytes
+        // index 1  fcmp_pp_tree_root
+        // index 2  coinbase transaction hash
+        // index 3+ other transaction hashes
+        //
+        // pre-FCMP++ layout:
+        //
+        // index 0  coinbase transaction hash
+        // index 1+ other transaction hashes
+        //
+        const uint32_t coinbase_tx_index = is_fcmp_pp ? 2 : 0;
+
+        m_hashes.clear();
+        m_hashes.resize((coinbase_tx_index + m_numHashes + 1) * kHashSize);
+
+        uint8_t* data = m_hashes.data() + coinbase_tx_index * kHashSize;
+
+        calculateMinerTxHash(blob(MINER_TX_PREFIX_OFFSET), blob(MINER_TX_PREFIX_END_OFFSET), data);
 
         for (uint64_t i = 1; i <= m_numHashes; ++i) {
             Span h;
             ar(h, kHashSize);
-            memcpy(m_hashes.data() + i * kHashSize, h.data(), kHashSize);
+            memcpy(data + i * kHashSize, h.data(), kHashSize);
         }
 
-        calculateMerkleTreeHash();
+        if (is_fcmp_pp) {
+            ar(m_FCMPTreeLayers);
+            ar(m_FCMPTreeRoot);
+
+            m_hashes[0] = m_FCMPTreeLayers;
+            memcpy(m_hashes.data() + kHashSize, m_FCMPTreeRoot, kHashSize);
+        }
+
+        calculateMerkleTreeHash(coinbase_tx_index);
     }
 
     return true;

src/base/tools/cryptonote/BlockTemplate.h

@@ -93,6 +93,7 @@ public:
     inline uint64_t numHashes() const                       { return m_numHashes; }
     inline const Buffer &hashes() const                     { return m_hashes; }
     inline const Buffer &minerTxMerkleTreeBranch() const    { return m_minerTxMerkleTreeBranch; }
+    inline uint32_t minerTxMerkleTreePath() const           { return m_minerTxMerkleTreePath; }
     inline const uint8_t *rootHash() const                  { return m_rootHash; }
 
     inline Buffer generateHashingBlob() const
@@ -104,13 +105,13 @@ public:
     }
 
     static void calculateMinerTxHash(const uint8_t *prefix_begin, const uint8_t *prefix_end, uint8_t *hash);
-    static void calculateRootHash(const uint8_t *prefix_begin, const uint8_t *prefix_end, const Buffer &miner_tx_merkle_tree_branch, uint8_t *root_hash);
+    static void calculateRootHash(const uint8_t *prefix_begin, const uint8_t *prefix_end, const Buffer &miner_tx_merkle_tree_branch, uint32_t miner_tx_merkle_tree_path, uint8_t *root_hash);
 
     bool parse(const Buffer &blocktemplate, const Coin &coin, bool hashes = kCalcHashes);
     bool parse(const char *blocktemplate, size_t size, const Coin &coin, bool hashes);
     bool parse(const rapidjson::Value &blocktemplate, const Coin &coin, bool hashes = kCalcHashes);
     bool parse(const String &blocktemplate, const Coin &coin, bool hashes = kCalcHashes);
-    void calculateMerkleTreeHash();
+    void calculateMerkleTreeHash(uint32_t index);
     void generateHashingBlob(Buffer &out) const;
 
 private:
@@ -147,7 +148,12 @@ private:
     uint64_t m_numHashes    = 0;
     Buffer m_hashes;
     Buffer m_minerTxMerkleTreeBranch;
+    uint32_t m_minerTxMerkleTreePath = 0;
     uint8_t m_rootHash[kHashSize]{};
+    uint8_t m_carrotViewTag[3]{};
+    uint8_t m_janusAnchor[16]{};
+    uint8_t m_FCMPTreeLayers = 0;
+    uint8_t m_FCMPTreeRoot[kHashSize]{};
 };
 
 

src/base/tools/cryptonote/umul128.h

@@ -23,15 +23,22 @@
 
 #pragma once
 
-
 #include <cstdint>
 
-#ifdef XMRIG_64_BIT
-#   ifdef _MSC_VER
+#if defined(XMRIG_64_BIT)
+#   if defined(_MSC_VER)
 #       include <intrin.h>
-#       pragma intrinsic(_umul128)
-#       define __umul128 _umul128
-#   elif defined __GNUC__
+#       if defined(XMRIG_ARM)
+            #pragma intrinsic(__umulh)
+            static inline uint64_t __umul128(uint64_t a, uint64_t b, uint64_t *high) {
+                *high = __umulh(a, b);
+                return a * b;
+            }
+#       else
+#           pragma intrinsic(_umul128)
+#           define __umul128 _umul128
+#       endif
+#   elif defined(__GNUC__)
         static inline uint64_t _umul128(uint64_t a, uint64_t b, uint64_t* hi)
         {
             unsigned __int128 r = (unsigned __int128) a * (unsigned __int128) b;

src/config.json

@@ -93,7 +93,7 @@
         "dhparam": null
     },
     "dns": {
-        "ipv6": false,
+        "ip_version": 0,
         "ttl": 30
     },
     "user-agent": null,

src/core/Miner.cpp

@@ -59,6 +59,7 @@
 #   include "crypto/rx/Profiler.h"
 #   include "crypto/rx/Rx.h"
 #   include "crypto/rx/RxConfig.h"
+#   include "crypto/rx/RxAlgo.h"
 #endif
 
 
@@ -556,11 +557,12 @@ void xmrig::Miner::setJob(const Job &job, bool donate)
     }
 
 #   ifdef XMRIG_ALGO_RANDOMX
-    if (job.algorithm().family() == Algorithm::RANDOM_X && !Rx::isReady(job)) {
+    if (job.algorithm().family() == Algorithm::RANDOM_X) {
         if (d_ptr->algorithm != job.algorithm()) {
             stop();
+            RxAlgo::apply(job.algorithm());
         }
-        else {
+        else if (!Rx::isReady(job)) {
             Nonce::pause(true);
             Nonce::touch();
         }
@@ -572,6 +574,7 @@ void xmrig::Miner::setJob(const Job &job, bool donate)
     mutex.lock();
 
     const uint8_t index = donate ? 1 : 0;
+    const bool same_job_index = d_ptr->job.index() == index;
 
     d_ptr->reset = !(d_ptr->job.index() == 1 && index == 0 && d_ptr->userJobId == job.id());
 
@@ -591,7 +594,8 @@ void xmrig::Miner::setJob(const Job &job, bool donate)
     const bool ready = d_ptr->initRX();
 
     // Always reset nonce on RandomX dataset change
-    if (!ready) {
+    // Except for switching to/from donation
+    if (!ready && same_job_index) {
         d_ptr->reset = true;
     }
 #   else

src/core/config/Config_platform.h

@@ -1,24 +1,11 @@
 /* XMRig
- * Copyright (c) 2018-2021 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2026 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2026 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
-#ifndef XMRIG_CONFIG_PLATFORM_H
-#define XMRIG_CONFIG_PLATFORM_H
-
+#pragma once
 
 #ifdef _MSC_VER
 #   include "getopt/getopt.h"
@@ -28,13 +15,12 @@
 
 
 #include "base/kernel/interfaces/IConfig.h"
-#include "version.h"
 
 
 namespace xmrig {
 
 
-static const char short_options[] = "a:c:kBp:Px:r:R:s:t:T:o:u:O:v:l:Sx:";
+static const char short_options[] = "a:c:kBp:x:r:R:s:t:T:o:u:O:v:l:S46";
 
 
 static const option options[] = {
@@ -99,7 +85,8 @@ static const option options[] = {
     { "no-title",              0, nullptr, IConfig::NoTitleKey            },
     { "pause-on-battery",      0, nullptr, IConfig::PauseOnBatteryKey     },
     { "pause-on-active",       1, nullptr, IConfig::PauseOnActiveKey      },
-    { "dns-ipv6",              0, nullptr, IConfig::DnsIPv6Key            },
+    { "ipv4",                  0, nullptr, IConfig::DnsIPv4Key            },
+    { "ipv6",                  0, nullptr, IConfig::DnsIPv6Key            },
     { "dns-ttl",               1, nullptr, IConfig::DnsTtlKey             },
     { "spend-secret-key",      1, nullptr, IConfig::SpendSecretKey        },
 #   ifdef XMRIG_FEATURE_BENCHMARK
@@ -169,6 +156,3 @@ static const option options[] = {
 
 
 } // namespace xmrig
-
-
-#endif /* XMRIG_CONFIG_PLATFORM_H */

src/core/config/usage.h

@@ -4,8 +4,8 @@
  * Copyright (c) 2014      Lucas Jones <https://github.com/lucasjones>
  * Copyright (c) 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
  * Copyright (c) 2016      Jay D Dee   <jayddee246@gmail.com>
- * Copyright (c) 2018-2024 SChernykh   <https://github.com/SChernykh>
- * Copyright (c) 2016-2024 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ * Copyright (c) 2018-2025 SChernykh   <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -21,13 +21,10 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef XMRIG_USAGE_H
-#define XMRIG_USAGE_H
-
+#pragma once
 
 #include "version.h"
 
-
 #include <string>
 
 
@@ -59,7 +56,8 @@ static inline const std::string &usage()
     u += "      --tls-fingerprint=HEX     pool TLS certificate fingerprint for strict certificate pinning\n";
 #   endif
 
-    u += "      --dns-ipv6                prefer IPv6 records from DNS responses\n";
+    u += "  -4, --ipv4                    resolve names to IPv4 addresses\n";
+    u += "  -6, --ipv6                    resolve names to IPv6 addresses\n";
     u += "      --dns-ttl=N               N seconds (default: 30) TTL for internal DNS cache\n";
 
 #   ifdef XMRIG_FEATURE_HTTP
@@ -205,6 +203,4 @@ static inline const std::string &usage()
 }
 
 
-} /* namespace xmrig */
-
-#endif /* XMRIG_USAGE_H */
+} // namespace xmrig

src/crypto/cn/CnHash.cpp

@@ -23,7 +23,7 @@
 #include "crypto/common/VirtualMemory.h"
 
 
-#if defined(XMRIG_ARM)
+#if defined(XMRIG_ARM) || defined(XMRIG_RISCV)
 #   include "crypto/cn/CryptoNight_arm.h"
 #else
 #   include "crypto/cn/CryptoNight_x86.h"

src/crypto/cn/CryptoNight.h

@@ -30,7 +30,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#if defined _MSC_VER || defined XMRIG_ARM
+#if defined _MSC_VER || defined XMRIG_ARM || defined XMRIG_RISCV
 #   define ABI_ATTRIBUTE
 #else
 #   define ABI_ATTRIBUTE __attribute__((ms_abi))

src/crypto/cn/CryptoNight_arm.h

@@ -27,6 +27,9 @@
 #ifndef XMRIG_CRYPTONIGHT_ARM_H
 #define XMRIG_CRYPTONIGHT_ARM_H
 
+#ifdef XMRIG_RISCV
+#   include "crypto/cn/sse2rvv.h"
+#endif
 
 #include "base/crypto/keccak.h"
 #include "crypto/cn/CnAlgo.h"

src/crypto/cn/CryptoNight_monero.h

@@ -30,7 +30,7 @@
 #include <math.h>
 
 // VARIANT ALTERATIONS
-#ifndef XMRIG_ARM
+#if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
 #   define VARIANT1_INIT(part) \
     uint64_t tweak1_2_##part = 0; \
     if (BASE == Algorithm::CN_1) { \
@@ -60,7 +60,7 @@
     }
 
 
-#ifndef XMRIG_ARM
+#if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
 #   define VARIANT2_INIT(part) \
     __m128i division_result_xmm_##part = _mm_cvtsi64_si128(static_cast<int64_t>(h##part[12])); \
     __m128i sqrt_result_xmm_##part     = _mm_cvtsi64_si128(static_cast<int64_t>(h##part[13]));

src/crypto/cn/c_jh.c

@@ -235,7 +235,7 @@ static HashReturn Init(hashState *state, int hashbitlen)
       /*initialize the initial hash value of JH*/
       state->hashbitlen = hashbitlen;
 
-      /*load the intital hash value into state*/
+      /*load the initial hash value into state*/
       switch (hashbitlen)
       {
             case 224: memcpy(state->x,JH224_H0,128); break;

src/crypto/cn/skein_port.h

@@ -48,7 +48,7 @@
                                 multiple of size / 8)
 
     ptr_cast(x,size)            casts a pointer to a pointer to a
-                                varaiable of length 'size' bits
+                                variable of length 'size' bits
 */
 
 #define ui_type(size)               uint##size##_t

src/crypto/cn/soft_aes.h

@@ -29,6 +29,8 @@
 
 #if defined(XMRIG_ARM)
 #   include "crypto/cn/sse2neon.h"
+#elif defined(XMRIG_RISCV)
+#   include "crypto/cn/sse2rvv.h"
 #elif defined(__GNUC__)
 #   include <x86intrin.h>
 #else

src/crypto/cn/sse2rvv.h

@@ -0,0 +1,748 @@
+/* XMRig
+ * Copyright (c) 2025      Slayingripper <https://github.com/Slayingripper>
+ * Copyright (c) 2018-2025 SChernykh     <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig         <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * SSE to RISC-V Vector (RVV) optimized compatibility header
+ * Provides both scalar fallback and vectorized implementations using RVV intrinsics
+ * 
+ * Based on sse2neon.h concepts, adapted for RISC-V architecture with RVV extensions
+ * Original sse2neon.h: https://github.com/DLTcollab/sse2neon
+ */
+
+#ifndef XMRIG_SSE2RVV_OPTIMIZED_H
+#define XMRIG_SSE2RVV_OPTIMIZED_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <string.h>
+
+/* Check if RVV is available */
+#if defined(__riscv_vector)
+#include <riscv_vector.h>
+#define USE_RVV_INTRINSICS 1
+#else
+#define USE_RVV_INTRINSICS 0
+#endif
+
+/* 128-bit vector type */
+typedef union {
+    uint8_t  u8[16];
+    uint16_t u16[8];
+    uint32_t u32[4];
+    uint64_t u64[2];
+    int8_t   i8[16];
+    int16_t  i16[8];
+    int32_t  i32[4];
+    int64_t  i64[2];
+} __m128i_union;
+
+typedef __m128i_union __m128i;
+
+/* Set operations */
+static inline __m128i _mm_set_epi32(int e3, int e2, int e1, int e0)
+{
+    __m128i result;
+    result.i32[0] = e0;
+    result.i32[1] = e1;
+    result.i32[2] = e2;
+    result.i32[3] = e3;
+    return result;
+}
+
+static inline __m128i _mm_set_epi64x(int64_t e1, int64_t e0)
+{
+    __m128i result;
+    result.i64[0] = e0;
+    result.i64[1] = e1;
+    return result;
+}
+
+static inline __m128i _mm_setzero_si128(void)
+{
+    __m128i result;
+    memset(&result, 0, sizeof(result));
+    return result;
+}
+
+/* Extract/insert operations */
+static inline int _mm_cvtsi128_si32(__m128i a)
+{
+    return a.i32[0];
+}
+
+static inline int64_t _mm_cvtsi128_si64(__m128i a)
+{
+    return a.i64[0];
+}
+
+static inline __m128i _mm_cvtsi32_si128(int a)
+{
+    __m128i result = _mm_setzero_si128();
+    result.i32[0] = a;
+    return result;
+}
+
+static inline __m128i _mm_cvtsi64_si128(int64_t a)
+{
+    __m128i result = _mm_setzero_si128();
+    result.i64[0] = a;
+    return result;
+}
+
+/* Shuffle operations */
+static inline __m128i _mm_shuffle_epi32(__m128i a, int imm8)
+{
+    __m128i result;
+    result.u32[0] = a.u32[(imm8 >> 0) & 0x3];
+    result.u32[1] = a.u32[(imm8 >> 2) & 0x3];
+    result.u32[2] = a.u32[(imm8 >> 4) & 0x3];
+    result.u32[3] = a.u32[(imm8 >> 6) & 0x3];
+    return result;
+}
+
+/* Logical operations - optimized with RVV when available */
+static inline __m128i _mm_xor_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+    vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+    vuint64m1_t vr = __riscv_vxor_vv_u64m1(va, vb, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = a.u64[0] ^ b.u64[0];
+    result.u64[1] = a.u64[1] ^ b.u64[1];
+    return result;
+#endif
+}
+
+static inline __m128i _mm_or_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+    vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+    vuint64m1_t vr = __riscv_vor_vv_u64m1(va, vb, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = a.u64[0] | b.u64[0];
+    result.u64[1] = a.u64[1] | b.u64[1];
+    return result;
+#endif
+}
+
+static inline __m128i _mm_and_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+    vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+    vuint64m1_t vr = __riscv_vand_vv_u64m1(va, vb, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = a.u64[0] & b.u64[0];
+    result.u64[1] = a.u64[1] & b.u64[1];
+    return result;
+#endif
+}
+
+static inline __m128i _mm_andnot_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+    vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+    vuint64m1_t vnot_a = __riscv_vnot_v_u64m1(va, vl);
+    vuint64m1_t vr = __riscv_vand_vv_u64m1(vnot_a, vb, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = (~a.u64[0]) & b.u64[0];
+    result.u64[1] = (~a.u64[1]) & b.u64[1];
+    return result;
+#endif
+}
+
+/* Shift operations */
+static inline __m128i _mm_slli_si128(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result = _mm_setzero_si128();
+    int count = imm8 & 0xFF;
+    if (count > 15) return result;
+    
+    size_t vl = __riscv_vsetvl_e8m1(16);
+    vuint8m1_t va = __riscv_vle8_v_u8m1(a.u8, vl);
+    vuint8m1_t vr = __riscv_vslideup_vx_u8m1(__riscv_vmv_v_x_u8m1(0, vl), va, count, vl);
+    __riscv_vse8_v_u8m1(result.u8, vr, vl);
+    return result;
+#else
+    __m128i result = _mm_setzero_si128();
+    int count = imm8 & 0xFF;
+    if (count > 15) return result;
+    
+    for (int i = 0; i < 16 - count; i++) {
+        result.u8[i + count] = a.u8[i];
+    }
+    return result;
+#endif
+}
+
+static inline __m128i _mm_srli_si128(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result = _mm_setzero_si128();
+    int count = imm8 & 0xFF;
+    if (count > 15) return result;
+    
+    size_t vl = __riscv_vsetvl_e8m1(16);
+    vuint8m1_t va = __riscv_vle8_v_u8m1(a.u8, vl);
+    vuint8m1_t vr = __riscv_vslidedown_vx_u8m1(va, count, vl);
+    __riscv_vse8_v_u8m1(result.u8, vr, vl);
+    return result;
+#else
+    __m128i result = _mm_setzero_si128();
+    int count = imm8 & 0xFF;
+    if (count > 15) return result;
+    
+    for (int i = count; i < 16; i++) {
+        result.u8[i - count] = a.u8[i];
+    }
+    return result;
+#endif
+}
+
+static inline __m128i _mm_slli_epi64(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    if (imm8 > 63) {
+        result.u64[0] = 0;
+        result.u64[1] = 0;
+    } else {
+        size_t vl = __riscv_vsetvl_e64m1(2);
+        vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+        vuint64m1_t vr = __riscv_vsll_vx_u64m1(va, imm8, vl);
+        __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    }
+    return result;
+#else
+    __m128i result;
+    if (imm8 > 63) {
+        result.u64[0] = 0;
+        result.u64[1] = 0;
+    } else {
+        result.u64[0] = a.u64[0] << imm8;
+        result.u64[1] = a.u64[1] << imm8;
+    }
+    return result;
+#endif
+}
+
+static inline __m128i _mm_srli_epi64(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    if (imm8 > 63) {
+        result.u64[0] = 0;
+        result.u64[1] = 0;
+    } else {
+        size_t vl = __riscv_vsetvl_e64m1(2);
+        vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+        vuint64m1_t vr = __riscv_vsrl_vx_u64m1(va, imm8, vl);
+        __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    }
+    return result;
+#else
+    __m128i result;
+    if (imm8 > 63) {
+        result.u64[0] = 0;
+        result.u64[1] = 0;
+    } else {
+        result.u64[0] = a.u64[0] >> imm8;
+        result.u64[1] = a.u64[1] >> imm8;
+    }
+    return result;
+#endif
+}
+
+/* Load/store operations - optimized with RVV */
+static inline __m128i _mm_load_si128(const __m128i* p)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t v = __riscv_vle64_v_u64m1((const uint64_t*)p, vl);
+    __riscv_vse64_v_u64m1(result.u64, v, vl);
+    return result;
+#else
+    __m128i result;
+    memcpy(&result, p, sizeof(__m128i));
+    return result;
+#endif
+}
+
+static inline __m128i _mm_loadu_si128(const __m128i* p)
+{
+    __m128i result;
+    memcpy(&result, p, sizeof(__m128i));
+    return result;
+}
+
+static inline void _mm_store_si128(__m128i* p, __m128i a)
+{
+#if USE_RVV_INTRINSICS
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t v = __riscv_vle64_v_u64m1(a.u64, vl);
+    __riscv_vse64_v_u64m1((uint64_t*)p, v, vl);
+#else
+    memcpy(p, &a, sizeof(__m128i));
+#endif
+}
+
+static inline void _mm_storeu_si128(__m128i* p, __m128i a)
+{
+    memcpy(p, &a, sizeof(__m128i));
+}
+
+/* Arithmetic operations - optimized with RVV */
+static inline __m128i _mm_add_epi64(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+    vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+    vuint64m1_t vr = __riscv_vadd_vv_u64m1(va, vb, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = a.u64[0] + b.u64[0];
+    result.u64[1] = a.u64[1] + b.u64[1];
+    return result;
+#endif
+}
+
+static inline __m128i _mm_add_epi32(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e32m1(4);
+    vuint32m1_t va = __riscv_vle32_v_u32m1(a.u32, vl);
+    vuint32m1_t vb = __riscv_vle32_v_u32m1(b.u32, vl);
+    vuint32m1_t vr = __riscv_vadd_vv_u32m1(va, vb, vl);
+    __riscv_vse32_v_u32m1(result.u32, vr, vl);
+    return result;
+#else
+    __m128i result;
+    for (int i = 0; i < 4; i++) {
+        result.i32[i] = a.i32[i] + b.i32[i];
+    }
+    return result;
+#endif
+}
+
+static inline __m128i _mm_sub_epi64(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+    vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+    vuint64m1_t vr = __riscv_vsub_vv_u64m1(va, vb, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = a.u64[0] - b.u64[0];
+    result.u64[1] = a.u64[1] - b.u64[1];
+    return result;
+#endif
+}
+
+static inline __m128i _mm_mul_epu32(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va_lo = __riscv_vzext_vf2_u64m1(__riscv_vle32_v_u32mf2(&a.u32[0], 2), vl);
+    vuint64m1_t vb_lo = __riscv_vzext_vf2_u64m1(__riscv_vle32_v_u32mf2(&b.u32[0], 2), vl);
+    vuint64m1_t vr = __riscv_vmul_vv_u64m1(va_lo, vb_lo, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = (uint64_t)a.u32[0] * (uint64_t)b.u32[0];
+    result.u64[1] = (uint64_t)a.u32[2] * (uint64_t)b.u32[2];
+    return result;
+#endif
+}
+
+/* Unpack operations */
+static inline __m128i _mm_unpacklo_epi64(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = a.u64[0];
+    result.u64[1] = b.u64[0];
+    return result;
+}
+
+static inline __m128i _mm_unpackhi_epi64(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = a.u64[1];
+    result.u64[1] = b.u64[1];
+    return result;
+}
+
+/* Pause instruction for spin-wait loops */
+static inline void _mm_pause(void)
+{
+    /* RISC-V pause hint if available (requires Zihintpause extension) */
+#if defined(__riscv_zihintpause)
+    __asm__ __volatile__("pause");
+#else
+    __asm__ __volatile__("nop");
+#endif
+}
+
+/* Memory fence - optimized for RISC-V */
+static inline void _mm_mfence(void)
+{
+    __asm__ __volatile__("fence rw,rw" ::: "memory");
+}
+
+static inline void _mm_lfence(void)
+{
+    __asm__ __volatile__("fence r,r" ::: "memory");
+}
+
+static inline void _mm_sfence(void)
+{
+    __asm__ __volatile__("fence w,w" ::: "memory");
+}
+
+/* Comparison operations */
+static inline __m128i _mm_cmpeq_epi32(__m128i a, __m128i b)
+{
+    __m128i result;
+    for (int i = 0; i < 4; i++) {
+        result.u32[i] = (a.u32[i] == b.u32[i]) ? 0xFFFFFFFF : 0;
+    }
+    return result;
+}
+
+static inline __m128i _mm_cmpeq_epi64(__m128i a, __m128i b)
+{
+    __m128i result;
+    for (int i = 0; i < 2; i++) {
+        result.u64[i] = (a.u64[i] == b.u64[i]) ? 0xFFFFFFFFFFFFFFFFULL : 0;
+    }
+    return result;
+}
+
+/* Additional shift operations */
+static inline __m128i _mm_slli_epi32(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    if (imm8 > 31) {
+        memset(&result, 0, sizeof(result));
+    } else {
+        size_t vl = __riscv_vsetvl_e32m1(4);
+        vuint32m1_t va = __riscv_vle32_v_u32m1(a.u32, vl);
+        vuint32m1_t vr = __riscv_vsll_vx_u32m1(va, imm8, vl);
+        __riscv_vse32_v_u32m1(result.u32, vr, vl);
+    }
+    return result;
+#else
+    __m128i result;
+    if (imm8 > 31) {
+        for (int i = 0; i < 4; i++) result.u32[i] = 0;
+    } else {
+        for (int i = 0; i < 4; i++) {
+            result.u32[i] = a.u32[i] << imm8;
+        }
+    }
+    return result;
+#endif
+}
+
+static inline __m128i _mm_srli_epi32(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    if (imm8 > 31) {
+        memset(&result, 0, sizeof(result));
+    } else {
+        size_t vl = __riscv_vsetvl_e32m1(4);
+        vuint32m1_t va = __riscv_vle32_v_u32m1(a.u32, vl);
+        vuint32m1_t vr = __riscv_vsrl_vx_u32m1(va, imm8, vl);
+        __riscv_vse32_v_u32m1(result.u32, vr, vl);
+    }
+    return result;
+#else
+    __m128i result;
+    if (imm8 > 31) {
+        for (int i = 0; i < 4; i++) result.u32[i] = 0;
+    } else {
+        for (int i = 0; i < 4; i++) {
+            result.u32[i] = a.u32[i] >> imm8;
+        }
+    }
+    return result;
+#endif
+}
+
+/* 64-bit integer operations */
+static inline __m128i _mm_set1_epi64x(int64_t a)
+{
+    __m128i result;
+    result.i64[0] = a;
+    result.i64[1] = a;
+    return result;
+}
+
+/* Float type for compatibility */
+typedef __m128i __m128;
+
+/* Float operations - simplified scalar implementations */
+static inline __m128 _mm_set1_ps(float a)
+{
+    __m128 result;
+    uint32_t val;
+    memcpy(&val, &a, sizeof(float));
+    for (int i = 0; i < 4; i++) {
+        result.u32[i] = val;
+    }
+    return result;
+}
+
+static inline __m128 _mm_setzero_ps(void)
+{
+    __m128 result;
+    memset(&result, 0, sizeof(result));
+    return result;
+}
+
+static inline __m128 _mm_add_ps(__m128 a, __m128 b)
+{
+    __m128 result;
+    float fa[4], fb[4], fr[4];
+    memcpy(fa, &a, sizeof(__m128));
+    memcpy(fb, &b, sizeof(__m128));
+    for (int i = 0; i < 4; i++) {
+        fr[i] = fa[i] + fb[i];
+    }
+    memcpy(&result, fr, sizeof(__m128));
+    return result;
+}
+
+static inline __m128 _mm_mul_ps(__m128 a, __m128 b)
+{
+    __m128 result;
+    float fa[4], fb[4], fr[4];
+    memcpy(fa, &a, sizeof(__m128));
+    memcpy(fb, &b, sizeof(__m128));
+    for (int i = 0; i < 4; i++) {
+        fr[i] = fa[i] * fb[i];
+    }
+    memcpy(&result, fr, sizeof(__m128));
+    return result;
+}
+
+static inline __m128 _mm_and_ps(__m128 a, __m128 b)
+{
+    __m128 result;
+    result.u64[0] = a.u64[0] & b.u64[0];
+    result.u64[1] = a.u64[1] & b.u64[1];
+    return result;
+}
+
+static inline __m128 _mm_or_ps(__m128 a, __m128 b)
+{
+    __m128 result;
+    result.u64[0] = a.u64[0] | b.u64[0];
+    result.u64[1] = a.u64[1] | b.u64[1];
+    return result;
+}
+
+static inline __m128 _mm_cvtepi32_ps(__m128i a)
+{
+    __m128 result;
+    float fr[4];
+    for (int i = 0; i < 4; i++) {
+        fr[i] = (float)a.i32[i];
+    }
+    memcpy(&result, fr, sizeof(__m128));
+    return result;
+}
+
+static inline __m128i _mm_cvttps_epi32(__m128 a)
+{
+    __m128i result;
+    float fa[4];
+    memcpy(fa, &a, sizeof(__m128));
+    for (int i = 0; i < 4; i++) {
+        result.i32[i] = (int32_t)fa[i];
+    }
+    return result;
+}
+
+/* Casting operations */
+static inline __m128 _mm_castsi128_ps(__m128i a)
+{
+    __m128 result;
+    memcpy(&result, &a, sizeof(__m128));
+    return result;
+}
+
+static inline __m128i _mm_castps_si128(__m128 a)
+{
+    __m128i result;
+    memcpy(&result, &a, sizeof(__m128));
+    return result;
+}
+
+/* Additional set operations */
+static inline __m128i _mm_set1_epi32(int a)
+{
+    __m128i result;
+    for (int i = 0; i < 4; i++) {
+        result.i32[i] = a;
+    }
+    return result;
+}
+
+/* AES instructions - placeholders for soft_aes compatibility */
+static inline __m128i _mm_aesenc_si128(__m128i a, __m128i roundkey)
+{
+    return _mm_xor_si128(a, roundkey);
+}
+
+static inline __m128i _mm_aeskeygenassist_si128(__m128i a, const int rcon)
+{
+    return a;
+}
+
+/* Rotate right operation for soft_aes.h */
+static inline uint32_t _rotr(uint32_t value, unsigned int count)
+{
+    const unsigned int mask = 31;
+    count &= mask;
+    return (value >> count) | (value << ((-count) & mask));
+}
+
+/* ARM NEON compatibility types and intrinsics for RISC-V */
+typedef __m128i_union uint64x2_t;
+typedef __m128i_union uint8x16_t;
+typedef __m128i_union int64x2_t;
+typedef __m128i_union int32x4_t;
+
+static inline uint64x2_t vld1q_u64(const uint64_t *ptr)
+{
+    uint64x2_t result;
+    result.u64[0] = ptr[0];
+    result.u64[1] = ptr[1];
+    return result;
+}
+
+static inline int64x2_t vld1q_s64(const int64_t *ptr)
+{
+    int64x2_t result;
+    result.i64[0] = ptr[0];
+    result.i64[1] = ptr[1];
+    return result;
+}
+
+static inline void vst1q_u64(uint64_t *ptr, uint64x2_t val)
+{
+    ptr[0] = val.u64[0];
+    ptr[1] = val.u64[1];
+}
+
+static inline uint64x2_t veorq_u64(uint64x2_t a, uint64x2_t b)
+{
+    return _mm_xor_si128(a, b);
+}
+
+static inline uint64x2_t vaddq_u64(uint64x2_t a, uint64x2_t b)
+{
+    return _mm_add_epi64(a, b);
+}
+
+static inline uint64x2_t vreinterpretq_u64_u8(uint8x16_t a)
+{
+    uint64x2_t result;
+    memcpy(&result, &a, sizeof(uint64x2_t));
+    return result;
+}
+
+static inline uint64_t vgetq_lane_u64(uint64x2_t v, int lane)
+{
+    return v.u64[lane];
+}
+
+static inline int64_t vgetq_lane_s64(int64x2_t v, int lane)
+{
+    return v.i64[lane];
+}
+
+static inline int32_t vgetq_lane_s32(int32x4_t v, int lane)
+{
+    return v.i32[lane];
+}
+
+typedef struct { uint64_t val[1]; } uint64x1_t;
+
+static inline uint64x1_t vcreate_u64(uint64_t a)
+{
+    uint64x1_t result;
+    result.val[0] = a;
+    return result;
+}
+
+static inline uint64x2_t vcombine_u64(uint64x1_t low, uint64x1_t high)
+{
+    uint64x2_t result;
+    result.u64[0] = low.val[0];
+    result.u64[1] = high.val[0];
+    return result;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* XMRIG_SSE2RVV_OPTIMIZED_H */

src/crypto/cn/sse2rvv_optimized.h

@@ -0,0 +1,748 @@
+/* XMRig
+ * Copyright (c) 2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * SSE to RISC-V Vector (RVV) optimized compatibility header
+ * Provides both scalar fallback and vectorized implementations using RVV intrinsics
+ */
+
+#ifndef XMRIG_SSE2RVV_OPTIMIZED_H
+#define XMRIG_SSE2RVV_OPTIMIZED_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <string.h>
+
+/* Check if RVV is available */
+#if defined(__riscv_vector)
+#include <riscv_vector.h>
+#define USE_RVV_INTRINSICS 1
+#else
+#define USE_RVV_INTRINSICS 0
+#endif
+
+/* 128-bit vector type */
+typedef union {
+    uint8_t  u8[16];
+    uint16_t u16[8];
+    uint32_t u32[4];
+    uint64_t u64[2];
+    int8_t   i8[16];
+    int16_t  i16[8];
+    int32_t  i32[4];
+    int64_t  i64[2];
+#if USE_RVV_INTRINSICS
+    vuint64m1_t rvv_u64;
+    vuint32m1_t rvv_u32;
+    vuint8m1_t  rvv_u8;
+#endif
+} __m128i_union;
+
+typedef __m128i_union __m128i;
+
+/* Set operations */
+static inline __m128i _mm_set_epi32(int e3, int e2, int e1, int e0)
+{
+    __m128i result;
+    result.i32[0] = e0;
+    result.i32[1] = e1;
+    result.i32[2] = e2;
+    result.i32[3] = e3;
+    return result;
+}
+
+static inline __m128i _mm_set_epi64x(int64_t e1, int64_t e0)
+{
+    __m128i result;
+    result.i64[0] = e0;
+    result.i64[1] = e1;
+    return result;
+}
+
+static inline __m128i _mm_setzero_si128(void)
+{
+    __m128i result;
+    memset(&result, 0, sizeof(result));
+    return result;
+}
+
+/* Extract/insert operations */
+static inline int _mm_cvtsi128_si32(__m128i a)
+{
+    return a.i32[0];
+}
+
+static inline int64_t _mm_cvtsi128_si64(__m128i a)
+{
+    return a.i64[0];
+}
+
+static inline __m128i _mm_cvtsi32_si128(int a)
+{
+    __m128i result = _mm_setzero_si128();
+    result.i32[0] = a;
+    return result;
+}
+
+static inline __m128i _mm_cvtsi64_si128(int64_t a)
+{
+    __m128i result = _mm_setzero_si128();
+    result.i64[0] = a;
+    return result;
+}
+
+/* Shuffle operations */
+static inline __m128i _mm_shuffle_epi32(__m128i a, int imm8)
+{
+    __m128i result;
+    result.u32[0] = a.u32[(imm8 >> 0) & 0x3];
+    result.u32[1] = a.u32[(imm8 >> 2) & 0x3];
+    result.u32[2] = a.u32[(imm8 >> 4) & 0x3];
+    result.u32[3] = a.u32[(imm8 >> 6) & 0x3];
+    return result;
+}
+
+/* Logical operations - optimized with RVV when available */
+static inline __m128i _mm_xor_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+    vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+    vuint64m1_t vr = __riscv_vxor_vv_u64m1(va, vb, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = a.u64[0] ^ b.u64[0];
+    result.u64[1] = a.u64[1] ^ b.u64[1];
+    return result;
+#endif
+}
+
+static inline __m128i _mm_or_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+    vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+    vuint64m1_t vr = __riscv_vor_vv_u64m1(va, vb, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = a.u64[0] | b.u64[0];
+    result.u64[1] = a.u64[1] | b.u64[1];
+    return result;
+#endif
+}
+
+static inline __m128i _mm_and_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+    vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+    vuint64m1_t vr = __riscv_vand_vv_u64m1(va, vb, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = a.u64[0] & b.u64[0];
+    result.u64[1] = a.u64[1] & b.u64[1];
+    return result;
+#endif
+}
+
+static inline __m128i _mm_andnot_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+    vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+    vuint64m1_t vnot_a = __riscv_vnot_v_u64m1(va, vl);
+    vuint64m1_t vr = __riscv_vand_vv_u64m1(vnot_a, vb, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = (~a.u64[0]) & b.u64[0];
+    result.u64[1] = (~a.u64[1]) & b.u64[1];
+    return result;
+#endif
+}
+
+/* Shift operations */
+static inline __m128i _mm_slli_si128(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result = _mm_setzero_si128();
+    int count = imm8 & 0xFF;
+    if (count > 15) return result;
+    
+    size_t vl = __riscv_vsetvl_e8m1(16);
+    vuint8m1_t va = __riscv_vle8_v_u8m1(a.u8, vl);
+    vuint8m1_t vr = __riscv_vslideup_vx_u8m1(__riscv_vmv_v_x_u8m1(0, vl), va, count, vl);
+    __riscv_vse8_v_u8m1(result.u8, vr, vl);
+    return result;
+#else
+    __m128i result = _mm_setzero_si128();
+    int count = imm8 & 0xFF;
+    if (count > 15) return result;
+    
+    for (int i = 0; i < 16 - count; i++) {
+        result.u8[i + count] = a.u8[i];
+    }
+    return result;
+#endif
+}
+
+static inline __m128i _mm_srli_si128(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result = _mm_setzero_si128();
+    int count = imm8 & 0xFF;
+    if (count > 15) return result;
+    
+    size_t vl = __riscv_vsetvl_e8m1(16);
+    vuint8m1_t va = __riscv_vle8_v_u8m1(a.u8, vl);
+    vuint8m1_t vr = __riscv_vslidedown_vx_u8m1(va, count, vl);
+    __riscv_vse8_v_u8m1(result.u8, vr, vl);
+    return result;
+#else
+    __m128i result = _mm_setzero_si128();
+    int count = imm8 & 0xFF;
+    if (count > 15) return result;
+    
+    for (int i = count; i < 16; i++) {
+        result.u8[i - count] = a.u8[i];
+    }
+    return result;
+#endif
+}
+
+static inline __m128i _mm_slli_epi64(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    if (imm8 > 63) {
+        result.u64[0] = 0;
+        result.u64[1] = 0;
+    } else {
+        size_t vl = __riscv_vsetvl_e64m1(2);
+        vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+        vuint64m1_t vr = __riscv_vsll_vx_u64m1(va, imm8, vl);
+        __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    }
+    return result;
+#else
+    __m128i result;
+    if (imm8 > 63) {
+        result.u64[0] = 0;
+        result.u64[1] = 0;
+    } else {
+        result.u64[0] = a.u64[0] << imm8;
+        result.u64[1] = a.u64[1] << imm8;
+    }
+    return result;
+#endif
+}
+
+static inline __m128i _mm_srli_epi64(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    if (imm8 > 63) {
+        result.u64[0] = 0;
+        result.u64[1] = 0;
+    } else {
+        size_t vl = __riscv_vsetvl_e64m1(2);
+        vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+        vuint64m1_t vr = __riscv_vsrl_vx_u64m1(va, imm8, vl);
+        __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    }
+    return result;
+#else
+    __m128i result;
+    if (imm8 > 63) {
+        result.u64[0] = 0;
+        result.u64[1] = 0;
+    } else {
+        result.u64[0] = a.u64[0] >> imm8;
+        result.u64[1] = a.u64[1] >> imm8;
+    }
+    return result;
+#endif
+}
+
+/* Load/store operations - optimized with RVV */
+static inline __m128i _mm_load_si128(const __m128i* p)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t v = __riscv_vle64_v_u64m1((const uint64_t*)p, vl);
+    __riscv_vse64_v_u64m1(result.u64, v, vl);
+    return result;
+#else
+    __m128i result;
+    memcpy(&result, p, sizeof(__m128i));
+    return result;
+#endif
+}
+
+static inline __m128i _mm_loadu_si128(const __m128i* p)
+{
+    __m128i result;
+    memcpy(&result, p, sizeof(__m128i));
+    return result;
+}
+
+static inline void _mm_store_si128(__m128i* p, __m128i a)
+{
+#if USE_RVV_INTRINSICS
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t v = __riscv_vle64_v_u64m1(a.u64, vl);
+    __riscv_vse64_v_u64m1((uint64_t*)p, v, vl);
+#else
+    memcpy(p, &a, sizeof(__m128i));
+#endif
+}
+
+static inline void _mm_storeu_si128(__m128i* p, __m128i a)
+{
+    memcpy(p, &a, sizeof(__m128i));
+}
+
+/* Arithmetic operations - optimized with RVV */
+static inline __m128i _mm_add_epi64(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+    vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+    vuint64m1_t vr = __riscv_vadd_vv_u64m1(va, vb, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = a.u64[0] + b.u64[0];
+    result.u64[1] = a.u64[1] + b.u64[1];
+    return result;
+#endif
+}
+
+static inline __m128i _mm_add_epi32(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e32m1(4);
+    vuint32m1_t va = __riscv_vle32_v_u32m1(a.u32, vl);
+    vuint32m1_t vb = __riscv_vle32_v_u32m1(b.u32, vl);
+    vuint32m1_t vr = __riscv_vadd_vv_u32m1(va, vb, vl);
+    __riscv_vse32_v_u32m1(result.u32, vr, vl);
+    return result;
+#else
+    __m128i result;
+    for (int i = 0; i < 4; i++) {
+        result.i32[i] = a.i32[i] + b.i32[i];
+    }
+    return result;
+#endif
+}
+
+static inline __m128i _mm_sub_epi64(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+    vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+    vuint64m1_t vr = __riscv_vsub_vv_u64m1(va, vb, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = a.u64[0] - b.u64[0];
+    result.u64[1] = a.u64[1] - b.u64[1];
+    return result;
+#endif
+}
+
+static inline __m128i _mm_mul_epu32(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    size_t vl = __riscv_vsetvl_e64m1(2);
+    vuint64m1_t va_lo = __riscv_vzext_vf2_u64m1(__riscv_vle32_v_u32mf2(&a.u32[0], 2), vl);
+    vuint64m1_t vb_lo = __riscv_vzext_vf2_u64m1(__riscv_vle32_v_u32mf2(&b.u32[0], 2), vl);
+    vuint64m1_t vr = __riscv_vmul_vv_u64m1(va_lo, vb_lo, vl);
+    __riscv_vse64_v_u64m1(result.u64, vr, vl);
+    return result;
+#else
+    __m128i result;
+    result.u64[0] = (uint64_t)a.u32[0] * (uint64_t)b.u32[0];
+    result.u64[1] = (uint64_t)a.u32[2] * (uint64_t)b.u32[2];
+    return result;
+#endif
+}
+
+/* Unpack operations */
+static inline __m128i _mm_unpacklo_epi64(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = a.u64[0];
+    result.u64[1] = b.u64[0];
+    return result;
+}
+
+static inline __m128i _mm_unpackhi_epi64(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = a.u64[1];
+    result.u64[1] = b.u64[1];
+    return result;
+}
+
+/* Pause instruction for spin-wait loops */
+static inline void _mm_pause(void)
+{
+    /* RISC-V pause hint if available (requires Zihintpause extension) */
+#if defined(__riscv_zihintpause)
+    __asm__ __volatile__("pause");
+#else
+    __asm__ __volatile__("nop");
+#endif
+}
+
+/* Memory fence - optimized for RISC-V */
+static inline void _mm_mfence(void)
+{
+    __asm__ __volatile__("fence rw,rw" ::: "memory");
+}
+
+static inline void _mm_lfence(void)
+{
+    __asm__ __volatile__("fence r,r" ::: "memory");
+}
+
+static inline void _mm_sfence(void)
+{
+    __asm__ __volatile__("fence w,w" ::: "memory");
+}
+
+/* Comparison operations */
+static inline __m128i _mm_cmpeq_epi32(__m128i a, __m128i b)
+{
+    __m128i result;
+    for (int i = 0; i < 4; i++) {
+        result.u32[i] = (a.u32[i] == b.u32[i]) ? 0xFFFFFFFF : 0;
+    }
+    return result;
+}
+
+static inline __m128i _mm_cmpeq_epi64(__m128i a, __m128i b)
+{
+    __m128i result;
+    for (int i = 0; i < 2; i++) {
+        result.u64[i] = (a.u64[i] == b.u64[i]) ? 0xFFFFFFFFFFFFFFFFULL : 0;
+    }
+    return result;
+}
+
+/* Additional shift operations */
+static inline __m128i _mm_slli_epi32(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    if (imm8 > 31) {
+        memset(&result, 0, sizeof(result));
+    } else {
+        size_t vl = __riscv_vsetvl_e32m1(4);
+        vuint32m1_t va = __riscv_vle32_v_u32m1(a.u32, vl);
+        vuint32m1_t vr = __riscv_vsll_vx_u32m1(va, imm8, vl);
+        __riscv_vse32_v_u32m1(result.u32, vr, vl);
+    }
+    return result;
+#else
+    __m128i result;
+    if (imm8 > 31) {
+        for (int i = 0; i < 4; i++) result.u32[i] = 0;
+    } else {
+        for (int i = 0; i < 4; i++) {
+            result.u32[i] = a.u32[i] << imm8;
+        }
+    }
+    return result;
+#endif
+}
+
+static inline __m128i _mm_srli_epi32(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+    __m128i result;
+    if (imm8 > 31) {
+        memset(&result, 0, sizeof(result));
+    } else {
+        size_t vl = __riscv_vsetvl_e32m1(4);
+        vuint32m1_t va = __riscv_vle32_v_u32m1(a.u32, vl);
+        vuint32m1_t vr = __riscv_vsrl_vx_u32m1(va, imm8, vl);
+        __riscv_vse32_v_u32m1(result.u32, vr, vl);
+    }
+    return result;
+#else
+    __m128i result;
+    if (imm8 > 31) {
+        for (int i = 0; i < 4; i++) result.u32[i] = 0;
+    } else {
+        for (int i = 0; i < 4; i++) {
+            result.u32[i] = a.u32[i] >> imm8;
+        }
+    }
+    return result;
+#endif
+}
+
+/* 64-bit integer operations */
+static inline __m128i _mm_set1_epi64x(int64_t a)
+{
+    __m128i result;
+    result.i64[0] = a;
+    result.i64[1] = a;
+    return result;
+}
+
+/* Float type for compatibility */
+typedef __m128i __m128;
+
+/* Float operations - simplified scalar implementations */
+static inline __m128 _mm_set1_ps(float a)
+{
+    __m128 result;
+    uint32_t val;
+    memcpy(&val, &a, sizeof(float));
+    for (int i = 0; i < 4; i++) {
+        result.u32[i] = val;
+    }
+    return result;
+}
+
+static inline __m128 _mm_setzero_ps(void)
+{
+    __m128 result;
+    memset(&result, 0, sizeof(result));
+    return result;
+}
+
+static inline __m128 _mm_add_ps(__m128 a, __m128 b)
+{
+    __m128 result;
+    float fa[4], fb[4], fr[4];
+    memcpy(fa, &a, sizeof(__m128));
+    memcpy(fb, &b, sizeof(__m128));
+    for (int i = 0; i < 4; i++) {
+        fr[i] = fa[i] + fb[i];
+    }
+    memcpy(&result, fr, sizeof(__m128));
+    return result;
+}
+
+static inline __m128 _mm_mul_ps(__m128 a, __m128 b)
+{
+    __m128 result;
+    float fa[4], fb[4], fr[4];
+    memcpy(fa, &a, sizeof(__m128));
+    memcpy(fb, &b, sizeof(__m128));
+    for (int i = 0; i < 4; i++) {
+        fr[i] = fa[i] * fb[i];
+    }
+    memcpy(&result, fr, sizeof(__m128));
+    return result;
+}
+
+static inline __m128 _mm_and_ps(__m128 a, __m128 b)
+{
+    __m128 result;
+    result.u64[0] = a.u64[0] & b.u64[0];
+    result.u64[1] = a.u64[1] & b.u64[1];
+    return result;
+}
+
+static inline __m128 _mm_or_ps(__m128 a, __m128 b)
+{
+    __m128 result;
+    result.u64[0] = a.u64[0] | b.u64[0];
+    result.u64[1] = a.u64[1] | b.u64[1];
+    return result;
+}
+
+static inline __m128 _mm_cvtepi32_ps(__m128i a)
+{
+    __m128 result;
+    float fr[4];
+    for (int i = 0; i < 4; i++) {
+        fr[i] = (float)a.i32[i];
+    }
+    memcpy(&result, fr, sizeof(__m128));
+    return result;
+}
+
+static inline __m128i _mm_cvttps_epi32(__m128 a)
+{
+    __m128i result;
+    float fa[4];
+    memcpy(fa, &a, sizeof(__m128));
+    for (int i = 0; i < 4; i++) {
+        result.i32[i] = (int32_t)fa[i];
+    }
+    return result;
+}
+
+/* Casting operations */
+static inline __m128 _mm_castsi128_ps(__m128i a)
+{
+    __m128 result;
+    memcpy(&result, &a, sizeof(__m128));
+    return result;
+}
+
+static inline __m128i _mm_castps_si128(__m128 a)
+{
+    __m128i result;
+    memcpy(&result, &a, sizeof(__m128));
+    return result;
+}
+
+/* Additional set operations */
+static inline __m128i _mm_set1_epi32(int a)
+{
+    __m128i result;
+    for (int i = 0; i < 4; i++) {
+        result.i32[i] = a;
+    }
+    return result;
+}
+
+/* AES instructions - placeholders for soft_aes compatibility */
+static inline __m128i _mm_aesenc_si128(__m128i a, __m128i roundkey)
+{
+    return _mm_xor_si128(a, roundkey);
+}
+
+static inline __m128i _mm_aeskeygenassist_si128(__m128i a, const int rcon)
+{
+    return a;
+}
+
+/* Rotate right operation for soft_aes.h */
+static inline uint32_t _rotr(uint32_t value, unsigned int count)
+{
+    const unsigned int mask = 31;
+    count &= mask;
+    return (value >> count) | (value << ((-count) & mask));
+}
+
+/* ARM NEON compatibility types and intrinsics for RISC-V */
+typedef __m128i_union uint64x2_t;
+typedef __m128i_union uint8x16_t;
+typedef __m128i_union int64x2_t;
+typedef __m128i_union int32x4_t;
+
+static inline uint64x2_t vld1q_u64(const uint64_t *ptr)
+{
+    uint64x2_t result;
+    result.u64[0] = ptr[0];
+    result.u64[1] = ptr[1];
+    return result;
+}
+
+static inline int64x2_t vld1q_s64(const int64_t *ptr)
+{
+    int64x2_t result;
+    result.i64[0] = ptr[0];
+    result.i64[1] = ptr[1];
+    return result;
+}
+
+static inline void vst1q_u64(uint64_t *ptr, uint64x2_t val)
+{
+    ptr[0] = val.u64[0];
+    ptr[1] = val.u64[1];
+}
+
+static inline uint64x2_t veorq_u64(uint64x2_t a, uint64x2_t b)
+{
+    return _mm_xor_si128(a, b);
+}
+
+static inline uint64x2_t vaddq_u64(uint64x2_t a, uint64x2_t b)
+{
+    return _mm_add_epi64(a, b);
+}
+
+static inline uint64x2_t vreinterpretq_u64_u8(uint8x16_t a)
+{
+    uint64x2_t result;
+    memcpy(&result, &a, sizeof(uint64x2_t));
+    return result;
+}
+
+static inline uint64_t vgetq_lane_u64(uint64x2_t v, int lane)
+{
+    return v.u64[lane];
+}
+
+static inline int64_t vgetq_lane_s64(int64x2_t v, int lane)
+{
+    return v.i64[lane];
+}
+
+static inline int32_t vgetq_lane_s32(int32x4_t v, int lane)
+{
+    return v.i32[lane];
+}
+
+typedef struct { uint64_t val[1]; } uint64x1_t;
+
+static inline uint64x1_t vcreate_u64(uint64_t a)
+{
+    uint64x1_t result;
+    result.val[0] = a;
+    return result;
+}
+
+static inline uint64x2_t vcombine_u64(uint64x1_t low, uint64x1_t high)
+{
+    uint64x2_t result;
+    result.u64[0] = low.val[0];
+    result.u64[1] = high.val[0];
+    return result;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* XMRIG_SSE2RVV_OPTIMIZED_H */

src/crypto/cn/sse2rvv_scalar_backup.h

@@ -0,0 +1,571 @@
+/* XMRig
+ * Copyright (c) 2025 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * SSE to RISC-V compatibility header
+ * Provides scalar implementations of SSE intrinsics for RISC-V architecture
+ */
+
+#ifndef XMRIG_SSE2RVV_H
+#define XMRIG_SSE2RVV_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <string.h>
+
+/* 128-bit vector type */
+typedef union {
+    uint8_t  u8[16];
+    uint16_t u16[8];
+    uint32_t u32[4];
+    uint64_t u64[2];
+    int8_t   i8[16];
+    int16_t  i16[8];
+    int32_t  i32[4];
+    int64_t  i64[2];
+} __m128i_union;
+
+typedef __m128i_union __m128i;
+
+/* Set operations */
+static inline __m128i _mm_set_epi32(int e3, int e2, int e1, int e0)
+{
+    __m128i result;
+    result.i32[0] = e0;
+    result.i32[1] = e1;
+    result.i32[2] = e2;
+    result.i32[3] = e3;
+    return result;
+}
+
+static inline __m128i _mm_set_epi64x(int64_t e1, int64_t e0)
+{
+    __m128i result;
+    result.i64[0] = e0;
+    result.i64[1] = e1;
+    return result;
+}
+
+static inline __m128i _mm_setzero_si128(void)
+{
+    __m128i result;
+    memset(&result, 0, sizeof(result));
+    return result;
+}
+
+/* Extract/insert operations */
+static inline int _mm_cvtsi128_si32(__m128i a)
+{
+    return a.i32[0];
+}
+
+static inline int64_t _mm_cvtsi128_si64(__m128i a)
+{
+    return a.i64[0];
+}
+
+static inline __m128i _mm_cvtsi32_si128(int a)
+{
+    __m128i result = _mm_setzero_si128();
+    result.i32[0] = a;
+    return result;
+}
+
+static inline __m128i _mm_cvtsi64_si128(int64_t a)
+{
+    __m128i result = _mm_setzero_si128();
+    result.i64[0] = a;
+    return result;
+}
+
+/* Shuffle operations */
+static inline __m128i _mm_shuffle_epi32(__m128i a, int imm8)
+{
+    __m128i result;
+    result.u32[0] = a.u32[(imm8 >> 0) & 0x3];
+    result.u32[1] = a.u32[(imm8 >> 2) & 0x3];
+    result.u32[2] = a.u32[(imm8 >> 4) & 0x3];
+    result.u32[3] = a.u32[(imm8 >> 6) & 0x3];
+    return result;
+}
+
+/* Logical operations */
+static inline __m128i _mm_xor_si128(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = a.u64[0] ^ b.u64[0];
+    result.u64[1] = a.u64[1] ^ b.u64[1];
+    return result;
+}
+
+static inline __m128i _mm_or_si128(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = a.u64[0] | b.u64[0];
+    result.u64[1] = a.u64[1] | b.u64[1];
+    return result;
+}
+
+static inline __m128i _mm_and_si128(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = a.u64[0] & b.u64[0];
+    result.u64[1] = a.u64[1] & b.u64[1];
+    return result;
+}
+
+static inline __m128i _mm_andnot_si128(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = (~a.u64[0]) & b.u64[0];
+    result.u64[1] = (~a.u64[1]) & b.u64[1];
+    return result;
+}
+
+/* Shift operations */
+static inline __m128i _mm_slli_si128(__m128i a, int imm8)
+{
+    __m128i result = _mm_setzero_si128();
+    int count = imm8 & 0xFF;
+    if (count > 15) return result;
+    
+    for (int i = 0; i < 16 - count; i++) {
+        result.u8[i + count] = a.u8[i];
+    }
+    return result;
+}
+
+static inline __m128i _mm_srli_si128(__m128i a, int imm8)
+{
+    __m128i result = _mm_setzero_si128();
+    int count = imm8 & 0xFF;
+    if (count > 15) return result;
+    
+    for (int i = count; i < 16; i++) {
+        result.u8[i - count] = a.u8[i];
+    }
+    return result;
+}
+
+static inline __m128i _mm_slli_epi64(__m128i a, int imm8)
+{
+    __m128i result;
+    if (imm8 > 63) {
+        result.u64[0] = 0;
+        result.u64[1] = 0;
+    } else {
+        result.u64[0] = a.u64[0] << imm8;
+        result.u64[1] = a.u64[1] << imm8;
+    }
+    return result;
+}
+
+static inline __m128i _mm_srli_epi64(__m128i a, int imm8)
+{
+    __m128i result;
+    if (imm8 > 63) {
+        result.u64[0] = 0;
+        result.u64[1] = 0;
+    } else {
+        result.u64[0] = a.u64[0] >> imm8;
+        result.u64[1] = a.u64[1] >> imm8;
+    }
+    return result;
+}
+
+/* Load/store operations */
+static inline __m128i _mm_load_si128(const __m128i* p)
+{
+    __m128i result;
+    memcpy(&result, p, sizeof(__m128i));
+    return result;
+}
+
+static inline __m128i _mm_loadu_si128(const __m128i* p)
+{
+    __m128i result;
+    memcpy(&result, p, sizeof(__m128i));
+    return result;
+}
+
+static inline void _mm_store_si128(__m128i* p, __m128i a)
+{
+    memcpy(p, &a, sizeof(__m128i));
+}
+
+static inline void _mm_storeu_si128(__m128i* p, __m128i a)
+{
+    memcpy(p, &a, sizeof(__m128i));
+}
+
+/* Arithmetic operations */
+static inline __m128i _mm_add_epi64(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = a.u64[0] + b.u64[0];
+    result.u64[1] = a.u64[1] + b.u64[1];
+    return result;
+}
+
+static inline __m128i _mm_add_epi32(__m128i a, __m128i b)
+{
+    __m128i result;
+    for (int i = 0; i < 4; i++) {
+        result.i32[i] = a.i32[i] + b.i32[i];
+    }
+    return result;
+}
+
+static inline __m128i _mm_sub_epi64(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = a.u64[0] - b.u64[0];
+    result.u64[1] = a.u64[1] - b.u64[1];
+    return result;
+}
+
+static inline __m128i _mm_mul_epu32(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = (uint64_t)a.u32[0] * (uint64_t)b.u32[0];
+    result.u64[1] = (uint64_t)a.u32[2] * (uint64_t)b.u32[2];
+    return result;
+}
+
+/* Unpack operations */
+static inline __m128i _mm_unpacklo_epi64(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = a.u64[0];
+    result.u64[1] = b.u64[0];
+    return result;
+}
+
+static inline __m128i _mm_unpackhi_epi64(__m128i a, __m128i b)
+{
+    __m128i result;
+    result.u64[0] = a.u64[1];
+    result.u64[1] = b.u64[1];
+    return result;
+}
+
+/* Pause instruction for spin-wait loops */
+static inline void _mm_pause(void)
+{
+    /* RISC-V doesn't have a direct equivalent to x86 PAUSE
+     * Use a simple NOP or yield hint */
+    __asm__ __volatile__("nop");
+}
+
+/* Memory fence */
+static inline void _mm_mfence(void)
+{
+    __asm__ __volatile__("fence" ::: "memory");
+}
+
+static inline void _mm_lfence(void)
+{
+    __asm__ __volatile__("fence r,r" ::: "memory");
+}
+
+static inline void _mm_sfence(void)
+{
+    __asm__ __volatile__("fence w,w" ::: "memory");
+}
+
+/* Comparison operations */
+static inline __m128i _mm_cmpeq_epi32(__m128i a, __m128i b)
+{
+    __m128i result;
+    for (int i = 0; i < 4; i++) {
+        result.u32[i] = (a.u32[i] == b.u32[i]) ? 0xFFFFFFFF : 0;
+    }
+    return result;
+}
+
+static inline __m128i _mm_cmpeq_epi64(__m128i a, __m128i b)
+{
+    __m128i result;
+    for (int i = 0; i < 2; i++) {
+        result.u64[i] = (a.u64[i] == b.u64[i]) ? 0xFFFFFFFFFFFFFFFFULL : 0;
+    }
+    return result;
+}
+
+/* Additional shift operations */
+static inline __m128i _mm_slli_epi32(__m128i a, int imm8)
+{
+    __m128i result;
+    if (imm8 > 31) {
+        for (int i = 0; i < 4; i++) result.u32[i] = 0;
+    } else {
+        for (int i = 0; i < 4; i++) {
+            result.u32[i] = a.u32[i] << imm8;
+        }
+    }
+    return result;
+}
+
+static inline __m128i _mm_srli_epi32(__m128i a, int imm8)
+{
+    __m128i result;
+    if (imm8 > 31) {
+        for (int i = 0; i < 4; i++) result.u32[i] = 0;
+    } else {
+        for (int i = 0; i < 4; i++) {
+            result.u32[i] = a.u32[i] >> imm8;
+        }
+    }
+    return result;
+}
+
+/* 64-bit integer operations */
+static inline __m128i _mm_set1_epi64x(int64_t a)
+{
+    __m128i result;
+    result.i64[0] = a;
+    result.i64[1] = a;
+    return result;
+}
+
+/* Float type for compatibility - we'll treat it as int for simplicity */
+typedef __m128i __m128;
+
+/* Float operations - simplified scalar implementations */
+static inline __m128 _mm_set1_ps(float a)
+{
+    __m128 result;
+    uint32_t val;
+    memcpy(&val, &a, sizeof(float));
+    for (int i = 0; i < 4; i++) {
+        result.u32[i] = val;
+    }
+    return result;
+}
+
+static inline __m128 _mm_setzero_ps(void)
+{
+    __m128 result;
+    memset(&result, 0, sizeof(result));
+    return result;
+}
+
+static inline __m128 _mm_add_ps(__m128 a, __m128 b)
+{
+    __m128 result;
+    float fa[4], fb[4], fr[4];
+    memcpy(fa, &a, sizeof(__m128));
+    memcpy(fb, &b, sizeof(__m128));
+    for (int i = 0; i < 4; i++) {
+        fr[i] = fa[i] + fb[i];
+    }
+    memcpy(&result, fr, sizeof(__m128));
+    return result;
+}
+
+static inline __m128 _mm_mul_ps(__m128 a, __m128 b)
+{
+    __m128 result;
+    float fa[4], fb[4], fr[4];
+    memcpy(fa, &a, sizeof(__m128));
+    memcpy(fb, &b, sizeof(__m128));
+    for (int i = 0; i < 4; i++) {
+        fr[i] = fa[i] * fb[i];
+    }
+    memcpy(&result, fr, sizeof(__m128));
+    return result;
+}
+
+static inline __m128 _mm_and_ps(__m128 a, __m128 b)
+{
+    __m128 result;
+    result.u64[0] = a.u64[0] & b.u64[0];
+    result.u64[1] = a.u64[1] & b.u64[1];
+    return result;
+}
+
+static inline __m128 _mm_or_ps(__m128 a, __m128 b)
+{
+    __m128 result;
+    result.u64[0] = a.u64[0] | b.u64[0];
+    result.u64[1] = a.u64[1] | b.u64[1];
+    return result;
+}
+
+static inline __m128 _mm_cvtepi32_ps(__m128i a)
+{
+    __m128 result;
+    float fr[4];
+    for (int i = 0; i < 4; i++) {
+        fr[i] = (float)a.i32[i];
+    }
+    memcpy(&result, fr, sizeof(__m128));
+    return result;
+}
+
+static inline __m128i _mm_cvttps_epi32(__m128 a)
+{
+    __m128i result;
+    float fa[4];
+    memcpy(fa, &a, sizeof(__m128));
+    for (int i = 0; i < 4; i++) {
+        result.i32[i] = (int32_t)fa[i];
+    }
+    return result;
+}
+
+/* Casting operations */
+static inline __m128 _mm_castsi128_ps(__m128i a)
+{
+    __m128 result;
+    memcpy(&result, &a, sizeof(__m128));
+    return result;
+}
+
+static inline __m128i _mm_castps_si128(__m128 a)
+{
+    __m128i result;
+    memcpy(&result, &a, sizeof(__m128));
+    return result;
+}
+
+/* Additional set operations */
+static inline __m128i _mm_set1_epi32(int a)
+{
+    __m128i result;
+    for (int i = 0; i < 4; i++) {
+        result.i32[i] = a;
+    }
+    return result;
+}
+
+/* AES instructions - these are placeholders, actual AES is done via soft_aes.h */
+/* On RISC-V without crypto extensions, these should never be called directly */
+/* They are only here for compilation compatibility */
+static inline __m128i _mm_aesenc_si128(__m128i a, __m128i roundkey)
+{
+    /* This is a placeholder - actual implementation should use soft_aes */
+    /* If this function is called, it means SOFT_AES template parameter wasn't used */
+    /* We return a XOR as a minimal fallback, but proper code should use soft_aesenc */
+    return _mm_xor_si128(a, roundkey);
+}
+
+static inline __m128i _mm_aeskeygenassist_si128(__m128i a, const int rcon)
+{
+    /* Placeholder for AES key generation - should use soft_aeskeygenassist */
+    return a;
+}
+
+/* Rotate right operation for soft_aes.h */
+static inline uint32_t _rotr(uint32_t value, unsigned int count)
+{
+    const unsigned int mask = 31;
+    count &= mask;
+    return (value >> count) | (value << ((-count) & mask));
+}
+
+/* ARM NEON compatibility types and intrinsics for RISC-V */
+typedef __m128i_union uint64x2_t;
+typedef __m128i_union uint8x16_t;
+typedef __m128i_union int64x2_t;
+typedef __m128i_union int32x4_t;
+
+static inline uint64x2_t vld1q_u64(const uint64_t *ptr)
+{
+    uint64x2_t result;
+    result.u64[0] = ptr[0];
+    result.u64[1] = ptr[1];
+    return result;
+}
+
+static inline int64x2_t vld1q_s64(const int64_t *ptr)
+{
+    int64x2_t result;
+    result.i64[0] = ptr[0];
+    result.i64[1] = ptr[1];
+    return result;
+}
+
+static inline void vst1q_u64(uint64_t *ptr, uint64x2_t val)
+{
+    ptr[0] = val.u64[0];
+    ptr[1] = val.u64[1];
+}
+
+static inline uint64x2_t veorq_u64(uint64x2_t a, uint64x2_t b)
+{
+    uint64x2_t result;
+    result.u64[0] = a.u64[0] ^ b.u64[0];
+    result.u64[1] = a.u64[1] ^ b.u64[1];
+    return result;
+}
+
+static inline uint64x2_t vaddq_u64(uint64x2_t a, uint64x2_t b)
+{
+    uint64x2_t result;
+    result.u64[0] = a.u64[0] + b.u64[0];
+    result.u64[1] = a.u64[1] + b.u64[1];
+    return result;
+}
+
+static inline uint64x2_t vreinterpretq_u64_u8(uint8x16_t a)
+{
+    uint64x2_t result;
+    memcpy(&result, &a, sizeof(uint64x2_t));
+    return result;
+}
+
+static inline uint64_t vgetq_lane_u64(uint64x2_t v, int lane)
+{
+    return v.u64[lane];
+}
+
+static inline int64_t vgetq_lane_s64(int64x2_t v, int lane)
+{
+    return v.i64[lane];
+}
+
+static inline int32_t vgetq_lane_s32(int32x4_t v, int lane)
+{
+    return v.i32[lane];
+}
+
+typedef struct { uint64_t val[1]; } uint64x1_t;
+
+static inline uint64x1_t vcreate_u64(uint64_t a)
+{
+    uint64x1_t result;
+    result.val[0] = a;
+    return result;
+}
+
+static inline uint64x2_t vcombine_u64(uint64x1_t low, uint64x1_t high)
+{
+    uint64x2_t result;
+    result.u64[0] = low.val[0];
+    result.u64[1] = high.val[0];
+    return result;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* XMRIG_SSE2RVV_H */