cmake_minimum_required(VERSION 3.20)

project(lw.PPOCR.C VERSION 1.2.1 LANGUAGES C)

option(LW_BUILD_HTTP_DEMO
    "Build the cross-platform cpp-httplib HTTP OCR Demo" ON)
option(LW_BUILD_CSHARP_DEMOS
    "Build the .NET Framework 3.5 WinForms Demo on Windows" OFF)
option(LW_RUNTIME_ONLY
    "Build only the dependency-free native runtime for an embedding target" OFF)
option(LW_DEPLOY_ONNX_MODELS
    "Deploy official ONNX assets in Web/Node packages (LWM remains supported)" ON)
option(LW_WASM_SIMD128
    "Enable portable WebAssembly SIMD128 for the standalone OCR HTML" ON)
option(LW_WASM_COMPILED_REC
    "Experimentally run WASM REC on the compiled physical backend" OFF)
option(LW_WASM_FINE_REC_WIDTHS
    "Use 64-pixel adaptive REC width buckets in compiled WASM OCR" OFF)
option(LW_NATIVE_FINE_REC_WIDTHS
    "Experimentally reduce native compiled REC padding with finer widths (including 480)" OFF)
option(LW_EXPERIMENTAL_REC_FFN_TILING
    "Experimental cache-local Pointwise/GELU/Pointwise scheduling (no arithmetic changes)" OFF)
set(LW_REC_FFN_TILE_PIXELS "96" CACHE STRING "Experimental FFN pixel block (12, 48 or 96)")
set_property(CACHE LW_REC_FFN_TILE_PIXELS PROPERTY STRINGS 12 48 96)
if(NOT LW_REC_FFN_TILE_PIXELS MATCHES "^(12|48|96)$")
    message(FATAL_ERROR "LW_REC_FFN_TILE_PIXELS must be 12, 48 or 96")
endif()
option(LW_WASM_COMPILED_DET
    "Run WASM DET on the compiled NHWC backend when compiled REC is enabled" ON)
option(LW_WASM_REC_SIMD_KERNELS
    "Use SIMD128 Dense and Depthwise kernels in experimental WASM compiled REC" ON)
set(LW_WASM_POINTWISE_ROWS "2" CACHE STRING
    "WASM SIMD128 pointwise pixel tile; supported values: 2 or 4")
set_property(CACHE LW_WASM_POINTWISE_ROWS PROPERTY STRINGS 2 4)
if(NOT LW_WASM_POINTWISE_ROWS STREQUAL "2" AND
   NOT LW_WASM_POINTWISE_ROWS STREQUAL "4")
    message(FATAL_ERROR "LW_WASM_POINTWISE_ROWS must be 2 or 4")
endif()
option(LW_WASM_DB_BITMAP_SIMD
    "Experimentally use SIMD128 DB thresholding in compiled WASM OCR" OFF)
option(LW_WEB_LEGACY
    "Build the Tiny scalar Web compatibility distribution" OFF)
set(LW_WEB_MIN_CHROME_VERSION "70" CACHE STRING
    "Minimum Chromium version for the legacy browser distribution")
option(LW_REC_RESIDENT_WIDTHS
    "Prewarm all standard REC widths for native performance experiments" OFF)
option(LW_EXPERIMENTAL_AVX2_FMA_DISPATCH
    "Use experimental AVX2+FMA Conv1x1 and terminal MatMul paths in native builds" OFF)
option(LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH
    "Use the experimental AVX2+FMA Conv1x1 dispatch in native builds" OFF)
option(LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH
    "Use the experimental AVX2+FMA terminal MatMul dispatch in native builds" OFF)
option(LW_EXPERIMENTAL_AVX2_FAST_PATH
    "Enable compiled AVX2/FMA x64 REC backends for adaptive widths" ON)
option(LW_EXPERIMENTAL_ADAPTIVE_REC_BUDGET
    "Share the native x64 REC intra-op thread budget across active line workers" ON)
option(LW_EXPERIMENTAL_DET_FIXED_POINT_RESIZE
    "Use the OpenCV-parity fixed-point DET resize with LUT normalization" ON)
option(LW_EXPERIMENTAL_CLS_FIXED_POINT_RESIZE
    "Use the keep-aspect fixed-point CLS resize with -1 padding" ON)
option(LW_EXPERIMENTAL_PERSISTENT_LINE_POOL
    "Reuse a persistent line-worker thread pool across OCR requests" ON)
option(LW_EXPERIMENTAL_PARALLEL_CROP_PHASE
    "Rasterize perspective crops as parallel row-band jobs" ON)
option(LW_EXPERIMENTAL_PREPARED_EXECUTION
    "Build the experimental session-local prepared execution table" OFF)
option(LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2
    "Use the experimental size-descending workspace interval planner" OFF)
option(LW_EXPERIMENTAL_FUSION_MEMORY
    "Use the experimental physical lifetime plan for fused GELU" OFF)
option(LW_EXPERIMENTAL_CTC_TILED
    "Use the experimental physical plan for greedy CTC output elision" OFF)
option(LW_WASM_REC_LAZY_FALLBACK
    "Avoid canonical REC execution allocations until a compiled WASM fallback is needed" OFF)
option(LW_EXPERIMENTAL_STREAMING_CROPS
    "Use experimental worker-local streaming crop buffers" OFF)
option(LW_AVX2_FMA_CONV3X3_DISPATCH
    "Enable the measured AVX2+FMA Conv3x3 Node 6 dispatch" ON)
option(LW_EXPERIMENTAL_AVX2_CONV3X3_EIGHT_OUTPUTS
    "Use experimental AVX2 eight-output blocking for unit-stride Conv3x3" OFF)
set(LW_WASM_HOST_ABI_VERSION "1" CACHE STRING
    "WASM Host ABI version embedded in the Web adapter and Node manifest")
set(LW_LWM_FORMAT_VERSION "0.1" CACHE STRING
    "LWM model format version recorded in distribution manifests")
option(LW_WEB_PDF
    "Embed offline PDF.js support in the standalone OCR HTML" ON)
option(LW_BUILD_WEB_MODEL_VARIANTS
    "Build standalone PP-OCRv6 Small and Medium browser SDK/HTML variants" OFF)
set(LW_PRECONVERTED_ASSETS_DIR "" CACHE PATH
    "Directory containing preconverted LWM models and PPM fixtures")
set(LW_BUILD_ENVIRONMENT_FILE "" CACHE FILEPATH
    "Optional build-environment report installed in the package root")
set(LW_STAGED_PACKAGE_TEST_TIMEOUT 240 CACHE STRING
    "Timeout in seconds for the installed-package smoke test")
set(LW_HTTP_TEST_REQUEST_TIMEOUT 30 CACHE STRING
    "Timeout in seconds for one HTTP package-test request")
set(LW_HTTP_TEST_PROCESS_TIMEOUT 120 CACHE STRING
    "Timeout in seconds for the complete HTTP package-test process")
set(LW_PACKAGE_PLATFORM_OVERRIDE "" CACHE STRING
    "Optional explicit platform suffix for the CPack archive name")

if(LW_BUILD_HTTP_DEMO)
    enable_language(CXX)
endif()

if(NOT LW_WASM_HOST_ABI_VERSION MATCHES "^[0-9]+$")
    message(FATAL_ERROR "LW_WASM_HOST_ABI_VERSION must be a positive integer")
endif()
if(NOT LW_LWM_FORMAT_VERSION MATCHES "^[0-9]+\\.[0-9]+$")
    message(FATAL_ERROR "LW_LWM_FORMAT_VERSION must use the form major.minor")
endif()
if(LW_EXPERIMENTAL_FUSION_MEMORY AND NOT LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2)
    message(FATAL_ERROR
        "LW_EXPERIMENTAL_FUSION_MEMORY requires LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2")
endif()
if(LW_EXPERIMENTAL_CTC_TILED AND NOT LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2)
    message(FATAL_ERROR
        "LW_EXPERIMENTAL_CTC_TILED requires LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2")
endif()

if(LW_WEB_LEGACY)
    if(LW_WASM_SIMD128)
        message(FATAL_ERROR
            "LW_WEB_LEGACY requires LW_WASM_SIMD128=OFF")
    endif()
    if(LW_WEB_PDF)
        message(FATAL_ERROR
            "LW_WEB_LEGACY requires LW_WEB_PDF=OFF")
    endif()
    if(LW_BUILD_WEB_MODEL_VARIANTS)
        message(FATAL_ERROR
            "LW_WEB_LEGACY supports PP-OCRv6 Tiny only")
    endif()
    if(NOT LW_WEB_MIN_CHROME_VERSION MATCHES "^[0-9]+$")
        message(FATAL_ERROR
            "LW_WEB_MIN_CHROME_VERSION must be an integer")
    endif()
endif()

include(CTest)
include(GNUInstallDirs)
include(CMakePackageConfigHelpers)
include(CheckCCompilerFlag)
if(NOT LW_RUNTIME_ONLY)
    find_package(Python3 3.9 COMPONENTS Interpreter REQUIRED)
endif()
if(NOT EMSCRIPTEN)
    find_package(Threads REQUIRED)
endif()

if(NOT LW_RUNTIME_ONLY)
set(LW_PPOCR_C_ANALYSIS_JSON
    "${CMAKE_CURRENT_SOURCE_DIR}/docs/ppocrv6-tiny-analysis.json")
set(LW_PPOCR_C_ANALYSIS_MARKDOWN
    "${CMAKE_CURRENT_SOURCE_DIR}/docs/SUPPORTED_OPS_V0.md")
set(LW_PPOCR_C_REC_ONNX
    "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/rec.onnx")
set(LW_PPOCR_C_REC_LWM
    "${CMAKE_CURRENT_BINARY_DIR}/models/rec.lwm")
set(LW_PPOCR_C_REC_LWM_METADATA
    "${CMAKE_CURRENT_BINARY_DIR}/models/rec-lwm.json")
set(LW_PPOCR_C_CLS_ONNX
    "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/cls.onnx")
set(LW_PPOCR_C_CLS_LWM
    "${CMAKE_CURRENT_BINARY_DIR}/models/cls.lwm")
set(LW_PPOCR_C_CLS_LWM_METADATA
    "${CMAKE_CURRENT_BINARY_DIR}/models/cls-lwm.json")
set(LW_PPOCR_C_DET_ONNX
    "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/det.onnx")
set(LW_PPOCR_C_DET_LWM
    "${CMAKE_CURRENT_BINARY_DIR}/models/det.lwm")
set(LW_PPOCR_C_DET_LWM_METADATA
    "${CMAKE_CURRENT_BINARY_DIR}/models/det-lwm.json")
if(LW_DEPLOY_ONNX_MODELS)
    set(LW_DEPLOY_MODEL_FORMAT onnx)
    set(LW_DEPLOY_DET "${LW_PPOCR_C_DET_ONNX}")
    set(LW_DEPLOY_CLS "${LW_PPOCR_C_CLS_ONNX}")
    set(LW_DEPLOY_REC "${LW_PPOCR_C_REC_ONNX}")
else()
    set(LW_DEPLOY_MODEL_FORMAT lwm)
    set(LW_DEPLOY_DET "${LW_PPOCR_C_DET_LWM}")
    set(LW_DEPLOY_CLS "${LW_PPOCR_C_CLS_LWM}")
    set(LW_DEPLOY_REC "${LW_PPOCR_C_REC_LWM}")
endif()

add_custom_target(analyze_models
    COMMAND "${Python3_EXECUTABLE}"
            "${CMAKE_CURRENT_SOURCE_DIR}/converter/analyze_onnx.py"
            --json-output "${LW_PPOCR_C_ANALYSIS_JSON}"
            --markdown-output "${LW_PPOCR_C_ANALYSIS_MARKDOWN}"
    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
    COMMENT "Analyzing bundled PP-OCRv6 tiny ONNX models"
    VERBATIM)

if(LW_PRECONVERTED_ASSETS_DIR)
    get_filename_component(LW_PRECONVERTED_ASSETS_DIR
        "${LW_PRECONVERTED_ASSETS_DIR}" ABSOLUTE)
    foreach(asset IN ITEMS
            rec.lwm rec-lwm.json cls.lwm cls-lwm.json det.lwm det-lwm.json
            sample-crop.ppm sample.ppm)
        if(NOT EXISTS "${LW_PRECONVERTED_ASSETS_DIR}/${asset}")
            message(FATAL_ERROR
                "LW_PRECONVERTED_ASSETS_DIR is missing required file: ${asset}")
        endif()
    endforeach()
    message(STATUS
        "Using preconverted models and fixtures from ${LW_PRECONVERTED_ASSETS_DIR}")

    function(lw_copy_preconverted_pair output_a name_a output_b name_b label)
        add_custom_command(
            OUTPUT "${output_a}" "${output_b}"
            COMMAND "${CMAKE_COMMAND}" -E make_directory
                    "${CMAKE_CURRENT_BINARY_DIR}/models"
            COMMAND "${CMAKE_COMMAND}" -E copy_if_different
                    "${LW_PRECONVERTED_ASSETS_DIR}/${name_a}" "${output_a}"
            COMMAND "${CMAKE_COMMAND}" -E copy_if_different
                    "${LW_PRECONVERTED_ASSETS_DIR}/${name_b}" "${output_b}"
            DEPENDS
                "${LW_PRECONVERTED_ASSETS_DIR}/${name_a}"
                "${LW_PRECONVERTED_ASSETS_DIR}/${name_b}"
            COMMENT "Copying preconverted ${label} assets"
            VERBATIM)
    endfunction()

    lw_copy_preconverted_pair(
        "${LW_PPOCR_C_REC_LWM}" rec.lwm
        "${LW_PPOCR_C_REC_LWM_METADATA}" rec-lwm.json REC)
    lw_copy_preconverted_pair(
        "${LW_PPOCR_C_CLS_LWM}" cls.lwm
        "${LW_PPOCR_C_CLS_LWM_METADATA}" cls-lwm.json CLS)
    lw_copy_preconverted_pair(
        "${LW_PPOCR_C_DET_LWM}" det.lwm
        "${LW_PPOCR_C_DET_LWM_METADATA}" det-lwm.json DET)
else()
    add_custom_command(
        OUTPUT "${LW_PPOCR_C_REC_LWM}" "${LW_PPOCR_C_REC_LWM_METADATA}"
        COMMAND "${Python3_EXECUTABLE}" -m converter.convert_rec
                --input "${LW_PPOCR_C_REC_ONNX}"
                --output "${LW_PPOCR_C_REC_LWM}"
                --metadata-output "${LW_PPOCR_C_REC_LWM_METADATA}"
        DEPENDS
            "${LW_PPOCR_C_REC_ONNX}"
            "${CMAKE_CURRENT_SOURCE_DIR}/converter/convert_rec.py"
            "${CMAKE_CURRENT_SOURCE_DIR}/converter/lwm_v0.py"
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        COMMENT "Converting PP-OCRv6 tiny REC to LWM v0.1"
        VERBATIM)

    add_custom_command(
        OUTPUT "${LW_PPOCR_C_CLS_LWM}" "${LW_PPOCR_C_CLS_LWM_METADATA}"
        COMMAND "${Python3_EXECUTABLE}" -m converter.convert_cls
                --input "${LW_PPOCR_C_CLS_ONNX}"
                --output "${LW_PPOCR_C_CLS_LWM}"
                --metadata-output "${LW_PPOCR_C_CLS_LWM_METADATA}"
        DEPENDS
            "${LW_PPOCR_C_CLS_ONNX}"
            "${CMAKE_CURRENT_SOURCE_DIR}/converter/convert_cls.py"
            "${CMAKE_CURRENT_SOURCE_DIR}/converter/lwm_v0.py"
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        COMMENT "Converting PP-OCRv6 tiny CLS to LWM v0.1"
        VERBATIM)

    add_custom_command(
        OUTPUT "${LW_PPOCR_C_DET_LWM}" "${LW_PPOCR_C_DET_LWM_METADATA}"
        COMMAND "${Python3_EXECUTABLE}" -m converter.convert_det
                --input "${LW_PPOCR_C_DET_ONNX}"
                --output "${LW_PPOCR_C_DET_LWM}"
                --metadata-output "${LW_PPOCR_C_DET_LWM_METADATA}"
        DEPENDS
            "${LW_PPOCR_C_DET_ONNX}"
            "${CMAKE_CURRENT_SOURCE_DIR}/converter/convert_det.py"
            "${CMAKE_CURRENT_SOURCE_DIR}/converter/lwm_v0.py"
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        COMMENT "Converting PP-OCRv6 tiny DET to LWM v0.1"
        VERBATIM)
endif()

add_custom_target(convert_rec_model ALL
    DEPENDS "${LW_PPOCR_C_REC_LWM}" "${LW_PPOCR_C_REC_LWM_METADATA}")
add_custom_target(convert_cls_model ALL
    DEPENDS "${LW_PPOCR_C_CLS_LWM}" "${LW_PPOCR_C_CLS_LWM_METADATA}")
add_custom_target(convert_det_model ALL
    DEPENDS "${LW_PPOCR_C_DET_LWM}" "${LW_PPOCR_C_DET_LWM_METADATA}")
endif()

set(LW_PPOCR_C_SOURCES
    src/kernels/packed_conv.c
    src/kernels/packed_conv3x3.c
    src/kernels/packed_matmul.c
    src/kernels/scalar_activation.c
    src/kernels/scalar_conv.c
    src/kernels/scalar_elementwise.c
    src/kernels/scalar_layout.c
    src/kernels/scalar_matmul.c
    src/kernels/scalar_reduction.c
    src/kernels/scalar_softmax.c
    src/ppocr/classifier.c
    src/ppocr/cls_preprocess.c
    src/ppocr/ctc_decode.c
    src/ppocr/crop.c
    src/ppocr/crop_buffer.c
    src/ppocr/db_postprocess.c
    src/ppocr/det_preprocess.c
    src/ppocr/det_preprocess_fixed.c
    src/ppocr/detector.c
    src/ppocr/ocr.c
    src/ppocr/profile.c
    src/ppocr/reading_order.c
    src/ppocr/rec_preprocess.c
    src/ppocr/recognizer.c
    src/runtime/executor.c
    src/runtime/cpu_topology.c
    src/runtime/execution_plan.c
    src/runtime/memory.c
    src/runtime/model.c
    src/runtime/onnx_import.c
    src/runtime/parallel.c
    src/runtime/ctc_head_parallel_internal.c
    src/runtime/prepared_execution.c
    src/runtime/session.c
    src/runtime/shape.c
    src/runtime/validate.c
    src/simd/avx2_binary.c
    src/simd/avx2_bitmap.c
    src/simd/avx2_conv1x1.c
    src/simd/avx2_conv2x2.c
    src/simd/avx2_conv3x3.c
    src/simd/avx2_conv3x3_eight.c
    src/simd/avx2_conv7x7.c
    src/simd/avx2_convtranspose2x2.c
    src/simd/avx2_depthwise3x3.c
    src/simd/avx2_depthwise5x5.c
    src/simd/avx2_depthwise9x9.c
    src/simd/avx2_erf.c
    src/simd/avx2_transpose.c
    src/simd/avx2_softmax.c
    src/simd/avx2_matmul.c
    src/simd/avx2_fma_packed_matmul.c
    src/simd/avx2_packed_conv1x1.c
    src/simd/avx2_fma_packed_conv1x1.c
    src/simd/avx2_fma_packed_conv1x1_8x8.c
    src/simd/cpu_features.c
    src/simd/lsx_packed_conv1x1.c
    src/simd/neon_conv3x3.c
    src/simd/neon_convtranspose2x2.c
    src/simd/neon_packed_conv1x1.c
    src/simd/sse2_binary.c
    src/simd/sse2_conv1x1.c
    src/simd/sse2_conv2x2.c
    src/simd/sse2_conv3x3.c
    src/simd/sse2_convtranspose2x2.c
    src/simd/sse2_depthwise3x3.c
    src/simd/sse2_depthwise5x5.c
    src/simd/sse2_matmul.c
    src/simd/sse2_packed_conv1x1.c
    src/simd/wasm128_erf.c)

set(LW_X64_REC_FAST_ENABLED OFF)
set(LW_WASM_COMPILED_REC_ENABLED OFF)
if(LW_EXPERIMENTAL_AVX2_FAST_PATH AND NOT EMSCRIPTEN AND
   (CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|amd64|AMD64|x64|X86)$" OR
    MSVC_C_ARCHITECTURE_ID MATCHES "^(x64|X86)$"))
    set(LW_X64_REC_FAST_ENABLED ON)
endif()
if(EMSCRIPTEN AND LW_WASM_SIMD128 AND LW_WASM_COMPILED_REC)
    set(LW_WASM_COMPILED_REC_ENABLED ON)
elseif(EMSCRIPTEN AND LW_WASM_COMPILED_REC)
    message(FATAL_ERROR "LW_WASM_COMPILED_REC requires LW_WASM_SIMD128=ON")
endif()
if(LW_WASM_REC_LAZY_FALLBACK AND
   (NOT LW_WASM_COMPILED_REC_ENABLED OR LW_EXPERIMENTAL_CTC_TILED))
    message(FATAL_ERROR
        "LW_WASM_REC_LAZY_FALLBACK requires compiled SIMD128 REC without CTC tiled mode")
endif()
if(LW_WASM_FINE_REC_WIDTHS AND NOT LW_WASM_COMPILED_REC_ENABLED)
    message(FATAL_ERROR "LW_WASM_FINE_REC_WIDTHS requires compiled SIMD128 WASM REC")
endif()
if(LW_NATIVE_FINE_REC_WIDTHS AND
   (NOT LW_X64_REC_FAST_ENABLED OR NOT CMAKE_SIZEOF_VOID_P EQUAL 8))
    message(FATAL_ERROR "LW_NATIVE_FINE_REC_WIDTHS requires compiled native x64 REC")
endif()
if(LW_X64_REC_FAST_ENABLED OR LW_WASM_COMPILED_REC_ENABLED)
    list(APPEND LW_PPOCR_C_SOURCES
        src/runtime/layout_planner.c
        src/runtime/x64_rec_fast_plan.c
        src/runtime/x64_rec_fast_executor.c
        src/runtime/x64_rec_backend_compile.c
        src/runtime/x64_rec_backend_execute.c
        src/runtime/x64_rec_backend_arena.c
        src/runtime/rec_backend_kernels.c
        src/runtime/x64_det_backend_compile.c
        src/runtime/x64_det_backend_execute.c
        src/runtime/ctc_projection_internal.c
        src/runtime/layout_convert_x64.c
        src/kernels/nhwc_pack.c
        src/kernels/nhwc_depthwise.c
        src/simd/avx2_nhwc_pointwise.c
        src/simd/avx2_nhwc_depthwise.c
        src/simd/avx2_nhwc_support.c
        src/simd/avx2_nhwc_dense.c
        src/simd/avx2_nhwc_convtranspose.c)
endif()
if(LW_WASM_COMPILED_REC_ENABLED)
    list(APPEND LW_PPOCR_C_SOURCES
        src/simd/wasm128_nhwc_pointwise.c
        src/simd/wasm128_elementwise.c
        src/simd/wasm128_matmul.c
        src/simd/wasm128_nhwc_convtranspose.c
        src/simd/wasm128_packed_matmul.c)
    if(LW_WASM_DB_BITMAP_SIMD)
        list(APPEND LW_PPOCR_C_SOURCES src/simd/wasm128_bitmap.c)
    endif()
endif()
if(MSVC AND MSVC_C_ARCHITECTURE_ID MATCHES "^(x64|X86)$")
    set_property(SOURCE src/simd/avx2_binary.c src/simd/avx2_conv1x1.c
        src/simd/avx2_conv2x2.c
        src/simd/avx2_conv3x3.c src/simd/avx2_conv3x3_eight.c
        src/simd/avx2_conv7x7.c
        src/simd/avx2_convtranspose2x2.c
        src/simd/avx2_depthwise3x3.c
        src/simd/avx2_depthwise5x5.c
        src/simd/avx2_depthwise9x9.c
        src/simd/avx2_erf.c src/simd/avx2_transpose.c src/simd/avx2_matmul.c
        src/simd/avx2_fma_packed_matmul.c
        src/simd/avx2_packed_conv1x1.c src/simd/avx2_fma_packed_conv1x1.c
        src/simd/avx2_fma_packed_conv1x1_8x8.c APPEND PROPERTY
        COMPILE_OPTIONS /arch:AVX2 /fp:strict)
    set_property(SOURCE src/simd/cpu_features.c APPEND PROPERTY
        COMPILE_OPTIONS /arch:AVX)
endif()

string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" LW_SYSTEM_PROCESSOR_LOWER)

# Keep the portable Conv references and their SIMD implementations on the same
# multiply-then-add contract. GCC enables FP contraction by default on AArch64
# and LoongArch, while the intrinsic kernels below deliberately use separate
# multiply and add instructions so their outputs remain byte-identical to the
# established x86 kernels and golden checksums.
set(LW_REPRODUCIBLE_CONV_SOURCES
    src/kernels/packed_conv.c
    src/kernels/packed_conv3x3.c
    src/kernels/scalar_conv.c
    src/simd/lsx_packed_conv1x1.c
    src/simd/neon_conv3x3.c
    src/simd/neon_convtranspose2x2.c
    src/simd/neon_packed_conv1x1.c)

if(MSVC AND LW_SYSTEM_PROCESSOR_LOWER MATCHES "^(arm64|aarch64)$")
    set_property(SOURCE ${LW_REPRODUCIBLE_CONV_SOURCES} APPEND PROPERTY
        COMPILE_OPTIONS /fp:strict)
elseif(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
    set_property(SOURCE ${LW_REPRODUCIBLE_CONV_SOURCES} APPEND PROPERTY
        COMPILE_OPTIONS -ffp-contract=off)
endif()

if(LW_SYSTEM_PROCESSOR_LOWER MATCHES "^(loongarch64|loong64)$")
    check_c_compiler_flag("-mlsx" LW_COMPILER_SUPPORTS_LSX)
    if(NOT LW_COMPILER_SUPPORTS_LSX)
        message(FATAL_ERROR "The LoongArch compiler must support -mlsx")
    endif()
    set_property(SOURCE src/simd/lsx_packed_conv1x1.c APPEND PROPERTY
        COMPILE_OPTIONS -mlsx -mno-lasx)
endif()

function(lw_configure_runtime_target target)
    if(LW_EXPERIMENTAL_REC_FFN_TILING)
        target_compile_definitions(${target} PRIVATE LW_EXPERIMENTAL_REC_FFN_TILING=1
            LW_REC_FFN_TILE_PIXELS=${LW_REC_FFN_TILE_PIXELS})
    endif()
    if(LW_NATIVE_FINE_REC_WIDTHS AND LW_X64_REC_FAST_ENABLED)
        target_compile_definitions(${target} PRIVATE LW_NATIVE_FINE_REC_WIDTHS=1)
    endif()
    target_include_directories(${target}
        PUBLIC
            "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
            "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
        PRIVATE
            "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
            "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
            "${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr"
            "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(${target} PUBLIC c_std_11)
    if(NOT EMSCRIPTEN)
        target_link_libraries(${target} PUBLIC Threads::Threads)
    endif()
    if(MSVC)
        target_compile_options(${target} PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(${target} PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
        target_link_libraries(${target} PUBLIC m)
    endif()
    if(EMSCRIPTEN AND LW_WASM_SIMD128)
        # Keep the offline single-HTML build single-threaded, but compile its
        # scalar/SSE2-compatible kernels to portable WebAssembly SIMD128.
        # -msse2 enables Emscripten's compatible <emmintrin.h> surface;
        # -msimd128 lowers those intrinsics to portable WASM SIMD instructions.
        target_compile_options(${target} PRIVATE -O3 -msimd128 -msse2)
    endif()
endfunction()

add_library(lw_ppocr_c STATIC ${LW_PPOCR_C_SOURCES})
set_target_properties(lw_ppocr_c PROPERTIES
    EXPORT_NAME static
    OUTPUT_NAME lw_ppocr_c_static
    POSITION_INDEPENDENT_CODE ON)
lw_configure_runtime_target(lw_ppocr_c)
if(LW_X64_REC_FAST_ENABLED OR LW_WASM_COMPILED_REC_ENABLED)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
    if(LW_X64_REC_FAST_ENABLED AND LW_EXPERIMENTAL_ADAPTIVE_REC_BUDGET)
        target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_ADAPTIVE_REC_BUDGET=1)
    endif()
    if(LW_WASM_COMPILED_REC_ENABLED)
        if(LW_WASM_FINE_REC_WIDTHS)
            target_compile_definitions(lw_ppocr_c PRIVATE LW_WASM_FINE_REC_WIDTHS=1)
        endif()
        target_compile_definitions(lw_ppocr_c PRIVATE
            LW_WASM_POINTWISE_ROWS=${LW_WASM_POINTWISE_ROWS})
    endif()
    if(LW_WASM_COMPILED_REC_ENABLED AND LW_WASM_REC_SIMD_KERNELS)
        target_compile_definitions(lw_ppocr_c PRIVATE LW_WASM_REC_SIMD_KERNELS=1)
    endif()
    if(LW_WASM_COMPILED_REC_ENABLED AND LW_WASM_DB_BITMAP_SIMD)
        target_compile_definitions(lw_ppocr_c PRIVATE LW_WASM_DB_BITMAP_SIMD=1)
    endif()
    if(LW_WASM_COMPILED_REC_ENABLED AND LW_WASM_COMPILED_DET AND
       LW_EXPERIMENTAL_DET_FIXED_POINT_RESIZE)
        target_compile_definitions(lw_ppocr_c PRIVATE LW_WASM_COMPILED_DET=1)
    endif()
    if(MSVC)
        set_property(SOURCE src/simd/avx2_nhwc_pointwise.c src/simd/avx2_nhwc_dense.c src/simd/avx2_nhwc_depthwise.c src/simd/avx2_nhwc_support.c src/simd/avx2_nhwc_convtranspose.c APPEND PROPERTY
            COMPILE_OPTIONS /arch:AVX2 /fp:strict)
    endif()
endif()
if(LW_WASM_REC_LAZY_FALLBACK)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_WASM_REC_LAZY_FALLBACK=1)
endif()
if(LW_EXPERIMENTAL_DET_FIXED_POINT_RESIZE)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_DET_FIXED_POINT_RESIZE=1)
endif()
if(LW_EXPERIMENTAL_CLS_FIXED_POINT_RESIZE)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_CLS_FIXED_POINT_RESIZE=1)
endif()
if(LW_EXPERIMENTAL_PERSISTENT_LINE_POOL)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_PERSISTENT_LINE_POOL=1)
endif()
if(LW_EXPERIMENTAL_PARALLEL_CROP_PHASE)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_PARALLEL_CROP_PHASE=1)
endif()
if(LW_REC_RESIDENT_WIDTHS AND NOT EMSCRIPTEN)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_REC_RESIDENT_WIDTHS=1)
endif()
if((LW_EXPERIMENTAL_AVX2_FMA_DISPATCH OR LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH) AND NOT EMSCRIPTEN)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH=1)
endif()
if((LW_EXPERIMENTAL_AVX2_FMA_DISPATCH OR LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH) AND NOT EMSCRIPTEN)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH=1)
endif()
if(LW_AVX2_FMA_CONV3X3_DISPATCH AND NOT EMSCRIPTEN)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_AVX2_FMA_CONV3X3_DISPATCH=1)
endif()
if(LW_EXPERIMENTAL_AVX2_CONV3X3_EIGHT_OUTPUTS AND NOT EMSCRIPTEN)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_AVX2_CONV3X3_EIGHT_OUTPUTS=1)
endif()
if(LW_EXPERIMENTAL_PREPARED_EXECUTION)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_PREPARED_EXECUTION=1)
endif()
if(LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2=1)
endif()
if(LW_EXPERIMENTAL_FUSION_MEMORY)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_FUSION_MEMORY=1)
endif()
if(LW_EXPERIMENTAL_CTC_TILED)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_CTC_TILED=1)
endif()
if(LW_EXPERIMENTAL_STREAMING_CROPS)
    target_compile_definitions(lw_ppocr_c PRIVATE LW_EXPERIMENTAL_STREAMING_CROPS=1)
endif()

if(NOT EMSCRIPTEN AND NOT LW_RUNTIME_ONLY)
add_library(lw_ppocr_c_shared SHARED ${LW_PPOCR_C_SOURCES})
set_target_properties(lw_ppocr_c_shared PROPERTIES
    EXPORT_NAME shared
    OUTPUT_NAME lw_ppocr_c
    VERSION ${PROJECT_VERSION}
    SOVERSION ${PROJECT_VERSION_MAJOR}
    C_VISIBILITY_PRESET hidden)
target_compile_definitions(lw_ppocr_c_shared
    PRIVATE LW_PPOCR_C_BUILD LW_PPOCR_C_SHARED
    INTERFACE LW_PPOCR_C_SHARED)
lw_configure_runtime_target(lw_ppocr_c_shared)
if(LW_X64_REC_FAST_ENABLED)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
    if(LW_EXPERIMENTAL_ADAPTIVE_REC_BUDGET)
        target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_ADAPTIVE_REC_BUDGET=1)
    endif()
    if(MSVC)
        set_property(SOURCE src/simd/avx2_nhwc_pointwise.c src/simd/avx2_nhwc_dense.c src/simd/avx2_nhwc_depthwise.c src/simd/avx2_nhwc_support.c src/simd/avx2_nhwc_convtranspose.c APPEND PROPERTY
            COMPILE_OPTIONS /arch:AVX2 /fp:strict)
    endif()
endif()
if(LW_EXPERIMENTAL_DET_FIXED_POINT_RESIZE)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_DET_FIXED_POINT_RESIZE=1)
endif()
if(LW_EXPERIMENTAL_CLS_FIXED_POINT_RESIZE)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_CLS_FIXED_POINT_RESIZE=1)
endif()
if(LW_EXPERIMENTAL_PERSISTENT_LINE_POOL)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_PERSISTENT_LINE_POOL=1)
endif()
if(LW_EXPERIMENTAL_PARALLEL_CROP_PHASE)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_PARALLEL_CROP_PHASE=1)
endif()
if(LW_REC_RESIDENT_WIDTHS)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_REC_RESIDENT_WIDTHS=1)
endif()
if(LW_EXPERIMENTAL_AVX2_FMA_DISPATCH OR LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH=1)
endif()
if(LW_EXPERIMENTAL_AVX2_FMA_DISPATCH OR LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH=1)
endif()
if(LW_AVX2_FMA_CONV3X3_DISPATCH AND NOT EMSCRIPTEN)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_AVX2_FMA_CONV3X3_DISPATCH=1)
endif()
if(LW_EXPERIMENTAL_AVX2_CONV3X3_EIGHT_OUTPUTS)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_AVX2_CONV3X3_EIGHT_OUTPUTS=1)
endif()
if(LW_EXPERIMENTAL_PREPARED_EXECUTION)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_PREPARED_EXECUTION=1)
endif()
if(LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_WORKSPACE_PLANNER_V2=1)
endif()
if(LW_EXPERIMENTAL_FUSION_MEMORY)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_FUSION_MEMORY=1)
endif()
if(LW_EXPERIMENTAL_CTC_TILED)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_CTC_TILED=1)
endif()
if(LW_EXPERIMENTAL_STREAMING_CROPS)
    target_compile_definitions(lw_ppocr_c_shared PRIVATE LW_EXPERIMENTAL_STREAMING_CROPS=1)
endif()
endif()

if(LW_RUNTIME_ONLY)
    message(STATUS "LW_RUNTIME_ONLY enabled: skipping model conversion, demos, tests, install and packaging")
    return()
endif()

if(EMSCRIPTEN)
    if(LW_WEB_LEGACY)
        find_program(LW_NODE_EXECUTABLE NAMES node nodejs REQUIRED)
        set(LW_LEGACY_ESBUILD_ENTRY
            "${CMAKE_CURRENT_SOURCE_DIR}/web/node_modules/esbuild/package.json")
        if(NOT EXISTS "${LW_LEGACY_ESBUILD_ENTRY}")
            message(FATAL_ERROR
                "LW_WEB_LEGACY requires web/node_modules; run npm ci in web first")
        endif()
    endif()
    add_executable(lw_ppocr_web web/lw_web_api.c)
    target_link_libraries(lw_ppocr_web PRIVATE lw_ppocr_c)
    target_include_directories(lw_ppocr_web PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include")
    target_compile_features(lw_ppocr_web PRIVATE c_std_11)
    target_compile_options(lw_ppocr_web PRIVATE -O3 -Wall -Wextra -Wpedantic -Werror)
    target_compile_definitions(lw_ppocr_web PRIVATE
        LW_WEB_ABI_VERSION=${LW_WASM_HOST_ABI_VERSION})
    if(LW_WASM_SIMD128)
        target_compile_options(lw_ppocr_web PRIVATE -msimd128 -msse2)
        target_link_options(lw_ppocr_web PRIVATE -msimd128)
    endif()
    if(LW_WEB_LEGACY)
        target_link_options(lw_ppocr_web PRIVATE
            "-sMIN_CHROME_VERSION=${LW_WEB_MIN_CHROME_VERSION}"
            "-sENVIRONMENT=web,webview,worker")
    endif()
    target_link_options(lw_ppocr_web PRIVATE
        -O3
        "-sMODULARIZE=1" "-sEXPORT_NAME=LwPpocrModule" "-sSINGLE_FILE=1"
        "-sFORCE_FILESYSTEM=1" "-sALLOW_MEMORY_GROWTH=1" "-sNO_EXIT_RUNTIME=1"
        "-sEXPORTED_RUNTIME_METHODS=['FS','HEAPU8','HEAPU32','HEAPF32']"
        "-sEXPORTED_FUNCTIONS=['_lw_web_init','_lw_web_shutdown','_lw_web_info_size','_lw_web_get_info','_lw_web_set_reading_order','_lw_web_run','_lw_web_last_error','_lw_web_malloc','_lw_web_free']"
        "--no-entry")
    set_target_properties(lw_ppocr_web PROPERTIES OUTPUT_NAME "lw_ppocr_web")
    if(NOT LW_DEPLOY_ONNX_MODELS)
        add_dependencies(lw_ppocr_web convert_det_model convert_cls_model convert_rec_model)
    endif()

    # The generated runtime remains a normal Emscripten module. The browser
    # SDK is a separate deterministic artifact layered on top of that module,
    # so other applications can consume it without the demo HTML.
    if(LW_WEB_LEGACY)
        set(LW_WEB_OUTPUT_SUFFIX "-legacy")
        set(LW_WEB_BUILD_FLAVOR "legacy")
        set(LW_WEB_WASM_SIMD128 "false")
        set(LW_WEB_PDF_ENABLED "false")
        set(LW_WEB_MIN_CHROME_VERSION_VALUE "${LW_WEB_MIN_CHROME_VERSION}")
        set(LW_WEB_JS_TARGET_VALUE "chrome${LW_WEB_MIN_CHROME_VERSION}")
        set(LW_WEB_HTML_TITLE
            "lw.PPOCR.C · PP-OCRv6 Tiny · 兼容版离线 OCR 工作台")
    else()
        set(LW_WEB_OUTPUT_SUFFIX "")
        set(LW_WEB_BUILD_FLAVOR "modern")
        if(LW_WASM_SIMD128)
            set(LW_WEB_WASM_SIMD128 "true")
        else()
            set(LW_WEB_WASM_SIMD128 "false")
        endif()
        if(LW_WEB_PDF)
            set(LW_WEB_PDF_ENABLED "true")
        else()
            set(LW_WEB_PDF_ENABLED "false")
        endif()
        set(LW_WEB_MIN_CHROME_VERSION_VALUE "")
        set(LW_WEB_JS_TARGET_VALUE "")
        set(LW_WEB_HTML_TITLE
            "lw.PPOCR.C · PP-OCRv6 Tiny · 离线 OCR 工作台")
    endif()

    if(LW_WEB_LEGACY)
        set(LW_PPOCR_C_LEGACY_RUNTIME_JS
            "${CMAKE_CURRENT_BINARY_DIR}/lw_ppocr_web.legacy.js")
        set(LW_PPOCR_C_LEGACY_RUNTIME_REPORT
            "${CMAKE_CURRENT_BINARY_DIR}/legacy-runtime-report.json")
        add_custom_command(
            OUTPUT
                "${LW_PPOCR_C_LEGACY_RUNTIME_JS}"
                "${LW_PPOCR_C_LEGACY_RUNTIME_REPORT}"
            COMMAND "${LW_NODE_EXECUTABLE}"
                    "${CMAKE_CURRENT_SOURCE_DIR}/web/transpile_legacy_runtime.mjs"
                    --input "$<TARGET_FILE_DIR:lw_ppocr_web>/lw_ppocr_web.js"
                    --output "${LW_PPOCR_C_LEGACY_RUNTIME_JS}"
                    --target "chrome${LW_WEB_MIN_CHROME_VERSION}"
                    --report "${LW_PPOCR_C_LEGACY_RUNTIME_REPORT}"
            DEPENDS
                lw_ppocr_web
                "${CMAKE_CURRENT_SOURCE_DIR}/web/transpile_legacy_runtime.mjs"
                "${CMAKE_CURRENT_SOURCE_DIR}/web/package-lock.json"
                "${CMAKE_CURRENT_SOURCE_DIR}/web/node_modules/esbuild/package.json"
            COMMENT "Lowering Legacy Web runtime for Chrome ${LW_WEB_MIN_CHROME_VERSION}"
            VERBATIM)
        add_custom_target(lw-legacy-runtime
            DEPENDS
                "${LW_PPOCR_C_LEGACY_RUNTIME_JS}"
                "${LW_PPOCR_C_LEGACY_RUNTIME_REPORT}")
        set(LW_PPOCR_C_WEB_RUNTIME_FOR_PACKAGE
            "${LW_PPOCR_C_LEGACY_RUNTIME_JS}")
        set(LW_PPOCR_C_WEB_RUNTIME_DEPENDS lw-legacy-runtime)
    else()
        set(LW_PPOCR_C_WEB_RUNTIME_FOR_PACKAGE
            "$<TARGET_FILE_DIR:lw_ppocr_web>/lw_ppocr_web.js")
        set(LW_PPOCR_C_WEB_RUNTIME_DEPENDS)
    endif()
    set(LW_PPOCR_C_WEB_SDK
        "${CMAKE_CURRENT_BINARY_DIR}/lw-ppocr${LW_WEB_OUTPUT_SUFFIX}.js")
    add_custom_command(
        OUTPUT "${LW_PPOCR_C_WEB_SDK}"
        COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_sdk.py"
            --template "${CMAKE_CURRENT_SOURCE_DIR}/web/lw_ppocr_sdk.template.js"
            --runtime "${LW_PPOCR_C_WEB_RUNTIME_FOR_PACKAGE}"
            --det "${LW_DEPLOY_DET}" --cls "${LW_DEPLOY_CLS}"
            --rec "${LW_DEPLOY_REC}"
            --dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
            --model-family "PP-OCRv6"
            --model-variant "tiny"
            --model-display-name "PP-OCRv6 Tiny"
            --version "${PROJECT_VERSION}"
            --build-flavor "${LW_WEB_BUILD_FLAVOR}"
            --wasm-simd128 "${LW_WEB_WASM_SIMD128}"
            --pdf-enabled "${LW_WEB_PDF_ENABLED}"
            --min-chrome-version "${LW_WEB_MIN_CHROME_VERSION_VALUE}"
            --js-target "${LW_WEB_JS_TARGET_VALUE}"
            --output "${LW_PPOCR_C_WEB_SDK}"
        DEPENDS
            lw_ppocr_web
            ${LW_PPOCR_C_WEB_RUNTIME_DEPENDS}
            "${CMAKE_CURRENT_SOURCE_DIR}/web/lw_ppocr_sdk.template.js"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_sdk.py"
            "${LW_DEPLOY_DET}" "${LW_DEPLOY_CLS}" "${LW_DEPLOY_REC}"
            "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
        COMMENT "Packaging the browser OCR SDK"
        VERBATIM)
    add_custom_target(lw-ocr-js DEPENDS "${LW_PPOCR_C_WEB_SDK}")

    # The standalone HTML is now only a thin UI shell plus the SDK. Keep it as
    # a separate target so CI and downstream users can download either file.
    set(LW_PPOCR_C_WEB_HTML
        "${CMAKE_CURRENT_BINARY_DIR}/ocr-demo${LW_WEB_OUTPUT_SUFFIX}.html")
    set(LW_PPOCR_C_WEB_HTML_PDF_ARGS --no-pdf)
    set(LW_PPOCR_C_WEB_HTML_PDF_DEPENDS)
    if(LW_WEB_PDF)
        set(LW_PPOCR_C_WEB_HTML_PDF_ARGS
            --pdf-adapter "${CMAKE_CURRENT_SOURCE_DIR}/web/pdf/lw_pdf_adapter.js"
            --pdfjs-core "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/pdf.min.mjs"
            --pdfjs-worker "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/pdf.worker.min.mjs"
            --pdfjs-jbig2 "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/jbig2.wasm"
            --pdfjs-openjpeg "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/openjpeg.wasm"
            --pdfjs-qcms "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/qcms_bg.wasm"
            --pdfjs-version "6.3.289")
        set(LW_PPOCR_C_WEB_HTML_PDF_DEPENDS
            "${CMAKE_CURRENT_SOURCE_DIR}/web/pdf/lw_pdf_adapter.js"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/pdf.min.mjs"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/pdf.worker.min.mjs"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/VERSION"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/jbig2.wasm"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/openjpeg.wasm"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/qcms_bg.wasm"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE_JBIG2"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE_OPENJPEG"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE_PDFJS_JBIG2"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE_PDFJS_OPENJPEG"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE_PDFJS_QCMS"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/vendor/pdfjs/LICENSE_QCMS")
    endif()
    add_custom_command(
        OUTPUT "${LW_PPOCR_C_WEB_HTML}"
        COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_html.py"
            --template "${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo.template.html"
            --sdk "${LW_PPOCR_C_WEB_SDK}"
            --ui "${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo-ui.js"
            --sponsor "${CMAKE_CURRENT_SOURCE_DIR}/docs/assets/sponsor.jpg"
            --title "${LW_WEB_HTML_TITLE}"
            ${LW_PPOCR_C_WEB_HTML_PDF_ARGS}
            --output "${LW_PPOCR_C_WEB_HTML}"
        DEPENDS
            lw-ocr-js
            "${LW_PPOCR_C_WEB_SDK}"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo.template.html"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo-ui.js"
            "${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_html.py"
            "${CMAKE_CURRENT_SOURCE_DIR}/docs/assets/sponsor.jpg"
            ${LW_PPOCR_C_WEB_HTML_PDF_DEPENDS}
        COMMENT "Packaging the standalone offline OCR HTML demo"
        VERBATIM)
    add_custom_target(lw-ocr-html DEPENDS "${LW_PPOCR_C_WEB_HTML}")

    # Tiny remains the compatibility/default browser artifact above.  Small
    # and Medium reuse the same generated WASM runtime and only add their
    # model staging plus SDK/HTML wrappers when explicitly requested.  This
    # keeps the normal browser build fast while providing deterministic,
    # independently downloadable model variants for release jobs.
    if(LW_BUILD_WEB_MODEL_VARIANTS)
        set(LW_WEB_VARIANT_ROOT
            "${CMAKE_CURRENT_BINARY_DIR}/runtime-models")
        set(LW_WEB_VARIANT_COMMON_DEPS
            "${CMAKE_CURRENT_SOURCE_DIR}/tools/prepare_ppocrv6_runtime_variant.py"
            "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-models.json"
            "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-small/det.onnx"
            "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-small/rec.onnx"
            "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-medium/det.onnx"
            "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-medium/rec.onnx"
            "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-shared/PP-OCRv6_small_rec_dict.txt"
            "${CMAKE_CURRENT_SOURCE_DIR}/tools/convert_small_det.py"
            "${CMAKE_CURRENT_SOURCE_DIR}/tools/convert_small_rec.py"
            "${CMAKE_CURRENT_SOURCE_DIR}/tools/convert_medium_det.py"
            "${CMAKE_CURRENT_SOURCE_DIR}/tools/convert_medium_rec.py"
            "${CMAKE_CURRENT_SOURCE_DIR}/tools/validate_model_catalog.py")

        function(lw_add_web_model_variant variant display_name)
            set(_variant_conversion_deps)
            if(NOT LW_DEPLOY_ONNX_MODELS)
                set(_variant_conversion_deps convert_cls_model)
            endif()
            set(_variant_root
                "${LW_WEB_VARIANT_ROOT}/ppocrv6-${variant}")
            set(_variant_stage_stamp
                "${_variant_root}/runtime-assets.json")
            add_custom_command(
                OUTPUT "${_variant_stage_stamp}"
                COMMAND "${Python3_EXECUTABLE}"
                        "${CMAKE_CURRENT_SOURCE_DIR}/tools/prepare_ppocrv6_runtime_variant.py"
                        --variant "${variant}"
                        --model-format "${LW_DEPLOY_MODEL_FORMAT}"
                        --build-dir "${CMAKE_CURRENT_BINARY_DIR}"
                        --output-dir "${_variant_root}"
                DEPENDS ${_variant_conversion_deps}
                        ${LW_WEB_VARIANT_COMMON_DEPS}
                WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
                COMMENT "Staging PP-OCRv6 ${display_name} browser model"
                VERBATIM)

            set(_variant_sdk
                "${CMAKE_CURRENT_BINARY_DIR}/lw-ppocr-v6-${variant}.js")
            add_custom_command(
                OUTPUT "${_variant_sdk}"
                COMMAND "${Python3_EXECUTABLE}"
                        "${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_sdk.py"
                        --template "${CMAKE_CURRENT_SOURCE_DIR}/web/lw_ppocr_sdk.template.js"
                        --runtime "$<TARGET_FILE_DIR:lw_ppocr_web>/lw_ppocr_web.js"
                        --det "${_variant_root}/det.${LW_DEPLOY_MODEL_FORMAT}"
                        --cls "${_variant_root}/cls.${LW_DEPLOY_MODEL_FORMAT}"
                        --rec "${_variant_root}/rec.${LW_DEPLOY_MODEL_FORMAT}"
                        --dictionary "${_variant_root}/ppocr_keys.txt"
                        --model-family "PP-OCRv6"
                        --model-variant "${variant}"
                        --model-display-name "${display_name}"
                        --version "${PROJECT_VERSION}"
                        --build-flavor "${LW_WEB_BUILD_FLAVOR}"
                        --wasm-simd128 "${LW_WEB_WASM_SIMD128}"
                        --pdf-enabled "${LW_WEB_PDF_ENABLED}"
                        --min-chrome-version "${LW_WEB_MIN_CHROME_VERSION_VALUE}"
                        --output "${_variant_sdk}"
                DEPENDS lw_ppocr_web
                        "${_variant_stage_stamp}"
                        "${CMAKE_CURRENT_SOURCE_DIR}/web/lw_ppocr_sdk.template.js"
                        "${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_sdk.py"
                COMMENT "Packaging the PP-OCRv6 ${display_name} browser SDK"
                VERBATIM)
            add_custom_target(lw-ocr-js-${variant} DEPENDS "${_variant_sdk}")

            set(_variant_html
                "${CMAKE_CURRENT_BINARY_DIR}/ocr-demo-${variant}.html")
            add_custom_command(
                OUTPUT "${_variant_html}"
                COMMAND "${Python3_EXECUTABLE}"
                        "${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_html.py"
                        --template "${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo.template.html"
                        --sdk "${_variant_sdk}"
                        --ui "${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo-ui.js"
                        --sponsor "${CMAKE_CURRENT_SOURCE_DIR}/docs/assets/sponsor.jpg"
                        --title "lw.PPOCR.C · ${display_name} · 离线 OCR 工作台"
                        ${LW_PPOCR_C_WEB_HTML_PDF_ARGS}
                        --output "${_variant_html}"
                DEPENDS lw-ocr-js-${variant}
                        "${_variant_sdk}"
                        "${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo.template.html"
                        "${CMAKE_CURRENT_SOURCE_DIR}/web/ocr-demo-ui.js"
                        "${CMAKE_CURRENT_SOURCE_DIR}/web/package_ocr_html.py"
                        "${CMAKE_CURRENT_SOURCE_DIR}/docs/assets/sponsor.jpg"
                        ${LW_PPOCR_C_WEB_HTML_PDF_DEPENDS}
                COMMENT "Packaging the PP-OCRv6 ${display_name} offline OCR HTML"
                VERBATIM)
            add_custom_target(lw-ocr-html-${variant} DEPENDS "${_variant_html}")
        endfunction()

        lw_add_web_model_variant(small "PP-OCRv6 Small")
        lw_add_web_model_variant(medium "PP-OCRv6 Medium")
        add_custom_target(lw-ocr-js-all
            DEPENDS lw-ocr-js lw-ocr-js-small lw-ocr-js-medium)
        add_custom_target(lw-ocr-html-all
            DEPENDS lw-ocr-html lw-ocr-html-small lw-ocr-html-medium)
    endif()

    if(NOT LW_WEB_LEGACY)
        # Node consumes the same WASM Host ABI as the browser. Keep this target
    # separate from the browser SDK so the Node release never needs to parse
    # or extract assets from ocr-demo.html.
    add_executable(lw_ppocr_node web/lw_web_api.c)
    target_link_libraries(lw_ppocr_node PRIVATE lw_ppocr_c)
    target_include_directories(lw_ppocr_node PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include")
    target_compile_features(lw_ppocr_node PRIVATE c_std_11)
    target_compile_options(lw_ppocr_node PRIVATE -O3 -Wall -Wextra -Wpedantic -Werror)
    target_compile_definitions(lw_ppocr_node PRIVATE
        LW_WEB_ABI_VERSION=${LW_WASM_HOST_ABI_VERSION})
    if(LW_WASM_SIMD128)
        target_compile_options(lw_ppocr_node PRIVATE -msimd128 -msse2)
        target_link_options(lw_ppocr_node PRIVATE -msimd128)
    endif()
    if(LW_WASM_COMPILED_REC_ENABLED)
        # Only the experimental Node package accepts the C profiler switch.
        # The browser SDK and canonical Node package keep their normal env policy.
        target_include_directories(lw_ppocr_node PRIVATE
            "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
            "${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
        target_compile_definitions(lw_ppocr_node PRIVATE LW_NODE_WASM_PROFILE=1)
    endif()
    target_link_options(lw_ppocr_node PRIVATE
        -O3
        "-sMODULARIZE=1" "-sEXPORT_NAME=LwPpocrModule" "-sSINGLE_FILE=1"
        "-sENVIRONMENT=node" "-sFORCE_FILESYSTEM=1" "-sALLOW_MEMORY_GROWTH=1"
        "-sNO_EXIT_RUNTIME=1"
        "-sEXPORTED_RUNTIME_METHODS=['FS','HEAPU8','HEAPU32','HEAPF32']"
        "-sEXPORTED_FUNCTIONS=['_lw_web_init','_lw_web_shutdown','_lw_web_info_size','_lw_web_get_info','_lw_web_set_reading_order','_lw_web_run','_lw_web_last_error','_lw_web_malloc','_lw_web_free']"
        "--no-entry")
    set_target_properties(lw_ppocr_node PROPERTIES OUTPUT_NAME "lw_ppocr_node")
    if(NOT LW_DEPLOY_ONNX_MODELS)
        add_dependencies(lw_ppocr_node convert_det_model convert_cls_model convert_rec_model)
    endif()

    if(LW_WASM_SIMD128)
        set(LW_NODE_WASM_BACKEND wasm128)
    else()
        set(LW_NODE_WASM_BACKEND scalar)
    endif()

    set(LW_PPOCR_C_NODE_RUNTIME
        "${CMAKE_CURRENT_BINARY_DIR}/runtime.cjs")
    add_custom_command(
        OUTPUT "${LW_PPOCR_C_NODE_RUNTIME}"
        COMMAND "${CMAKE_COMMAND}" -E make_directory
                "${CMAKE_CURRENT_BINARY_DIR}/node-wasm"
        COMMAND "${CMAKE_COMMAND}" -E copy
                "$<TARGET_FILE:lw_ppocr_node>" "${LW_PPOCR_C_NODE_RUNTIME}"
        DEPENDS lw_ppocr_node
        COMMENT "Preparing the Node.js WASM runtime"
        VERBATIM)
    add_custom_target(lw-node-wasm DEPENDS "${LW_PPOCR_C_NODE_RUNTIME}")

    set(LW_PPOCR_C_NODE_PACKAGE_DIR
        "${CMAKE_CURRENT_BINARY_DIR}/node-wasm")
    set(LW_PPOCR_C_NODE_PACKAGE_ARCHIVE
        "${CMAKE_CURRENT_BINARY_DIR}/lw.PPOCR.C-${PROJECT_VERSION}-node-wasm.zip")
    set(LW_PPOCR_C_NODE_PACKAGE_CHECKSUM
        "${LW_PPOCR_C_NODE_PACKAGE_ARCHIVE}.sha256")
    add_custom_command(
        OUTPUT "${LW_PPOCR_C_NODE_PACKAGE_ARCHIVE}"
               "${LW_PPOCR_C_NODE_PACKAGE_CHECKSUM}"
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tools/package_node_wasm.py"
                --runtime "${LW_PPOCR_C_NODE_RUNTIME}"
                --det "${LW_DEPLOY_DET}"
                --cls "${LW_DEPLOY_CLS}"
                --rec "${LW_DEPLOY_REC}"
                --dictionary
                "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
                --license "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE"
                --model-license
                "${CMAKE_CURRENT_SOURCE_DIR}/licenses/PaddleOCR-models-APACHE-2.0.txt"
                --notices "${CMAKE_CURRENT_SOURCE_DIR}/THIRD-PARTY-NOTICES.md"
                --version "${PROJECT_VERSION}"
                --wasm-backend "${LW_NODE_WASM_BACKEND}"
                --wasm-host-abi-version "${LW_WASM_HOST_ABI_VERSION}"
                --lwm-version "${LW_LWM_FORMAT_VERSION}"
                --output-dir "${LW_PPOCR_C_NODE_PACKAGE_DIR}"
                --archive "${LW_PPOCR_C_NODE_PACKAGE_ARCHIVE}"
        DEPENDS lw-node-wasm "${LW_PPOCR_C_NODE_RUNTIME}"
                "${LW_DEPLOY_DET}" "${LW_DEPLOY_CLS}" "${LW_DEPLOY_REC}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tools/package_node_wasm.py"
                "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE"
                "${CMAKE_CURRENT_SOURCE_DIR}/licenses/PaddleOCR-models-APACHE-2.0.txt"
                "${CMAKE_CURRENT_SOURCE_DIR}/THIRD-PARTY-NOTICES.md"
        COMMENT "Packaging the Node.js WASM distribution"
        VERBATIM)
    add_custom_target(lw-node-wasm-package
        DEPENDS "${LW_PPOCR_C_NODE_PACKAGE_ARCHIVE}"
                "${LW_PPOCR_C_NODE_PACKAGE_CHECKSUM}")
    endif()
endif()

if(EMSCRIPTEN AND LW_WASM_SIMD128)
    add_executable(wasm-erf-contract tests/wasm_erf_contract_driver.c)
    target_include_directories(wasm-erf-contract PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/include"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels")
    target_compile_features(wasm-erf-contract PRIVATE c_std_11)
    target_compile_options(wasm-erf-contract PRIVATE
        -O3 -Wall -Wextra -Wpedantic -Werror -msimd128)
    target_link_options(wasm-erf-contract PRIVATE -O3 -msimd128 "-sENVIRONMENT=node")
endif()

if(LW_WASM_COMPILED_REC_ENABLED)
    add_executable(wasm-pointwise-contract tests/wasm_pointwise_contract_driver.c)
    target_include_directories(wasm-pointwise-contract PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/include"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels")
    target_compile_features(wasm-pointwise-contract PRIVATE c_std_11)
    target_compile_options(wasm-pointwise-contract PRIVATE
        -O3 -Wall -Wextra -Wpedantic -Werror -msimd128)
    target_link_libraries(wasm-pointwise-contract PRIVATE lw_ppocr_c)
    target_link_options(wasm-pointwise-contract PRIVATE -O3 -msimd128 "-sENVIRONMENT=node")

    # Keep the bitwise generic/prepared kernel contract even though the
    # compiled prepared-offset experiment did not meet the E2E threshold.
    add_executable(wasm-dense-prepared-contract tests/wasm_dense_prepared_contract_driver.c)
    target_include_directories(wasm-dense-prepared-contract PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/include"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels")
    target_compile_features(wasm-dense-prepared-contract PRIVATE c_std_11)
    target_compile_options(wasm-dense-prepared-contract PRIVATE
        -O3 -Wall -Wextra -Wpedantic -Werror -msimd128)
    target_link_libraries(wasm-dense-prepared-contract PRIVATE lw_ppocr_c)
    target_link_options(wasm-dense-prepared-contract PRIVATE -O3 -msimd128 "-sENVIRONMENT=node")
endif()

if(EMSCRIPTEN AND LW_WASM_REC_LAZY_FALLBACK)
    # Private CI executable: exercise a source whose canonical REC session was
    # released, a compiled clone, and a clone forced onto canonical fallback.
    add_executable(wasm-rec-lazy-contract tests/wasm_rec_lazy_contract_driver.c)
    target_link_libraries(wasm-rec-lazy-contract PRIVATE lw_ppocr_c m)
    target_include_directories(wasm-rec-lazy-contract PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/include"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
    target_compile_features(wasm-rec-lazy-contract PRIVATE c_std_11)
    target_compile_definitions(wasm-rec-lazy-contract PRIVATE
        LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
    if(LW_WASM_FINE_REC_WIDTHS)
        target_compile_definitions(wasm-rec-lazy-contract PRIVATE LW_WASM_FINE_REC_WIDTHS=1)
    endif()
    target_compile_options(wasm-rec-lazy-contract PRIVATE
        -O3 -Wall -Wextra -Wpedantic -Werror -msimd128)
    target_link_options(wasm-rec-lazy-contract PRIVATE
        -O3 -msimd128 "-sENVIRONMENT=node" "-sFORCE_FILESYSTEM=1"
        "-sALLOW_MEMORY_GROWTH=1"
        "SHELL:--embed-file \"${LW_PPOCR_C_REC_LWM}@/models/rec.lwm\""
        "SHELL:--embed-file \"${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt@/models/ppocr_keys.txt\"")
    add_dependencies(wasm-rec-lazy-contract convert_rec_model)
endif()

set(LW_PPOCR_C_REC_DEMO_PPM
    "${CMAKE_CURRENT_BINARY_DIR}/models/sample-crop.ppm")
if(LW_PRECONVERTED_ASSETS_DIR)
    add_custom_command(
        OUTPUT "${LW_PPOCR_C_REC_DEMO_PPM}"
        COMMAND "${CMAKE_COMMAND}" -E make_directory
                "${CMAKE_CURRENT_BINARY_DIR}/models"
        COMMAND "${CMAKE_COMMAND}" -E copy_if_different
                "${LW_PRECONVERTED_ASSETS_DIR}/sample-crop.ppm"
                "${LW_PPOCR_C_REC_DEMO_PPM}"
        DEPENDS "${LW_PRECONVERTED_ASSETS_DIR}/sample-crop.ppm"
        COMMENT "Copying preconverted REC demo fixture"
        VERBATIM)
else()
    add_custom_command(
        OUTPUT "${LW_PPOCR_C_REC_DEMO_PPM}"
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tools/create_rec_demo_fixture.py"
                --input "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
                --output "${LW_PPOCR_C_REC_DEMO_PPM}"
        DEPENDS
            "${CMAKE_CURRENT_SOURCE_DIR}/tools/create_rec_demo_fixture.py"
            "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
        COMMENT "Creating dependency-free REC demo PPM fixture"
        VERBATIM)
endif()
add_custom_target(rec_demo_fixture ALL DEPENDS "${LW_PPOCR_C_REC_DEMO_PPM}")

set(LW_PPOCR_C_DET_DEMO_PPM
    "${CMAKE_CURRENT_BINARY_DIR}/models/sample.ppm")
if(LW_PRECONVERTED_ASSETS_DIR)
    add_custom_command(
        OUTPUT "${LW_PPOCR_C_DET_DEMO_PPM}"
        COMMAND "${CMAKE_COMMAND}" -E make_directory
                "${CMAKE_CURRENT_BINARY_DIR}/models"
        COMMAND "${CMAKE_COMMAND}" -E copy_if_different
                "${LW_PRECONVERTED_ASSETS_DIR}/sample.ppm"
                "${LW_PPOCR_C_DET_DEMO_PPM}"
        DEPENDS "${LW_PRECONVERTED_ASSETS_DIR}/sample.ppm"
        COMMENT "Copying preconverted DET demo fixture"
        VERBATIM)
else()
    add_custom_command(
        OUTPUT "${LW_PPOCR_C_DET_DEMO_PPM}"
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tools/create_det_demo_fixture.py"
                --input "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
                --output "${LW_PPOCR_C_DET_DEMO_PPM}"
        DEPENDS
            "${CMAKE_CURRENT_SOURCE_DIR}/tools/create_det_demo_fixture.py"
            "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
        COMMENT "Creating dependency-free DET demo PPM fixture"
        VERBATIM)
endif()
add_custom_target(det_demo_fixture ALL DEPENDS "${LW_PPOCR_C_DET_DEMO_PPM}")

if(NOT EMSCRIPTEN)
add_executable(lw-recognize-ppm examples/recognize_ppm.c)
target_link_libraries(lw-recognize-ppm PRIVATE lw_ppocr_c_shared)
target_compile_features(lw-recognize-ppm PRIVATE c_std_11)
add_dependencies(lw-recognize-ppm convert_rec_model rec_demo_fixture)
if(WIN32)
    target_link_libraries(lw-recognize-ppm PRIVATE shell32)
elseif(APPLE)
    set_target_properties(lw-recognize-ppm PROPERTIES INSTALL_RPATH "@loader_path/../lib")
else()
    set_target_properties(lw-recognize-ppm PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
endif()

add_executable(lw-rec-benchmark examples/benchmark_ppm.c)
target_sources(lw-rec-benchmark PRIVATE src/simd/cpu_features.c)
target_link_libraries(lw-rec-benchmark PRIVATE lw_ppocr_c_shared)
target_include_directories(lw-rec-benchmark PRIVATE
    "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(lw-rec-benchmark PRIVATE c_std_11)
add_dependencies(lw-rec-benchmark convert_rec_model rec_demo_fixture)
if(WIN32)
    target_link_libraries(lw-rec-benchmark PRIVATE shell32 psapi)
elseif(APPLE)
    set_target_properties(lw-rec-benchmark PROPERTIES
        INSTALL_RPATH "@loader_path/../lib")
else()
    set_target_properties(lw-rec-benchmark PROPERTIES
        INSTALL_RPATH "$ORIGIN/../lib")
endif()

add_executable(lw-ocr-benchmark examples/ocr_benchmark_ppm.c)
target_sources(lw-ocr-benchmark PRIVATE src/simd/cpu_features.c)
target_link_libraries(lw-ocr-benchmark PRIVATE lw_ppocr_c_shared)
target_include_directories(lw-ocr-benchmark PRIVATE
    "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
target_compile_features(lw-ocr-benchmark PRIVATE c_std_11)
add_dependencies(lw-ocr-benchmark convert_det_model convert_cls_model
    convert_rec_model det_demo_fixture)
if(WIN32)
    target_link_libraries(lw-ocr-benchmark PRIVATE shell32 psapi)
elseif(APPLE)
    set_target_properties(lw-ocr-benchmark PROPERTIES
        INSTALL_RPATH "@loader_path/../lib")
else()
    set_target_properties(lw-ocr-benchmark PROPERTIES
        INSTALL_RPATH "$ORIGIN/../lib")
endif()

add_executable(lw-classify-ppm examples/classify_ppm.c)
target_link_libraries(lw-classify-ppm PRIVATE lw_ppocr_c_shared)
target_compile_features(lw-classify-ppm PRIVATE c_std_11)
add_dependencies(lw-classify-ppm convert_cls_model rec_demo_fixture)
if(WIN32)
    target_link_libraries(lw-classify-ppm PRIVATE shell32)
elseif(APPLE)
    set_target_properties(lw-classify-ppm PROPERTIES INSTALL_RPATH "@loader_path/../lib")
else()
    set_target_properties(lw-classify-ppm PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
endif()

add_executable(lw-detect-ppm examples/detect_ppm.c)
target_link_libraries(lw-detect-ppm PRIVATE lw_ppocr_c_shared)
target_compile_features(lw-detect-ppm PRIVATE c_std_11)
add_dependencies(lw-detect-ppm convert_det_model det_demo_fixture)
if(WIN32)
    target_link_libraries(lw-detect-ppm PRIVATE shell32)
elseif(APPLE)
    set_target_properties(lw-detect-ppm PROPERTIES INSTALL_RPATH "@loader_path/../lib")
else()
    set_target_properties(lw-detect-ppm PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
endif()

add_executable(lw-ocr-ppm examples/ocr_ppm.c)
target_link_libraries(lw-ocr-ppm PRIVATE lw_ppocr_c_shared)
target_compile_features(lw-ocr-ppm PRIVATE c_std_11)
add_dependencies(lw-ocr-ppm convert_det_model convert_cls_model
    convert_rec_model det_demo_fixture)
if(WIN32)
    target_link_libraries(lw-ocr-ppm PRIVATE shell32)
elseif(APPLE)
    set_target_properties(lw-ocr-ppm PROPERTIES INSTALL_RPATH "@loader_path/../lib")
else()
    set_target_properties(lw-ocr-ppm PROPERTIES INSTALL_RPATH "$ORIGIN/../lib")
endif()
if(MSVC)
    target_compile_options(lw-classify-ppm PRIVATE /W4 /WX /utf-8)
else()
    target_compile_options(lw-classify-ppm PRIVATE
        -Wall -Wextra -Wpedantic -Werror)
endif()
if(MSVC)
    target_compile_options(lw-detect-ppm PRIVATE /W4 /WX /utf-8)
else()
    target_compile_options(lw-detect-ppm PRIVATE
        -Wall -Wextra -Wpedantic -Werror)
endif()
if(MSVC)
    target_compile_options(lw-ocr-ppm PRIVATE /W4 /WX /utf-8)
else()
    target_compile_options(lw-ocr-ppm PRIVATE
        -Wall -Wextra -Wpedantic -Werror)
endif()
if(MSVC)
    target_compile_options(lw-rec-benchmark PRIVATE /W4 /WX /utf-8)
else()
    target_compile_options(lw-rec-benchmark PRIVATE
        -Wall -Wextra -Wpedantic -Werror)
endif()
if(MSVC)
    target_compile_options(lw-ocr-benchmark PRIVATE /W4 /WX /utf-8)
else()
    target_compile_options(lw-ocr-benchmark PRIVATE
        -Wall -Wextra -Wpedantic -Werror)
endif()
if(MSVC)
    target_compile_options(lw-recognize-ppm PRIVATE /W4 /WX /utf-8)
else()
    target_compile_options(lw-recognize-ppm PRIVATE
        -Wall -Wextra -Wpedantic -Werror)
endif()

add_executable(lwm-inspect tools/lwm_inspect.c)
target_link_libraries(lwm-inspect PRIVATE lw_ppocr_c)
if(WIN32)
    target_link_libraries(lwm-inspect PRIVATE shell32)
endif()
target_compile_features(lwm-inspect PRIVATE c_std_11)
if(MSVC)
    target_compile_options(lwm-inspect PRIVATE /W4 /WX /utf-8)
else()
    target_compile_options(lwm-inspect PRIVATE -Wall -Wextra -Wpedantic -Werror)
endif()

if(LW_BUILD_HTTP_DEMO)
    set(LW_HTTPLIB_HEADER
        "${CMAKE_CURRENT_SOURCE_DIR}/examples/http-server/third_party/httplib.h")
    file(SHA256 "${LW_HTTPLIB_HEADER}" LW_HTTPLIB_SHA256)
    if(NOT LW_HTTPLIB_SHA256 STREQUAL
       "1c8b44c8ab0498322c08840dbdfcd5006bc28c5a3b140b0c2cf30777b7232fc6")
        message(FATAL_ERROR "vendored cpp-httplib checksum mismatch")
    endif()
    configure_file(
        examples/http-server/www/index.html
        "${CMAKE_CURRENT_BINARY_DIR}/www/index.html"
        COPYONLY)
    add_executable(lw-http-ocr examples/http-server/main.cpp)
    set_target_properties(lw-http-ocr PROPERTIES
        OUTPUT_NAME "lw.PPOCR.C.HttpServer"
        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
    foreach(lw_config Debug Release RelWithDebInfo MinSizeRel)
        string(TOUPPER "${lw_config}" lw_config_upper)
        set_target_properties(lw-http-ocr PROPERTIES
            "RUNTIME_OUTPUT_DIRECTORY_${lw_config_upper}"
            "${CMAKE_CURRENT_BINARY_DIR}/bin")
    endforeach()
    target_include_directories(lw-http-ocr PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/include")
    target_include_directories(lw-http-ocr SYSTEM PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/examples/http-server/third_party")
    target_link_libraries(lw-http-ocr PRIVATE lw_ppocr_c)
    target_compile_features(lw-http-ocr PRIVATE cxx_std_11)
    add_dependencies(lw-http-ocr convert_det_model convert_cls_model
        convert_rec_model)
    if(WIN32)
        target_compile_definitions(lw-http-ocr PRIVATE
            WINVER=0x0601 _WIN32_WINNT=0x0601
            WIN32_LEAN_AND_MEAN NOMINMAX)
        target_link_libraries(lw-http-ocr PRIVATE ws2_32)
    elseif(UNIX AND NOT APPLE)
        target_link_libraries(lw-http-ocr PRIVATE pthread)
    endif()
    if(CMAKE_SIZEOF_VOID_P EQUAL 4)
        target_compile_definitions(lw-http-ocr PRIVATE
            LW_HTTP_THREAD_POOL_COUNT=2)
    endif()
    if(MSVC)
        target_compile_options(lw-http-ocr PRIVATE /W4 /WX /utf-8)
        target_link_options(lw-http-ocr PRIVATE
            /SUBSYSTEM:CONSOLE,6.01
            $<$<EQUAL:${CMAKE_SIZEOF_VOID_P},4>:/LARGEADDRESSAWARE>)
    else()
        target_compile_options(lw-http-ocr PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_custom_command(TARGET lw-http-ocr POST_BUILD
        COMMAND "${CMAKE_COMMAND}" -E copy_if_different
                "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
                "${CMAKE_CURRENT_BINARY_DIR}/models/ppocr_keys.txt"
        VERBATIM)
endif()

if(LW_BUILD_CSHARP_DEMOS)
    if(NOT WIN32)
        message(FATAL_ERROR "LW_BUILD_CSHARP_DEMOS is supported only on Windows")
    endif()
    find_program(LW_MSBUILD_EXECUTABLE NAMES MSBuild.exe msbuild REQUIRED)
    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
        set(LW_MANAGED_PLATFORM x64)
    else()
        set(LW_MANAGED_PLATFORM x86)
    endif()
    set(LW_MANAGED_ROOT "${CMAKE_CURRENT_BINARY_DIR}/managed")
    set(LW_MANAGED_WINFORMS_DIR "${LW_MANAGED_ROOT}/winforms")
    set(LW_MANAGED_MODELS_DIR "${LW_MANAGED_ROOT}/models")
    set(LW_MANAGED_WINFORMS_EXE
        "${LW_MANAGED_WINFORMS_DIR}/lw.PPOCR.C.WinForms.exe")
    add_custom_target(lw-csharp-demos ALL
        COMMAND "${CMAKE_COMMAND}" -E make_directory
                "${LW_MANAGED_WINFORMS_DIR}" "${LW_MANAGED_MODELS_DIR}"
        COMMAND "${LW_MSBUILD_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/examples/csharp-winforms/LwPpocrWinForms.csproj"
                -t:Restore -p:RestorePackagesConfig=true
                -p:RestoreIgnoreFailedSources=true -p:NuGetAudit=false -v:minimal
        COMMAND "${LW_MSBUILD_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/examples/csharp-winforms/LwPpocrWinForms.csproj"
                -t:Rebuild -p:Configuration=Release
                -p:Platform=${LW_MANAGED_PLATFORM}
                "-p:OutputPath=${LW_MANAGED_WINFORMS_DIR}/" -v:minimal
        COMMAND "${CMAKE_COMMAND}" -E copy_if_different
                "$<TARGET_FILE:lw_ppocr_c_shared>"
                "${LW_MANAGED_WINFORMS_DIR}/"
        COMMAND "${CMAKE_COMMAND}" -E copy_if_different
                "${LW_PPOCR_C_DET_LWM}" "${LW_PPOCR_C_CLS_LWM}"
                "${LW_PPOCR_C_REC_LWM}"
                "${LW_PPOCR_C_DET_ONNX}" "${LW_PPOCR_C_CLS_ONNX}" "${LW_PPOCR_C_REC_ONNX}"
                "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
                "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/model.json"
                "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
                "${LW_MANAGED_MODELS_DIR}/"
        DEPENDS
            lw_ppocr_c_shared
            convert_det_model convert_cls_model convert_rec_model
            "${CMAKE_CURRENT_SOURCE_DIR}/examples/csharp-common/NativeOcr.cs"
            "${CMAKE_CURRENT_SOURCE_DIR}/examples/csharp-common/OcrModels.cs"
            "${CMAKE_CURRENT_SOURCE_DIR}/examples/csharp-winforms/MainForm.cs"
            "${CMAKE_CURRENT_SOURCE_DIR}/examples/csharp-winforms/OcrResultExporter.cs"
        COMMENT "Building .NET Framework 3.5 WinForms OCR Demo"
        VERBATIM)
endif()

endif()

if(BUILD_TESTING AND NOT EMSCRIPTEN)

    add_executable(wasm-ctc-projection-driver
        tests/test_wasm_ctc_projection.c
        src/simd/wasm128_packed_matmul.c
        src/kernels/packed_matmul.c)
    target_include_directories(wasm-ctc-projection-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels")
    target_compile_features(wasm-ctc-projection-driver PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(wasm-ctc-projection-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(wasm-ctc-projection-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
        target_link_libraries(wasm-ctc-projection-driver PRIVATE m)
    endif()
    add_test(NAME wasm_ctc_projection COMMAND wasm-ctc-projection-driver)

    add_executable(avx2-ctc-projection-driver tests/test_avx2_ctc_projection.c)
    target_link_libraries(avx2-ctc-projection-driver PRIVATE lw_ppocr_c)
    target_include_directories(avx2-ctc-projection-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(avx2-ctc-projection-driver PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(avx2-ctc-projection-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(avx2-ctc-projection-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
        target_link_libraries(avx2-ctc-projection-driver PRIVATE m)
    endif()
    add_test(NAME avx2_ctc_projection_tails COMMAND avx2-ctc-projection-driver)
    set_tests_properties(avx2_ctc_projection_tails PROPERTIES SKIP_RETURN_CODE 77)

    add_executable(nhwc-depthwise-portable-driver
        tests/test_nhwc_depthwise_portable.c
        src/simd/avx2_nhwc_depthwise.c)
    target_include_directories(nhwc-depthwise-portable-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/include"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels")
    target_compile_features(nhwc-depthwise-portable-driver PRIVATE c_std_11)
    target_compile_definitions(nhwc-depthwise-portable-driver PRIVATE
        LW_NHWC_FORCE_PORTABLE=1)
    if(MSVC)
        target_compile_options(nhwc-depthwise-portable-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(nhwc-depthwise-portable-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(NAME nhwc_depthwise_portable COMMAND nhwc-depthwise-portable-driver)

    foreach(policy IN ITEMS default fine)
        add_executable(rec-width-policy-${policy} tests/rec_width_policy_driver.c)
        target_include_directories(rec-width-policy-${policy} PRIVATE
            "${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
        target_compile_features(rec-width-policy-${policy} PRIVATE c_std_11)
        if(policy STREQUAL "fine")
            target_compile_definitions(rec-width-policy-${policy} PRIVATE
                LW_NATIVE_FINE_REC_WIDTHS=1 LW_TEST_FINE_WIDTHS=1)
        endif()
        if(MSVC)
            target_compile_options(rec-width-policy-${policy} PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(rec-width-policy-${policy} PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME rec_width_policy_${policy} COMMAND rec-width-policy-${policy})
    endforeach()
    add_test(NAME onnx_e2e_comparison_contract
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v tests.test_onnx_e2e_comparison)
    set_tests_properties(onnx_e2e_comparison_contract PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 30)
    if(WIN32 AND MSVC AND CMAKE_SIZEOF_VOID_P EQUAL 8 AND
       MSVC_C_ARCHITECTURE_ID MATCHES "^(x64|X86)$")
        add_test(NAME csharp_image_limits_contract
            COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_csharp_image_limits.py"
                --native "$<TARGET_FILE:lw_ppocr_c_shared>")
        set_tests_properties(csharp_image_limits_contract PROPERTIES
            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 240)
    endif()
    add_test(NAME web_release_profile_contract
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v tests.test_web_release_profile)
    set_tests_properties(web_release_profile_contract PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 30)
    add_test(NAME winforms_release_version_contract
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v tests.test_winforms_release)
    set_tests_properties(winforms_release_version_contract PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 30)
    add_test(NAME native_rec_quality_contract
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v tests.test_native_rec_quality)
    set_tests_properties(native_rec_quality_contract PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 30)

    add_test(
        NAME source_final_newline_contract
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_source_newlines.py"
                --root "${CMAKE_CURRENT_SOURCE_DIR}")
    set_tests_properties(source_final_newline_contract PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 30)
    set(LW_RESHAPE_FIXTURE_DIR "${CMAKE_CURRENT_BINARY_DIR}/test-fixtures")
    set(LW_RESHAPE_FIXTURES
        "${LW_RESHAPE_FIXTURE_DIR}/valid.lwm"
        "${LW_RESHAPE_FIXTURE_DIR}/two-unknown.lwm"
        "${LW_RESHAPE_FIXTURE_DIR}/non-divisible.lwm"
        "${LW_RESHAPE_FIXTURE_DIR}/zero.lwm"
        "${LW_RESHAPE_FIXTURE_DIR}/overflow.lwm")
    add_custom_command(
        OUTPUT ${LW_RESHAPE_FIXTURES}
        COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tools/create_reshape_test_models.py"
                --output-dir "${LW_RESHAPE_FIXTURE_DIR}"
        DEPENDS
            "${CMAKE_CURRENT_SOURCE_DIR}/tools/create_reshape_test_models.py"
            "${CMAKE_CURRENT_SOURCE_DIR}/converter/lwm_v0.py"
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        COMMENT "Creating direct dynamic Reshape contract fixtures"
        VERBATIM)
    add_custom_target(dynamic_reshape_fixtures DEPENDS ${LW_RESHAPE_FIXTURES})
    add_executable(test-dynamic-reshape tests/reshape_dynamic_driver.c)
    target_link_libraries(test-dynamic-reshape PRIVATE lw_ppocr_c)
    target_compile_features(test-dynamic-reshape PRIVATE c_std_11)
    add_dependencies(test-dynamic-reshape dynamic_reshape_fixtures)
    if(MSVC)
        target_compile_options(test-dynamic-reshape PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(test-dynamic-reshape PRIVATE -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME dynamic_reshape_contract
        COMMAND test-dynamic-reshape ${LW_RESHAPE_FIXTURES})

    add_test(
        NAME model_analysis
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v
                tests.test_analyze_onnx tests.test_compare_model_analysis
                tests.test_cls_identity tests.test_model_contract
                tests.test_small_validation_bundle
                tests.test_model_catalog
                tests.test_model_manifest
                tests.test_probe_rec_shape_metadata
                tests.test_small_contracts
                tests.test_medium_contracts
                tests.test_ocr_dataset
                tests.test_generate_ocr_dataset
                tests.test_prepare_ocr_dataset_ppm
                tests.test_build_ocr_width_switch_manifest
                tests.test_compare_ocr_dataset_runtime
                tests.test_collect_rec_shape_profile
                tests.test_collect_det_shape_profile
                tests.test_compare_ocr_dataset_reports
                tests.test_build_engine_comparison_report
                tests.test_layout_plan_snapshot
                tests.test_summarize_ocr_dataset_reports
                tests.test_check_ocr_dataset_regression
                tests.test_experimental_ops tests.test_small_ocr_baseline
                tests.test_runtime_model_pack
                tests.test_release_assets
                tests.test_web_ocr_contracts
                tests.test_versioning)
    set_tests_properties(model_analysis PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_test(
        NAME release_metadata_consistency
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tools/check_release_readiness.py"
                --mode preview
                --version "${PROJECT_VERSION}")
    set_tests_properties(release_metadata_consistency PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_test(
        NAME wasm_host_abi_contract
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v
                tests.test_web_abi_contract)
    set_tests_properties(wasm_host_abi_contract PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_test(
        NAME conv_shape_analysis
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v
                tests.test_analyze_conv_shapes)
    set_tests_properties(conv_shape_analysis PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_test(
        NAME rec_aot_pattern_analysis
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v
                tests.test_analyze_rec_aot_patterns)
    set_tests_properties(rec_aot_pattern_analysis PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_test(
        NAME ocr_dispatch_profile_comparison
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v
                tests.test_compare_ocr_dispatch_profiles)
    set_tests_properties(ocr_dispatch_profile_comparison PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_test(
        NAME rec_runtime_profile_comparison
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v
                tests.test_compare_rec_runtime_profiles)
    set_tests_properties(rec_runtime_profile_comparison PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_test(
        NAME opencv_dnn_comparison_helpers
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v
                tests.test_compare_opencv_dnn)
    set_tests_properties(opencv_dnn_comparison_helpers PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_test(
        NAME conv_bn_fusion
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v
                tests.test_conv_bn_fusion)
    set_tests_properties(conv_bn_fusion PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_test(
        NAME rec_converter
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v
                tests.test_convert_rec)
    set_tests_properties(rec_converter PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_test(
        NAME cls_converter
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v
                tests.test_convert_cls)
    set_tests_properties(cls_converter PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_test(
        NAME det_converter
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v
                tests.test_convert_det)
    set_tests_properties(det_converter PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_executable(test-lwm-loader tests/test_model.c)
    target_link_libraries(test-lwm-loader PRIVATE lw_ppocr_c)
    target_compile_features(test-lwm-loader PRIVATE c_std_11)
    add_dependencies(test-lwm-loader convert_rec_model)
    if(MSVC)
        target_compile_options(test-lwm-loader PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(test-lwm-loader PRIVATE -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(NAME lwm_loader COMMAND test-lwm-loader "${LW_PPOCR_C_REC_LWM}")

    add_executable(test-crop-buffer tests/test_crop_buffer.c)
    target_link_libraries(test-crop-buffer PRIVATE lw_ppocr_c)
    target_include_directories(test-crop-buffer PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
    target_compile_features(test-crop-buffer PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(test-crop-buffer PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(test-crop-buffer PRIVATE -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(NAME crop_buffer COMMAND test-crop-buffer)
    add_executable(test-session-planner tests/test_session.c)
    target_link_libraries(test-session-planner PRIVATE lw_ppocr_c)
    target_include_directories(test-session-planner PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
    if(LW_EXPERIMENTAL_PREPARED_EXECUTION)
        target_compile_definitions(test-session-planner PRIVATE LW_EXPERIMENTAL_PREPARED_EXECUTION=1)
    endif()
    target_compile_features(test-session-planner PRIVATE c_std_11)
    add_dependencies(test-session-planner convert_rec_model)
    if(MSVC)
        target_compile_options(test-session-planner PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(test-session-planner PRIVATE -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(NAME session_planner COMMAND test-session-planner "${LW_PPOCR_C_REC_LWM}")
    add_executable(layout-plan-driver
        tests/layout_plan_driver.c
        src/runtime/layout_planner.c)
    target_link_libraries(layout-plan-driver PRIVATE lw_ppocr_c)
    target_include_directories(layout-plan-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
    target_compile_features(layout-plan-driver PRIVATE c_std_11)
    add_dependencies(layout-plan-driver convert_rec_model convert_det_model)
    if(MSVC)
        target_compile_options(layout-plan-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(layout-plan-driver PRIVATE -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(NAME layout_plan_analysis
        COMMAND layout-plan-driver "${LW_PPOCR_C_REC_LWM}" 48 960)
    add_test(NAME layout_plan_direct_input
        COMMAND layout-plan-driver "${LW_PPOCR_C_REC_LWM}" 48 960 direct-nhwc)
    add_test(NAME layout_plan_det
        COMMAND layout-plan-driver "${LW_PPOCR_C_DET_LWM}" 640 640 direct-nhwc)

    add_executable(workspace-report-driver tests/workspace_report_driver.c)
    target_link_libraries(workspace-report-driver PRIVATE lw_ppocr_c)
    target_include_directories(workspace-report-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
    target_compile_features(workspace-report-driver PRIVATE c_std_11)
    add_dependencies(workspace-report-driver convert_rec_model)
    if(MSVC)
        target_compile_options(workspace-report-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(workspace-report-driver PRIVATE -Wall -Wextra -Wpedantic -Werror)
    endif()
    if(LW_EXPERIMENTAL_CTC_TILED)
        target_compile_definitions(workspace-report-driver PRIVATE LW_EXPERIMENTAL_CTC_TILED=1)
    endif()
    add_test(NAME workspace_memory_report
        COMMAND workspace-report-driver "${LW_PPOCR_C_REC_LWM}" 320 1)
    add_test(NAME workspace_ctc_memory_report
        COMMAND workspace-report-driver "${LW_PPOCR_C_REC_LWM}" 320 1 --ctc-greedy)

    add_executable(test-cpu-topology tests/test_cpu_topology.c)
    target_link_libraries(test-cpu-topology PRIVATE lw_ppocr_c)
    target_include_directories(test-cpu-topology PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
    target_compile_features(test-cpu-topology PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(test-cpu-topology PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(test-cpu-topology PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(NAME cpu_topology_policy COMMAND test-cpu-topology)

    add_executable(test-c-abi tests/test_abi.c)
    target_link_libraries(test-c-abi PRIVATE lw_ppocr_c)
    target_compile_features(test-c-abi PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(test-c-abi PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(test-c-abi PRIVATE -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(NAME c_abi_contract COMMAND test-c-abi)

    add_executable(test-c-abi-prefix tests/test_abi_prefix.c)
    target_link_libraries(test-c-abi-prefix PRIVATE lw_ppocr_c)
    target_compile_features(test-c-abi-prefix PRIVATE c_std_11)
    add_dependencies(test-c-abi-prefix convert_det_model convert_cls_model convert_rec_model)
    if(MSVC)
        target_compile_options(test-c-abi-prefix PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(test-c-abi-prefix PRIVATE -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME c_abi_prefix_compatibility
        COMMAND test-c-abi-prefix
                "${LW_PPOCR_C_DET_LWM}"
                "${LW_PPOCR_C_CLS_LWM}"
                "${LW_PPOCR_C_REC_LWM}"
                "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt")

    add_executable(abi-layout-driver tests/abi_layout_driver.c)
    target_include_directories(abi-layout-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/include")
    target_compile_features(abi-layout-driver PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(abi-layout-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(abi-layout-driver PRIVATE -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME abi_layout_contract
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_abi_layout.py"
                --driver "$<TARGET_FILE:abi-layout-driver>"
                --manifest "${CMAKE_CURRENT_SOURCE_DIR}/abi/c-abi-v1-layout.json")

    add_test(
        NAME lwm_layout_contract
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_lwm_layout.py"
                --manifest "${CMAKE_CURRENT_SOURCE_DIR}/abi/lwm-v0.1-layout.json"
                --model "${LW_PPOCR_C_DET_LWM}"
                --model "${LW_PPOCR_C_CLS_LWM}"
                --model "${LW_PPOCR_C_REC_LWM}")
    set_tests_properties(lwm_layout_contract PROPERTIES
        DEPENDS "det_converter;cls_converter;rec_converter")

    add_executable(test-recognizer-api tests/test_recognizer.c)
    target_link_libraries(test-recognizer-api PRIVATE lw_ppocr_c)
    target_compile_features(test-recognizer-api PRIVATE c_std_11)
    add_dependencies(test-recognizer-api convert_rec_model)
    if(MSVC)
        target_compile_options(test-recognizer-api PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(test-recognizer-api PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME recognizer_api_contract
        COMMAND test-recognizer-api
                "${LW_PPOCR_C_REC_LWM}"
                "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt")

    add_executable(test-classifier-api tests/test_classifier.c)
    target_link_libraries(test-classifier-api PRIVATE lw_ppocr_c)
    target_compile_features(test-classifier-api PRIVATE c_std_11)
    add_dependencies(test-classifier-api convert_cls_model)
    if(MSVC)
        target_compile_options(test-classifier-api PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(test-classifier-api PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME classifier_api_contract
        COMMAND test-classifier-api "${LW_PPOCR_C_CLS_LWM}")

    add_test(
        NAME c_demo_classification
        COMMAND lw-classify-ppm
                "${LW_PPOCR_C_CLS_LWM}"
                "${LW_PPOCR_C_REC_DEMO_PPM}")

    add_test(
        NAME c_demo_detection
        COMMAND lw-detect-ppm
                "${LW_PPOCR_C_DET_LWM}"
                "${LW_PPOCR_C_DET_DEMO_PPM}")
    set_tests_properties(c_demo_detection PROPERTIES TIMEOUT 300)

    add_test(
        NAME c_demo_full_ocr
        COMMAND lw-ocr-ppm
                "${LW_PPOCR_C_DET_LWM}"
                "${LW_PPOCR_C_CLS_LWM}"
                "${LW_PPOCR_C_REC_LWM}"
                "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
                "${LW_PPOCR_C_DET_DEMO_PPM}")
    set_tests_properties(c_demo_full_ocr PROPERTIES TIMEOUT 600)

    add_test(
        NAME c_demo_recognition
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_recognize_ppm_demo.py"
                --demo "$<TARGET_FILE:lw-recognize-ppm>"
                --model "${LW_PPOCR_C_REC_LWM}"
                --dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
                --image "${LW_PPOCR_C_REC_DEMO_PPM}")
    set_tests_properties(c_demo_recognition PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 180)

    add_test(
        NAME rec_scalar_benchmark
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_rec_benchmark.py"
                --benchmark "$<TARGET_FILE:lw-rec-benchmark>"
                --model "${LW_PPOCR_C_REC_LWM}"
                --dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
                --image "${LW_PPOCR_C_REC_DEMO_PPM}")
    set_tests_properties(rec_scalar_benchmark PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 240)

    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
        set(LW_FULL_OCR_BENCH_WORKERS 8)
    else()
        set(LW_FULL_OCR_BENCH_WORKERS 1)
    endif()
    add_test(
        NAME full_ocr_parallel_benchmark
        COMMAND lw-ocr-benchmark
                "${LW_PPOCR_C_DET_LWM}"
                "${LW_PPOCR_C_CLS_LWM}"
                "${LW_PPOCR_C_REC_LWM}"
                "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
                "${LW_PPOCR_C_DET_DEMO_PPM}"
                1 1 "${LW_FULL_OCR_BENCH_WORKERS}" 960)
    set_tests_properties(full_ocr_parallel_benchmark PROPERTIES TIMEOUT 300)

    if(MSVC)
        get_filename_component(LW_EXPORT_TOOL_DIR "${CMAKE_C_COMPILER}" DIRECTORY)
        set(LW_EXPORT_TOOL "${LW_EXPORT_TOOL_DIR}/dumpbin.exe")
    else()
        set(LW_EXPORT_TOOL "${CMAKE_NM}")
    endif()
    add_test(
        NAME shared_export_contract
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_shared_exports.py"
                --library "$<TARGET_FILE:lw_ppocr_c_shared>"
                --allowlist "${CMAKE_CURRENT_SOURCE_DIR}/abi/exports-v0.txt"
                --tool "${LW_EXPORT_TOOL}")
    set_tests_properties(shared_export_contract PROPERTIES TIMEOUT 60)

    add_test(
        NAME shared_export_candidate_contract
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_abi_v1_candidate.py"
                --header "${CMAKE_CURRENT_SOURCE_DIR}/include/lw_infer.h"
                --manifest "${CMAKE_CURRENT_SOURCE_DIR}/abi/c-abi-v1-candidate.json"
                --allowlist "${CMAKE_CURRENT_SOURCE_DIR}/abi/exports-v1-candidate.txt"
                --library "$<TARGET_FILE:lw_ppocr_c_shared>"
                --tool "${LW_EXPORT_TOOL}")
    set_tests_properties(shared_export_candidate_contract PROPERTIES TIMEOUT 60)

    add_executable(kernel-reference-driver tests/kernel_reference_driver.c)
    target_link_libraries(kernel-reference-driver PRIVATE lw_ppocr_c)
    target_include_directories(kernel-reference-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(kernel-reference-driver PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(kernel-reference-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(kernel-reference-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME scalar_kernel_reference
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_scalar_kernels_reference.py"
                --driver "$<TARGET_FILE:kernel-reference-driver>")
    set_tests_properties(scalar_kernel_reference PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_executable(tensor-reference-driver tests/tensor_reference_driver.c)
    target_link_libraries(tensor-reference-driver PRIVATE lw_ppocr_c)
    target_include_directories(tensor-reference-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(tensor-reference-driver PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(tensor-reference-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(tensor-reference-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME tensor_kernel_reference
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_tensor_kernels_reference.py"
                --driver "$<TARGET_FILE:tensor-reference-driver>")
    set_tests_properties(tensor_kernel_reference PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_executable(conv-reference-driver tests/conv_reference_driver.c)
    target_link_libraries(conv-reference-driver PRIVATE lw_ppocr_c)
    target_include_directories(conv-reference-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(conv-reference-driver PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(conv-reference-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(conv-reference-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME conv_kernel_reference
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_conv_kernels_reference.py"
                --driver "$<TARGET_FILE:conv-reference-driver>")

    add_executable(conv3x3-benchmark-driver
        tests/conv3x3_benchmark_driver.c)
    target_link_libraries(conv3x3-benchmark-driver PRIVATE lw_ppocr_c)
    target_include_directories(conv3x3-benchmark-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(conv3x3-benchmark-driver PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(conv3x3-benchmark-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(conv3x3-benchmark-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME conv3x3_benchmark_smoke
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_conv3x3_benchmark.py"
                --driver "$<TARGET_FILE:conv3x3-benchmark-driver>")
    set_tests_properties(conv3x3_benchmark_smoke PROPERTIES TIMEOUT 120)

    add_executable(convtranspose-benchmark-driver
        tests/convtranspose_benchmark_driver.c)
    target_link_libraries(convtranspose-benchmark-driver PRIVATE lw_ppocr_c)
    target_include_directories(convtranspose-benchmark-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(convtranspose-benchmark-driver PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(convtranspose-benchmark-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(convtranspose-benchmark-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME convtranspose_benchmark_smoke
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_convtranspose_benchmark.py"
                --driver "$<TARGET_FILE:convtranspose-benchmark-driver>")
    set_tests_properties(convtranspose_benchmark_smoke PROPERTIES TIMEOUT 120)

    add_executable(packed-conv1x1-benchmark-driver
        tests/packed_conv1x1_benchmark_driver.c)
    target_link_libraries(packed-conv1x1-benchmark-driver PRIVATE lw_ppocr_c)
    target_include_directories(packed-conv1x1-benchmark-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(packed-conv1x1-benchmark-driver PRIVATE c_std_11)
    if(LW_EXPERIMENTAL_AVX2_FMA_DISPATCH OR LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH)
        target_compile_definitions(packed-conv1x1-benchmark-driver PRIVATE LW_EXPERIMENTAL_AVX2_FMA_CONV1X1_DISPATCH=1)
    endif()
    if(MSVC)
        target_compile_options(packed-conv1x1-benchmark-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(packed-conv1x1-benchmark-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME packed_conv1x1_benchmark_smoke
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_packed_conv1x1_benchmark.py"
                --driver "$<TARGET_FILE:packed-conv1x1-benchmark-driver>")
    set_tests_properties(packed_conv1x1_benchmark_smoke PROPERTIES TIMEOUT 120)

    add_executable(packed-matmul-benchmark-driver
        tests/packed_matmul_benchmark_driver.c)
    target_link_libraries(packed-matmul-benchmark-driver PRIVATE lw_ppocr_c)
    target_include_directories(packed-matmul-benchmark-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(packed-matmul-benchmark-driver PRIVATE c_std_11)
    if(LW_EXPERIMENTAL_AVX2_FMA_DISPATCH OR LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH)
        target_compile_definitions(packed-matmul-benchmark-driver PRIVATE LW_EXPERIMENTAL_AVX2_FMA_MATMUL_DISPATCH=1)
    endif()
    if(MSVC)
        target_compile_options(packed-matmul-benchmark-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(packed-matmul-benchmark-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME packed_matmul_benchmark_smoke
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_packed_matmul_benchmark.py"
                --driver "$<TARGET_FILE:packed-matmul-benchmark-driver>")
    set_tests_properties(packed_matmul_benchmark_smoke PROPERTIES TIMEOUT 120)
    add_executable(erf-benchmark-driver
        tests/erf_benchmark_driver.c)
    target_link_libraries(erf-benchmark-driver PRIVATE lw_ppocr_c)
    target_include_directories(erf-benchmark-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(erf-benchmark-driver PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(erf-benchmark-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(erf-benchmark-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME erf_benchmark_smoke
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_erf_benchmark.py"
                --driver "$<TARGET_FILE:erf-benchmark-driver>")
    set_tests_properties(erf_benchmark_smoke PROPERTIES TIMEOUT 120)

    add_executable(conv3x3-stride2-benchmark-driver
        tests/conv3x3_stride2_benchmark_driver.c)
    target_link_libraries(conv3x3-stride2-benchmark-driver PRIVATE lw_ppocr_c)
    target_include_directories(conv3x3-stride2-benchmark-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(conv3x3-stride2-benchmark-driver PRIVATE c_std_11)
    if(LW_EXPERIMENTAL_AVX2_FMA_DISPATCH)
        target_compile_definitions(conv3x3-stride2-benchmark-driver PRIVATE LW_EXPERIMENTAL_AVX2_FMA_DISPATCH=1)
    endif()
    if(LW_AVX2_FMA_CONV3X3_DISPATCH AND NOT EMSCRIPTEN)
        target_compile_definitions(conv3x3-stride2-benchmark-driver PRIVATE LW_AVX2_FMA_CONV3X3_DISPATCH=1)
    endif()
    if(MSVC)
        target_compile_options(conv3x3-stride2-benchmark-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(conv3x3-stride2-benchmark-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME conv3x3_stride2_benchmark_smoke
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_conv3x3_stride2_benchmark.py"
                --driver "$<TARGET_FILE:conv3x3-stride2-benchmark-driver>")
    set_tests_properties(conv3x3_stride2_benchmark_smoke PROPERTIES TIMEOUT 120)
    set_tests_properties(conv_kernel_reference PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    add_executable(simd-backend-driver tests/simd_backend_driver.c)
    target_link_libraries(simd-backend-driver PRIVATE lw_ppocr_c)
    target_include_directories(simd-backend-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(simd-backend-driver PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(simd-backend-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(simd-backend-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(NAME simd_backend_detection COMMAND simd-backend-driver)

    add_executable(rec-graph-driver tests/rec_graph_driver.c)
    target_link_libraries(rec-graph-driver PRIVATE lw_ppocr_c)
    target_include_directories(rec-graph-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
    target_compile_features(rec-graph-driver PRIVATE c_std_11)
    add_dependencies(rec-graph-driver convert_rec_model)
    if(MSVC)
        target_compile_definitions(rec-graph-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
        target_compile_options(rec-graph-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(rec-graph-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME rec_graph_reference
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_rec_graph_reference.py"
                --driver "$<TARGET_FILE:rec-graph-driver>"
                --lwm-model "${LW_PPOCR_C_REC_LWM}"
                --onnx-model "${LW_PPOCR_C_REC_ONNX}")
    set_tests_properties(rec_graph_reference PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 360)
    set(LW_ONNX_WIDTH_TEST_ARGS)
    if(LW_NATIVE_FINE_REC_WIDTHS)
        list(APPEND LW_ONNX_WIDTH_TEST_ARGS --fine-rec-widths)
    endif()
    add_test(NAME native_onnx_import
        COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_onnx_import.py"
            --inspect "$<TARGET_FILE:lwm-inspect>"
            --rec-driver "$<TARGET_FILE:rec-graph-driver>"
            --ocr-driver "$<TARGET_FILE:lw-ocr-ppm>"
            --root "${CMAKE_CURRENT_SOURCE_DIR}"
            --sample "${LW_PPOCR_C_DET_DEMO_PPM}"
            ${LW_ONNX_WIDTH_TEST_ARGS}
            --report "${CMAKE_CURRENT_BINARY_DIR}/onnx-import-report.json")
    set_tests_properties(native_onnx_import PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 600)
    add_test(NAME deployment_model_formats
        COMMAND "${Python3_EXECUTABLE}" -m unittest -v tests.test_deployment_model_formats)
    set_tests_properties(deployment_model_formats PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" TIMEOUT 120)

    add_executable(cls-graph-driver tests/cls_graph_driver.c)
    target_link_libraries(cls-graph-driver PRIVATE lw_ppocr_c)
    target_include_directories(cls-graph-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
    target_compile_features(cls-graph-driver PRIVATE c_std_11)
    add_dependencies(cls-graph-driver convert_cls_model)
    if(MSVC)
        target_compile_options(cls-graph-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(cls-graph-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME cls_graph_reference
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_cls_graph_reference.py"
                --driver "$<TARGET_FILE:cls-graph-driver>"
                --lwm-model "${LW_PPOCR_C_CLS_LWM}"
                --onnx-model "${LW_PPOCR_C_CLS_ONNX}")
    set_tests_properties(cls_graph_reference PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 360)

    add_executable(det-graph-driver tests/det_graph_driver.c)
    target_link_libraries(det-graph-driver PRIVATE lw_ppocr_c)
    target_include_directories(det-graph-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
    target_compile_features(det-graph-driver PRIVATE c_std_11)
    add_dependencies(det-graph-driver convert_det_model)
    if(MSVC)
        target_compile_definitions(det-graph-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
        target_compile_options(det-graph-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(det-graph-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME det_graph_reference
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_det_graph_reference.py"
                --driver "$<TARGET_FILE:det-graph-driver>"
                --lwm-model "${LW_PPOCR_C_DET_LWM}"
                --onnx-model "${LW_PPOCR_C_DET_ONNX}")
    set_tests_properties(det_graph_reference PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 600)

    add_executable(det-pipeline-driver tests/det_pipeline_driver.c)
    target_link_libraries(det-pipeline-driver PRIVATE lw_ppocr_c)
    target_include_directories(det-pipeline-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
    target_compile_features(det-pipeline-driver PRIVATE c_std_11)
    add_dependencies(det-pipeline-driver convert_det_model)
    if(MSVC)
        target_compile_options(det-pipeline-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(det-pipeline-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME det_pipeline_reference
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_det_pipeline_reference.py"
                --driver "$<TARGET_FILE:det-pipeline-driver>"
                --model "${LW_PPOCR_C_DET_LWM}"
                --sample "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg")
    set_tests_properties(det_pipeline_reference PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 900)

    add_executable(reading-order-driver tests/reading_order_driver.c)
    target_link_libraries(reading-order-driver PRIVATE lw_ppocr_c)
    target_include_directories(reading-order-driver PRIVATE src/ppocr)
    target_compile_features(reading-order-driver PRIVATE c_std_11)
    if(MSVC)
        target_compile_options(reading-order-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(reading-order-driver PRIVATE -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(NAME reading_order_sorting COMMAND reading-order-driver)

    add_executable(ocr-pipeline-driver tests/ocr_pipeline_driver.c)
    target_link_libraries(ocr-pipeline-driver PRIVATE lw_ppocr_c)
    target_include_directories(ocr-pipeline-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
    target_compile_features(ocr-pipeline-driver PRIVATE c_std_11)
    add_dependencies(ocr-pipeline-driver convert_det_model convert_cls_model
        convert_rec_model)
    if(MSVC)
        target_compile_definitions(ocr-pipeline-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
        target_compile_options(ocr-pipeline-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(ocr-pipeline-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME full_ocr_pipeline_reference
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_ocr_pipeline_reference.py"
                --driver "$<TARGET_FILE:ocr-pipeline-driver>"
                --detector "${LW_PPOCR_C_DET_LWM}"
                --classifier "${LW_PPOCR_C_CLS_LWM}"
                --recognizer "${LW_PPOCR_C_REC_LWM}"
                --dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
                --sample "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg")
    set_tests_properties(full_ocr_pipeline_reference PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 1200)

    add_test(
        NAME full_ocr_golden_corpus
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_ocr_golden_corpus.py"
                --driver "$<TARGET_FILE:ocr-pipeline-driver>"
                --detector "${LW_PPOCR_C_DET_LWM}"
                --classifier "${LW_PPOCR_C_CLS_LWM}"
                --recognizer "${LW_PPOCR_C_REC_LWM}"
                --dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
                --detector-source "${LW_PPOCR_C_DET_ONNX}"
                --classifier-source "${LW_PPOCR_C_CLS_ONNX}"
                --recognizer-source "${LW_PPOCR_C_REC_ONNX}"
                --sample "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
                --corpus "${CMAKE_CURRENT_SOURCE_DIR}/tests/fixtures/ocr-golden-corpus.json")
    set_tests_properties(full_ocr_golden_corpus PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 1200)

    add_executable(cls-pipeline-driver tests/cls_pipeline_driver.c)
    target_link_libraries(cls-pipeline-driver PRIVATE lw_ppocr_c)
    if(WIN32)
        target_link_libraries(cls-pipeline-driver PRIVATE shell32)
    endif()
    target_include_directories(cls-pipeline-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
    target_compile_features(cls-pipeline-driver PRIVATE c_std_11)
    add_dependencies(cls-pipeline-driver convert_cls_model)
    if(MSVC)
        target_compile_options(cls-pipeline-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(cls-pipeline-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME cls_pipeline_reference
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_cls_pipeline_reference.py"
                --driver "$<TARGET_FILE:cls-pipeline-driver>"
                --lwm-model "${LW_PPOCR_C_CLS_LWM}"
                --onnx-model "${LW_PPOCR_C_CLS_ONNX}")
    set_tests_properties(cls_pipeline_reference PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 360)

    add_executable(rec-profile-driver tests/rec_profile_driver.c)
    target_link_libraries(rec-profile-driver PRIVATE lw_ppocr_c)
    target_include_directories(rec-profile-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
    target_compile_features(rec-profile-driver PRIVATE c_std_11)
    add_dependencies(rec-profile-driver convert_rec_model)
    if(MSVC)
        target_compile_options(rec-profile-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(rec-profile-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME rec_operator_profile
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_rec_profile.py"
                --driver "$<TARGET_FILE:rec-profile-driver>"
                --model "${LW_PPOCR_C_REC_LWM}")
    set_tests_properties(rec_operator_profile PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 240)

    add_executable(full-ocr-profile-driver tests/full_ocr_profile_driver.c)
    target_link_libraries(full-ocr-profile-driver PRIVATE lw_ppocr_c)
    target_include_directories(full-ocr-profile-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/examples"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
    target_compile_features(full-ocr-profile-driver PRIVATE c_std_11)
    add_dependencies(full-ocr-profile-driver convert_det_model convert_cls_model
        convert_rec_model det_demo_fixture)
    if(MSVC)
        target_compile_options(full-ocr-profile-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(full-ocr-profile-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    set(full_ocr_profile_test_args
        --driver "$<TARGET_FILE:full-ocr-profile-driver>"
        --det-model "${LW_PPOCR_C_DET_LWM}"
        --cls-model "${LW_PPOCR_C_CLS_LWM}"
        --rec-model "${LW_PPOCR_C_REC_LWM}"
        --dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
        --image "${LW_PPOCR_C_DET_DEMO_PPM}")
    if(LW_REC_RESIDENT_WIDTHS AND NOT EMSCRIPTEN)
        list(APPEND full_ocr_profile_test_args --expect-resident)
    endif()
    if(LW_X64_REC_FAST_ENABLED)
        list(APPEND full_ocr_profile_test_args --expect-compiled-rec)
    endif()
    if(LW_EXPERIMENTAL_PREPARED_EXECUTION AND NOT EMSCRIPTEN)
        list(APPEND full_ocr_profile_test_args --expect-prepared)
    endif()
    add_test(
        NAME full_ocr_operator_profile
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_full_ocr_profile.py"
                ${full_ocr_profile_test_args})
    set_tests_properties(full_ocr_operator_profile PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 360)

    # Test-only benchmark variant: it links the static runtime so an internal
    # DET intra-op override can be measured without expanding the public ABI.
    add_executable(full-ocr-intra-benchmark examples/ocr_benchmark_ppm.c)
    target_link_libraries(full-ocr-intra-benchmark PRIVATE lw_ppocr_c)
    target_compile_definitions(full-ocr-intra-benchmark PRIVATE
        LW_OCR_BENCHMARK_INTERNAL=1)
    target_include_directories(full-ocr-intra-benchmark PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/examples"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(full-ocr-intra-benchmark PRIVATE c_std_11)
    add_dependencies(full-ocr-intra-benchmark convert_det_model convert_cls_model
        convert_rec_model det_demo_fixture)
    if(WIN32)
        target_link_libraries(full-ocr-intra-benchmark PRIVATE shell32 psapi)
    endif()
    if(MSVC)
        target_compile_options(full-ocr-intra-benchmark PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(full-ocr-intra-benchmark PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()

    # Same-process dataset benchmark used to measure resident/compact memory
    # and latency without restarting the OCR runtime for every image.
    if(NOT EMSCRIPTEN)
        add_executable(full-ocr-dataset-benchmark examples/ocr_dataset_benchmark.c)
        target_link_libraries(full-ocr-dataset-benchmark PRIVATE lw_ppocr_c)
        target_include_directories(full-ocr-dataset-benchmark PRIVATE
            "${CMAKE_CURRENT_SOURCE_DIR}/examples"
            "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
            "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
        target_compile_features(full-ocr-dataset-benchmark PRIVATE c_std_11)
        add_dependencies(full-ocr-dataset-benchmark convert_det_model convert_cls_model
            convert_rec_model det_demo_fixture)
        if(LW_REC_RESIDENT_WIDTHS)
            target_compile_definitions(full-ocr-dataset-benchmark PRIVATE LW_REC_RESIDENT_WIDTHS=1)
        endif()
        if(WIN32)
            target_link_libraries(full-ocr-dataset-benchmark PRIVATE shell32 psapi)
        endif()
        if(MSVC)
            target_compile_definitions(full-ocr-dataset-benchmark PRIVATE _CRT_SECURE_NO_WARNINGS)
            target_compile_options(full-ocr-dataset-benchmark PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(full-ocr-dataset-benchmark PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        if(LW_X64_REC_FAST_ENABLED AND LW_EXPERIMENTAL_ADAPTIVE_REC_BUDGET)
            add_test(
                NAME full_ocr_adaptive_rec_budget
                COMMAND "${Python3_EXECUTABLE}"
                        "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_ocr_adaptive_rec_budget.py"
                        --benchmark "$<TARGET_FILE:full-ocr-dataset-benchmark>"
                        --det "${LW_PPOCR_C_DET_LWM}"
                        --cls "${LW_PPOCR_C_CLS_LWM}"
                        --rec "${LW_PPOCR_C_REC_LWM}"
                        --dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
                        --sample "${LW_PPOCR_C_DET_DEMO_PPM}")
            set_tests_properties(full_ocr_adaptive_rec_budget PROPERTIES TIMEOUT 180)
        endif()
    endif()

    add_executable(rec-preprocess-layout-driver tests/rec_preprocess_layout_driver.c)
    target_link_libraries(rec-preprocess-layout-driver PRIVATE lw_ppocr_c)
    target_include_directories(rec-preprocess-layout-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
    target_compile_features(rec-preprocess-layout-driver PRIVATE c_std_11)
    if(MSVC)
        target_compile_definitions(rec-preprocess-layout-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
        target_compile_options(rec-preprocess-layout-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(rec-preprocess-layout-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(NAME rec_preprocess_layout COMMAND rec-preprocess-layout-driver)
    set_tests_properties(rec_preprocess_layout PROPERTIES TIMEOUT 30)
    add_executable(nhwc-conv1x1-driver tests/nhwc_conv1x1_driver.c)
    target_link_libraries(nhwc-conv1x1-driver PRIVATE lw_ppocr_c)
    target_include_directories(nhwc-conv1x1-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
    target_compile_features(nhwc-conv1x1-driver PRIVATE c_std_11)
    if(MSVC AND CMAKE_SYSTEM_PROCESSOR MATCHES "(AMD64|x86_64|amd64|X86)")
        target_compile_options(nhwc-conv1x1-driver PRIVATE /arch:AVX2)
    endif()
    if(MSVC)
        target_compile_definitions(nhwc-conv1x1-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
        target_compile_options(nhwc-conv1x1-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(nhwc-conv1x1-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(NAME nhwc_conv1x1_layout COMMAND nhwc-conv1x1-driver)
    set_tests_properties(nhwc_conv1x1_layout PROPERTIES TIMEOUT 30)
    if(LW_EXPERIMENTAL_AVX2_FAST_PATH AND
       (CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|amd64|AMD64|x64|X86)$" OR
        MSVC_C_ARCHITECTURE_ID MATCHES "^(x64|X86)$"))
        add_executable(nhwc-pointwise-benchmark-driver
            tests/nhwc_pointwise_driver.c
            src/kernels/nhwc_pack.c
            src/simd/avx2_nhwc_pointwise.c)
        target_link_libraries(nhwc-pointwise-benchmark-driver PRIVATE lw_ppocr_c)
        target_include_directories(nhwc-pointwise-benchmark-driver PRIVATE
            "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
            "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
        target_compile_features(nhwc-pointwise-benchmark-driver PRIVATE c_std_11)
        target_compile_definitions(nhwc-pointwise-benchmark-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        if(MSVC)
            set_property(SOURCE src/simd/avx2_nhwc_pointwise.c APPEND PROPERTY
                COMPILE_OPTIONS /arch:AVX2 /fp:strict)
            target_compile_definitions(nhwc-pointwise-benchmark-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(nhwc-pointwise-benchmark-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(nhwc-pointwise-benchmark-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME nhwc_pointwise_benchmark
            COMMAND "${Python3_EXECUTABLE}"
                    "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_nhwc_pointwise_benchmark.py"
                    --driver "$<TARGET_FILE:nhwc-pointwise-benchmark-driver>")
        set_tests_properties(nhwc_pointwise_benchmark PROPERTIES TIMEOUT 120)
        add_executable(nhwc-support-driver
            tests/nhwc_support_driver.c)
        target_link_libraries(nhwc-support-driver PRIVATE lw_ppocr_c)
        target_include_directories(nhwc-support-driver PRIVATE
            src/kernels)
        target_compile_features(nhwc-support-driver PRIVATE c_std_11)
        target_compile_definitions(nhwc-support-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        if(MSVC)
            target_compile_definitions(nhwc-support-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(nhwc-support-driver PRIVATE /arch:AVX2 /W4 /WX /utf-8)
        else()
            target_compile_options(nhwc-support-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME nhwc_support_pool COMMAND nhwc-support-driver)
        set_tests_properties(nhwc_support_pool PROPERTIES TIMEOUT 30)
        add_executable(nhwc-dense-benchmark-driver
            tests/nhwc_dense_driver.c
            src/kernels/nhwc_pack.c
            src/simd/avx2_nhwc_dense.c)
        target_link_libraries(nhwc-dense-benchmark-driver PRIVATE lw_ppocr_c)
        target_include_directories(nhwc-dense-benchmark-driver PRIVATE
            "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
            "${CMAKE_CURRENT_SOURCE_DIR}/src/simd")
        target_compile_features(nhwc-dense-benchmark-driver PRIVATE c_std_11)
        target_compile_definitions(nhwc-dense-benchmark-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        if(MSVC)
            set_property(SOURCE src/simd/avx2_nhwc_dense.c APPEND PROPERTY
                COMPILE_OPTIONS /arch:AVX2 /fp:strict)
            target_compile_definitions(nhwc-dense-benchmark-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(nhwc-dense-benchmark-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(nhwc-dense-benchmark-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME nhwc_dense_benchmark
            COMMAND "${Python3_EXECUTABLE}"
                    "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_nhwc_dense_benchmark.py"
                    --driver "$<TARGET_FILE:nhwc-dense-benchmark-driver>")
        set_tests_properties(nhwc_dense_benchmark PROPERTIES TIMEOUT 120)
        add_executable(nhwc-convtranspose-driver
            tests/nhwc_convtranspose_driver.c)
        target_link_libraries(nhwc-convtranspose-driver PRIVATE lw_ppocr_c)
        target_include_directories(nhwc-convtranspose-driver PRIVATE
            "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels"
            "${CMAKE_CURRENT_SOURCE_DIR}/src/simd"
            "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime")
        target_compile_features(nhwc-convtranspose-driver PRIVATE c_std_11)
        target_compile_definitions(nhwc-convtranspose-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        if(MSVC)
            target_compile_definitions(nhwc-convtranspose-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(nhwc-convtranspose-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(nhwc-convtranspose-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME nhwc_convtranspose_contract COMMAND nhwc-convtranspose-driver)
        set_tests_properties(nhwc_convtranspose_contract PROPERTIES TIMEOUT 120)
        add_executable(x64-rec-backend-contract-driver
            tests/x64_rec_backend_contract_driver.c)
        target_link_libraries(x64-rec-backend-contract-driver PRIVATE lw_ppocr_c)
        target_include_directories(x64-rec-backend-contract-driver PRIVATE
            src/runtime
            src/kernels
            src/simd)
        target_compile_features(x64-rec-backend-contract-driver PRIVATE c_std_11)
        target_compile_definitions(x64-rec-backend-contract-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        add_dependencies(x64-rec-backend-contract-driver convert_rec_model)
        if(MSVC)
            target_compile_definitions(x64-rec-backend-contract-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(x64-rec-backend-contract-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(x64-rec-backend-contract-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME x64_rec_backend_contract
            COMMAND x64-rec-backend-contract-driver ${LW_PPOCR_C_REC_LWM})
        set_tests_properties(x64_rec_backend_contract PROPERTIES TIMEOUT 120)
        add_executable(x64-rec-backend-execution-driver
            tests/x64_rec_backend_execution_driver.c)
        if(LW_EXPERIMENTAL_REC_FFN_TILING)
            add_executable(rec-ffn-contract-driver tests/rec_ffn_contract_driver.c)
            target_link_libraries(rec-ffn-contract-driver PRIVATE lw_ppocr_c)
            target_include_directories(rec-ffn-contract-driver PRIVATE src/runtime src/kernels src/simd)
            target_compile_features(rec-ffn-contract-driver PRIVATE c_std_11)
            if(MSVC)
                target_compile_options(rec-ffn-contract-driver PRIVATE /W4 /WX /utf-8)
            else()
                target_compile_options(rec-ffn-contract-driver PRIVATE -Wall -Wextra -Wpedantic -Werror)
            endif()
            foreach(variant tiny small medium)
                add_test(NAME rec_ffn_contract_${variant}
                    COMMAND rec-ffn-contract-driver
                        "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-${variant}/rec.onnx")
                set_tests_properties(rec_ffn_contract_${variant} PROPERTIES TIMEOUT 180)
            endforeach()
        endif()
        target_link_libraries(x64-rec-backend-execution-driver PRIVATE lw_ppocr_c)
        target_include_directories(x64-rec-backend-execution-driver PRIVATE
            src/runtime
            src/kernels
            src/simd
            src/ppocr)
        target_compile_features(x64-rec-backend-execution-driver PRIVATE c_std_11)
        target_compile_definitions(x64-rec-backend-execution-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        add_dependencies(x64-rec-backend-execution-driver convert_rec_model)
        if(MSVC)
            target_compile_definitions(x64-rec-backend-execution-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(x64-rec-backend-execution-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(x64-rec-backend-execution-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME x64_rec_backend_execution
            COMMAND x64-rec-backend-execution-driver ${LW_PPOCR_C_REC_LWM})
        set_tests_properties(x64_rec_backend_execution PROPERTIES TIMEOUT 120)
        add_executable(x64-rec-shared-constants-driver
            tests/x64_rec_shared_constants_driver.c)
        target_link_libraries(x64-rec-shared-constants-driver PRIVATE lw_ppocr_c)
        target_include_directories(x64-rec-shared-constants-driver PRIVATE
            src/runtime src/kernels src/simd)
        target_compile_features(x64-rec-shared-constants-driver PRIVATE c_std_11)
        add_dependencies(x64-rec-shared-constants-driver convert_rec_model)
        if(MSVC)
            target_compile_options(x64-rec-shared-constants-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(x64-rec-shared-constants-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME x64_rec_shared_constants
            COMMAND x64-rec-shared-constants-driver ${LW_PPOCR_C_REC_LWM})
        set_tests_properties(x64_rec_shared_constants PROPERTIES TIMEOUT 120)
        add_executable(x64-rec-backend-nchw-driver
            tests/x64_rec_backend_nchw_driver.c)
        target_link_libraries(x64-rec-backend-nchw-driver PRIVATE lw_ppocr_c)
        target_include_directories(x64-rec-backend-nchw-driver PRIVATE
            src/runtime
            src/kernels
            src/simd
            src/ppocr)
        target_compile_features(x64-rec-backend-nchw-driver PRIVATE c_std_11)
        target_compile_definitions(x64-rec-backend-nchw-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        add_dependencies(x64-rec-backend-nchw-driver convert_rec_model)
        if(MSVC)
            target_compile_definitions(x64-rec-backend-nchw-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(x64-rec-backend-nchw-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(x64-rec-backend-nchw-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME x64_rec_backend_nchw
            COMMAND x64-rec-backend-nchw-driver ${LW_PPOCR_C_REC_LWM})
        set_tests_properties(x64_rec_backend_nchw PROPERTIES TIMEOUT 120)
        add_executable(x64-rec-layout-benchmark-driver
            tests/x64_rec_layout_benchmark_driver.c)
        target_link_libraries(x64-rec-layout-benchmark-driver PRIVATE lw_ppocr_c)
        target_include_directories(x64-rec-layout-benchmark-driver PRIVATE
            src/runtime
            src/kernels
            src/simd
            src/ppocr)
        target_compile_features(x64-rec-layout-benchmark-driver PRIVATE c_std_11)
        target_compile_definitions(x64-rec-layout-benchmark-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        add_dependencies(x64-rec-layout-benchmark-driver convert_rec_model)
        if(MSVC)
            target_compile_definitions(x64-rec-layout-benchmark-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(x64-rec-layout-benchmark-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(x64-rec-layout-benchmark-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME x64_rec_layout_benchmark
            COMMAND x64-rec-layout-benchmark-driver ${LW_PPOCR_C_REC_LWM} 5)
        set_tests_properties(x64_rec_layout_benchmark PROPERTIES TIMEOUT 120)
        foreach(rec_width IN ITEMS 192 320 480 640)
            add_test(NAME x64_rec_layout_benchmark_${rec_width}
                COMMAND x64-rec-layout-benchmark-driver ${LW_PPOCR_C_REC_LWM}
                        5 ${rec_width})
            set_tests_properties(x64_rec_layout_benchmark_${rec_width}
                PROPERTIES TIMEOUT 120)
        endforeach()
        add_executable(x64-det-backend-contract-driver
            tests/x64_det_backend_contract_driver.c)
        target_link_libraries(x64-det-backend-contract-driver PRIVATE lw_ppocr_c)
        target_include_directories(x64-det-backend-contract-driver PRIVATE
            src/runtime
            src/kernels
            src/simd
            src/ppocr)
        target_compile_features(x64-det-backend-contract-driver PRIVATE c_std_11)
        target_compile_definitions(x64-det-backend-contract-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        add_dependencies(x64-det-backend-contract-driver convert_det_model)
        if(MSVC)
            target_compile_definitions(x64-det-backend-contract-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(x64-det-backend-contract-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(x64-det-backend-contract-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME x64_det_backend_contract
            COMMAND x64-det-backend-contract-driver ${LW_PPOCR_C_DET_LWM} 32 64)
        set_tests_properties(x64_det_backend_contract PROPERTIES TIMEOUT 120)
        add_test(NAME x64_det_backend_contract_sharded
            COMMAND x64-det-backend-contract-driver ${LW_PPOCR_C_DET_LWM} 640 640)
        set_tests_properties(x64_det_backend_contract_sharded PROPERTIES TIMEOUT 180)
        add_executable(x64-det-layout-benchmark-driver
            tests/x64_det_layout_benchmark_driver.c)
        target_link_libraries(x64-det-layout-benchmark-driver PRIVATE lw_ppocr_c)
        target_include_directories(x64-det-layout-benchmark-driver PRIVATE
            src/runtime
            src/kernels
            src/simd
            src/ppocr)
        target_compile_features(x64-det-layout-benchmark-driver PRIVATE c_std_11)
        target_compile_definitions(x64-det-layout-benchmark-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        add_dependencies(x64-det-layout-benchmark-driver convert_det_model)
        if(MSVC)
            target_compile_definitions(x64-det-layout-benchmark-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(x64-det-layout-benchmark-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(x64-det-layout-benchmark-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME x64_det_layout_benchmark
            COMMAND x64-det-layout-benchmark-driver ${LW_PPOCR_C_DET_LWM} 32 64 1 3)
        set_tests_properties(x64_det_layout_benchmark PROPERTIES TIMEOUT 120)
        add_executable(x64-rec-backend-benchmark-driver
            tests/x64_rec_backend_benchmark_driver.c)
        target_link_libraries(x64-rec-backend-benchmark-driver PRIVATE lw_ppocr_c)
        target_include_directories(x64-rec-backend-benchmark-driver PRIVATE
            src/runtime
            src/kernels
            src/simd
            src/ppocr)
        target_compile_features(x64-rec-backend-benchmark-driver PRIVATE c_std_11)
        target_compile_definitions(x64-rec-backend-benchmark-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        add_dependencies(x64-rec-backend-benchmark-driver convert_rec_model)
        if(MSVC)
            target_compile_definitions(x64-rec-backend-benchmark-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(x64-rec-backend-benchmark-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(x64-rec-backend-benchmark-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME x64_rec_backend_benchmark
            COMMAND x64-rec-backend-benchmark-driver ${LW_PPOCR_C_REC_LWM} 5)
        set_tests_properties(x64_rec_backend_benchmark PROPERTIES TIMEOUT 120)
        add_test(NAME x64_rec_backend_benchmark_nchw
            COMMAND x64-rec-backend-benchmark-driver ${LW_PPOCR_C_REC_LWM} 5 nchw)
        set_tests_properties(x64_rec_backend_benchmark_nchw PROPERTIES TIMEOUT 120)
        add_executable(x64-rec-recognizer-benchmark-driver
            tests/x64_rec_recognizer_benchmark_driver.c)
        target_link_libraries(x64-rec-recognizer-benchmark-driver PRIVATE lw_ppocr_c)
        target_include_directories(x64-rec-recognizer-benchmark-driver PRIVATE
            src/ppocr)
        target_compile_features(x64-rec-recognizer-benchmark-driver PRIVATE c_std_11)
        target_compile_definitions(x64-rec-recognizer-benchmark-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        add_dependencies(x64-rec-recognizer-benchmark-driver convert_rec_model)
        if(MSVC)
            target_compile_definitions(x64-rec-recognizer-benchmark-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(x64-rec-recognizer-benchmark-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(x64-rec-recognizer-benchmark-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME x64_rec_recognizer_benchmark
            COMMAND x64-rec-recognizer-benchmark-driver ${LW_PPOCR_C_REC_LWM}
                ${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt 5)
        foreach(rec_width IN ITEMS 192 320 480 640)
            add_test(NAME x64_rec_recognizer_benchmark_${rec_width}
                COMMAND x64-rec-recognizer-benchmark-driver ${LW_PPOCR_C_REC_LWM}
                    ${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt
                    5 ${rec_width})
            set_tests_properties(x64_rec_recognizer_benchmark_${rec_width}
                PROPERTIES TIMEOUT 120)
        endforeach()
        set_tests_properties(x64_rec_recognizer_benchmark PROPERTIES TIMEOUT 120)
        add_executable(x64-rec-pointwise-layout-driver
            tests/x64_rec_pointwise_layout_driver.c)
        target_link_libraries(x64-rec-pointwise-layout-driver PRIVATE lw_ppocr_c)
        target_include_directories(x64-rec-pointwise-layout-driver PRIVATE
            src/runtime
            src/kernels
            src/simd)
        target_compile_features(x64-rec-pointwise-layout-driver PRIVATE c_std_11)
        target_compile_definitions(x64-rec-pointwise-layout-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        add_dependencies(x64-rec-pointwise-layout-driver convert_rec_model)
        if(MSVC)
            target_compile_definitions(x64-rec-pointwise-layout-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(x64-rec-pointwise-layout-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(x64-rec-pointwise-layout-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME x64_rec_pointwise_layout
            COMMAND x64-rec-pointwise-layout-driver ${LW_PPOCR_C_REC_LWM} 5)
        set_tests_properties(x64_rec_pointwise_layout PROPERTIES TIMEOUT 120)
        add_executable(x64-rec-pointwise-tuning-driver
            tests/x64_rec_pointwise_tuning_driver.c)
        target_link_libraries(x64-rec-pointwise-tuning-driver PRIVATE lw_ppocr_c)
        target_include_directories(x64-rec-pointwise-tuning-driver PRIVATE
            src/runtime
            src/kernels
            src/simd
            src/ppocr)
        target_compile_features(x64-rec-pointwise-tuning-driver PRIVATE c_std_11)
        target_compile_definitions(x64-rec-pointwise-tuning-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        add_dependencies(x64-rec-pointwise-tuning-driver convert_rec_model)
        if(MSVC)
            target_compile_definitions(x64-rec-pointwise-tuning-driver PRIVATE
                _CRT_SECURE_NO_WARNINGS)
            target_compile_options(x64-rec-pointwise-tuning-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(x64-rec-pointwise-tuning-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_executable(rec-fast-prototype-driver tests/rec_fast_prototype_driver.c)
        target_link_libraries(rec-fast-prototype-driver PRIVATE lw_ppocr_c)
        target_include_directories(rec-fast-prototype-driver PRIVATE
            "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
            "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels")
        target_compile_features(rec-fast-prototype-driver PRIVATE c_std_11)
        target_compile_definitions(rec-fast-prototype-driver PRIVATE
            LW_EXPERIMENTAL_AVX2_FAST_PATH=1)
        add_dependencies(rec-fast-prototype-driver convert_rec_model)
        if(MSVC)
            target_compile_definitions(rec-fast-prototype-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
            target_compile_options(rec-fast-prototype-driver PRIVATE /W4 /WX /utf-8)
        else()
            target_compile_options(rec-fast-prototype-driver PRIVATE
                -Wall -Wextra -Wpedantic -Werror)
        endif()
        add_test(NAME x64_rec_fast_prototype
            COMMAND rec-fast-prototype-driver "${LW_PPOCR_C_REC_LWM}" 960)
        set_tests_properties(x64_rec_fast_prototype PROPERTIES TIMEOUT 120)
    elseif(LW_EXPERIMENTAL_AVX2_FAST_PATH)
        message(WARNING
            "LW_EXPERIMENTAL_AVX2_FAST_PATH requires an x86/x64 build; benchmark target skipped")
    endif()
    add_executable(rec-pipeline-driver tests/rec_pipeline_driver.c)
    target_link_libraries(rec-pipeline-driver PRIVATE lw_ppocr_c)
    if(WIN32)
        target_link_libraries(rec-pipeline-driver PRIVATE shell32)
    endif()
    target_include_directories(rec-pipeline-driver PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime"
        "${CMAKE_CURRENT_SOURCE_DIR}/src/ppocr")
    target_compile_features(rec-pipeline-driver PRIVATE c_std_11)
    add_dependencies(rec-pipeline-driver convert_rec_model)
    if(MSVC)
        target_compile_definitions(rec-pipeline-driver PRIVATE _CRT_SECURE_NO_WARNINGS)
        target_compile_options(rec-pipeline-driver PRIVATE /W4 /WX /utf-8)
    else()
        target_compile_options(rec-pipeline-driver PRIVATE
            -Wall -Wextra -Wpedantic -Werror)
    endif()
    add_test(
        NAME rec_pipeline_reference
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_rec_pipeline_reference.py"
                --driver "$<TARGET_FILE:rec-pipeline-driver>"
                --lwm-model "${LW_PPOCR_C_REC_LWM}"
                --onnx-model "${LW_PPOCR_C_REC_ONNX}"
                --dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
                --sample "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg")
    set_tests_properties(rec_pipeline_reference PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 360)

    add_test(
        NAME rec_golden_corpus
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_rec_golden_corpus.py"
                --driver "$<TARGET_FILE:rec-pipeline-driver>"
                --lwm-model "${LW_PPOCR_C_REC_LWM}"
                --onnx-model "${LW_PPOCR_C_REC_ONNX}"
                --dictionary "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
                --sample "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
                --corpus "${CMAKE_CURRENT_SOURCE_DIR}/tests/fixtures/rec-golden-corpus.json")
    set_tests_properties(rec_golden_corpus PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
        TIMEOUT 600)

    add_test(
        NAME lwm_corruption
        COMMAND "${Python3_EXECUTABLE}"
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_lwm_corruption.py"
                --inspect "$<TARGET_FILE:lwm-inspect>"
                --model "${LW_PPOCR_C_REC_LWM}")
    set_tests_properties(lwm_corruption PROPERTIES
        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

    if(LW_BUILD_HTTP_DEMO)
        add_test(
            NAME http_demo_smoke
            COMMAND "${Python3_EXECUTABLE}"
                    "${CMAKE_CURRENT_SOURCE_DIR}/tests/test_http_demo.py"
                    --server "$<TARGET_FILE:lw-http-ocr>"
                    --models "${CMAKE_CURRENT_BINARY_DIR}/models"
                    --www "${CMAKE_CURRENT_BINARY_DIR}/www"
                    --sample "${LW_PPOCR_C_DET_DEMO_PPM}")
        set_tests_properties(http_demo_smoke PROPERTIES TIMEOUT 120)
    endif()
endif()

if(MSVC)
    set(CMAKE_INSTALL_SYSTEM_RUNTIME_DESTINATION "${CMAKE_INSTALL_BINDIR}")
    set(CMAKE_INSTALL_UCRT_LIBRARIES TRUE)
    include(InstallRequiredSystemLibraries)
endif()

if(NOT EMSCRIPTEN)
install(TARGETS lw_ppocr_c lw_ppocr_c_shared
    EXPORT lw.PPOCR.CTargets
    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}")
install(TARGETS lw-recognize-ppm lw-rec-benchmark lw-ocr-benchmark lw-classify-ppm lw-detect-ppm
    lw-ocr-ppm
    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
install(FILES include/lw_infer.h
    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
install(FILES
    examples/CMakeLists.txt
    examples/classify_ppm.c
    examples/detect_ppm.c
    examples/ocr_ppm.c
    examples/abi_v1_client.c
    examples/ppm_image.h
    examples/recognize_ppm.c
    DESTINATION examples)
install(DIRECTORY
    examples/csharp-common
    examples/csharp-winforms
    examples/http-server
    examples/java-jni
    DESTINATION examples
    PATTERN "bin" EXCLUDE
    PATTERN "obj" EXCLUDE)
install(FILES
    "${LW_PPOCR_C_REC_LWM}"
    "${LW_PPOCR_C_CLS_LWM}"
    "${LW_PPOCR_C_DET_LWM}"
    "${LW_PPOCR_C_REC_ONNX}" "${LW_PPOCR_C_CLS_ONNX}" "${LW_PPOCR_C_DET_ONNX}"
    "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/ppocr_keys.txt"
    "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/model.json"
    "${LW_PPOCR_C_REC_DEMO_PPM}"
    "${LW_PPOCR_C_DET_DEMO_PPM}"
    "${CMAKE_CURRENT_SOURCE_DIR}/models/ppocrv6-tiny/sample.jpg"
    DESTINATION models)
endif()
if(LW_BUILD_CSHARP_DEMOS)
    install(FILES
        "${LW_MANAGED_WINFORMS_EXE}"
        "${LW_MANAGED_WINFORMS_EXE}.config"
        DESTINATION "${CMAKE_INSTALL_BINDIR}")
endif()
if(LW_BUILD_HTTP_DEMO)
    install(TARGETS lw-http-ocr
        RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
    install(DIRECTORY examples/http-server/www/
        DESTINATION www)
endif()
install(DIRECTORY docs/
    DESTINATION docs
    FILES_MATCHING
    PATTERN "*.md"
    PATTERN "*.jpg")
install(FILES
    abi/c-abi-v1-candidate.json
    abi/runtime-contract-v1.json
    abi/c-abi-v1-layout.json
    abi/lwm-v0.1-layout.json
    abi/web-abi-v1-candidate.json
    abi/exports-v1-candidate.txt
    DESTINATION docs/abi)
install(FILES
    README.md
    README.zh-CN.md
    LICENSE
    THIRD-PARTY-NOTICES.md
    dependencies.lock.json
    sbom.cdx.json
    DESTINATION .)
install(FILES
    ci/stable-release-scope.json
    DESTINATION ci)
if(LW_BUILD_ENVIRONMENT_FILE)
    if(NOT EXISTS "${LW_BUILD_ENVIRONMENT_FILE}")
        message(FATAL_ERROR
            "LW_BUILD_ENVIRONMENT_FILE does not exist: ${LW_BUILD_ENVIRONMENT_FILE}")
    endif()
    install(FILES "${LW_BUILD_ENVIRONMENT_FILE}"
        DESTINATION .
        RENAME BUILD-ENVIRONMENT.txt)
endif()
install(FILES
    licenses/PaddleOCR-models-APACHE-2.0.txt
    licenses/cpp-httplib-MIT.txt
    DESTINATION licenses)

if(NOT EMSCRIPTEN)
set(LW_CMAKE_PACKAGE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/lw.PPOCR.C")
configure_package_config_file(
    cmake/lw.PPOCR.CConfig.cmake.in
    "${CMAKE_CURRENT_BINARY_DIR}/lw.PPOCR.CConfig.cmake"
    INSTALL_DESTINATION "${LW_CMAKE_PACKAGE_DIR}")
write_basic_package_version_file(
    "${CMAKE_CURRENT_BINARY_DIR}/lw.PPOCR.CConfigVersion.cmake"
    VERSION "${PROJECT_VERSION}"
    COMPATIBILITY SameMajorVersion)
install(EXPORT lw.PPOCR.CTargets
    FILE lw.PPOCR.CTargets.cmake
    NAMESPACE lw.PPOCR.C::
    DESTINATION "${LW_CMAKE_PACKAGE_DIR}")
install(FILES
    "${CMAKE_CURRENT_BINARY_DIR}/lw.PPOCR.CConfig.cmake"
    "${CMAKE_CURRENT_BINARY_DIR}/lw.PPOCR.CConfigVersion.cmake"
    DESTINATION "${LW_CMAKE_PACKAGE_DIR}")
endif()

if(BUILD_TESTING AND NOT EMSCRIPTEN)
    add_test(
        NAME staged_package
        COMMAND "${CMAKE_COMMAND}"
                -DLW_BUILD_DIR=${CMAKE_CURRENT_BINARY_DIR}
                -DLW_STAGE_DIR=${CMAKE_CURRENT_BINARY_DIR}/stage-test
                -DLW_CONFIG=$<CONFIG>
                -DLW_GENERATOR=${CMAKE_GENERATOR}
                -DLW_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
                -DLW_C_COMPILER=${CMAKE_C_COMPILER}
                -DLW_RC_COMPILER=${CMAKE_RC_COMPILER}
                -DLW_MT=${CMAKE_MT}
                -DLW_PYTHON=${Python3_EXECUTABLE}
                -DLW_TEST_SCRIPT=${CMAKE_CURRENT_SOURCE_DIR}/tests/test_staged_package.py
                -DLW_HTTP_TEST_SCRIPT=${CMAKE_CURRENT_SOURCE_DIR}/tests/test_http_demo.py
                -DLW_HTTP_TEST_REQUEST_TIMEOUT=${LW_HTTP_TEST_REQUEST_TIMEOUT}
                -DLW_HTTP_TEST_PROCESS_TIMEOUT=${LW_HTTP_TEST_PROCESS_TIMEOUT}
                -P "${CMAKE_CURRENT_SOURCE_DIR}/tests/run_staged_package_test.cmake")
    set_tests_properties(staged_package PROPERTIES
        TIMEOUT "${LW_STAGED_PACKAGE_TEST_TIMEOUT}")
endif()

if(LW_PACKAGE_PLATFORM_OVERRIDE)
    set(LW_PACKAGE_PLATFORM "${LW_PACKAGE_PLATFORM_OVERRIDE}")
    if(WIN32)
        set(CPACK_GENERATOR ZIP)
    else()
        set(CPACK_GENERATOR TGZ)
    endif()
elseif(WIN32)
    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
        set(LW_PACKAGE_PLATFORM windows-x64-msvc)
    else()
        set(LW_PACKAGE_PLATFORM windows-x86-msvc)
    endif()
    set(CPACK_GENERATOR ZIP)
else()
    string(TOLOWER "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}"
        LW_PACKAGE_PLATFORM)
    set(CPACK_GENERATOR TGZ)
endif()
set(CPACK_PACKAGE_NAME "lw.PPOCR.C")
set(CPACK_PACKAGE_VENDOR "天天代码码天天")
set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
set(CPACK_PACKAGE_FILE_NAME
    "lw.PPOCR.C-${PROJECT_VERSION}-${LW_PACKAGE_PLATFORM}")
set(CPACK_PACKAGE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/packages")
set(CPACK_PACKAGE_CHECKSUM SHA256)
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
include(CPack)
