diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 54af9a0..a2442b1 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -1,18 +1,33 @@
-# Workflow to run against the corresponding QuantLib release,
-# testing if the build and tests are working fine
-# Note: In addition to pushes/pull requests, this workflow 
-# can also be executed manually, and the repositories / branches 
-# for QuantLib and XAD can be provided in this case.
+##############################################################################
+#
+#  QuantLib-Risks-Cpp-Forge CI Workflow
+#
+#  This workflow mirrors the original QuantLib-Risks-Cpp CI and additionally
+#  tests with Forge JIT acceleration on Linux and Windows.
+#
+#  Jobs:
+#  - xad-linux: Original XAD tests (C++17, C++20, AAD ON/OFF)
+#  - xad-win: Original XAD tests (C++17, C++20, AAD ON/OFF)
+#  - xad-macos: Original XAD tests (C++17, C++20, AAD ON/OFF)
+#  - xad-linux-std-classes: Original XAD with QL_USE_STD_CLASSES
+#  - forge-linux: XAD + Forge JIT tests (C++17, Release/Debug)
+#  - forge-windows: XAD + Forge JIT tests (C++17, Release/Debug)
+#
+#  Copyright (C) 2025 The QuantLib-Risks-Cpp-Forge Authors
+#
+#  SPDX-License-Identifier: AGPL-3.0-or-later
+#
+##############################################################################
+
 name: CI
-on: 
-  repository_dispatch:
-    types: [xad-ci-trigger]
+
+on:
   push:
   pull_request:
   workflow_dispatch:
     inputs:
       ql_repo:
-        description: Quantlib repository in <owner>/<repo> format
+        description: QuantLib repository in <owner>/<repo> format
         required: true
         default: lballabio/QuantLib
       ql_branch:
@@ -27,15 +42,41 @@ on:
         description: Branch or tag for XAD repository
         required: true
         default: main
-  schedule:
-    - cron: '02 5 * * *'  # 5:02 every day
+      forge_repo:
+        description: Forge repository in <owner>/<repo> format
+        required: true
+        default: da-roth/forge
+      forge_branch:
+        description: Branch or tag for Forge repository
+        required: true
+        default: main
+      xad_forge_repo:
+        description: xad-forge repository in <owner>/<repo> format
+        required: true
+        default: da-roth/xad-forge
+      xad_forge_branch:
+        description: Branch or tag for xad-forge repository
+        required: true
+        default: main
+
 env:
   ql_repo: ${{ github.event.inputs.ql_repo || 'lballabio/QuantLib' }}
   ql_branch: ${{ github.event.inputs.ql_branch || 'master' }}
   xad_repo: ${{ github.event.inputs.xad_repo || 'auto-differentiation/xad' }}
   xad_branch: ${{ github.event.inputs.xad_branch || 'main' }}
-jobs:
+  forge_repo: ${{ github.event.inputs.forge_repo || 'da-roth/forge' }}
+  forge_branch: ${{ github.event.inputs.forge_branch || 'main' }}
+  xad_forge_repo: ${{ github.event.inputs.xad_forge_repo || 'da-roth/xad-forge' }}
+  xad_forge_branch: ${{ github.event.inputs.xad_forge_branch || 'main' }}
 
+jobs:
+  ##############################################################################
+  # Linux - Original XAD (mirrors QuantLib-Risks-Cpp)
+  #
+  # Note on disable_aad naming: This uses the original QuantLib-Risks-Cpp
+  # convention where QLRISKS_DISABLE_AAD=OFF means AAD is ENABLED (not disabled).
+  # The confusing double-negative is preserved for compatibility.
+  ##############################################################################
   xad-linux:
     strategy:
       fail-fast: false
@@ -44,87 +85,99 @@ jobs:
         cxx: ["17", "20"]
     runs-on: ubuntu-latest
     container: ghcr.io/lballabio/quantlib-devenv:rolling
+
+    name: Linux XAD C++${{ matrix.cxx }} AAD=${{ matrix.disable_aad == 'OFF' && 'ON' || 'OFF' }}
+
     steps:
-    - uses: actions/checkout@v4
-      with:
-        repository: ${{ env.ql_repo }}
-        ref: ${{ env.ql_branch }}
-        path: QuantLib
-    - uses: actions/checkout@v4
-      with:
-        repository: ${{ env.xad_repo }}
-        ref: ${{ env.xad_branch }}
-        path: xad
-    - uses: actions/checkout@v4
-      with:
-        path: QuantLib-Risks-Cpp
-    - name: ccache
-      uses: hendrikmuhs/ccache-action@v1.2.12
-      with:
-        key: linux-${{ matrix.disable_aad }}
-        max-size: 650M
-    - name: Setup
-      run: |
-        apt-get update \
-        && apt install -y ccache ninja-build
-    - name: Configure
-      run: |
-        rm -rf ${{ github.workspace }}/install
-        cd QuantLib
-        mkdir build
-        cd build
-        cmake -G Ninja -DBOOST_ROOT=/usr \
-          -DCMAKE_CXX_STANDARD=${{ matrix.cxx }} \
-          -DQLRISKS_DISABLE_AAD=${{ matrix.disable_aad }} \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-          -DQL_EXTERNAL_SUBDIRECTORIES="$(pwd)/../../xad;$(pwd)/../../QuantLib-Risks-Cpp" \
-          -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
-          -DQL_NULL_AS_FUNCTIONS=ON \
-          -DCMAKE_INSTALL_PREFIX=$(pwd)/../../install \
-          ..
-    - name: Compile
-      run: |
-        cd QuantLib/build
-        cmake --build .
-    - name: Test QuantLib
-      run: |
-        cd QuantLib/build
-        ./test-suite/quantlib-test-suite --log_level=message    
-    - name: Test QuantLib-Risks
-      if: ${{ matrix.disable_aad == 'OFF' }}
-      run: |
-        cd QuantLib/build
-        ./QuantLib-Risks-Cpp/test-suite/quantlib-risks-test-suite --log_level=message
-    - name: Install
-      if: ${{ matrix.disable_aad == 'OFF' }}
-      run: |
-        cd QuantLib/build
-        cmake --install .
-    - name: Test Install
-      if: ${{ matrix.disable_aad == 'OFF' }}
-      run: |
-        mkdir installtest
-        cp QuantLib-Risks-Cpp/Examples/AdjointSwap/AdjointSwapXAD.cpp installtest
-        cd installtest
-        echo "cmake_minimum_required(VERSION 3.15.2)" > CMakeLists.txt
-        echo "project(QlTest LANGUAGES CXX)" >> CMakeLists.txt
-        echo "find_package(QuantLib-Risks REQUIRED)" >> CMakeLists.txt
-        echo "add_executable(AdjointSwapXAD AdjointSwapXAD.cpp)" >> CMakeLists.txt
-        echo "target_link_libraries(AdjointSwapXAD PRIVATE QuantLib::QuantLib)" >> CMakeLists.txt
-        echo "target_compile_features(AdjointSwapXAD PUBLIC cxx_std_17)" >> CMakeLists.txt
-        mkdir build
-        cd build
-        cmake -G Ninja -DBOOST_ROOT=/usr \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_PREFIX_PATH=$(pwd)/../../install \
-          ..
-        cmake --build .
-        ./AdjointSwapXAD
+      - uses: actions/checkout@v4
+        with:
+          repository: ${{ env.ql_repo }}
+          ref: ${{ env.ql_branch }}
+          path: QuantLib
+
+      - uses: actions/checkout@v4
+        with:
+          repository: ${{ env.xad_repo }}
+          ref: ${{ env.xad_branch }}
+          path: xad
+
+      - uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2.12
+        with:
+          key: linux-xad-${{ matrix.cxx }}-${{ matrix.disable_aad }}
+          max-size: 650M
+
+      - name: Setup
+        run: |
+          apt-get update && apt install -y ccache ninja-build
+
+      - name: Configure
+        run: |
+          rm -rf ${{ github.workspace }}/install
+          cd QuantLib
+          mkdir build
+          cd build
+          cmake -G Ninja -DBOOST_ROOT=/usr \
+            -DCMAKE_CXX_STANDARD=${{ matrix.cxx }} \
+            -DQLRISKS_DISABLE_AAD=${{ matrix.disable_aad }} \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DQL_EXTERNAL_SUBDIRECTORIES="$(pwd)/../../xad;$(pwd)/../../QuantLib-Risks-Cpp-Forge" \
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
+            -DQL_NULL_AS_FUNCTIONS=ON \
+            -DCMAKE_INSTALL_PREFIX=$(pwd)/../../install \
+            ..
 
+      - name: Compile
+        run: |
+          cd QuantLib/build
+          cmake --build .
 
+      - name: Test QuantLib
+        run: |
+          cd QuantLib/build
+          ./test-suite/quantlib-test-suite --log_level=message
 
+      - name: Test QuantLib-Risks
+        if: ${{ matrix.disable_aad == 'OFF' }}
+        run: |
+          cd QuantLib/build
+          ./QuantLib-Risks-Cpp-Forge/test-suite/quantlib-risks-test-suite --log_level=message
 
+      - name: Install
+        if: ${{ matrix.disable_aad == 'OFF' }}
+        run: |
+          cd QuantLib/build
+          cmake --install .
+
+      - name: Test Install
+        if: ${{ matrix.disable_aad == 'OFF' }}
+        run: |
+          mkdir installtest
+          cp QuantLib-Risks-Cpp-Forge/Examples/AdjointSwap/AdjointSwapXAD.cpp installtest
+          cd installtest
+          echo "cmake_minimum_required(VERSION 3.15.2)" > CMakeLists.txt
+          echo "project(QlTest LANGUAGES CXX)" >> CMakeLists.txt
+          echo "find_package(QuantLib-Risks REQUIRED)" >> CMakeLists.txt
+          echo "add_executable(AdjointSwapXAD AdjointSwapXAD.cpp)" >> CMakeLists.txt
+          echo "target_link_libraries(AdjointSwapXAD PRIVATE QuantLib::QuantLib)" >> CMakeLists.txt
+          echo "target_compile_features(AdjointSwapXAD PUBLIC cxx_std_17)" >> CMakeLists.txt
+          mkdir build
+          cd build
+          cmake -G Ninja -DBOOST_ROOT=/usr \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_PREFIX_PATH=$(pwd)/../../install \
+            ..
+          cmake --build .
+          ./AdjointSwapXAD
+
+  ##############################################################################
+  # Windows - Original XAD (mirrors QuantLib-Risks-Cpp)
+  ##############################################################################
   xad-win:
     strategy:
       fail-fast: false
@@ -132,100 +185,117 @@ jobs:
         disable_aad: ["ON", "OFF"]
         cxx: ["17", "20"]
     runs-on: windows-2022
+
+    name: Windows XAD C++${{ matrix.cxx }} AAD=${{ matrix.disable_aad == 'OFF' && 'ON' || 'OFF' }}
+
     env:
       vsvarsall: C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat
+
     steps:
-    - uses: actions/checkout@v3
-      with:
-        repository: ${{ env.ql_repo }}
-        ref: ${{ env.ql_branch }}
-        path: QuantLib
-    - uses: actions/checkout@v3
-      with:
-        repository: ${{ env.xad_repo }}
-        ref: ${{ env.xad_branch }}
-        path: xad
-    - uses: actions/checkout@v3
-      with:
-        path: QuantLib-Risks-Cpp
-    - name: sccache
-      uses: hendrikmuhs/ccache-action@v1.2.12
-      with:
-        key: windows-${{ matrix.disable_aad }}
-        variant: sccache
-        max-size: 650M
-    - name: Setup
-      run: |
-        choco install -y ninja
-        $Url = "https://downloads.sourceforge.net/project/boost/boost-binaries/1.84.0/boost_1_84_0-msvc-14.3-64.exe"
-        (New-Object System.Net.WebClient).DownloadFile($Url, "$RUNNER_TEMP\boost.exe")
-        Start-Process -Wait -FilePath "$RUNNER_TEMP\boost.exe" "/SILENT","/SP-","/SUPPRESSMSGBOXES","/DIR=C:\local\boost"
-    - name: Configure
-      env:
-        BOOST_ROOT: C:\local\boost
-      shell: cmd
-      run: |
-        cd QuantLib
-        mkdir build
-        cd build
-        call "${{ env.vsvarsall }}" amd64
-        cmake .. -G Ninja -DQLRISKS_DISABLE_AAD=${{ matrix.disable_aad }} ^
-        -DCMAKE_CXX_STANDARD=${{ matrix.cxx }} ^
-        -DCMAKE_CXX_COMPILER_LAUNCHER=sccache ^
-        -DCMAKE_BUILD_TYPE=Release ^
-        -DQL_EXTERNAL_SUBDIRECTORIES="${{ github.workspace }}/xad;${{ github.workspace }}/QuantLib-Risks-Cpp" ^
-        -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks ^
-        -DQL_NULL_AS_FUNCTIONS=ON ^
-        -DXAD_STATIC_MSVC_RUNTIME=ON ^
-        -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/install
-    - name: Build
-      shell: cmd
-      run: |
-        cd QuantLib\build
-        call "${{ env.vsvarsall }}" amd64
-        cmake --build .
-    - name: Test QuantLib
-      shell: cmd
-      run: |
-        cd QuantLib\build
-        call "${{ env.vsvarsall }}" amd64
-        .\test-suite\quantlib-test-suite --log_level=message
-    - name: Test QuantLib-Risks
-      if: ${{ matrix.disable_aad == 'OFF' }}
-      shell: cmd
-      run: |
-        cd QuantLib\build
-        call "${{ env.vsvarsall }}" amd64
-        .\QuantLib-Risks-Cpp\test-suite\quantlib-risks-test-suite --log_level=message
-    - name: Install
-      if: ${{ matrix.disable_aad == 'OFF' }}
-      run: |
-        cd QuantLib/build
-        cmake --install .
-    - name: Test Install
-      if: ${{ matrix.disable_aad == 'OFF' }}
-      env:
-        BOOST_ROOT: C:\local\boost
-      shell: cmd
-      run: |
-        mkdir installtest
-        copy QuantLib-Risks-Cpp\Examples\AdjointSwap\AdjointSwapXAD.cpp installtest
-        cd installtest
-        echo cmake_minimum_required(VERSION 3.15.2) > CMakeLists.txt
-        echo project(QlTest LANGUAGES CXX) >> CMakeLists.txt
-        echo find_package(QuantLib-Risks REQUIRED) >> CMakeLists.txt
-        echo add_executable(AdjointSwapXAD AdjointSwapXAD.cpp) >> CMakeLists.txt
-        echo target_link_libraries(AdjointSwapXAD PRIVATE QuantLib::QuantLib) >> CMakeLists.txt
-        echo set_target_properties(AdjointSwapXAD PROPERTIES MSVC_RUNTIME_LIBRARY MultiThreaded) >> CMakeLists.txt
-        echo target_compile_features(AdjointSwapXAD PUBLIC cxx_std_17) >> CMakeLists.txt
-        mkdir build
-        cd build
-        call "${{ env.vsvarsall }}" amd64
-        cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install ..
-        cmake --build .
-        AdjointSwapXAD.exe
+      - uses: actions/checkout@v4
+        with:
+          repository: ${{ env.ql_repo }}
+          ref: ${{ env.ql_branch }}
+          path: QuantLib
+
+      - uses: actions/checkout@v4
+        with:
+          repository: ${{ env.xad_repo }}
+          ref: ${{ env.xad_branch }}
+          path: xad
 
+      - uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
 
+      - name: sccache
+        uses: hendrikmuhs/ccache-action@v1.2.12
+        with:
+          key: windows-xad-${{ matrix.cxx }}-${{ matrix.disable_aad }}
+          variant: sccache
+          max-size: 650M
+
+      - name: Setup
+        run: |
+          choco install -y ninja
+          $Url = "https://downloads.sourceforge.net/project/boost/boost-binaries/1.86.0/boost_1_86_0-msvc-14.3-64.exe"
+          (New-Object System.Net.WebClient).DownloadFile($Url, "$RUNNER_TEMP\boost.exe")
+          Start-Process -Wait -FilePath "$RUNNER_TEMP\boost.exe" "/SILENT","/SP-","/SUPPRESSMSGBOXES","/DIR=C:\local\boost"
+
+      - name: Configure
+        env:
+          BOOST_ROOT: C:\local\boost
+        shell: cmd
+        run: |
+          cd QuantLib
+          mkdir build
+          cd build
+          call "${{ env.vsvarsall }}" amd64
+          cmake .. -G Ninja -DQLRISKS_DISABLE_AAD=${{ matrix.disable_aad }} ^
+          -DCMAKE_CXX_STANDARD=${{ matrix.cxx }} ^
+          -DCMAKE_CXX_COMPILER_LAUNCHER=sccache ^
+          -DCMAKE_BUILD_TYPE=Release ^
+          -DQL_EXTERNAL_SUBDIRECTORIES="${{ github.workspace }}/xad;${{ github.workspace }}/QuantLib-Risks-Cpp-Forge" ^
+          -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks ^
+          -DQL_NULL_AS_FUNCTIONS=ON ^
+          -DXAD_STATIC_MSVC_RUNTIME=ON ^
+          -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/install
+
+      - name: Build
+        shell: cmd
+        run: |
+          cd QuantLib\build
+          call "${{ env.vsvarsall }}" amd64
+          cmake --build .
+
+      - name: Test QuantLib
+        shell: cmd
+        run: |
+          cd QuantLib\build
+          call "${{ env.vsvarsall }}" amd64
+          .\test-suite\quantlib-test-suite --log_level=message
+
+      - name: Test QuantLib-Risks
+        if: ${{ matrix.disable_aad == 'OFF' }}
+        shell: cmd
+        run: |
+          cd QuantLib\build
+          call "${{ env.vsvarsall }}" amd64
+          .\QuantLib-Risks-Cpp-Forge\test-suite\quantlib-risks-test-suite --log_level=message
+
+      - name: Install
+        if: ${{ matrix.disable_aad == 'OFF' }}
+        run: |
+          cd QuantLib/build
+          cmake --install .
+
+      - name: Test Install
+        if: ${{ matrix.disable_aad == 'OFF' }}
+        env:
+          BOOST_ROOT: C:\local\boost
+        shell: cmd
+        run: |
+          mkdir installtest
+          copy QuantLib-Risks-Cpp-Forge\Examples\AdjointSwap\AdjointSwapXAD.cpp installtest
+          cd installtest
+          echo cmake_minimum_required(VERSION 3.15.2) > CMakeLists.txt
+          echo project(QlTest LANGUAGES CXX) >> CMakeLists.txt
+          echo find_package(QuantLib-Risks REQUIRED) >> CMakeLists.txt
+          echo add_executable(AdjointSwapXAD AdjointSwapXAD.cpp) >> CMakeLists.txt
+          echo target_link_libraries(AdjointSwapXAD PRIVATE QuantLib::QuantLib) >> CMakeLists.txt
+          echo set_target_properties(AdjointSwapXAD PROPERTIES MSVC_RUNTIME_LIBRARY MultiThreaded) >> CMakeLists.txt
+          echo target_compile_features(AdjointSwapXAD PUBLIC cxx_std_17) >> CMakeLists.txt
+          mkdir build
+          cd build
+          call "${{ env.vsvarsall }}" amd64
+          cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install ..
+          cmake --build .
+          AdjointSwapXAD.exe
+
+  ##############################################################################
+  # macOS - Original XAD (mirrors QuantLib-Risks-Cpp)
+  # Note: Forge not supported on macOS ARM yet
+  ##############################################################################
   xad-macos:
     strategy:
       fail-fast: false
@@ -233,134 +303,380 @@ jobs:
         disable_aad: ["ON", "OFF"]
         cxx: ["17", "20"]
     runs-on: macos-latest
+
+    name: macOS XAD C++${{ matrix.cxx }} AAD=${{ matrix.disable_aad == 'OFF' && 'ON' || 'OFF' }}
+
     steps:
-    - uses: actions/checkout@v4
-      with:
-        repository: ${{ env.ql_repo }}
-        ref: ${{ env.ql_branch }}
-        path: QuantLib
-    - uses: actions/checkout@v4
-      with:
-        repository: ${{ env.xad_repo }}
-        ref: ${{ env.xad_branch }}
-        path: xad
-    - uses: actions/checkout@v4
-      with:
-        path: QuantLib-Risks-Cpp
-    - name: Setup
-      run: |
-        brew install boost
-        brew install ninja
-        brew install ccache
-    - name: ccache
-      uses: hendrikmuhs/ccache-action@v1.2.12
-      with:
-        key: macos-${{ matrix.disable_aad }}
-        max-size: 650M
-    - name: Configure
-      run: |
-        cd QuantLib
-        mkdir build
-        cd build
-        cmake -G Ninja -DBOOST_ROOT=/usr \
-        -DCMAKE_CXX_STANDARD=${{ matrix.cxx }} \
-          -DQLRISKS_DISABLE_AAD=${{ matrix.disable_aad }} \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-          -DQL_EXTERNAL_SUBDIRECTORIES="${{ github.workspace }}/xad;${{ github.workspace }}/QuantLib-Risks-Cpp" \
-          -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
-          -DQL_NULL_AS_FUNCTIONS=ON \
-          -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/install \
-          ..
-    - name: Compile
-      run: |
-        cd QuantLib/build
-        cmake --build .
-    - name: Test QuantLib
-      run: |
-        cd QuantLib/build
-        ./test-suite/quantlib-test-suite --log_level=message    
-    - name: Test QuantLib-Risks
-      if: ${{ matrix.disable_aad == 'OFF' }}
-      run: |
-        cd QuantLib/build
-        ./QuantLib-Risks-Cpp/test-suite/quantlib-risks-test-suite --log_level=message
-    - name: Install
-      if: ${{ matrix.disable_aad == 'OFF' }}
-      run: |
-        cd QuantLib/build
-        cmake --install .
-    - name: Test Install
-      if: ${{ matrix.disable_aad == 'OFF' }}
-      run: |
-        mkdir installtest
-        cp QuantLib-Risks-Cpp/Examples/AdjointSwap/AdjointSwapXAD.cpp installtest
-        cd installtest
-        echo "cmake_minimum_required(VERSION 3.15.2)" > CMakeLists.txt
-        echo "project(QlTest LANGUAGES CXX)" >> CMakeLists.txt
-        echo "find_package(QuantLib-Risks REQUIRED)" >> CMakeLists.txt
-        echo "add_executable(AdjointSwapXAD AdjointSwapXAD.cpp)" >> CMakeLists.txt
-        echo "target_link_libraries(AdjointSwapXAD PRIVATE QuantLib::QuantLib)" >> CMakeLists.txt
-        echo "target_compile_features(AdjointSwapXAD PUBLIC cxx_std_17)" >> CMakeLists.txt
-        mkdir build
-        cd build
-        cmake -G Ninja -DBOOST_ROOT=/usr \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install \
-          ..
-        cmake --build .
-        ./AdjointSwapXAD
+      - uses: actions/checkout@v4
+        with:
+          repository: ${{ env.ql_repo }}
+          ref: ${{ env.ql_branch }}
+          path: QuantLib
+
+      - uses: actions/checkout@v4
+        with:
+          repository: ${{ env.xad_repo }}
+          ref: ${{ env.xad_branch }}
+          path: xad
+
+      - uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
 
+      - name: Setup
+        run: |
+          brew install boost ninja ccache
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2.12
+        with:
+          key: macos-xad-${{ matrix.cxx }}-${{ matrix.disable_aad }}
+          max-size: 650M
+
+      - name: Configure
+        run: |
+          cd QuantLib
+          mkdir build
+          cd build
+          cmake -G Ninja \
+            -DCMAKE_CXX_STANDARD=${{ matrix.cxx }} \
+            -DQLRISKS_DISABLE_AAD=${{ matrix.disable_aad }} \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DQL_EXTERNAL_SUBDIRECTORIES="${{ github.workspace }}/xad;${{ github.workspace }}/QuantLib-Risks-Cpp-Forge" \
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
+            -DQL_NULL_AS_FUNCTIONS=ON \
+            -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/install \
+            ..
+
+      - name: Compile
+        run: |
+          cd QuantLib/build
+          cmake --build .
+
+      - name: Test QuantLib
+        run: |
+          cd QuantLib/build
+          ./test-suite/quantlib-test-suite --log_level=message
+
+      - name: Test QuantLib-Risks
+        if: ${{ matrix.disable_aad == 'OFF' }}
+        run: |
+          cd QuantLib/build
+          ./QuantLib-Risks-Cpp-Forge/test-suite/quantlib-risks-test-suite --log_level=message
+
+      - name: Install
+        if: ${{ matrix.disable_aad == 'OFF' }}
+        run: |
+          cd QuantLib/build
+          cmake --install .
+
+      - name: Test Install
+        if: ${{ matrix.disable_aad == 'OFF' }}
+        run: |
+          mkdir installtest
+          cp QuantLib-Risks-Cpp-Forge/Examples/AdjointSwap/AdjointSwapXAD.cpp installtest
+          cd installtest
+          echo "cmake_minimum_required(VERSION 3.15.2)" > CMakeLists.txt
+          echo "project(QlTest LANGUAGES CXX)" >> CMakeLists.txt
+          echo "find_package(QuantLib-Risks REQUIRED)" >> CMakeLists.txt
+          echo "add_executable(AdjointSwapXAD AdjointSwapXAD.cpp)" >> CMakeLists.txt
+          echo "target_link_libraries(AdjointSwapXAD PRIVATE QuantLib::QuantLib)" >> CMakeLists.txt
+          echo "target_compile_features(AdjointSwapXAD PUBLIC cxx_std_17)" >> CMakeLists.txt
+          mkdir build
+          cd build
+          cmake -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install \
+            ..
+          cmake --build .
+          ./AdjointSwapXAD
+
+  ##############################################################################
+  # Linux - Original XAD with QL_USE_STD_CLASSES (mirrors QuantLib-Risks-Cpp)
+  ##############################################################################
   xad-linux-std-classes:
+    runs-on: ubuntu-latest
+    container: ghcr.io/lballabio/quantlib-devenv:rolling
+
+    name: Linux XAD std-classes
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          repository: ${{ env.ql_repo }}
+          ref: ${{ env.ql_branch }}
+          path: QuantLib
+
+      - uses: actions/checkout@v4
+        with:
+          repository: ${{ env.xad_repo }}
+          ref: ${{ env.xad_branch }}
+          path: xad
+
+      - uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
+
+      - name: Setup
+        run: |
+          apt-get update && apt install -y ccache ninja-build
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2.12
+        with:
+          key: linux-xad-std-classes
+          max-size: 650M
+
+      - name: Configure
+        run: |
+          cd QuantLib
+          mkdir build
+          cd build
+          cmake -G Ninja -DBOOST_ROOT=/usr \
+            -DQL_USE_STD_CLASSES=ON \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DQL_EXTERNAL_SUBDIRECTORIES="$(pwd)/../../xad;$(pwd)/../../QuantLib-Risks-Cpp-Forge" \
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
+            -DQL_NULL_AS_FUNCTIONS=ON \
+            ..
+
+      - name: Compile
+        run: |
+          cd QuantLib/build
+          cmake --build .
+
+      - name: Test QuantLib
+        run: |
+          cd QuantLib/build
+          ./test-suite/quantlib-test-suite --log_level=message
+
+      - name: Test QuantLib-Risks
+        run: |
+          cd QuantLib/build
+          ./QuantLib-Risks-Cpp-Forge/test-suite/quantlib-risks-test-suite --log_level=message
+
+  ##############################################################################
+  # Linux - XAD + Forge JIT
+  #
+  # Forge accelerates AAD tape computations via JIT compilation, so these jobs
+  # only make sense with AAD enabled (QLRISKS_DISABLE_AAD=OFF).
+  # Tests C++17 and C++20 to match original XAD job coverage.
+  ##############################################################################
+  forge-linux:
     strategy:
       fail-fast: false
+      matrix:
+        build_type: ["Release", "Debug"]
+        cxx: ["17", "20"]
     runs-on: ubuntu-latest
     container: ghcr.io/lballabio/quantlib-devenv:rolling
+
+    name: Linux Forge C++${{ matrix.cxx }} ${{ matrix.build_type }}
+
+    steps:
+      - name: Checkout QuantLib
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.ql_repo }}
+          ref: ${{ env.ql_branch }}
+          path: QuantLib
+
+      - name: Checkout XAD
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.xad_repo }}
+          ref: ${{ env.xad_branch }}
+          path: xad
+
+      - name: Checkout Forge
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.forge_repo }}
+          ref: ${{ env.forge_branch }}
+          path: forge
+
+      - name: Checkout xad-forge
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.xad_forge_repo }}
+          ref: ${{ env.xad_forge_branch }}
+          path: xad-forge
+
+      - name: Checkout QuantLib-Risks-Cpp-Forge
+        uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2.12
+        with:
+          key: linux-forge-${{ matrix.build_type }}
+          max-size: 650M
+
+      - name: Setup
+        run: |
+          apt-get update && apt-get install -y ninja-build ccache
+
+      - name: Build Forge C API
+        run: |
+          cd forge
+          cmake -B build -S api/c \
+            -G Ninja \
+            -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
+            -DCMAKE_INSTALL_PREFIX=$(pwd)/../install
+          cmake --build build --config ${{ matrix.build_type }}
+          cmake --install build --config ${{ matrix.build_type }}
+
+      - name: Configure QuantLib with XAD + Forge
+        run: |
+          cd QuantLib
+          mkdir build
+          cd build
+          cmake -G Ninja -DBOOST_ROOT=/usr \
+            -DCMAKE_CXX_STANDARD=${{ matrix.cxx }} \
+            -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DXAD_WARNINGS_PARANOID=OFF \
+            -DXAD_ENABLE_JIT=ON \
+            -DCMAKE_PREFIX_PATH=$(pwd)/../../install \
+            -DQL_EXTERNAL_SUBDIRECTORIES="$(pwd)/../../xad;$(pwd)/../../xad-forge;$(pwd)/../../QuantLib-Risks-Cpp-Forge" \
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
+            -DQL_NULL_AS_FUNCTIONS=ON \
+            -DQL_BUILD_TEST_SUITE=OFF \
+            -DQL_BUILD_EXAMPLES=OFF \
+            -DQL_BUILD_BENCHMARK=OFF \
+            -DQLRISKS_DISABLE_AAD=OFF \
+            -DQLRISKS_ENABLE_FORGE=ON \
+            -DQLRISKS_USE_FORGE_CAPI=ON \
+            -DXAD_FORGE_USE_CAPI=ON \
+            -DQLRISKS_BUILD_TEST_SUITE=ON \
+            -DQLRISKS_ENABLE_FORGE_TESTS=ON \
+            ..
+
+      - name: Build
+        run: |
+          cd QuantLib/build
+          cmake --build .
+
+      - name: Test QuantLib-Risks
+        run: |
+          cd QuantLib/build
+          ./QuantLib-Risks-Cpp-Forge/test-suite/quantlib-risks-test-suite --log_level=message
+
+  ##############################################################################
+  # Windows - XAD + Forge JIT
+  #
+  # Forge accelerates AAD tape computations via JIT compilation, so these jobs
+  # only make sense with AAD enabled (QLRISKS_DISABLE_AAD=OFF).
+  # Tests C++17 and C++20 to match original XAD job coverage.
+  ##############################################################################
+  forge-windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        build_type: ["Release", "Debug"]
+        cxx: ["17", "20"]
+    runs-on: windows-2022
+
+    name: Windows Forge C++${{ matrix.cxx }} ${{ matrix.build_type }}
+
+    env:
+      VSVARSALL: C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat
+
     steps:
-    - uses: actions/checkout@v4
-      with:
-        repository: ${{ env.ql_repo }}
-        ref: ${{ env.ql_branch }}
-        path: QuantLib
-    - uses: actions/checkout@v4
-      with:
-        repository: ${{ env.xad_repo }}
-        ref: ${{ env.xad_branch }}
-        path: xad
-    - uses: actions/checkout@v4
-      with:
-        path: QuantLib-Risks-Cpp
-    - name: Setup
-      run: |
-        apt-get update \
-        && apt install -y ccache ninja-build \
-    - name: ccache
-      uses: hendrikmuhs/ccache-action@v1.2.12
-      with:
-        key: linux-std-classes
-        max-size: 650M
-    - name: Configure
-      run: |
-        cd QuantLib
-        mkdir build
-        cd build
-        cmake -G Ninja -DBOOST_ROOT=/usr \
-        -DQL_USE_STD_CLASSES=ON \
-        -DCMAKE_BUILD_TYPE=Release \
-        -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-        -DQL_EXTERNAL_SUBDIRECTORIES="$(pwd)/../../xad;$(pwd)/../../QuantLib-Risks-Cpp" \
-        -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
-        -DQL_NULL_AS_FUNCTIONS=ON \
-        ..
-    - name: Compile
-      run: |
-        cd QuantLib/build
-        cmake --build .
-    - name: Test QuantLib
-      run: |
-        cd QuantLib/build
-        ./test-suite/quantlib-test-suite --log_level=message    
-    - name: Test QuantLib-Risks
-      run: |
-        cd QuantLib/build
-        ./QuantLib-Risks-Cpp/test-suite/quantlib-risks-test-suite --log_level=message
+      - name: Checkout QuantLib
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.ql_repo }}
+          ref: ${{ env.ql_branch }}
+          path: QuantLib
+
+      - name: Checkout XAD
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.xad_repo }}
+          ref: ${{ env.xad_branch }}
+          path: xad
+
+      - name: Checkout Forge
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.forge_repo }}
+          ref: ${{ env.forge_branch }}
+          path: forge
+
+      - name: Checkout xad-forge
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.xad_forge_repo }}
+          ref: ${{ env.xad_forge_branch }}
+          path: xad-forge
+
+      - name: Checkout QuantLib-Risks-Cpp-Forge
+        uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
+
+      - name: Setup
+        run: choco install -y ninja
+
+      - name: Setup Boost
+        run: |
+          $Url = "https://downloads.sourceforge.net/project/boost/boost-binaries/1.86.0/boost_1_86_0-msvc-14.3-64.exe"
+          (New-Object System.Net.WebClient).DownloadFile($Url, "$RUNNER_TEMP\boost.exe")
+          Start-Process -Wait -FilePath "$RUNNER_TEMP\boost.exe" "/SILENT","/SP-","/SUPPRESSMSGBOXES","/DIR=C:\local\boost"
+          echo "BOOST_ROOT=C:\local\boost" >> $env:GITHUB_ENV
+
+      - name: Build Forge C API
+        shell: cmd
+        run: |
+          cd forge
+          call "%VSVARSALL%" amd64
+          cmake -B build -S api/c -G Ninja ^
+            -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} ^
+            -DFORGE_CAPI_BUILD_TESTS=OFF ^
+            -DFORGE_CAPI_USE_STATIC_RUNTIME=ON ^
+            -DCMAKE_INSTALL_PREFIX="%cd%\..\install"
+          cmake --build build --config ${{ matrix.build_type }}
+          cmake --install build --config ${{ matrix.build_type }}
+
+      - name: Configure QuantLib with XAD + Forge
+        shell: cmd
+        run: |
+          cd QuantLib
+          call "%VSVARSALL%" amd64
+          cmake -B build -G Ninja ^
+            -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} ^
+            -DCMAKE_CXX_STANDARD=${{ matrix.cxx }} ^
+            -DXAD_WARNINGS_PARANOID=OFF ^
+            -DXAD_ENABLE_JIT=ON ^
+            -DXAD_STATIC_MSVC_RUNTIME=ON ^
+            -DCMAKE_PREFIX_PATH="%cd%\..\install" ^
+            -DQL_EXTERNAL_SUBDIRECTORIES="%cd%\..\xad;%cd%\..\xad-forge;%cd%\..\QuantLib-Risks-Cpp-Forge" ^
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks ^
+            -DQL_NULL_AS_FUNCTIONS=ON ^
+            -DQL_BUILD_TEST_SUITE=OFF ^
+            -DQL_BUILD_EXAMPLES=OFF ^
+            -DQL_BUILD_BENCHMARK=OFF ^
+            -DQLRISKS_DISABLE_AAD=OFF ^
+            -DQLRISKS_ENABLE_FORGE=ON ^
+            -DQLRISKS_USE_FORGE_CAPI=ON ^
+            -DXAD_FORGE_USE_CAPI=ON ^
+            -DQLRISKS_BUILD_TEST_SUITE=ON ^
+            -DQLRISKS_ENABLE_FORGE_TESTS=ON
+
+      - name: Build
+        shell: cmd
+        run: |
+          cd QuantLib\build
+          call "%VSVARSALL%" amd64
+          cmake --build . --config ${{ matrix.build_type }}
+
+      - name: Test QuantLib-Risks
+        shell: cmd
+        run: |
+          cd QuantLib\build
+          set PATH=%cd%\..\..\install\bin;%PATH%
+          QuantLib-Risks-Cpp-Forge\test-suite\quantlib-risks-test-suite.exe --log_level=message
diff --git a/.github/workflows/ql-benchmarks.yaml b/.github/workflows/ql-benchmarks.yaml
new file mode 100644
index 0000000..073f703
--- /dev/null
+++ b/.github/workflows/ql-benchmarks.yaml
@@ -0,0 +1,1692 @@
+##############################################################################
+#
+#  QuantLib-Risks Benchmarks
+#
+#  Compares different AD configurations for Swaption pricing:
+#  - QL + XAD:       Original QuantLib-Risks-Cpp with XAD tape (baseline)
+#  - QL + XAD-Forge: QuantLib-Risks-Cpp-Forge with Forge JIT backends
+#
+#  Jobs:
+#  - Linux/Windows, QL + XAD:       True baseline (original repo, XAD tape)
+#  - Linux/Windows, QL + XAD-Forge: Forge JIT (runs XAD tape + JIT + JIT-AVX)
+#  - Decomposition:                 Detailed timing breakdown
+#  - Compare:                       Statistical comparison XAD vs XAD-Forge
+#
+#  Type Overhead Measurement (pricing-only, no derivatives):
+#  - Linux/Windows, double vs AReal (no diff): Compares plain double vs xad::AReal<double> on same hardware
+#
+#  Dependencies:
+#  - QuantLib (lballabio/QuantLib)
+#  - XAD (auto-differentiation/xad)
+#  - QuantLib-Risks-Cpp (auto-differentiation/QuantLib-Risks-Cpp) [baseline]
+#  - xad-forge (da-roth/xad-forge) [Forge jobs]
+#  - Forge C API (da-roth/forge) [Forge jobs]
+#
+#  Copyright (C) 2025 Xcelerit Computing Limited
+#  SPDX-License-Identifier: AGPL-3.0-or-later
+#
+##############################################################################
+
+name: QL Benchmarks
+
+on:
+  push:
+    paths:
+      - 'test-suite/swaption_benchmark*.cpp'
+      - 'test-suite/benchmark_main.cpp'
+      - 'test-suite/benchmark_utils.hpp'
+      - '.github/workflows/ql-benchmarks.yaml'
+  pull_request:
+    paths:
+      - 'test-suite/swaption_benchmark*.cpp'
+      - 'test-suite/benchmark_main.cpp'
+      - 'test-suite/benchmark_utils.hpp'
+      - '.github/workflows/ql-benchmarks.yaml'
+  workflow_dispatch:
+    inputs:
+      ql_repo:
+        description: 'QuantLib repository'
+        required: false
+        default: 'lballabio/QuantLib'
+      ql_branch:
+        description: 'QuantLib branch'
+        required: false
+        default: 'master'
+      xad_repo:
+        description: 'XAD repository'
+        required: false
+        default: 'auto-differentiation/xad'
+      xad_branch:
+        description: 'XAD branch'
+        required: false
+        default: 'main'
+      qlrisks_repo:
+        description: 'QuantLib-Risks-Cpp repository (for baseline)'
+        required: false
+        default: 'auto-differentiation/QuantLib-Risks-Cpp'
+      qlrisks_branch:
+        description: 'QuantLib-Risks-Cpp branch (for baseline)'
+        required: false
+        default: 'main'
+      forge_repo:
+        description: 'Forge repository'
+        required: false
+        default: 'da-roth/forge'
+      forge_branch:
+        description: 'Forge branch'
+        required: false
+        default: 'main'
+      xad_forge_repo:
+        description: 'xad-forge repository'
+        required: false
+        default: 'da-roth/xad-forge'
+      xad_forge_branch:
+        description: 'xad-forge branch'
+        required: false
+        default: 'main'
+
+env:
+  QL_REPO: ${{ github.event.inputs.ql_repo || 'lballabio/QuantLib' }}
+  QL_BRANCH: ${{ github.event.inputs.ql_branch || 'master' }}
+  XAD_REPO: ${{ github.event.inputs.xad_repo || 'auto-differentiation/xad' }}
+  XAD_BRANCH: ${{ github.event.inputs.xad_branch || 'main' }}
+  QLRISKS_REPO: ${{ github.event.inputs.qlrisks_repo || 'auto-differentiation/QuantLib-Risks-Cpp' }}
+  QLRISKS_BRANCH: ${{ github.event.inputs.qlrisks_branch || 'main' }}
+  FORGE_REPO: ${{ github.event.inputs.forge_repo || 'da-roth/forge' }}
+  FORGE_BRANCH: ${{ github.event.inputs.forge_branch || 'main' }}
+  XAD_FORGE_REPO: ${{ github.event.inputs.xad_forge_repo || 'da-roth/xad-forge' }}
+  XAD_FORGE_BRANCH: ${{ github.event.inputs.xad_forge_branch || 'main' }}
+
+jobs:
+  ##############################################################################
+  # Linux, QL + XAD (True Baseline)
+  # Uses original QuantLib-Risks-Cpp with XAD tape - no Forge code
+  ##############################################################################
+  linux-xad:
+    name: Linux, QL + XAD
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/lballabio/quantlib-devenv:rolling
+
+    steps:
+      - name: Hardware Info
+        run: |
+          echo "===== CPU ====="
+          lscpu | grep -E "^(Model name|CPU\(s\)|Thread|Core|Socket|CPU max MHz)"
+          echo "===== Memory ====="
+          free -h
+
+      - name: Checkout QuantLib
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QL_REPO }}
+          ref: ${{ env.QL_BRANCH }}
+          path: QuantLib
+
+      - name: Checkout XAD
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.XAD_REPO }}
+          ref: ${{ env.XAD_BRANCH }}
+          path: xad
+
+      - name: Checkout QuantLib-Risks-Cpp (Original)
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QLRISKS_REPO }}
+          ref: ${{ env.QLRISKS_BRANCH }}
+          path: QuantLib-Risks-Cpp
+
+      - name: Checkout QuantLib-Risks-Cpp-Forge (for benchmark code)
+        uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
+
+      - name: Setup
+        run: |
+          apt-get update
+          apt-get install -y ninja-build cmake
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2.12
+        with:
+          key: linux-ql-xad
+          max-size: 650M
+
+      - name: Patch benchmark into original QuantLib-Risks-Cpp
+        run: |
+          # Copy standalone benchmark files from Forge repo to original
+          cp QuantLib-Risks-Cpp-Forge/test-suite/benchmark_main.cpp \
+             QuantLib-Risks-Cpp/test-suite/
+          cp QuantLib-Risks-Cpp-Forge/test-suite/PlatformInfo.hpp \
+             QuantLib-Risks-Cpp/test-suite/
+          cp QuantLib-Risks-Cpp-Forge/test-suite/utilities_xad.cpp \
+             QuantLib-Risks-Cpp/test-suite/
+          cp QuantLib-Risks-Cpp-Forge/test-suite/utilities_xad.hpp \
+             QuantLib-Risks-Cpp/test-suite/
+
+          # Add standalone benchmark target to CMakeLists.txt
+          cat >> QuantLib-Risks-Cpp/test-suite/CMakeLists.txt << 'EOF'
+
+          # Standalone benchmark (patched from QuantLib-Risks-Cpp-Forge)
+          add_executable(QuantLib-Risks_benchmark_standalone benchmark_main.cpp)
+          set_target_properties(QuantLib-Risks_benchmark_standalone PROPERTIES
+              OUTPUT_NAME "quantlib-risks-benchmark-standalone")
+          target_link_libraries(QuantLib-Risks_benchmark_standalone PRIVATE
+              ql_library
+              ${QL_THREAD_LIBRARIES})
+          EOF
+
+      - name: Configure QuantLib
+        run: |
+          cd QuantLib
+          cmake -B build -G Ninja -DBOOST_ROOT=/usr \
+            -DCMAKE_CXX_STANDARD=17 \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DXAD_WARNINGS_PARANOID=OFF \
+            -DXAD_ENABLE_JIT=OFF \
+            -DQL_EXTERNAL_SUBDIRECTORIES="$(pwd)/../xad;$(pwd)/../QuantLib-Risks-Cpp" \
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
+            -DQL_NULL_AS_FUNCTIONS=ON \
+            -DQL_BUILD_TEST_SUITE=OFF \
+            -DQL_BUILD_EXAMPLES=OFF \
+            -DQL_BUILD_BENCHMARK=OFF \
+            -DQLRISKS_DISABLE_AAD=OFF \
+            -DQLRISKS_BUILD_TEST_SUITE=ON
+
+      - name: Build
+        run: |
+          cd QuantLib/build
+          cmake --build . --target QuantLib-Risks_benchmark_standalone
+
+      - name: Run Benchmark
+        run: |
+          cd QuantLib/build
+          ./QuantLib-Risks-Cpp/test-suite/quantlib-risks-benchmark-standalone
+
+  ##############################################################################
+  # Linux, QL + XAD-Forge
+  # Uses QuantLib-Risks-Cpp-Forge with Forge JIT backends
+  # Runs all methods: XAD tape + JIT-Forge + JIT-ForgeAVX2
+  ##############################################################################
+  linux-xad-forge:
+    name: Linux, QL + XAD-Forge
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/lballabio/quantlib-devenv:rolling
+
+    steps:
+      - name: Hardware Info
+        run: |
+          echo "===== CPU ====="
+          lscpu | grep -E "^(Model name|CPU\(s\)|Thread|Core|Socket|CPU max MHz)"
+          echo "===== Memory ====="
+          free -h
+
+      - name: Checkout QuantLib
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QL_REPO }}
+          ref: ${{ env.QL_BRANCH }}
+          path: QuantLib
+
+      - name: Checkout XAD
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.XAD_REPO }}
+          ref: ${{ env.XAD_BRANCH }}
+          path: xad
+
+      - name: Checkout Forge
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.FORGE_REPO }}
+          ref: ${{ env.FORGE_BRANCH }}
+          path: forge
+
+      - name: Checkout xad-forge
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.XAD_FORGE_REPO }}
+          ref: ${{ env.XAD_FORGE_BRANCH }}
+          path: xad-forge
+
+      - name: Checkout QuantLib-Risks-Cpp-Forge
+        uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
+
+      - name: Setup
+        run: |
+          apt-get update
+          apt-get install -y ninja-build cmake
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2.12
+        with:
+          key: linux-ql-xad-forge
+          max-size: 650M
+
+      - name: Build Forge C API
+        run: |
+          cd forge
+          cmake -B build -S api/c -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DFORGE_CAPI_BUILD_TESTS=OFF \
+            -DCMAKE_INSTALL_PREFIX=$(pwd)/../install
+          cmake --build build
+          cmake --install build
+
+      - name: Configure QuantLib
+        run: |
+          cd QuantLib
+          cmake -B build -G Ninja -DBOOST_ROOT=/usr \
+            -DCMAKE_CXX_STANDARD=17 \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DXAD_WARNINGS_PARANOID=OFF \
+            -DXAD_ENABLE_JIT=ON \
+            -DCMAKE_PREFIX_PATH=$(pwd)/../install \
+            -DQL_EXTERNAL_SUBDIRECTORIES="$(pwd)/../xad;$(pwd)/../xad-forge;$(pwd)/../QuantLib-Risks-Cpp-Forge" \
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
+            -DQL_NULL_AS_FUNCTIONS=ON \
+            -DQL_BUILD_TEST_SUITE=OFF \
+            -DQL_BUILD_EXAMPLES=OFF \
+            -DQL_BUILD_BENCHMARK=OFF \
+            -DQLRISKS_DISABLE_AAD=OFF \
+            -DQLRISKS_ENABLE_FORGE=ON \
+            -DQLRISKS_USE_FORGE_CAPI=ON \
+            -DXAD_FORGE_USE_CAPI=ON \
+            -DQLRISKS_BUILD_TEST_SUITE=OFF \
+            -DQLRISKS_BUILD_BENCHMARK_STANDALONE=ON \
+            -DQLRISKS_ENABLE_FORGE_TESTS=ON
+
+      - name: Build
+        run: |
+          cd QuantLib/build
+          cmake --build .
+
+      - name: Run Benchmark
+        run: |
+          cd QuantLib/build
+          export LD_LIBRARY_PATH=$(pwd)/../../install/lib:$LD_LIBRARY_PATH
+          ./QuantLib-Risks-Cpp-Forge/test-suite/quantlib-risks-benchmark-standalone
+
+  ##############################################################################
+  # Windows, QL + XAD (True Baseline)
+  ##############################################################################
+  windows-xad:
+    name: Windows, QL + XAD
+    runs-on: windows-2022
+
+    env:
+      VSVARSALL: C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat
+
+    steps:
+      - name: Checkout QuantLib
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QL_REPO }}
+          ref: ${{ env.QL_BRANCH }}
+          path: QuantLib
+
+      - name: Checkout XAD
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.XAD_REPO }}
+          ref: ${{ env.XAD_BRANCH }}
+          path: xad
+
+      - name: Checkout QuantLib-Risks-Cpp (Original)
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QLRISKS_REPO }}
+          ref: ${{ env.QLRISKS_BRANCH }}
+          path: QuantLib-Risks-Cpp
+
+      - name: Checkout QuantLib-Risks-Cpp-Forge (for benchmark code)
+        uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
+
+      - name: Setup
+        run: choco install -y ninja
+
+      - name: Setup Boost
+        run: |
+          $Url = "https://downloads.sourceforge.net/project/boost/boost-binaries/1.86.0/boost_1_86_0-msvc-14.3-64.exe"
+          (New-Object System.Net.WebClient).DownloadFile($Url, "$RUNNER_TEMP\boost.exe")
+          Start-Process -Wait -FilePath "$RUNNER_TEMP\boost.exe" "/SILENT","/SP-","/SUPPRESSMSGBOXES","/DIR=C:\local\boost"
+          echo "BOOST_ROOT=C:\local\boost" >> $env:GITHUB_ENV
+
+      - name: Patch benchmark into original QuantLib-Risks-Cpp
+        shell: pwsh
+        run: |
+          # Copy standalone benchmark files from Forge repo to original
+          Copy-Item "QuantLib-Risks-Cpp-Forge/test-suite/benchmark_main.cpp" "QuantLib-Risks-Cpp/test-suite/"
+          Copy-Item "QuantLib-Risks-Cpp-Forge/test-suite/PlatformInfo.hpp" "QuantLib-Risks-Cpp/test-suite/"
+          Copy-Item "QuantLib-Risks-Cpp-Forge/test-suite/utilities_xad.cpp" "QuantLib-Risks-Cpp/test-suite/"
+          Copy-Item "QuantLib-Risks-Cpp-Forge/test-suite/utilities_xad.hpp" "QuantLib-Risks-Cpp/test-suite/"
+
+          # Add standalone benchmark target to CMakeLists.txt
+          $cmakeAddition = @"
+
+          # Standalone benchmark (patched from QuantLib-Risks-Cpp-Forge)
+          add_executable(QuantLib-Risks_benchmark_standalone benchmark_main.cpp)
+          set_target_properties(QuantLib-Risks_benchmark_standalone PROPERTIES
+              OUTPUT_NAME "quantlib-risks-benchmark-standalone")
+          target_link_libraries(QuantLib-Risks_benchmark_standalone PRIVATE
+              ql_library
+              `${QL_THREAD_LIBRARIES})
+          "@
+          Add-Content -Path "QuantLib-Risks-Cpp/test-suite/CMakeLists.txt" -Value $cmakeAddition
+
+      - name: Configure QuantLib
+        shell: cmd
+        run: |
+          cd QuantLib
+          call "%VSVARSALL%" amd64
+          cmake -B build -G Ninja ^
+            -DCMAKE_BUILD_TYPE=Release ^
+            -DCMAKE_CXX_STANDARD=17 ^
+            -DXAD_WARNINGS_PARANOID=OFF ^
+            -DXAD_ENABLE_JIT=OFF ^
+            -DXAD_STATIC_MSVC_RUNTIME=ON ^
+            -DQL_EXTERNAL_SUBDIRECTORIES="%cd%\..\xad;%cd%\..\QuantLib-Risks-Cpp" ^
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks ^
+            -DQL_NULL_AS_FUNCTIONS=ON ^
+            -DQL_BUILD_TEST_SUITE=OFF ^
+            -DQL_BUILD_EXAMPLES=OFF ^
+            -DQL_BUILD_BENCHMARK=OFF ^
+            -DQLRISKS_DISABLE_AAD=OFF ^
+            -DQLRISKS_BUILD_TEST_SUITE=ON
+
+      - name: Build
+        shell: cmd
+        run: |
+          cd QuantLib\build
+          call "%VSVARSALL%" amd64
+          cmake --build . --target QuantLib-Risks_benchmark_standalone --config Release
+
+      - name: Run Benchmark
+        shell: cmd
+        run: |
+          cd QuantLib\build
+          QuantLib-Risks-Cpp\test-suite\quantlib-risks-benchmark-standalone.exe
+
+  ##############################################################################
+  # Windows, QL + XAD-Forge
+  ##############################################################################
+  windows-xad-forge:
+    name: Windows, QL + XAD-Forge
+    runs-on: windows-2022
+
+    env:
+      VSVARSALL: C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat
+
+    steps:
+      - name: Checkout QuantLib
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QL_REPO }}
+          ref: ${{ env.QL_BRANCH }}
+          path: QuantLib
+
+      - name: Checkout XAD
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.XAD_REPO }}
+          ref: ${{ env.XAD_BRANCH }}
+          path: xad
+
+      - name: Checkout Forge
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.FORGE_REPO }}
+          ref: ${{ env.FORGE_BRANCH }}
+          path: forge
+
+      - name: Checkout xad-forge
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.XAD_FORGE_REPO }}
+          ref: ${{ env.XAD_FORGE_BRANCH }}
+          path: xad-forge
+
+      - name: Checkout QuantLib-Risks-Cpp-Forge
+        uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
+
+      - name: Setup
+        run: choco install -y ninja
+
+      - name: Setup Boost
+        run: |
+          $Url = "https://downloads.sourceforge.net/project/boost/boost-binaries/1.86.0/boost_1_86_0-msvc-14.3-64.exe"
+          (New-Object System.Net.WebClient).DownloadFile($Url, "$RUNNER_TEMP\boost.exe")
+          Start-Process -Wait -FilePath "$RUNNER_TEMP\boost.exe" "/SILENT","/SP-","/SUPPRESSMSGBOXES","/DIR=C:\local\boost"
+          echo "BOOST_ROOT=C:\local\boost" >> $env:GITHUB_ENV
+
+      - name: Build Forge C API
+        shell: cmd
+        run: |
+          cd forge
+          call "%VSVARSALL%" amd64
+          cmake -B build -S api/c -G Ninja ^
+            -DCMAKE_BUILD_TYPE=Release ^
+            -DFORGE_CAPI_BUILD_TESTS=OFF ^
+            -DFORGE_CAPI_USE_STATIC_RUNTIME=ON ^
+            -DCMAKE_INSTALL_PREFIX="%cd%\..\install"
+          cmake --build build
+          cmake --install build
+
+      - name: Configure QuantLib
+        shell: cmd
+        run: |
+          cd QuantLib
+          call "%VSVARSALL%" amd64
+          cmake -B build -G Ninja ^
+            -DCMAKE_BUILD_TYPE=Release ^
+            -DCMAKE_CXX_STANDARD=17 ^
+            -DXAD_WARNINGS_PARANOID=OFF ^
+            -DXAD_ENABLE_JIT=ON ^
+            -DXAD_STATIC_MSVC_RUNTIME=ON ^
+            -DCMAKE_PREFIX_PATH="%cd%\..\install" ^
+            -DQL_EXTERNAL_SUBDIRECTORIES="%cd%\..\xad;%cd%\..\xad-forge;%cd%\..\QuantLib-Risks-Cpp-Forge" ^
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks ^
+            -DQL_NULL_AS_FUNCTIONS=ON ^
+            -DQL_BUILD_TEST_SUITE=OFF ^
+            -DQL_BUILD_EXAMPLES=OFF ^
+            -DQL_BUILD_BENCHMARK=OFF ^
+            -DQLRISKS_DISABLE_AAD=OFF ^
+            -DQLRISKS_ENABLE_FORGE=ON ^
+            -DQLRISKS_USE_FORGE_CAPI=ON ^
+            -DXAD_FORGE_USE_CAPI=ON ^
+            -DQLRISKS_BUILD_TEST_SUITE=OFF ^
+            -DQLRISKS_BUILD_BENCHMARK_STANDALONE=ON ^
+            -DQLRISKS_ENABLE_FORGE_TESTS=ON
+
+      - name: Build
+        shell: cmd
+        run: |
+          cd QuantLib\build
+          call "%VSVARSALL%" amd64
+          cmake --build . --config Release
+
+      - name: Run Benchmark
+        shell: cmd
+        run: |
+          cd QuantLib\build
+          set PATH=%cd%\..\..\install\bin;%PATH%
+          QuantLib-Risks-Cpp-Forge\test-suite\quantlib-risks-benchmark-standalone.exe
+
+  ##############################################################################
+  # Performance Decomposition - Detailed timing breakdown (XAD-Forge)
+  ##############################################################################
+  decomposition:
+    name: Decomposition
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/lballabio/quantlib-devenv:rolling
+
+    steps:
+      - name: Hardware Info
+        run: |
+          echo "===== CPU ====="
+          lscpu | grep -E "^(Model name|CPU\(s\)|Thread|Core|Socket|CPU max MHz)"
+          echo "===== Memory ====="
+          free -h
+
+      - name: Checkout QuantLib
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QL_REPO }}
+          ref: ${{ env.QL_BRANCH }}
+          path: QuantLib
+
+      - name: Checkout XAD
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.XAD_REPO }}
+          ref: ${{ env.XAD_BRANCH }}
+          path: xad
+
+      - name: Checkout Forge
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.FORGE_REPO }}
+          ref: ${{ env.FORGE_BRANCH }}
+          path: forge
+
+      - name: Checkout xad-forge
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.XAD_FORGE_REPO }}
+          ref: ${{ env.XAD_FORGE_BRANCH }}
+          path: xad-forge
+
+      - name: Checkout QuantLib-Risks-Cpp-Forge
+        uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
+
+      - name: Setup
+        run: |
+          apt-get update
+          apt-get install -y ninja-build cmake
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2.12
+        with:
+          key: linux-decomposition
+          max-size: 650M
+
+      - name: Build Forge C API
+        run: |
+          cd forge
+          cmake -B build -S api/c -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DFORGE_CAPI_BUILD_TESTS=OFF \
+            -DCMAKE_INSTALL_PREFIX=$(pwd)/../install
+          cmake --build build
+          cmake --install build
+
+      - name: Configure QuantLib
+        run: |
+          cd QuantLib
+          cmake -B build -G Ninja -DBOOST_ROOT=/usr \
+            -DCMAKE_CXX_STANDARD=17 \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DXAD_WARNINGS_PARANOID=OFF \
+            -DXAD_ENABLE_JIT=ON \
+            -DCMAKE_PREFIX_PATH=$(pwd)/../install \
+            -DQL_EXTERNAL_SUBDIRECTORIES="$(pwd)/../xad;$(pwd)/../xad-forge;$(pwd)/../QuantLib-Risks-Cpp-Forge" \
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
+            -DQL_NULL_AS_FUNCTIONS=ON \
+            -DQL_BUILD_TEST_SUITE=OFF \
+            -DQL_BUILD_EXAMPLES=OFF \
+            -DQL_BUILD_BENCHMARK=OFF \
+            -DQLRISKS_DISABLE_AAD=OFF \
+            -DQLRISKS_ENABLE_FORGE=ON \
+            -DQLRISKS_USE_FORGE_CAPI=ON \
+            -DXAD_FORGE_USE_CAPI=ON \
+            -DQLRISKS_BUILD_TEST_SUITE=OFF \
+            -DQLRISKS_BUILD_BENCHMARK_STANDALONE=ON \
+            -DQLRISKS_ENABLE_FORGE_TESTS=ON
+
+      - name: Build
+        run: |
+          cd QuantLib/build
+          cmake --build .
+
+      - name: Run Performance Decomposition
+        run: |
+          cd QuantLib/build
+          export LD_LIBRARY_PATH=$(pwd)/../../install/lib:$LD_LIBRARY_PATH
+          ./QuantLib-Risks-Cpp-Forge/test-suite/quantlib-risks-benchmark-standalone --decomposition
+
+  ##############################################################################
+  # Compare XAD vs XAD-Forge - Statistical comparison
+  ##############################################################################
+  compare:
+    name: Compare XAD vs XAD-Forge
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/lballabio/quantlib-devenv:rolling
+
+    steps:
+      - name: Hardware Info
+        run: |
+          echo "===== CPU ====="
+          lscpu | grep -E "^(Model name|CPU\(s\)|Thread|Core|Socket|CPU max MHz)"
+          echo "===== Memory ====="
+          free -h
+
+      - name: Checkout QuantLib
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QL_REPO }}
+          ref: ${{ env.QL_BRANCH }}
+          path: QuantLib
+
+      - name: Checkout XAD
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.XAD_REPO }}
+          ref: ${{ env.XAD_BRANCH }}
+          path: xad
+
+      - name: Checkout QuantLib-Risks-Cpp (Original)
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QLRISKS_REPO }}
+          ref: ${{ env.QLRISKS_BRANCH }}
+          path: QuantLib-Risks-Cpp
+
+      - name: Checkout Forge
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.FORGE_REPO }}
+          ref: ${{ env.FORGE_BRANCH }}
+          path: forge
+
+      - name: Checkout xad-forge
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.XAD_FORGE_REPO }}
+          ref: ${{ env.XAD_FORGE_BRANCH }}
+          path: xad-forge
+
+      - name: Checkout QuantLib-Risks-Cpp-Forge
+        uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
+
+      - name: Setup
+        run: |
+          apt-get update
+          apt-get install -y ninja-build cmake bc
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2.12
+        with:
+          key: linux-compare
+          max-size: 650M
+
+      # --- Build QL + XAD (baseline) ---
+      - name: Patch benchmark into original QuantLib-Risks-Cpp
+        run: |
+          cp QuantLib-Risks-Cpp-Forge/test-suite/benchmark_main.cpp \
+             QuantLib-Risks-Cpp/test-suite/
+          cp QuantLib-Risks-Cpp-Forge/test-suite/PlatformInfo.hpp \
+             QuantLib-Risks-Cpp/test-suite/
+          cp QuantLib-Risks-Cpp-Forge/test-suite/utilities_xad.cpp \
+             QuantLib-Risks-Cpp/test-suite/
+          cp QuantLib-Risks-Cpp-Forge/test-suite/utilities_xad.hpp \
+             QuantLib-Risks-Cpp/test-suite/
+
+          cat >> QuantLib-Risks-Cpp/test-suite/CMakeLists.txt << 'EOF'
+
+          # Standalone benchmark (patched from QuantLib-Risks-Cpp-Forge)
+          add_executable(QuantLib-Risks_benchmark_standalone benchmark_main.cpp)
+          set_target_properties(QuantLib-Risks_benchmark_standalone PROPERTIES
+              OUTPUT_NAME "quantlib-risks-benchmark-standalone")
+          target_link_libraries(QuantLib-Risks_benchmark_standalone PRIVATE
+              ql_library
+              ${QL_THREAD_LIBRARIES})
+          EOF
+
+      - name: Configure QuantLib (QL + XAD)
+        run: |
+          cd QuantLib
+          cmake -B build-xad -G Ninja -DBOOST_ROOT=/usr \
+            -DCMAKE_CXX_STANDARD=17 \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DXAD_WARNINGS_PARANOID=OFF \
+            -DXAD_ENABLE_JIT=OFF \
+            -DQL_EXTERNAL_SUBDIRECTORIES="$(pwd)/../xad;$(pwd)/../QuantLib-Risks-Cpp" \
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
+            -DQL_NULL_AS_FUNCTIONS=ON \
+            -DQL_BUILD_TEST_SUITE=OFF \
+            -DQL_BUILD_EXAMPLES=OFF \
+            -DQL_BUILD_BENCHMARK=OFF \
+            -DQLRISKS_DISABLE_AAD=OFF \
+            -DQLRISKS_BUILD_TEST_SUITE=ON
+
+      - name: Build (QL + XAD)
+        run: |
+          cd QuantLib/build-xad
+          cmake --build . --target QuantLib-Risks_benchmark_standalone
+
+      # --- Build QL + XAD-Forge ---
+      - name: Build Forge C API
+        run: |
+          cd forge
+          cmake -B build -S api/c -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DFORGE_CAPI_BUILD_TESTS=OFF \
+            -DCMAKE_INSTALL_PREFIX=$(pwd)/../install
+          cmake --build build
+          cmake --install build
+
+      - name: Configure QuantLib (QL + XAD-Forge)
+        run: |
+          cd QuantLib
+          cmake -B build-forge -G Ninja -DBOOST_ROOT=/usr \
+            -DCMAKE_CXX_STANDARD=17 \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DXAD_WARNINGS_PARANOID=OFF \
+            -DXAD_ENABLE_JIT=ON \
+            -DCMAKE_PREFIX_PATH=$(pwd)/../install \
+            -DQL_EXTERNAL_SUBDIRECTORIES="$(pwd)/../xad;$(pwd)/../xad-forge;$(pwd)/../QuantLib-Risks-Cpp-Forge" \
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
+            -DQL_NULL_AS_FUNCTIONS=ON \
+            -DQL_BUILD_TEST_SUITE=OFF \
+            -DQL_BUILD_EXAMPLES=OFF \
+            -DQL_BUILD_BENCHMARK=OFF \
+            -DQLRISKS_DISABLE_AAD=OFF \
+            -DQLRISKS_ENABLE_FORGE=ON \
+            -DQLRISKS_USE_FORGE_CAPI=ON \
+            -DXAD_FORGE_USE_CAPI=ON \
+            -DQLRISKS_BUILD_TEST_SUITE=OFF \
+            -DQLRISKS_BUILD_BENCHMARK_STANDALONE=ON \
+            -DQLRISKS_ENABLE_FORGE_TESTS=ON
+
+      - name: Build (QL + XAD-Forge)
+        run: |
+          cd QuantLib/build-forge
+          cmake --build .
+
+      # --- Run benchmarks multiple times ---
+      - name: Run Benchmark (QL + XAD)
+        run: |
+          set -e
+          cd QuantLib/build-xad
+          # warmup run
+          ./QuantLib-Risks-Cpp/test-suite/quantlib-risks-benchmark-standalone --quick
+          rm -f benchmark_xad.log || true
+          for i in $(seq 1 5) ; do \
+            ./QuantLib-Risks-Cpp/test-suite/quantlib-risks-benchmark-standalone | tee -a benchmark_xad.log ; \
+          done
+
+      - name: Run Benchmark (QL + XAD-Forge)
+        run: |
+          set -e
+          cd QuantLib/build-forge
+          export LD_LIBRARY_PATH=$(pwd)/../../install/lib:$LD_LIBRARY_PATH
+          # warmup run
+          ./QuantLib-Risks-Cpp-Forge/test-suite/quantlib-risks-benchmark-standalone --quick
+          rm -f benchmark_forge.log || true
+          for i in $(seq 1 5) ; do \
+            ./QuantLib-Risks-Cpp-Forge/test-suite/quantlib-risks-benchmark-standalone | tee -a benchmark_forge.log ; \
+          done
+
+      - name: Compare Results
+        id: compare
+        run: |
+          set -e
+
+          echo "## Benchmark Comparison: QL + XAD vs QL + XAD-Forge" > benchmark_results.md
+          echo "" >> benchmark_results.md
+          echo "Comparing original QuantLib-Risks-Cpp (XAD tape) vs Forge repo (JIT + JIT-AVX)." >> benchmark_results.md
+          echo "" >> benchmark_results.md
+          echo "- Commit: \`${{ github.sha }}\`" >> benchmark_results.md
+          echo "- Runs: 5 (after warmup)" >> benchmark_results.md
+          echo "" >> benchmark_results.md
+
+          echo "### QL + XAD (Baseline)" >> benchmark_results.md
+          echo "\`\`\`" >> benchmark_results.md
+          tail -80 QuantLib/build-xad/benchmark_xad.log >> benchmark_results.md || echo "No log available" >> benchmark_results.md
+          echo "\`\`\`" >> benchmark_results.md
+          echo "" >> benchmark_results.md
+
+          echo "### QL + XAD-Forge" >> benchmark_results.md
+          echo "\`\`\`" >> benchmark_results.md
+          tail -80 QuantLib/build-forge/benchmark_forge.log >> benchmark_results.md || echo "No log available" >> benchmark_results.md
+          echo "\`\`\`" >> benchmark_results.md
+
+          cat benchmark_results.md
+
+      - name: Upload Results
+        uses: actions/upload-artifact@v4
+        with:
+          name: benchmark-compare
+          path: benchmark_results.md
+
+  ##############################################################################
+  # Linux, double vs AReal (no diff)
+  # Compares plain double vs xad::AReal<double> on same hardware
+  # This measures the overhead of the XAD type system in passive mode
+  ##############################################################################
+  linux-type-overhead:
+    name: Linux, double vs AReal (no diff)
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/lballabio/quantlib-devenv:rolling
+
+    steps:
+      - name: Hardware Info
+        run: |
+          echo "===== CPU ====="
+          lscpu | grep -E "^(Model name|CPU\(s\)|Thread|Core|Socket|CPU max MHz)"
+          echo "===== Memory ====="
+          free -h
+
+      - name: Checkout QuantLib
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QL_REPO }}
+          ref: ${{ env.QL_BRANCH }}
+          path: QuantLib
+
+      - name: Checkout XAD
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.XAD_REPO }}
+          ref: ${{ env.XAD_BRANCH }}
+          path: xad
+
+      - name: Checkout QuantLib-Risks-Cpp (Original)
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QLRISKS_REPO }}
+          ref: ${{ env.QLRISKS_BRANCH }}
+          path: QuantLib-Risks-Cpp
+
+      - name: Checkout QuantLib-Risks-Cpp-Forge (for benchmark code)
+        uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
+
+      - name: Setup
+        run: |
+          apt-get update
+          apt-get install -y ninja-build cmake
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2.12
+        with:
+          key: linux-type-overhead
+          max-size: 1G
+
+      # =========================================================================
+      # Build 1: QuantLib with plain double
+      # =========================================================================
+      - name: Create pricing-only benchmark for plain double
+        run: |
+          mkdir -p QuantLib/test-suite-double
+          cat > QuantLib/test-suite-double/benchmark_double.cpp << 'EOFCPP'
+          /*
+           * Pricing-only benchmark using plain double (no XAD types)
+           */
+          #include <ql/quantlib.hpp>
+          #include <chrono>
+          #include <iostream>
+          #include <iomanip>
+          #include <vector>
+          #include <numeric>
+          #include <cmath>
+          #include <algorithm>
+
+          using namespace QuantLib;
+
+          std::string getCpuInfo() {
+          #ifdef __linux__
+              FILE* fp = popen("grep 'model name' /proc/cpuinfo | head -1 | cut -d: -f2", "r");
+              if (fp) {
+                  char buf[256];
+                  if (fgets(buf, sizeof(buf), fp)) {
+                      pclose(fp);
+                      std::string s(buf);
+                      s.erase(0, s.find_first_not_of(" \t\n"));
+                      s.erase(s.find_last_not_of(" \t\n") + 1);
+                      return s;
+                  }
+                  pclose(fp);
+              }
+          #endif
+              return "Unknown CPU";
+          }
+
+          double computeMean(const std::vector<double>& v) {
+              if (v.empty()) return 0.0;
+              return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
+          }
+
+          double computeStddev(const std::vector<double>& v) {
+              if (v.size() < 2) return 0.0;
+              double mean = computeMean(v);
+              double sq_sum = 0.0;
+              for (auto x : v) sq_sum += (x - mean) * (x - mean);
+              return std::sqrt(sq_sum / (v.size() - 1));
+          }
+
+          ext::shared_ptr<IborIndex> makeIndex(std::vector<Date> dates, const std::vector<Rate>& rates) {
+              DayCounter dayCounter = Actual360();
+              RelinkableHandle<YieldTermStructure> termStructure;
+              ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+              Date todaysDate = index->fixingCalendar().adjust(Date(4, September, 2005));
+              Settings::instance().evaluationDate() = todaysDate;
+              dates[0] = index->fixingCalendar().advance(todaysDate, index->fixingDays(), Days);
+              termStructure.linkTo(ext::make_shared<ZeroCurve>(dates, rates, dayCounter));
+              return index;
+          }
+
+          void runBenchmark(Size size, Size i_opt, Size j_opt, Size steps, int curveEndYears,
+                            std::vector<std::pair<int, double>>& results) {
+              using Clock = std::chrono::high_resolution_clock;
+              using Duration = std::chrono::duration<double, std::milli>;
+
+              Calendar calendar = TARGET();
+              Date todaysDate(4, September, 2005);
+              Settings::instance().evaluationDate() = todaysDate;
+              Integer fixingDays = 2;
+              Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+              DayCounter dayCounter = Actual360();
+
+              std::vector<Rate> baseZeroRates = {0.035, 0.0575};
+              std::vector<Date> baseDates = {settlementDate, settlementDate + curveEndYears * Years};
+              auto baseIndex = makeIndex(baseDates, baseZeroRates);
+
+              ext::shared_ptr<LiborForwardModelProcess> process(
+                  new LiborForwardModelProcess(size, baseIndex));
+              process->setCovarParam(ext::make_shared<LfmCovarianceProxy>(
+                  ext::make_shared<LmLinearExponentialVolatilityModel>(
+                      process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                  ext::make_shared<LmExponentialCorrelationModel>(size, 0.5)));
+
+              std::vector<Time> fixingTimes = process->fixingTimes();
+              TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+              std::vector<Size> location;
+              for (Size idx = 0; idx < fixingTimes.size(); ++idx)
+                  location.push_back(std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+
+              Size numFactors = process->factors();
+              Size exerciseStep = location[i_opt];
+              Size fullGridSteps = grid.size() - 1;
+              Size fullGridRandoms = fullGridSteps * numFactors;
+
+              BusinessDayConvention convention = baseIndex->businessDayConvention();
+              Date fwdStart = settlementDate + Period(6 * i_opt, Months);
+              Date fwdMaturity = fwdStart + Period(6 * j_opt, Months);
+              Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                                convention, convention, DateGeneration::Forward, false);
+
+              std::vector<double> accrualStart(size), accrualEnd(size);
+              for (Size k = 0; k < size; ++k) {
+                  accrualStart[k] = process->accrualStartTimes()[k];
+                  accrualEnd[k] = process->accrualEndTimes()[k];
+              }
+
+              std::vector<int> pathCounts = {10, 100, 1000, 10000, 100000};
+              Size maxPaths = 100000;
+
+              std::cerr << "  Generating randoms..." << std::flush;
+              typedef PseudoRandom::rsg_type rsg_type;
+              rsg_type rsg = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+              std::vector<std::vector<double>> allRandoms(maxPaths);
+              for (Size n = 0; n < maxPaths; ++n) {
+                  allRandoms[n].resize(fullGridRandoms);
+                  const auto& seq = rsg.nextSequence();
+                  for (Size m = 0; m < fullGridRandoms; ++m)
+                      allRandoms[n][m] = seq.value[m];
+              }
+              std::cerr << " Done." << std::endl;
+
+              ext::shared_ptr<VanillaSwap> fwdSwap(
+                  new VanillaSwap(Swap::Receiver, 1.0, schedule, 0.05, dayCounter,
+                                  schedule, baseIndex, 0.0, baseIndex->dayCounter()));
+              fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                  baseIndex->forwardingTermStructure()));
+              double swapRate = fwdSwap->fairRate();
+              Array initRates = process->initialValues();
+
+              size_t warmupIters = 2, benchIters = 5;
+
+              for (size_t tc = 0; tc < pathCounts.size(); ++tc) {
+                  Size nrTrails = pathCounts[tc];
+                  std::vector<double> times;
+
+                  for (size_t iter = 0; iter < warmupIters + benchIters; ++iter) {
+                      auto t_start = Clock::now();
+                      double price = 0.0;
+                      for (Size n = 0; n < nrTrails; ++n) {
+                          Array asset(size);
+                          for (Size k = 0; k < size; ++k) asset[k] = initRates[k];
+                          Array assetAtExercise(size);
+                          for (Size step = 1; step <= fullGridSteps; ++step) {
+                              Size offset = (step - 1) * numFactors;
+                              Array dw(numFactors);
+                              for (Size f = 0; f < numFactors; ++f)
+                                  dw[f] = allRandoms[n][offset + f];
+                              asset = process->evolve(grid[step - 1], asset, grid.dt(step - 1), dw);
+                              if (step == exerciseStep)
+                                  for (Size k = 0; k < size; ++k) assetAtExercise[k] = asset[k];
+                          }
+                          Array dis(size);
+                          double df = 1.0;
+                          for (Size k = 0; k < size; ++k) {
+                              df = df / (1.0 + assetAtExercise[k] * (accrualEnd[k] - accrualStart[k]));
+                              dis[k] = df;
+                          }
+                          double npv = 0.0;
+                          for (Size m = i_opt; m < i_opt + j_opt; ++m)
+                              npv += (swapRate - assetAtExercise[m]) * (accrualEnd[m] - accrualStart[m]) * dis[m];
+                          if (npv > 0.0) price += npv;
+                      }
+                      (void)price;
+                      auto t_end = Clock::now();
+                      if (iter >= warmupIters)
+                          times.push_back(Duration(t_end - t_start).count());
+                  }
+                  results.push_back({pathCounts[tc], computeMean(times)});
+              }
+          }
+
+          int main() {
+              std::vector<std::pair<int, double>> smallResults, largeResults;
+
+              std::cerr << "Running small swaption benchmark..." << std::endl;
+              runBenchmark(10, 2, 2, 8, 6, smallResults);
+
+              std::cerr << "Running large swaption benchmark..." << std::endl;
+              runBenchmark(20, 10, 10, 20, 12, largeResults);
+
+              // Output results in parseable format
+              std::cout << "DOUBLE_SMALL:";
+              for (auto& r : smallResults) std::cout << r.first << "=" << r.second << ";";
+              std::cout << std::endl;
+
+              std::cout << "DOUBLE_LARGE:";
+              for (auto& r : largeResults) std::cout << r.first << "=" << r.second << ";";
+              std::cout << std::endl;
+
+              return 0;
+          }
+          EOFCPP
+
+      - name: Add benchmark target to QuantLib CMakeLists
+        run: |
+          # Add standalone benchmark target to QuantLib's CMakeLists.txt
+          cat >> QuantLib/CMakeLists.txt << 'EOF'
+
+          # Plain double benchmark for type overhead comparison
+          add_executable(benchmark_double test-suite-double/benchmark_double.cpp)
+          target_link_libraries(benchmark_double PRIVATE ql_library ${QL_THREAD_LIBRARIES})
+          EOF
+
+      - name: Configure QuantLib (plain double)
+        run: |
+          cd QuantLib
+          cmake -B build-double -G Ninja -DBOOST_ROOT=/usr \
+            -DCMAKE_CXX_STANDARD=17 \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DQL_BUILD_TEST_SUITE=OFF \
+            -DQL_BUILD_EXAMPLES=OFF \
+            -DQL_BUILD_BENCHMARK=OFF
+
+      - name: Build QuantLib and benchmark (plain double)
+        run: |
+          cd QuantLib/build-double
+          cmake --build . --target benchmark_double
+
+      # =========================================================================
+      # Build 2: QuantLib-Risks with xad::AReal<double>
+      # =========================================================================
+      - name: Patch benchmark into QuantLib-Risks-Cpp
+        run: |
+          cp QuantLib-Risks-Cpp-Forge/test-suite/benchmark_main.cpp \
+             QuantLib-Risks-Cpp/test-suite/
+          cp QuantLib-Risks-Cpp-Forge/test-suite/PlatformInfo.hpp \
+             QuantLib-Risks-Cpp/test-suite/
+
+          cat >> QuantLib-Risks-Cpp/test-suite/CMakeLists.txt << 'EOF'
+
+          add_executable(QuantLib-Risks_benchmark_standalone benchmark_main.cpp)
+          set_target_properties(QuantLib-Risks_benchmark_standalone PROPERTIES
+              OUTPUT_NAME "quantlib-risks-benchmark-standalone")
+          target_link_libraries(QuantLib-Risks_benchmark_standalone PRIVATE
+              ql_library
+              ${QL_THREAD_LIBRARIES})
+          EOF
+
+      - name: Configure QuantLib (xad::AReal)
+        run: |
+          cd QuantLib
+          cmake -B build-xad -G Ninja -DBOOST_ROOT=/usr \
+            -DCMAKE_CXX_STANDARD=17 \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DXAD_WARNINGS_PARANOID=OFF \
+            -DXAD_ENABLE_JIT=OFF \
+            -DQL_EXTERNAL_SUBDIRECTORIES="$(pwd)/../xad;$(pwd)/../QuantLib-Risks-Cpp" \
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks \
+            -DQL_NULL_AS_FUNCTIONS=ON \
+            -DQL_BUILD_TEST_SUITE=OFF \
+            -DQL_BUILD_EXAMPLES=OFF \
+            -DQL_BUILD_BENCHMARK=OFF \
+            -DQLRISKS_DISABLE_AAD=OFF \
+            -DQLRISKS_BUILD_TEST_SUITE=ON
+
+      - name: Build QuantLib-Risks (xad::AReal)
+        run: |
+          cd QuantLib/build-xad
+          cmake --build . --target QuantLib-Risks_benchmark_standalone
+
+      # =========================================================================
+      # Run both benchmarks and compare
+      # =========================================================================
+      - name: Run Benchmarks
+        run: |
+          set -e
+
+          echo "===== Running plain double benchmark ====="
+          cd QuantLib/build-double
+          ./benchmark_double > double_results.txt 2>&1
+          cat double_results.txt
+
+          echo ""
+          echo "===== Running xad::AReal benchmark ====="
+          cd ../build-xad
+          ./QuantLib-Risks-Cpp/test-suite/quantlib-risks-benchmark-standalone --pricing-only > xad_results.txt 2>&1
+          cat xad_results.txt
+
+      - name: Generate Comparison Report
+        run: |
+          set -e
+          cd QuantLib
+
+          # Parse double results
+          DOUBLE_SMALL=$(grep "^DOUBLE_SMALL:" build-double/double_results.txt | sed 's/DOUBLE_SMALL://')
+          DOUBLE_LARGE=$(grep "^DOUBLE_LARGE:" build-double/double_results.txt | sed 's/DOUBLE_LARGE://')
+
+          # Extract double timings (format: 10=0.0437;100=0.439;...)
+          D_S_10=$(echo "$DOUBLE_SMALL" | grep -oP '10=\K[0-9.]+')
+          D_S_100=$(echo "$DOUBLE_SMALL" | grep -oP '100=\K[0-9.]+')
+          D_S_1K=$(echo "$DOUBLE_SMALL" | grep -oP '1000=\K[0-9.]+')
+          D_S_10K=$(echo "$DOUBLE_SMALL" | grep -oP '10000=\K[0-9.]+')
+          D_S_100K=$(echo "$DOUBLE_SMALL" | grep -oP '100000=\K[0-9.]+')
+
+          D_L_10=$(echo "$DOUBLE_LARGE" | grep -oP '10=\K[0-9.]+')
+          D_L_100=$(echo "$DOUBLE_LARGE" | grep -oP '100=\K[0-9.]+')
+          D_L_1K=$(echo "$DOUBLE_LARGE" | grep -oP '1000=\K[0-9.]+')
+          D_L_10K=$(echo "$DOUBLE_LARGE" | grep -oP '10000=\K[0-9.]+')
+          D_L_100K=$(echo "$DOUBLE_LARGE" | grep -oP '100000=\K[0-9.]+')
+
+          # Parse AReal results (extract Mean values from table lines like "|     10 |   Pricing |      0.1 |")
+          # Get small swaption results (first set of results)
+          AREAL_RESULTS=$(cat build-xad/xad_results.txt)
+
+          # Extract pricing times from the output - look for lines with "Pricing" and extract the mean
+          SMALL_SECTION=$(echo "$AREAL_RESULTS" | sed -n '/PRICING-ONLY: Small/,/PRICING-ONLY: Large/p')
+          LARGE_SECTION=$(echo "$AREAL_RESULTS" | sed -n '/PRICING-ONLY: Large/,/All benchmarks complete/p')
+
+          A_S_10=$(echo "$SMALL_SECTION" | grep -E "^\|[[:space:]]+10 \|" | awk -F'|' '{print $4}' | tr -d ' ')
+          A_S_100=$(echo "$SMALL_SECTION" | grep -E "^\|[[:space:]]+100 \|" | awk -F'|' '{print $4}' | tr -d ' ')
+          A_S_1K=$(echo "$SMALL_SECTION" | grep -E "^\|[[:space:]]+1K \|" | awk -F'|' '{print $4}' | tr -d ' ')
+          A_S_10K=$(echo "$SMALL_SECTION" | grep -E "^\|[[:space:]]+10K \|" | awk -F'|' '{print $4}' | tr -d ' ')
+          A_S_100K=$(echo "$SMALL_SECTION" | grep -E "^\|[[:space:]]+100K \|" | awk -F'|' '{print $4}' | tr -d ' ')
+
+          A_L_10=$(echo "$LARGE_SECTION" | grep -E "^\|[[:space:]]+10 \|" | awk -F'|' '{print $4}' | tr -d ' ')
+          A_L_100=$(echo "$LARGE_SECTION" | grep -E "^\|[[:space:]]+100 \|" | awk -F'|' '{print $4}' | tr -d ' ')
+          A_L_1K=$(echo "$LARGE_SECTION" | grep -E "^\|[[:space:]]+1K \|" | awk -F'|' '{print $4}' | tr -d ' ')
+          A_L_10K=$(echo "$LARGE_SECTION" | grep -E "^\|[[:space:]]+10K \|" | awk -F'|' '{print $4}' | tr -d ' ')
+          A_L_100K=$(echo "$LARGE_SECTION" | grep -E "^\|[[:space:]]+100K \|" | awk -F'|' '{print $4}' | tr -d ' ')
+
+          echo "================================================================================"
+          echo "  TYPE OVERHEAD COMPARISON: double vs xad::AReal<double>"
+          echo "================================================================================"
+          echo ""
+          echo "This compares pricing-only performance (no derivatives) to measure"
+          echo "the overhead of using xad::AReal<double> instead of plain double."
+          echo "Both benchmarks ran on the same hardware in this job."
+          echo ""
+          echo "================================================================================"
+          echo "  SMALL SWAPTION (1Y into 1Y)"
+          echo "================================================================================"
+          echo ""
+          printf "| %6s | %12s | %12s | %10s |\n" "Paths" "double (ms)" "AReal (ms)" "Overhead"
+          printf "|%s|%s|%s|%s|\n" "-------:" "-------------:" "-------------:" "-----------:"
+
+          for paths in "10 $D_S_10 $A_S_10" "100 $D_S_100 $A_S_100" "1K $D_S_1K $A_S_1K" "10K $D_S_10K $A_S_10K" "100K $D_S_100K $A_S_100K"; do
+            set -- $paths
+            p=$1; d=$2; a=$3
+            if [ -n "$d" ] && [ -n "$a" ] && [ "$d" != "0" ]; then
+              overhead=$(awk "BEGIN {printf \"%.1f\", (($a - $d) / $d) * 100}")
+              printf "| %6s | %12.2f | %12.1f | %9s%% |\n" "$p" "$d" "$a" "$overhead"
+            fi
+          done
+
+          echo ""
+          echo "================================================================================"
+          echo "  LARGE SWAPTION (5Y into 5Y)"
+          echo "================================================================================"
+          echo ""
+          printf "| %6s | %12s | %12s | %10s |\n" "Paths" "double (ms)" "AReal (ms)" "Overhead"
+          printf "|%s|%s|%s|%s|\n" "-------:" "-------------:" "-------------:" "-----------:"
+
+          for paths in "10 $D_L_10 $A_L_10" "100 $D_L_100 $A_L_100" "1K $D_L_1K $A_L_1K" "10K $D_L_10K $A_L_10K" "100K $D_L_100K $A_L_100K"; do
+            set -- $paths
+            p=$1; d=$2; a=$3
+            if [ -n "$d" ] && [ -n "$a" ] && [ "$d" != "0" ]; then
+              overhead=$(awk "BEGIN {printf \"%.1f\", (($a - $d) / $d) * 100}")
+              printf "| %6s | %12.2f | %12.1f | %9s%% |\n" "$p" "$d" "$a" "$overhead"
+            fi
+          done
+
+          echo ""
+          echo "================================================================================"
+          echo "  SUMMARY"
+          echo "================================================================================"
+          echo ""
+          echo "Overhead represents the cost of using xad::AReal<double> instead of plain double,"
+          echo "even when not computing derivatives (passive mode, no tape recording)."
+          echo ""
+
+  ##############################################################################
+  # Windows, double vs AReal (no diff)
+  # Compares plain double vs xad::AReal<double> on same hardware
+  # This measures the overhead of the XAD type system in passive mode
+  ##############################################################################
+  windows-type-overhead:
+    name: Windows, double vs AReal (no diff)
+    runs-on: windows-2022
+
+    env:
+      VSVARSALL: C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat
+
+    steps:
+      - name: Checkout QuantLib
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QL_REPO }}
+          ref: ${{ env.QL_BRANCH }}
+          path: QuantLib
+
+      - name: Checkout XAD
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.XAD_REPO }}
+          ref: ${{ env.XAD_BRANCH }}
+          path: xad
+
+      - name: Checkout QuantLib-Risks-Cpp (Original)
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.QLRISKS_REPO }}
+          ref: ${{ env.QLRISKS_BRANCH }}
+          path: QuantLib-Risks-Cpp
+
+      - name: Checkout QuantLib-Risks-Cpp-Forge (for benchmark code)
+        uses: actions/checkout@v4
+        with:
+          path: QuantLib-Risks-Cpp-Forge
+
+      - name: Setup
+        run: choco install -y ninja
+
+      - name: Setup Boost
+        run: |
+          $Url = "https://downloads.sourceforge.net/project/boost/boost-binaries/1.86.0/boost_1_86_0-msvc-14.3-64.exe"
+          (New-Object System.Net.WebClient).DownloadFile($Url, "$RUNNER_TEMP\boost.exe")
+          Start-Process -Wait -FilePath "$RUNNER_TEMP\boost.exe" "/SILENT","/SP-","/SUPPRESSMSGBOXES","/DIR=C:\local\boost"
+          echo "BOOST_ROOT=C:\local\boost" >> $env:GITHUB_ENV
+
+      # =========================================================================
+      # Build 1: QuantLib with plain double
+      # =========================================================================
+      - name: Create pricing-only benchmark for plain double
+        shell: pwsh
+        run: |
+          New-Item -ItemType Directory -Force -Path "QuantLib/test-suite-double"
+          @'
+          /*
+           * Pricing-only benchmark using plain double (no XAD types)
+           */
+          #include <ql/quantlib.hpp>
+          #include <chrono>
+          #include <iostream>
+          #include <iomanip>
+          #include <vector>
+          #include <numeric>
+          #include <cmath>
+          #include <algorithm>
+
+          using namespace QuantLib;
+
+          double computeMean(const std::vector<double>& v) {
+              if (v.empty()) return 0.0;
+              return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
+          }
+
+          double computeStddev(const std::vector<double>& v) {
+              if (v.size() < 2) return 0.0;
+              double mean = computeMean(v);
+              double sq_sum = 0.0;
+              for (auto x : v) sq_sum += (x - mean) * (x - mean);
+              return std::sqrt(sq_sum / (v.size() - 1));
+          }
+
+          ext::shared_ptr<IborIndex> makeIndex(std::vector<Date> dates, const std::vector<Rate>& rates) {
+              DayCounter dayCounter = Actual360();
+              RelinkableHandle<YieldTermStructure> termStructure;
+              ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+              Date todaysDate = index->fixingCalendar().adjust(Date(4, September, 2005));
+              Settings::instance().evaluationDate() = todaysDate;
+              dates[0] = index->fixingCalendar().advance(todaysDate, index->fixingDays(), Days);
+              termStructure.linkTo(ext::make_shared<ZeroCurve>(dates, rates, dayCounter));
+              return index;
+          }
+
+          void runBenchmark(Size size, Size i_opt, Size j_opt, Size steps, int curveEndYears,
+                            std::vector<std::pair<int, double>>& results) {
+              using Clock = std::chrono::high_resolution_clock;
+              using Duration = std::chrono::duration<double, std::milli>;
+
+              Calendar calendar = TARGET();
+              Date todaysDate(4, September, 2005);
+              Settings::instance().evaluationDate() = todaysDate;
+              Integer fixingDays = 2;
+              Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+              DayCounter dayCounter = Actual360();
+
+              std::vector<Rate> baseZeroRates = {0.035, 0.0575};
+              std::vector<Date> baseDates = {settlementDate, settlementDate + curveEndYears * Years};
+              auto baseIndex = makeIndex(baseDates, baseZeroRates);
+
+              ext::shared_ptr<LiborForwardModelProcess> process(
+                  new LiborForwardModelProcess(size, baseIndex));
+              process->setCovarParam(ext::make_shared<LfmCovarianceProxy>(
+                  ext::make_shared<LmLinearExponentialVolatilityModel>(
+                      process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                  ext::make_shared<LmExponentialCorrelationModel>(size, 0.5)));
+
+              std::vector<Time> fixingTimes = process->fixingTimes();
+              TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+              std::vector<Size> location;
+              for (Size idx = 0; idx < fixingTimes.size(); ++idx)
+                  location.push_back(std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+
+              Size numFactors = process->factors();
+              Size exerciseStep = location[i_opt];
+              Size fullGridSteps = grid.size() - 1;
+              Size fullGridRandoms = fullGridSteps * numFactors;
+
+              BusinessDayConvention convention = baseIndex->businessDayConvention();
+              Date fwdStart = settlementDate + Period(6 * i_opt, Months);
+              Date fwdMaturity = fwdStart + Period(6 * j_opt, Months);
+              Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                                convention, convention, DateGeneration::Forward, false);
+
+              std::vector<double> accrualStart(size), accrualEnd(size);
+              for (Size k = 0; k < size; ++k) {
+                  accrualStart[k] = process->accrualStartTimes()[k];
+                  accrualEnd[k] = process->accrualEndTimes()[k];
+              }
+
+              std::vector<int> pathCounts = {10, 100, 1000, 10000, 100000};
+              Size maxPaths = 100000;
+
+              std::cerr << "  Generating randoms..." << std::flush;
+              typedef PseudoRandom::rsg_type rsg_type;
+              rsg_type rsg = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+              std::vector<std::vector<double>> allRandoms(maxPaths);
+              for (Size n = 0; n < maxPaths; ++n) {
+                  allRandoms[n].resize(fullGridRandoms);
+                  const auto& seq = rsg.nextSequence();
+                  for (Size m = 0; m < fullGridRandoms; ++m)
+                      allRandoms[n][m] = seq.value[m];
+              }
+              std::cerr << " Done." << std::endl;
+
+              ext::shared_ptr<VanillaSwap> fwdSwap(
+                  new VanillaSwap(Swap::Receiver, 1.0, schedule, 0.05, dayCounter,
+                                  schedule, baseIndex, 0.0, baseIndex->dayCounter()));
+              fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                  baseIndex->forwardingTermStructure()));
+              double swapRate = fwdSwap->fairRate();
+              Array initRates = process->initialValues();
+
+              size_t warmupIters = 2, benchIters = 5;
+
+              for (size_t tc = 0; tc < pathCounts.size(); ++tc) {
+                  Size nrTrails = pathCounts[tc];
+                  std::vector<double> times;
+
+                  for (size_t iter = 0; iter < warmupIters + benchIters; ++iter) {
+                      auto t_start = Clock::now();
+                      double price = 0.0;
+                      for (Size n = 0; n < nrTrails; ++n) {
+                          Array asset(size);
+                          for (Size k = 0; k < size; ++k) asset[k] = initRates[k];
+                          Array assetAtExercise(size);
+                          for (Size step = 1; step <= fullGridSteps; ++step) {
+                              Size offset = (step - 1) * numFactors;
+                              Array dw(numFactors);
+                              for (Size f = 0; f < numFactors; ++f)
+                                  dw[f] = allRandoms[n][offset + f];
+                              asset = process->evolve(grid[step - 1], asset, grid.dt(step - 1), dw);
+                              if (step == exerciseStep)
+                                  for (Size k = 0; k < size; ++k) assetAtExercise[k] = asset[k];
+                          }
+                          Array dis(size);
+                          double df = 1.0;
+                          for (Size k = 0; k < size; ++k) {
+                              df = df / (1.0 + assetAtExercise[k] * (accrualEnd[k] - accrualStart[k]));
+                              dis[k] = df;
+                          }
+                          double npv = 0.0;
+                          for (Size m = i_opt; m < i_opt + j_opt; ++m)
+                              npv += (swapRate - assetAtExercise[m]) * (accrualEnd[m] - accrualStart[m]) * dis[m];
+                          if (npv > 0.0) price += npv;
+                      }
+                      (void)price;
+                      auto t_end = Clock::now();
+                      if (iter >= warmupIters)
+                          times.push_back(Duration(t_end - t_start).count());
+                  }
+                  results.push_back({pathCounts[tc], computeMean(times)});
+              }
+          }
+
+          int main() {
+              std::vector<std::pair<int, double>> smallResults, largeResults;
+
+              std::cerr << "Running small swaption benchmark..." << std::endl;
+              runBenchmark(10, 2, 2, 8, 6, smallResults);
+
+              std::cerr << "Running large swaption benchmark..." << std::endl;
+              runBenchmark(20, 10, 10, 20, 12, largeResults);
+
+              std::cout << "DOUBLE_SMALL:";
+              for (auto& r : smallResults) std::cout << r.first << "=" << r.second << ";";
+              std::cout << std::endl;
+
+              std::cout << "DOUBLE_LARGE:";
+              for (auto& r : largeResults) std::cout << r.first << "=" << r.second << ";";
+              std::cout << std::endl;
+
+              return 0;
+          }
+          '@ | Out-File -FilePath "QuantLib/test-suite-double/benchmark_double.cpp" -Encoding utf8
+
+      - name: Add benchmark target to QuantLib CMakeLists
+        shell: pwsh
+        run: |
+          # Add standalone benchmark target to QuantLib's CMakeLists.txt
+          $cmakeAddition = @"
+
+          # Plain double benchmark for type overhead comparison
+          add_executable(benchmark_double test-suite-double/benchmark_double.cpp)
+          target_link_libraries(benchmark_double PRIVATE ql_library `${QL_THREAD_LIBRARIES})
+          "@
+          Add-Content -Path "QuantLib/CMakeLists.txt" -Value $cmakeAddition
+
+      - name: Configure QuantLib (plain double)
+        shell: cmd
+        run: |
+          cd QuantLib
+          call "%VSVARSALL%" amd64
+          cmake -B build-double -G Ninja ^
+            -DCMAKE_BUILD_TYPE=Release ^
+            -DCMAKE_CXX_STANDARD=17 ^
+            -DQL_BUILD_TEST_SUITE=OFF ^
+            -DQL_BUILD_EXAMPLES=OFF ^
+            -DQL_BUILD_BENCHMARK=OFF
+
+      - name: Build QuantLib and benchmark (plain double)
+        shell: cmd
+        run: |
+          cd QuantLib\build-double
+          call "%VSVARSALL%" amd64
+          cmake --build . --target benchmark_double --config Release
+
+      # =========================================================================
+      # Build 2: QuantLib-Risks with xad::AReal<double>
+      # =========================================================================
+      - name: Patch benchmark into QuantLib-Risks-Cpp
+        shell: pwsh
+        run: |
+          Copy-Item "QuantLib-Risks-Cpp-Forge/test-suite/benchmark_main.cpp" "QuantLib-Risks-Cpp/test-suite/"
+          Copy-Item "QuantLib-Risks-Cpp-Forge/test-suite/PlatformInfo.hpp" "QuantLib-Risks-Cpp/test-suite/"
+
+          $cmakeAddition = @"
+
+          add_executable(QuantLib-Risks_benchmark_standalone benchmark_main.cpp)
+          set_target_properties(QuantLib-Risks_benchmark_standalone PROPERTIES
+              OUTPUT_NAME "quantlib-risks-benchmark-standalone")
+          target_link_libraries(QuantLib-Risks_benchmark_standalone PRIVATE
+              ql_library
+              `${QL_THREAD_LIBRARIES})
+          "@
+          Add-Content -Path "QuantLib-Risks-Cpp/test-suite/CMakeLists.txt" -Value $cmakeAddition
+
+      - name: Configure QuantLib (xad::AReal)
+        shell: cmd
+        run: |
+          cd QuantLib
+          call "%VSVARSALL%" amd64
+          cmake -B build-xad -G Ninja ^
+            -DCMAKE_BUILD_TYPE=Release ^
+            -DCMAKE_CXX_STANDARD=17 ^
+            -DXAD_WARNINGS_PARANOID=OFF ^
+            -DXAD_ENABLE_JIT=OFF ^
+            -DXAD_STATIC_MSVC_RUNTIME=ON ^
+            -DQL_EXTERNAL_SUBDIRECTORIES="%cd%\..\xad;%cd%\..\QuantLib-Risks-Cpp" ^
+            -DQL_EXTRA_LINK_LIBRARIES=QuantLib-Risks ^
+            -DQL_NULL_AS_FUNCTIONS=ON ^
+            -DQL_BUILD_TEST_SUITE=OFF ^
+            -DQL_BUILD_EXAMPLES=OFF ^
+            -DQL_BUILD_BENCHMARK=OFF ^
+            -DQLRISKS_DISABLE_AAD=OFF ^
+            -DQLRISKS_BUILD_TEST_SUITE=ON
+
+      - name: Build QuantLib-Risks (xad::AReal)
+        shell: cmd
+        run: |
+          cd QuantLib\build-xad
+          call "%VSVARSALL%" amd64
+          cmake --build . --target QuantLib-Risks_benchmark_standalone --config Release
+
+      # =========================================================================
+      # Run both benchmarks and compare
+      # =========================================================================
+      - name: Run Benchmarks
+        shell: cmd
+        run: |
+          echo ===== Running plain double benchmark =====
+          cd QuantLib\build-double
+          benchmark_double.exe > double_results.txt 2>&1
+          type double_results.txt
+
+          echo.
+          echo ===== Running xad::AReal benchmark =====
+          cd ..\build-xad
+          QuantLib-Risks-Cpp\test-suite\quantlib-risks-benchmark-standalone.exe --pricing-only > xad_results.txt 2>&1
+          type xad_results.txt
+
+      - name: Generate Comparison Report
+        shell: pwsh
+        run: |
+          # Parse double results
+          $doubleContent = Get-Content "QuantLib/build-double/double_results.txt" -Raw
+          $doubleSmall = ($doubleContent | Select-String "DOUBLE_SMALL:(.+)").Matches[0].Groups[1].Value
+          $doubleLarge = ($doubleContent | Select-String "DOUBLE_LARGE:(.+)").Matches[0].Groups[1].Value
+
+          # Extract double timings
+          function Parse-DoubleResults($line) {
+            $results = @{}
+            $line -split ';' | Where-Object { $_ -match '(\d+)=([0-9.]+)' } | ForEach-Object {
+              $_ -match '(\d+)=([0-9.]+)' | Out-Null
+              $results[$Matches[1]] = [double]$Matches[2]
+            }
+            return $results
+          }
+
+          $dSmall = Parse-DoubleResults $doubleSmall
+          $dLarge = Parse-DoubleResults $doubleLarge
+
+          # Parse AReal results
+          $xadContent = Get-Content "QuantLib/build-xad/xad_results.txt" -Raw
+
+          function Parse-XadResults($content, $section) {
+            $results = @{}
+            $inSection = $false
+            $content -split "`n" | ForEach-Object {
+              if ($_ -match "PRICING-ONLY: $section") { $inSection = $true }
+              elseif ($_ -match "PRICING-ONLY:" -and $inSection) { $inSection = $false }
+              elseif ($inSection -and $_ -match '^\|\s+(\d+K?)\s+\|\s+Pricing\s+\|\s+([0-9.]+)') {
+                $paths = $Matches[1]
+                $time = [double]$Matches[2]
+                # Convert path label to number
+                $pathNum = if ($paths -match '(\d+)K') { [int]$Matches[1] * 1000 } else { [int]$paths }
+                $results["$pathNum"] = $time
+              }
+            }
+            return $results
+          }
+
+          $aSmall = Parse-XadResults $xadContent "Small"
+          $aLarge = Parse-XadResults $xadContent "Large"
+
+          Write-Host "================================================================================"
+          Write-Host "  TYPE OVERHEAD COMPARISON: double vs xad::AReal<double>"
+          Write-Host "================================================================================"
+          Write-Host ""
+          Write-Host "This compares pricing-only performance (no derivatives) to measure"
+          Write-Host "the overhead of using xad::AReal<double> instead of plain double."
+          Write-Host "Both benchmarks ran on the same hardware in this job."
+          Write-Host ""
+          Write-Host "================================================================================"
+          Write-Host "  SMALL SWAPTION (1Y into 1Y)"
+          Write-Host "================================================================================"
+          Write-Host ""
+          Write-Host ("| {0,6} | {1,12} | {2,12} | {3,10} |" -f "Paths", "double (ms)", "AReal (ms)", "Overhead")
+          Write-Host "|-------:|-------------:|-------------:|-----------:|"
+
+          @("10", "100", "1000", "10000", "100000") | ForEach-Object {
+            $p = $_
+            $label = if ([int]$p -ge 1000) { "{0}K" -f ([int]$p / 1000) } else { $p }
+            if ($dSmall[$p] -and $aSmall[$p]) {
+              $d = $dSmall[$p]
+              $a = $aSmall[$p]
+              $overhead = (($a - $d) / $d) * 100
+              Write-Host ("| {0,6} | {1,12:F2} | {2,12:F1} | {3,9:F1}% |" -f $label, $d, $a, $overhead)
+            }
+          }
+
+          Write-Host ""
+          Write-Host "================================================================================"
+          Write-Host "  LARGE SWAPTION (5Y into 5Y)"
+          Write-Host "================================================================================"
+          Write-Host ""
+          Write-Host ("| {0,6} | {1,12} | {2,12} | {3,10} |" -f "Paths", "double (ms)", "AReal (ms)", "Overhead")
+          Write-Host "|-------:|-------------:|-------------:|-----------:|"
+
+          @("10", "100", "1000", "10000", "100000") | ForEach-Object {
+            $p = $_
+            $label = if ([int]$p -ge 1000) { "{0}K" -f ([int]$p / 1000) } else { $p }
+            if ($dLarge[$p] -and $aLarge[$p]) {
+              $d = $dLarge[$p]
+              $a = $aLarge[$p]
+              $overhead = (($a - $d) / $d) * 100
+              Write-Host ("| {0,6} | {1,12:F2} | {2,12:F1} | {3,9:F1}% |" -f $label, $d, $a, $overhead)
+            }
+          }
+
+          Write-Host ""
+          Write-Host "================================================================================"
+          Write-Host "  SUMMARY"
+          Write-Host "================================================================================"
+          Write-Host ""
+          Write-Host "Overhead represents the cost of using xad::AReal<double> instead of plain double,"
+          Write-Host "even when not computing derivatives (passive mode, no tape recording)."
+          Write-Host ""
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f7e42c5..0d93db2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,5 @@
 ##############################################################################
-#   
+#
 #
 #  This file is part of QuantLib-Risks, an adaptor module to enable using XAD with
 #  QuantLib. XAD is a fast and comprehensive C++ library for
@@ -19,16 +19,69 @@
 #
 #  You should have received a copy of the GNU Affero General Public License
 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#   
+#
 ##############################################################################
 
 option(QLRISKS_DISABLE_AAD "Disable using XAD for QuantLib's Real, allowing to run samples with double" OFF)
+option(QLRISKS_ENABLE_FORGE "Enable Forge JIT backend via xad-forge" OFF)
+option(QLRISKS_USE_FORGE_CAPI "Use Forge C API instead of C++ API for binary compatibility" OFF)
 
 add_subdirectory(ql)
 if(MSVC)
 	set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 endif()
 add_subdirectory(Examples)
+
+##############################################################################
+# QLRisks-Forge integration via xad-forge
+# NOTE: This must be defined BEFORE test-suite so tests can link to it
+##############################################################################
+
+if(QLRISKS_ENABLE_FORGE)
+    message(STATUS "QLRisks-Forge: Looking for xad-forge...")
+
+    # Pass through the C API option to xad-forge
+    set(XAD_FORGE_USE_CAPI ${QLRISKS_USE_FORGE_CAPI} CACHE BOOL "" FORCE)
+
+    # Option 1: Check if xad-forge was added as subdirectory
+    if(TARGET xad-forge)
+        message(STATUS "QLRisks-Forge: Found xad-forge target (subdirectory mode)")
+        set(XAD_FORGE_FOUND TRUE)
+    endif()
+
+    # Option 2: Try find_package for pre-built xad-forge
+    if(NOT XAD_FORGE_FOUND)
+        find_package(xad-forge CONFIG QUIET)
+        if(xad-forge_FOUND)
+            message(STATUS "QLRisks-Forge: Found xad-forge package (pre-built mode)")
+            set(XAD_FORGE_FOUND TRUE)
+        endif()
+    endif()
+
+    if(XAD_FORGE_FOUND)
+        # Create qlrisks-forge as an INTERFACE library wrapping xad-forge
+        add_library(qlrisks-forge INTERFACE)
+        add_library(QLRisks::forge ALIAS qlrisks-forge)
+
+        target_link_libraries(qlrisks-forge INTERFACE
+            XADForge::xad-forge
+        )
+
+        target_compile_definitions(qlrisks-forge INTERFACE QLRISKS_HAS_FORGE=1)
+
+        message(STATUS "QLRisks-Forge: Configured with xad-forge")
+    else()
+        message(STATUS "QLRisks-Forge: xad-forge not found - ForgeBackend will not be available")
+        message(STATUS "QLRisks-Forge: To enable, either:")
+        message(STATUS "  1. Add xad-forge as subdirectory")
+        message(STATUS "  2. Set CMAKE_PREFIX_PATH to xad-forge installation")
+    endif()
+endif()
+
+##############################################################################
+# Test suite (after QLRisks::forge is defined)
+##############################################################################
+
 if(NOT QLRISKS_DISABLE_AAD)
     # the test suite is not supporting double
 	add_subdirectory(test-suite)
diff --git a/test-suite/CMakeLists.txt b/test-suite/CMakeLists.txt
index c96f8ae..b5ecb53 100644
--- a/test-suite/CMakeLists.txt
+++ b/test-suite/CMakeLists.txt
@@ -1,3 +1,8 @@
+option(QLRISKS_BUILD_TEST_SUITE "Build the QuantLib-Risks test suite" OFF)
+option(QLRISKS_ENABLE_FORGE_TESTS "Enable Forge JIT tests (requires Forge)" OFF)
+option(QLRISKS_BUILD_BENCHMARK "Build the QuantLib-Risks benchmark suite (Boost.Test)" OFF)
+option(QLRISKS_BUILD_BENCHMARK_STANDALONE "Build standalone benchmark executable (no Boost.Test)" OFF)
+
 set(QLRISKS_TEST_SOURCES
     americanoption_xad.cpp
     barrieroption_xad.cpp
@@ -9,14 +14,32 @@ set(QLRISKS_TEST_SOURCES
     forwardrateagreement_xad.cpp
     hestonmodel_xad.cpp
     swap_xad.cpp
-    
+
     utilities_xad.cpp
     quantlibtestsuite_xad.cpp
 )
 
+# Benchmark sources (separate from test suite)
+set(QLRISKS_BENCHMARK_SOURCES
+    quantlibrisks_benchmark.cpp
+    swaption_benchmark.cpp
+    utilities_xad.cpp
+)
+
+# Forge JIT tests - only added when explicitly enabled AND Forge is available
+# These tests require Forge's JIT compiler for AAD
+set(QLRISKS_FORGE_TESTS_ENABLED FALSE)
+if(QLRISKS_ENABLE_FORGE_TESTS AND TARGET QLRisks::forge)
+    message(STATUS "QLRisks test-suite: Adding Forge JIT tests")
+    list(APPEND QLRISKS_TEST_SOURCES jit_xad.cpp forgebackend_xad.cpp swaption_jit_pipeline_xad.cpp)
+    set(QLRISKS_FORGE_TESTS_ENABLED TRUE)
+elseif(QLRISKS_ENABLE_FORGE_TESTS)
+    message(WARNING "QLRisks test-suite: QLRISKS_ENABLE_FORGE_TESTS=ON but QLRisks::forge not available")
+endif()
+
 set(QLRISKS_TEST_HEADERS utilities_xad.hpp)
 
-if(QL_BUILD_TEST_SUITE)
+if(QL_BUILD_TEST_SUITE OR QLRISKS_BUILD_TEST_SUITE)
     add_executable(QuantLib-Risks_test_suite ${QLRISKS_TEST_SOURCES} ${QLRISKS_TEST_HEADERS})
     set_target_properties(QuantLib-Risks_test_suite PROPERTIES OUTPUT_NAME "quantlib-risks-test-suite")
     if (NOT Boost_USE_STATIC_LIBS)
@@ -25,8 +48,68 @@ if(QL_BUILD_TEST_SUITE)
     target_link_libraries(QuantLib-Risks_test_suite PRIVATE
         ql_library
         ${QL_THREAD_LIBRARIES})
+
+    # ONLY link to Forge if Forge tests are actually enabled
+    # This is important because linking Forge brings in AVX2-compiled code
+    # which can cause ODR violations if not properly isolated
+    if(QLRISKS_FORGE_TESTS_ENABLED)
+        message(STATUS "QLRisks test-suite: Linking QLRisks::forge (Forge tests enabled)")
+        target_link_libraries(QuantLib-Risks_test_suite PRIVATE QLRisks::forge)
+        target_compile_definitions(QuantLib-Risks_test_suite PRIVATE QLRISKS_HAS_FORGE=1)
+    else()
+        message(STATUS "QLRisks test-suite: NOT linking Forge (Forge tests disabled)")
+    endif()
+
     if (QL_INSTALL_TEST_SUITE)
         install(TARGETS QuantLib-Risks_test_suite RUNTIME DESTINATION ${QL_INSTALL_BINDIR})
     endif()
     add_test(NAME QuantLib-Risks_test_suite COMMAND QuantLib-Risks_test_suite --log_level=message)
+endif()
+
+# Benchmark suite - separate executable for CI benchmarks
+# Requires Forge to be available
+if(QLRISKS_BUILD_BENCHMARK AND TARGET QLRisks::forge)
+    message(STATUS "QLRisks: Building benchmark suite")
+    add_executable(QuantLib-Risks_benchmark ${QLRISKS_BENCHMARK_SOURCES} ${QLRISKS_TEST_HEADERS})
+    set_target_properties(QuantLib-Risks_benchmark PROPERTIES OUTPUT_NAME "quantlib-risks-benchmark")
+    if (NOT Boost_USE_STATIC_LIBS)
+        target_compile_definitions(QuantLib-Risks_benchmark PRIVATE BOOST_ALL_DYN_LINK)
+    endif()
+    target_link_libraries(QuantLib-Risks_benchmark PRIVATE
+        ql_library
+        QLRisks::forge
+        ${QL_THREAD_LIBRARIES})
+    target_compile_definitions(QuantLib-Risks_benchmark PRIVATE QLRISKS_HAS_FORGE=1)
+
+    if (QL_INSTALL_TEST_SUITE)
+        install(TARGETS QuantLib-Risks_benchmark RUNTIME DESTINATION ${QL_INSTALL_BINDIR})
+    endif()
+    add_test(NAME QuantLib-Risks_benchmark COMMAND QuantLib-Risks_benchmark --log_level=message)
+elseif(QLRISKS_BUILD_BENCHMARK)
+    message(WARNING "QLRisks: QLRISKS_BUILD_BENCHMARK=ON but QLRisks::forge not available")
+endif()
+
+# Standalone benchmark executable - no Boost.Test dependency
+# Can be built with or without Forge
+if(QLRISKS_BUILD_BENCHMARK_STANDALONE)
+    message(STATUS "QLRisks: Building standalone benchmark executable")
+    add_executable(QuantLib-Risks_benchmark_standalone benchmark_main.cpp)
+    set_target_properties(QuantLib-Risks_benchmark_standalone PROPERTIES
+        OUTPUT_NAME "quantlib-risks-benchmark-standalone")
+    target_link_libraries(QuantLib-Risks_benchmark_standalone PRIVATE
+        ql_library
+        ${QL_THREAD_LIBRARIES})
+
+    # Optionally link Forge if available
+    if(TARGET QLRisks::forge)
+        message(STATUS "QLRisks standalone benchmark: Linking QLRisks::forge")
+        target_link_libraries(QuantLib-Risks_benchmark_standalone PRIVATE QLRisks::forge)
+        target_compile_definitions(QuantLib-Risks_benchmark_standalone PRIVATE QLRISKS_HAS_FORGE=1)
+    else()
+        message(STATUS "QLRisks standalone benchmark: Building without Forge (XAD tape only)")
+    endif()
+
+    if (QL_INSTALL_TEST_SUITE)
+        install(TARGETS QuantLib-Risks_benchmark_standalone RUNTIME DESTINATION ${QL_INSTALL_BINDIR})
+    endif()
 endif()
\ No newline at end of file
diff --git a/test-suite/PlatformInfo.hpp b/test-suite/PlatformInfo.hpp
new file mode 100644
index 0000000..a8d201f
--- /dev/null
+++ b/test-suite/PlatformInfo.hpp
@@ -0,0 +1,212 @@
+/*******************************************************************************
+
+   Platform Information Utilities
+
+   This header provides cross-platform functions for detecting and reporting
+   system information such as CPU, memory, OS, compiler, and SIMD capabilities.
+
+   Adapted from XAD's PlatformInfo.hpp for QuantLib-Risks benchmarks.
+
+   Copyright (C) 2010-2025 Xcelerit Computing Ltd.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+******************************************************************************/
+
+#pragma once
+
+#include <cstring>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#ifdef _WIN32
+#include <intrin.h>
+#include <windows.h>
+#else
+#include <sys/utsname.h>
+#include <unistd.h>
+#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
+#include <cpuid.h>
+#endif
+#endif
+
+namespace platform_info
+{
+
+/// Get CPU brand string (e.g., "Intel Core i7-9700K")
+inline std::string getCpuInfo()
+{
+#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
+    char brand[49] = {0};
+    unsigned int regs[4];
+
+#ifdef _WIN32
+    __cpuid(reinterpret_cast<int*>(regs), 0x80000000);
+#else
+    __get_cpuid(0x80000000, &regs[0], &regs[1], &regs[2], &regs[3]);
+#endif
+
+    if (regs[0] >= 0x80000004)
+    {
+        for (unsigned int i = 0; i < 3; ++i)
+        {
+#ifdef _WIN32
+            __cpuid(reinterpret_cast<int*>(regs), 0x80000002 + i);
+#else
+            __get_cpuid(0x80000002 + i, &regs[0], &regs[1], &regs[2], &regs[3]);
+#endif
+            std::memcpy(brand + i * 16, regs, 16);
+        }
+        std::string result(brand);
+        size_t start = result.find_first_not_of(' ');
+        if (start != std::string::npos)
+            result = result.substr(start);
+        return result;
+    }
+#endif
+    return "Unknown CPU";
+}
+
+/// Get OS/platform information (e.g., "Windows 10.0 (Build 19041)" or "Linux 5.4.0")
+inline std::string getPlatformInfo()
+{
+#ifdef _WIN32
+    typedef LONG(WINAPI * RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);
+    HMODULE hMod = GetModuleHandleW(L"ntdll.dll");
+    if (hMod)
+    {
+        auto RtlGetVersion = (RtlGetVersionPtr)GetProcAddress(hMod, "RtlGetVersion");
+        if (RtlGetVersion)
+        {
+            RTL_OSVERSIONINFOW rovi = {0};
+            rovi.dwOSVersionInfoSize = sizeof(rovi);
+            if (RtlGetVersion(&rovi) == 0)
+            {
+                std::ostringstream oss;
+                oss << "Windows " << rovi.dwMajorVersion << "." << rovi.dwMinorVersion << " (Build "
+                    << rovi.dwBuildNumber << ")";
+                return oss.str();
+            }
+        }
+    }
+    return "Windows";
+#else
+    struct utsname buf;
+    if (uname(&buf) == 0)
+    {
+        std::ostringstream oss;
+        oss << buf.sysname << " " << buf.release;
+        return oss.str();
+    }
+    return "Unknown";
+#endif
+}
+
+/// Get total system memory (e.g., "16 GB")
+inline std::string getMemoryInfo()
+{
+#ifdef _WIN32
+    MEMORYSTATUSEX memInfo;
+    memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+    if (GlobalMemoryStatusEx(&memInfo))
+    {
+        double gb = static_cast<double>(memInfo.ullTotalPhys) / (1024.0 * 1024.0 * 1024.0);
+        std::ostringstream oss;
+        oss << std::fixed << std::setprecision(0) << gb << " GB";
+        return oss.str();
+    }
+#else
+    long pages = sysconf(_SC_PHYS_PAGES);
+    long page_size = sysconf(_SC_PAGE_SIZE);
+    if (pages > 0 && page_size > 0)
+    {
+        double gb = static_cast<double>(pages) * page_size / (1024.0 * 1024.0 * 1024.0);
+        std::ostringstream oss;
+        oss << std::fixed << std::setprecision(0) << gb << " GB";
+        return oss.str();
+    }
+#endif
+    return "Unknown";
+}
+
+/// Get compiler information (e.g., "GCC 11.2.0" or "MSVC 19.29 (Release)")
+inline std::string getCompilerInfo()
+{
+#if defined(_MSC_VER)
+    std::ostringstream oss;
+    oss << "MSVC " << _MSC_VER / 100 << "." << _MSC_VER % 100;
+#if defined(_DEBUG)
+    oss << " (Debug)";
+#else
+    oss << " (Release)";
+#endif
+    return oss.str();
+#elif defined(__clang__)
+    std::ostringstream oss;
+    oss << "Clang " << __clang_major__ << "." << __clang_minor__ << "." << __clang_patchlevel__;
+    return oss.str();
+#elif defined(__GNUC__)
+    std::ostringstream oss;
+    oss << "GCC " << __GNUC__ << "." << __GNUC_MINOR__ << "." << __GNUC_PATCHLEVEL__;
+    return oss.str();
+#else
+    return "Unknown Compiler";
+#endif
+}
+
+/// Get supported SIMD instruction sets (e.g., "SSE3, SSE4.1, SSE4.2, AVX, AVX2")
+inline std::string getSimdInfo()
+{
+#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
+    unsigned int regs[4];
+    std::vector<std::string> features;
+
+#ifdef _WIN32
+    __cpuid(reinterpret_cast<int*>(regs), 1);
+#else
+    __get_cpuid(1, &regs[0], &regs[1], &regs[2], &regs[3]);
+#endif
+
+    if (regs[2] & (1 << 0)) features.push_back("SSE3");
+    if (regs[2] & (1 << 19)) features.push_back("SSE4.1");
+    if (regs[2] & (1 << 20)) features.push_back("SSE4.2");
+    if (regs[2] & (1 << 28)) features.push_back("AVX");
+
+#ifdef _WIN32
+    __cpuidex(reinterpret_cast<int*>(regs), 7, 0);
+#else
+    __get_cpuid_count(7, 0, &regs[0], &regs[1], &regs[2], &regs[3]);
+#endif
+
+    if (regs[1] & (1 << 5)) features.push_back("AVX2");
+    if (regs[1] & (1 << 16)) features.push_back("AVX512F");
+
+    if (features.empty())
+        return "None detected";
+
+    std::ostringstream oss;
+    for (size_t i = 0; i < features.size(); ++i)
+    {
+        if (i > 0) oss << ", ";
+        oss << features[i];
+    }
+    return oss.str();
+#else
+    return "N/A (non-x86)";
+#endif
+}
+
+}  // namespace platform_info
diff --git a/test-suite/benchmark_main.cpp b/test-suite/benchmark_main.cpp
new file mode 100644
index 0000000..81569eb
--- /dev/null
+++ b/test-suite/benchmark_main.cpp
@@ -0,0 +1,2078 @@
+/*******************************************************************************
+
+   QuantLib-Risks Swaption Benchmark - Standalone Executable
+
+   This benchmark compares different approaches for computing sensitivities
+   in Monte Carlo pricing of swaptions using the LIBOR Market Model.
+
+   APPROACHES TESTED:
+     XAD     - XAD tape-based reverse-mode AAD
+     JIT     - Forge JIT-compiled native code (scalar)
+     JIT-AVX - Forge JIT + AVX2 SIMD (4 paths/instruction)
+
+   Usage:
+     ./quantlib-risks-benchmark-standalone [options]
+
+   Options:
+     --help, -h        Show this help message
+     --quick           Run quick benchmark (fewer iterations, fewer path counts)
+     --small-only      Run only the small swaption benchmark (1Y into 1Y)
+     --large-only      Run only the large swaption benchmark (5Y into 5Y)
+     --decomposition   Run performance decomposition analysis
+
+   By default, runs both small (1Y into 1Y) and large (5Y into 5Y) benchmarks.
+
+   Copyright (C) 2025 Xcelerit Computing Limited
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+******************************************************************************/
+
+#include "PlatformInfo.hpp"
+
+// QuantLib includes
+#include <ql/indexes/ibor/euribor.hpp>
+#include <ql/instruments/vanillaswap.hpp>
+#include <ql/pricingengines/swap/discountingswapengine.hpp>
+#include <ql/termstructures/yield/piecewiseyieldcurve.hpp>
+#include <ql/termstructures/yield/ratehelpers.hpp>
+#include <ql/termstructures/yield/zerocurve.hpp>
+#include <ql/time/calendars/target.hpp>
+#include <ql/time/daycounters/actual360.hpp>
+#include <ql/time/daycounters/thirty360.hpp>
+
+// LMM Monte Carlo includes
+#include <ql/legacy/libormarketmodels/lfmcovarproxy.hpp>
+#include <ql/legacy/libormarketmodels/liborforwardmodel.hpp>
+#include <ql/legacy/libormarketmodels/lmexpcorrmodel.hpp>
+#include <ql/legacy/libormarketmodels/lmlinexpvolmodel.hpp>
+#include <ql/math/randomnumbers/rngtraits.hpp>
+#include <ql/methods/montecarlo/multipathgenerator.hpp>
+
+// XAD includes
+#include <XAD/XAD.hpp>
+
+// Forge JIT backends (conditionally included)
+#if defined(QLRISKS_HAS_FORGE)
+#include <xad-forge/ForgeBackend.hpp>
+#include <xad-forge/ForgeBackendAVX.hpp>
+#endif
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+#include <numeric>
+#include <string>
+#include <vector>
+
+using namespace QuantLib;
+using platform_info::getCompilerInfo;
+using platform_info::getCpuInfo;
+using platform_info::getMemoryInfo;
+using platform_info::getPlatformInfo;
+using platform_info::getSimdInfo;
+
+// Overload value() for plain double (for consistency with utilities_xad.hpp)
+inline double value(double x) { return x; }
+
+// ============================================================================
+// XAD Type Definitions
+// ============================================================================
+
+// Note: QuantLib's Real is already defined as xad::AReal<double> via qlrisks.hpp
+// (via #define QL_REAL xad::AReal<double> in qlrisks.hpp)
+// We use QuantLib::Real directly through "using namespace QuantLib"
+// The tape_type is accessed as Real::tape_type where needed
+
+// ============================================================================
+// Statistics Helpers
+// ============================================================================
+
+double computeMean(const std::vector<double>& v)
+{
+    if (v.empty()) return 0.0;
+    return std::accumulate(v.begin(), v.end(), 0.0) / static_cast<double>(v.size());
+}
+
+double computeStddev(const std::vector<double>& v)
+{
+    if (v.size() <= 1) return 0.0;
+    double m = computeMean(v);
+    double sq_sum = 0.0;
+    for (double x : v)
+    {
+        double diff = x - m;
+        sq_sum += diff * diff;
+    }
+    return std::sqrt(sq_sum / static_cast<double>(v.size() - 1));
+}
+
+// ============================================================================
+// Helper: Create IborIndex with ZeroCurve
+// ============================================================================
+
+ext::shared_ptr<IborIndex> makeIndex(std::vector<Date> dates,
+                                     const std::vector<Rate>& rates)
+{
+    DayCounter dayCounter = Actual360();
+    RelinkableHandle<YieldTermStructure> termStructure;
+    ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+
+    Date todaysDate = index->fixingCalendar().adjust(Date(4, September, 2005));
+    Settings::instance().evaluationDate() = todaysDate;
+
+    dates[0] = index->fixingCalendar().advance(todaysDate,
+                                                index->fixingDays(), Days);
+
+    termStructure.linkTo(ext::shared_ptr<YieldTermStructure>(
+        new ZeroCurve(dates, rates, dayCounter)));
+
+    return index;
+}
+
+// ============================================================================
+// Chain Rule Helper
+// ============================================================================
+
+inline void applyChainRule(const double* __restrict jacobian,
+                           const double* __restrict derivatives,
+                           double* __restrict result,
+                           std::size_t numIntermediates,
+                           std::size_t numInputs)
+{
+    for (std::size_t j = 0; j < numInputs; ++j)
+        result[j] = 0.0;
+
+    for (std::size_t i = 0; i < numIntermediates; ++i)
+    {
+        const double deriv_i = derivatives[i];
+        const double* jac_row = jacobian + i * numInputs;
+        for (std::size_t j = 0; j < numInputs; ++j)
+        {
+            result[j] += deriv_i * jac_row[j];
+        }
+    }
+}
+
+// ============================================================================
+// Benchmark Configuration
+// ============================================================================
+
+// Maximum paths for finite differences (FD is O(n) per path for n parameters)
+constexpr int FD_MAX_PATHS = 1000;
+
+struct BenchmarkConfig
+{
+    // Market data
+    Size numDeposits = 4;
+    Size numSwaps = 5;
+    std::vector<Period> depoTenors;
+    std::vector<Period> swapTenors;
+    std::vector<double> depoRates;
+    std::vector<double> swapRates;
+
+    // LMM parameters
+    Size size = 10;       // Number of forward rates
+    Size i_opt = 2;       // Option exercise index
+    Size j_opt = 2;       // Swap length
+    Size steps = 8;       // Time steps
+
+    // Curve end date
+    int curveEndYears = 6;
+
+    // Test configuration
+    std::vector<int> pathCounts;
+    size_t warmupIterations = 2;
+    size_t benchmarkIterations = 5;
+
+    // Instrument description
+    std::string instrumentDesc = "European swaption (1Y into 1Y)";
+
+    BenchmarkConfig()
+    {
+        depoTenors = {1 * Days, 1 * Months, 3 * Months, 6 * Months};
+        swapTenors = {1 * Years, 2 * Years, 3 * Years, 4 * Years, 5 * Years};
+        depoRates = {0.0350, 0.0365, 0.0380, 0.0400};
+        swapRates = {0.0420, 0.0480, 0.0520, 0.0550, 0.0575};
+        pathCounts = {10, 100, 1000, 10000, 100000};
+    }
+
+    // Configure for larger swaption (5Y into 5Y)
+    void setLargeConfig()
+    {
+        // More market quotes for longer curve
+        numDeposits = 4;
+        numSwaps = 10;
+        depoTenors = {1 * Days, 1 * Months, 3 * Months, 6 * Months};
+        swapTenors = {1 * Years, 2 * Years, 3 * Years, 4 * Years, 5 * Years,
+                      6 * Years, 7 * Years, 8 * Years, 9 * Years, 10 * Years};
+        depoRates = {0.0320, 0.0335, 0.0355, 0.0375};
+        swapRates = {0.0400, 0.0435, 0.0460, 0.0480, 0.0495,
+                     0.0505, 0.0515, 0.0522, 0.0528, 0.0532};
+
+        // Larger LMM: 20 forward rates (semi-annual to 10Y)
+        size = 20;
+        i_opt = 10;    // Option starts at 5Y (10 × 6 months)
+        j_opt = 10;    // 5Y swap (10 × 6 months)
+        steps = 20;    // More time steps for 5Y simulation
+
+        curveEndYears = 12;  // Extra buffer for accrual periods
+
+        instrumentDesc = "European swaption (5Y into 5Y)";
+    }
+};
+
+// ============================================================================
+// Timing Results Structure
+// ============================================================================
+
+struct TimingResult
+{
+    double fd_mean = 0, fd_std = 0;       // Finite differences (bump-and-revalue)
+    double xad_mean = 0, xad_std = 0;     // XAD tape-based AAD
+    double jit_mean = 0, jit_std = 0;     // Forge JIT scalar
+    double jit_avx_mean = 0, jit_avx_std = 0;  // Forge JIT AVX2
+    bool fd_enabled = false;              // Whether FD was run for this path count
+};
+
+// ============================================================================
+// Main Benchmark Function
+// ============================================================================
+
+void runBenchmark(const BenchmarkConfig& config, bool quickMode)
+{
+    using Clock = std::chrono::high_resolution_clock;
+    using Duration = std::chrono::duration<double, std::milli>;
+
+    Calendar calendar = TARGET();
+    Date todaysDate(4, September, 2005);
+    Settings::instance().evaluationDate() = todaysDate;
+    Integer fixingDays = 2;
+    Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+    DayCounter dayCounter = Actual360();
+
+    // Build base curve (using first deposit rate and last swap rate as endpoints)
+    std::vector<Rate> baseZeroRates = {config.depoRates[0], config.swapRates.back()};
+    std::vector<Date> baseDates = {settlementDate, settlementDate + config.curveEndYears * Years};
+    auto baseIndex = makeIndex(baseDates, baseZeroRates);
+
+    ext::shared_ptr<LiborForwardModelProcess> baseProcess(
+        new LiborForwardModelProcess(config.size, baseIndex));
+    ext::shared_ptr<LmCorrelationModel> baseCorrModel(
+        new LmExponentialCorrelationModel(config.size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> baseVolaModel(
+        new LmLinearExponentialVolatilityModel(baseProcess->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    baseProcess->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(baseVolaModel, baseCorrModel)));
+
+    // Grid setup
+    std::vector<Time> fixingTimes = baseProcess->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), config.steps);
+
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx)
+    {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    Size numFactors = baseProcess->factors();
+    Size exerciseStep = location[config.i_opt];
+    Size fullGridSteps = grid.size() - 1;
+    Size fullGridRandoms = fullGridSteps * numFactors;
+
+    // Swap schedule
+    BusinessDayConvention convention = baseIndex->businessDayConvention();
+    Date fwdStart = settlementDate + Period(6 * config.i_opt, Months);
+    Date fwdMaturity = fwdStart + Period(6 * config.j_opt, Months);
+    Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    // Accrual periods
+    std::vector<double> accrualStart(config.size), accrualEnd(config.size);
+    for (Size k = 0; k < config.size; ++k)
+    {
+        accrualStart[k] = value(baseProcess->accrualStartTimes()[k]);
+        accrualEnd[k] = value(baseProcess->accrualEndTimes()[k]);
+    }
+
+    // Pre-generate random numbers
+    Size maxPaths = static_cast<Size>(*std::max_element(config.pathCounts.begin(), config.pathCounts.end()));
+    std::cout << "  Generating " << maxPaths << " x " << fullGridRandoms << " random numbers..." << std::flush;
+
+    typedef PseudoRandom::rsg_type rsg_type;
+    rsg_type rsg_base = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+
+    std::vector<std::vector<double>> allRandoms(maxPaths);
+    for (Size n = 0; n < maxPaths; ++n)
+    {
+        allRandoms[n].resize(fullGridRandoms);
+        const auto& seq = rsg_base.nextSequence();
+        for (Size m = 0; m < fullGridRandoms; ++m)
+        {
+            allRandoms[n][m] = value(seq.value[m]);
+        }
+    }
+    std::cout << " Done." << std::endl;
+
+    // Results storage
+    std::vector<TimingResult> results(config.pathCounts.size());
+
+    // Run benchmarks for each path count
+    for (size_t tc = 0; tc < config.pathCounts.size(); ++tc)
+    {
+        Size nrTrails = static_cast<Size>(config.pathCounts[tc]);
+
+        std::cout << "  [" << (tc + 1) << "/" << config.pathCounts.size() << "] ";
+        if (config.pathCounts[tc] >= 1000)
+            std::cout << (config.pathCounts[tc] / 1000) << "K";
+        else
+            std::cout << config.pathCounts[tc];
+        std::cout << " paths " << std::flush;
+
+        std::vector<double> fd_times, xad_times, jit_times, jit_avx_times;
+        bool runFD = (config.pathCounts[tc] <= FD_MAX_PATHS);
+
+        for (size_t iter = 0; iter < config.warmupIterations + config.benchmarkIterations; ++iter)
+        {
+            bool recordTiming = (iter >= config.warmupIterations);
+
+            // =================================================================
+            // Finite Differences (bump-and-revalue) - only for small path counts
+            // =================================================================
+            if (runFD)
+            {
+                auto t_start = Clock::now();
+
+                Size fdNumMarketQuotes = config.numDeposits + config.numSwaps;
+                Real eps = 1e-5;
+
+                // Price computation function using Real (passive mode - no tape)
+                // Uses Real types throughout since QuantLib APIs expect them
+                auto computePrice = [&](const std::vector<Real>& depoRatesIn,
+                                        const std::vector<Real>& swapRatesIn) -> Real
+                {
+                    RelinkableHandle<YieldTermStructure> euriborTS;
+                    auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                    euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                    std::vector<ext::shared_ptr<RateHelper>> instruments;
+                    for (Size idx = 0; idx < config.numDeposits; ++idx)
+                    {
+                        auto depoQuote = ext::make_shared<SimpleQuote>(depoRatesIn[idx]);
+                        instruments.push_back(ext::make_shared<DepositRateHelper>(
+                            Handle<Quote>(depoQuote), config.depoTenors[idx], fixingDays,
+                            calendar, ModifiedFollowing, true, dayCounter));
+                    }
+                    for (Size idx = 0; idx < config.numSwaps; ++idx)
+                    {
+                        auto swapQuote = ext::make_shared<SimpleQuote>(swapRatesIn[idx]);
+                        instruments.push_back(ext::make_shared<SwapRateHelper>(
+                            Handle<Quote>(swapQuote), config.swapTenors[idx],
+                            calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                            euribor6m));
+                    }
+
+                    auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                        settlementDate, instruments, dayCounter);
+                    yieldCurve->enableExtrapolation();
+
+                    std::vector<Date> curveDates;
+                    std::vector<Real> zeroRatesVec;
+                    curveDates.push_back(settlementDate);
+                    zeroRatesVec.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                    Date endDate = settlementDate + config.curveEndYears * Years;
+                    curveDates.push_back(endDate);
+                    zeroRatesVec.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                    RelinkableHandle<YieldTermStructure> termStructure;
+                    ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                    index->addFixing(Date(2, September, 2005), 0.04);
+                    termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRatesVec, dayCounter));
+
+                    ext::shared_ptr<LiborForwardModelProcess> process(
+                        new LiborForwardModelProcess(config.size, index));
+                    process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                        new LfmCovarianceProxy(
+                            ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                            ext::make_shared<LmExponentialCorrelationModel>(config.size, 0.5))));
+
+                    ext::shared_ptr<VanillaSwap> fwdSwap(
+                        new VanillaSwap(Swap::Receiver, 1.0,
+                                        schedule, 0.05, dayCounter,
+                                        schedule, index, 0.0, index->dayCounter()));
+                    fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                        index->forwardingTermStructure()));
+                    Real swapRateFD = fwdSwap->fairRate();
+
+                    Array initRates = process->initialValues();
+
+                    // MC simulation
+                    Real price = 0.0;
+                    for (Size n = 0; n < nrTrails; ++n)
+                    {
+                        Array asset(config.size);
+                        for (Size k = 0; k < config.size; ++k) asset[k] = initRates[k];
+
+                        Array assetAtExercise(config.size);
+                        for (Size step = 1; step <= fullGridSteps; ++step)
+                        {
+                            Size offset = (step - 1) * numFactors;
+                            Time t = grid[step - 1];
+                            Time dt = grid.dt(step - 1);
+
+                            Array dw(numFactors);
+                            for (Size f = 0; f < numFactors; ++f)
+                                dw[f] = allRandoms[n][offset + f];
+
+                            asset = process->evolve(t, asset, dt, dw);
+
+                            if (step == exerciseStep)
+                            {
+                                for (Size k = 0; k < config.size; ++k)
+                                    assetAtExercise[k] = asset[k];
+                            }
+                        }
+
+                        // Discount factors
+                        Array dis(config.size);
+                        Real df = 1.0;
+                        for (Size k = 0; k < config.size; ++k)
+                        {
+                            Real accrual = accrualEnd[k] - accrualStart[k];
+                            df = df / (1.0 + assetAtExercise[k] * accrual);
+                            dis[k] = df;
+                        }
+
+                        // NPV
+                        Real npv = 0.0;
+                        for (Size m = config.i_opt; m < config.i_opt + config.j_opt; ++m)
+                        {
+                            Real accrual = accrualEnd[m] - accrualStart[m];
+                            npv += (swapRateFD - assetAtExercise[m]) * accrual * dis[m];
+                        }
+                        price += std::max(value(npv), 0.0);
+                    }
+                    return price / static_cast<Real>(nrTrails);
+                };
+
+                // Convert config rates to Real vectors
+                std::vector<Real> baseDepoRates(config.depoRates.begin(), config.depoRates.end());
+                std::vector<Real> baseSwapRates(config.swapRates.begin(), config.swapRates.end());
+
+                // Base price
+                Real basePrice = computePrice(baseDepoRates, baseSwapRates);
+
+                // Bump each market quote and compute derivative
+                std::vector<Real> derivatives(fdNumMarketQuotes);
+                for (Size q = 0; q < fdNumMarketQuotes; ++q)
+                {
+                    std::vector<Real> bumpedDepo = baseDepoRates;
+                    std::vector<Real> bumpedSwap = baseSwapRates;
+
+                    if (q < config.numDeposits)
+                        bumpedDepo[q] += eps;
+                    else
+                        bumpedSwap[q - config.numDeposits] += eps;
+
+                    Real bumpedPrice = computePrice(bumpedDepo, bumpedSwap);
+                    derivatives[q] = (bumpedPrice - basePrice) / eps;
+                }
+
+                auto t_end = Clock::now();
+                if (recordTiming)
+                {
+                    fd_times.push_back(Duration(t_end - t_start).count());
+                }
+
+                // Suppress unused variable warning
+                (void)basePrice;
+                (void)derivatives;
+            }
+
+            // =================================================================
+            // XAD Tape-based approach (direct evolve)
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(config.numDeposits);
+                std::vector<Real> swapRatesAD(config.numSwaps);
+                for (Size idx = 0; idx < config.numDeposits; ++idx)
+                    depositRates[idx] = config.depoRates[idx];
+                for (Size idx = 0; idx < config.numSwaps; ++idx)
+                    swapRatesAD[idx] = config.swapRates[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRatesAD);
+                tape.newRecording();
+
+                // Build curve
+                RelinkableHandle<YieldTermStructure> euriborTS;
+                auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<ext::shared_ptr<RateHelper>> instruments;
+                for (Size idx = 0; idx < config.numDeposits; ++idx)
+                {
+                    auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                    instruments.push_back(ext::make_shared<DepositRateHelper>(
+                        Handle<Quote>(depoQuote), config.depoTenors[idx], fixingDays,
+                        calendar, ModifiedFollowing, true, dayCounter));
+                }
+                for (Size idx = 0; idx < config.numSwaps; ++idx)
+                {
+                    auto swapQuote = ext::make_shared<SimpleQuote>(swapRatesAD[idx]);
+                    instruments.push_back(ext::make_shared<SwapRateHelper>(
+                        Handle<Quote>(swapQuote), config.swapTenors[idx],
+                        calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                        euribor6m));
+                }
+
+                auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                    settlementDate, instruments, dayCounter);
+                yieldCurve->enableExtrapolation();
+
+                std::vector<Date> curveDates;
+                std::vector<Real> zeroRates;
+                curveDates.push_back(settlementDate);
+                zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                Date endDate = settlementDate + config.curveEndYears * Years;
+                curveDates.push_back(endDate);
+                zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                std::vector<Rate> zeroRates_ql;
+                for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(config.size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(config.size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate = fwdSwap->fairRate();
+
+                Array initRates = process->initialValues();
+
+                // MC simulation
+                Real price = Real(0.0);
+                for (Size n = 0; n < nrTrails; ++n)
+                {
+                    Array asset(config.size);
+                    for (Size k = 0; k < config.size; ++k) asset[k] = initRates[k];
+
+                    Array assetAtExercise(config.size);
+                    for (Size step = 1; step <= fullGridSteps; ++step)
+                    {
+                        Size offset = (step - 1) * numFactors;
+                        Time t = grid[step - 1];
+                        Time dt = grid.dt(step - 1);
+
+                        Array dw(numFactors);
+                        for (Size f = 0; f < numFactors; ++f)
+                            dw[f] = allRandoms[n][offset + f];
+
+                        asset = process->evolve(t, asset, dt, dw);
+
+                        if (step == exerciseStep)
+                        {
+                            for (Size k = 0; k < config.size; ++k)
+                                assetAtExercise[k] = asset[k];
+                        }
+                    }
+
+                    // Discount factors
+                    Array dis(config.size);
+                    Real df = Real(1.0);
+                    for (Size k = 0; k < config.size; ++k)
+                    {
+                        Real accrual = accrualEnd[k] - accrualStart[k];
+                        df = df / (Real(1.0) + assetAtExercise[k] * accrual);
+                        dis[k] = df;
+                    }
+
+                    // NPV
+                    Real npv = Real(0.0);
+                    for (Size m = config.i_opt; m < config.i_opt + config.j_opt; ++m)
+                    {
+                        Real accrual = accrualEnd[m] - accrualStart[m];
+                        npv += (swapRate - assetAtExercise[m]) * accrual * dis[m];
+                    }
+                    price += max(npv, Real(0.0));
+                }
+                price /= Real(static_cast<double>(nrTrails));
+
+                tape.registerOutput(price);
+                derivative(price) = 1.0;
+                tape.computeAdjoints();
+
+                auto t_end = Clock::now();
+                if (recordTiming)
+                {
+                    xad_times.push_back(Duration(t_end - t_start).count());
+                }
+                tape.deactivate();
+            }
+
+#if defined(QLRISKS_HAS_FORGE)
+            // Variables used by JIT sections
+            Size numMarketQuotes = config.numDeposits + config.numSwaps;
+            Size numIntermediates = config.size + 1;
+
+            // =================================================================
+            // JIT Scalar approach (ForgeBackend)
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(config.numDeposits);
+                std::vector<Real> swapRatesAD(config.numSwaps);
+                for (Size idx = 0; idx < config.numDeposits; ++idx)
+                    depositRates[idx] = config.depoRates[idx];
+                for (Size idx = 0; idx < config.numSwaps; ++idx)
+                    swapRatesAD[idx] = config.swapRates[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRatesAD);
+                tape.newRecording();
+
+                // Build curve
+                RelinkableHandle<YieldTermStructure> euriborTS;
+                auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<ext::shared_ptr<RateHelper>> instruments;
+                for (Size idx = 0; idx < config.numDeposits; ++idx)
+                {
+                    auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                    instruments.push_back(ext::make_shared<DepositRateHelper>(
+                        Handle<Quote>(depoQuote), config.depoTenors[idx], fixingDays,
+                        calendar, ModifiedFollowing, true, dayCounter));
+                }
+                for (Size idx = 0; idx < config.numSwaps; ++idx)
+                {
+                    auto swapQuote = ext::make_shared<SimpleQuote>(swapRatesAD[idx]);
+                    instruments.push_back(ext::make_shared<SwapRateHelper>(
+                        Handle<Quote>(swapQuote), config.swapTenors[idx],
+                        calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                        euribor6m));
+                }
+
+                auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                    settlementDate, instruments, dayCounter);
+                yieldCurve->enableExtrapolation();
+
+                std::vector<Date> curveDates;
+                std::vector<Real> zeroRates;
+                curveDates.push_back(settlementDate);
+                zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                Date endDate = settlementDate + config.curveEndYears * Years;
+                curveDates.push_back(endDate);
+                zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                std::vector<Rate> zeroRates_ql;
+                for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(config.size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(config.size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate_tape = fwdSwap->fairRate();
+
+                Array initRates = process->initialValues();
+
+                // Jacobian computation
+                std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+                for (Size k = 0; k < config.size; ++k)
+                {
+                    if (initRates[k].shouldRecord())
+                    {
+                        tape.clearDerivatives();
+                        tape.registerOutput(initRates[k]);
+                        derivative(initRates[k]) = 1.0;
+                        tape.computeAdjoints();
+
+                        double* jac_row = jacobian.data() + k * numMarketQuotes;
+                        for (Size m = 0; m < config.numDeposits; ++m)
+                            jac_row[m] = derivative(depositRates[m]);
+                        for (Size m = 0; m < config.numSwaps; ++m)
+                            jac_row[config.numDeposits + m] = derivative(swapRatesAD[m]);
+                    }
+                }
+                if (swapRate_tape.shouldRecord())
+                {
+                    tape.clearDerivatives();
+                    tape.registerOutput(swapRate_tape);
+                    derivative(swapRate_tape) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + config.size * numMarketQuotes;
+                    for (Size m = 0; m < config.numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < config.numSwaps; ++m)
+                        jac_row[config.numDeposits + m] = derivative(swapRatesAD[m]);
+                }
+                tape.deactivate();
+
+                // JIT kernel creation with ForgeBackend
+                auto forgeBackend = std::make_unique<xad::forge::ForgeBackend<double>>(false);
+                xad::JITCompiler<double> jit(std::move(forgeBackend));
+
+                std::vector<xad::AD> jit_initRates(config.size);
+                xad::AD jit_swapRate;
+                std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+                for (Size k = 0; k < config.size; ++k)
+                {
+                    jit_initRates[k] = xad::AD(value(initRates[k]));
+                    jit.registerInput(jit_initRates[k]);
+                }
+                jit_swapRate = xad::AD(value(swapRate_tape));
+                jit.registerInput(jit_swapRate);
+                for (Size m = 0; m < fullGridRandoms; ++m)
+                {
+                    jit_randoms[m] = xad::AD(0.0);
+                    jit.registerInput(jit_randoms[m]);
+                }
+
+                jit.newRecording();
+
+                std::vector<xad::AD> asset_jit(config.size);
+                std::vector<xad::AD> assetAtExercise_jit(config.size);
+                for (Size k = 0; k < config.size; ++k) asset_jit[k] = jit_initRates[k];
+
+                for (Size step = 1; step <= fullGridSteps; ++step)
+                {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f)
+                        dw[f] = jit_randoms[offset + f];
+
+                    Array asset_arr(config.size);
+                    for (Size k = 0; k < config.size; ++k) asset_arr[k] = asset_jit[k];
+
+                    Array evolved = process->evolve(t, asset_arr, dt, dw);
+                    for (Size k = 0; k < config.size; ++k) asset_jit[k] = evolved[k];
+
+                    if (step == exerciseStep)
+                    {
+                        for (Size k = 0; k < config.size; ++k)
+                            assetAtExercise_jit[k] = asset_jit[k];
+                    }
+                }
+
+                std::vector<xad::AD> dis_jit(config.size);
+                xad::AD df_jit = xad::AD(1.0);
+                for (Size k = 0; k < config.size; ++k)
+                {
+                    double accrual = accrualEnd[k] - accrualStart[k];
+                    df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                    dis_jit[k] = df_jit;
+                }
+
+                xad::AD jit_npv = xad::AD(0.0);
+                for (Size m = config.i_opt; m < config.i_opt + config.j_opt; ++m)
+                {
+                    double accrual = accrualEnd[m] - accrualStart[m];
+                    jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+                }
+
+                xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+                jit.registerOutput(jit_payoff);
+
+                // Compile the JIT kernel
+                jit.compile();
+
+                // MC execution
+                double mcPrice = 0.0;
+                std::vector<double> dPrice_dInitRates(config.size, 0.0);
+                double dPrice_dSwapRate = 0.0;
+
+                const auto& graph = jit.getGraph();
+                uint32_t outputSlot = graph.output_ids[0];
+
+                for (Size n = 0; n < nrTrails; ++n)
+                {
+                    for (Size k = 0; k < config.size; ++k)
+                        value(jit_initRates[k]) = value(initRates[k]);
+                    value(jit_swapRate) = value(swapRate_tape);
+                    for (Size m = 0; m < fullGridRandoms; ++m)
+                        value(jit_randoms[m]) = allRandoms[n][m];
+
+                    double payoff_value;
+                    jit.forward(&payoff_value);
+                    mcPrice += payoff_value;
+
+                    jit.clearDerivatives();
+                    jit.setDerivative(outputSlot, 1.0);
+                    jit.computeAdjoints();
+
+                    for (Size k = 0; k < config.size; ++k)
+                        dPrice_dInitRates[k] += jit.derivative(graph.input_ids[k]);
+                    dPrice_dSwapRate += jit.derivative(graph.input_ids[config.size]);
+                }
+
+                mcPrice /= static_cast<double>(nrTrails);
+                for (Size k = 0; k < config.size; ++k)
+                    dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+                dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+                // Chain rule
+                std::vector<double> dPrice_dIntermediates(numIntermediates);
+                for (Size k = 0; k < config.size; ++k)
+                    dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+                dPrice_dIntermediates[config.size] = dPrice_dSwapRate;
+
+                std::vector<double> dPrice_market(numMarketQuotes);
+                applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                               numIntermediates, numMarketQuotes);
+
+                auto t_end = Clock::now();
+                if (recordTiming)
+                {
+                    jit_times.push_back(Duration(t_end - t_start).count());
+                }
+            }
+
+            // =================================================================
+            // JIT-AVX approach (ForgeBackendAVX with 4-path batching)
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(config.numDeposits);
+                std::vector<Real> swapRatesAD(config.numSwaps);
+                for (Size idx = 0; idx < config.numDeposits; ++idx)
+                    depositRates[idx] = config.depoRates[idx];
+                for (Size idx = 0; idx < config.numSwaps; ++idx)
+                    swapRatesAD[idx] = config.swapRates[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRatesAD);
+                tape.newRecording();
+
+                // Build curve
+                RelinkableHandle<YieldTermStructure> euriborTS;
+                auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<ext::shared_ptr<RateHelper>> instruments;
+                for (Size idx = 0; idx < config.numDeposits; ++idx)
+                {
+                    auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                    instruments.push_back(ext::make_shared<DepositRateHelper>(
+                        Handle<Quote>(depoQuote), config.depoTenors[idx], fixingDays,
+                        calendar, ModifiedFollowing, true, dayCounter));
+                }
+                for (Size idx = 0; idx < config.numSwaps; ++idx)
+                {
+                    auto swapQuote = ext::make_shared<SimpleQuote>(swapRatesAD[idx]);
+                    instruments.push_back(ext::make_shared<SwapRateHelper>(
+                        Handle<Quote>(swapQuote), config.swapTenors[idx],
+                        calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                        euribor6m));
+                }
+
+                auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                    settlementDate, instruments, dayCounter);
+                yieldCurve->enableExtrapolation();
+
+                std::vector<Date> curveDates;
+                std::vector<Real> zeroRates;
+                curveDates.push_back(settlementDate);
+                zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                Date endDate = settlementDate + config.curveEndYears * Years;
+                curveDates.push_back(endDate);
+                zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                std::vector<Rate> zeroRates_ql;
+                for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(config.size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(config.size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate_tape = fwdSwap->fairRate();
+
+                Array initRates = process->initialValues();
+
+                // Jacobian computation
+                std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+                for (Size k = 0; k < config.size; ++k)
+                {
+                    if (initRates[k].shouldRecord())
+                    {
+                        tape.clearDerivatives();
+                        tape.registerOutput(initRates[k]);
+                        derivative(initRates[k]) = 1.0;
+                        tape.computeAdjoints();
+
+                        double* jac_row = jacobian.data() + k * numMarketQuotes;
+                        for (Size m = 0; m < config.numDeposits; ++m)
+                            jac_row[m] = derivative(depositRates[m]);
+                        for (Size m = 0; m < config.numSwaps; ++m)
+                            jac_row[config.numDeposits + m] = derivative(swapRatesAD[m]);
+                    }
+                }
+                if (swapRate_tape.shouldRecord())
+                {
+                    tape.clearDerivatives();
+                    tape.registerOutput(swapRate_tape);
+                    derivative(swapRate_tape) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + config.size * numMarketQuotes;
+                    for (Size m = 0; m < config.numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < config.numSwaps; ++m)
+                        jac_row[config.numDeposits + m] = derivative(swapRatesAD[m]);
+                }
+                tape.deactivate();
+
+                // JIT kernel creation for AVX backend
+                xad::JITCompiler<double> jit;
+
+                std::vector<xad::AD> jit_initRates(config.size);
+                xad::AD jit_swapRate;
+                std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+                for (Size k = 0; k < config.size; ++k)
+                {
+                    jit_initRates[k] = xad::AD(value(initRates[k]));
+                    jit.registerInput(jit_initRates[k]);
+                }
+                jit_swapRate = xad::AD(value(swapRate_tape));
+                jit.registerInput(jit_swapRate);
+                for (Size m = 0; m < fullGridRandoms; ++m)
+                {
+                    jit_randoms[m] = xad::AD(0.0);
+                    jit.registerInput(jit_randoms[m]);
+                }
+
+                jit.newRecording();
+
+                std::vector<xad::AD> asset_jit(config.size);
+                std::vector<xad::AD> assetAtExercise_jit(config.size);
+                for (Size k = 0; k < config.size; ++k) asset_jit[k] = jit_initRates[k];
+
+                for (Size step = 1; step <= fullGridSteps; ++step)
+                {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f)
+                        dw[f] = jit_randoms[offset + f];
+
+                    Array asset_arr(config.size);
+                    for (Size k = 0; k < config.size; ++k) asset_arr[k] = asset_jit[k];
+
+                    Array evolved = process->evolve(t, asset_arr, dt, dw);
+                    for (Size k = 0; k < config.size; ++k) asset_jit[k] = evolved[k];
+
+                    if (step == exerciseStep)
+                    {
+                        for (Size k = 0; k < config.size; ++k)
+                            assetAtExercise_jit[k] = asset_jit[k];
+                    }
+                }
+
+                std::vector<xad::AD> dis_jit(config.size);
+                xad::AD df_jit = xad::AD(1.0);
+                for (Size k = 0; k < config.size; ++k)
+                {
+                    double accrual = accrualEnd[k] - accrualStart[k];
+                    df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                    dis_jit[k] = df_jit;
+                }
+
+                xad::AD jit_npv = xad::AD(0.0);
+                for (Size m = config.i_opt; m < config.i_opt + config.j_opt; ++m)
+                {
+                    double accrual = accrualEnd[m] - accrualStart[m];
+                    jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+                }
+
+                xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+                jit.registerOutput(jit_payoff);
+
+                // Get the JIT graph and deactivate the JIT compiler
+                const auto& jitGraph = jit.getGraph();
+                jit.deactivate();
+
+                // AVX backend with 4-path batching
+                xad::forge::ForgeBackendAVX<double> avxBackend(false);
+                avxBackend.compile(jitGraph);
+
+                // MC execution with 4-path batching
+                double mcPrice = 0.0;
+                std::vector<double> dPrice_dInitRates(config.size, 0.0);
+                double dPrice_dSwapRate = 0.0;
+
+                constexpr int BATCH_SIZE = xad::forge::ForgeBackendAVX<double>::VECTOR_WIDTH;
+                Size numBatches = (nrTrails + BATCH_SIZE - 1) / BATCH_SIZE;
+
+                std::vector<double> inputBatch(BATCH_SIZE);
+                std::vector<double> outputBatch(BATCH_SIZE);
+
+                for (Size batch = 0; batch < numBatches; ++batch)
+                {
+                    Size batchStart = batch * BATCH_SIZE;
+                    Size actualBatchSize = std::min(static_cast<Size>(BATCH_SIZE), nrTrails - batchStart);
+
+                    // Set initRates (same for all paths in batch)
+                    for (Size k = 0; k < config.size; ++k)
+                    {
+                        for (int lane = 0; lane < BATCH_SIZE; ++lane)
+                            inputBatch[lane] = value(initRates[k]);
+                        avxBackend.setInput(k, inputBatch.data());
+                    }
+
+                    // Set swapRate (same for all paths in batch)
+                    for (int lane = 0; lane < BATCH_SIZE; ++lane)
+                        inputBatch[lane] = value(swapRate_tape);
+                    avxBackend.setInput(config.size, inputBatch.data());
+
+                    // Set random numbers (different for each path in batch)
+                    for (Size m = 0; m < fullGridRandoms; ++m)
+                    {
+                        for (int lane = 0; lane < BATCH_SIZE; ++lane)
+                        {
+                            Size pathIdx = batchStart + lane;
+                            inputBatch[lane] = (pathIdx < nrTrails) ? allRandoms[pathIdx][m] : 0.0;
+                        }
+                        avxBackend.setInput(config.size + 1 + m, inputBatch.data());
+                    }
+
+                    // Execute forward + backward
+                    std::size_t numInputs = avxBackend.numInputs();
+                    std::vector<double> inputGradients(numInputs * BATCH_SIZE);
+                    avxBackend.forwardAndBackward(outputBatch.data(), inputGradients.data());
+
+                    // Accumulate MC price
+                    for (Size lane = 0; lane < actualBatchSize; ++lane)
+                    {
+                        mcPrice += outputBatch[lane];
+                    }
+
+                    // Accumulate gradients for initRates
+                    for (Size k = 0; k < config.size; ++k)
+                    {
+                        for (Size lane = 0; lane < actualBatchSize; ++lane)
+                        {
+                            dPrice_dInitRates[k] += inputGradients[k * BATCH_SIZE + lane];
+                        }
+                    }
+
+                    // Accumulate gradient for swap rate
+                    for (Size lane = 0; lane < actualBatchSize; ++lane)
+                    {
+                        dPrice_dSwapRate += inputGradients[config.size * BATCH_SIZE + lane];
+                    }
+                }
+
+                mcPrice /= static_cast<double>(nrTrails);
+                for (Size k = 0; k < config.size; ++k)
+                    dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+                dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+                // Chain rule
+                std::vector<double> dPrice_dIntermediates(numIntermediates);
+                for (Size k = 0; k < config.size; ++k)
+                    dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+                dPrice_dIntermediates[config.size] = dPrice_dSwapRate;
+
+                std::vector<double> dPrice_market(numMarketQuotes);
+                applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                               numIntermediates, numMarketQuotes);
+
+                auto t_end = Clock::now();
+                if (recordTiming)
+                {
+                    jit_avx_times.push_back(Duration(t_end - t_start).count());
+                }
+            }
+#endif // QLRISKS_HAS_FORGE
+        }
+
+        // Store FD results
+        if (runFD)
+        {
+            results[tc].fd_mean = computeMean(fd_times);
+            results[tc].fd_std = computeStddev(fd_times);
+            results[tc].fd_enabled = true;
+        }
+
+        results[tc].xad_mean = computeMean(xad_times);
+        results[tc].xad_std = computeStddev(xad_times);
+#if defined(QLRISKS_HAS_FORGE)
+        results[tc].jit_mean = computeMean(jit_times);
+        results[tc].jit_std = computeStddev(jit_times);
+        results[tc].jit_avx_mean = computeMean(jit_avx_times);
+        results[tc].jit_avx_std = computeStddev(jit_avx_times);
+#endif
+
+        std::cout << "done\n";
+    }
+
+    // Print results table
+    std::cout << "\n";
+    std::cout << std::string(80, '=') << "\n";
+    std::cout << "  RESULTS (mean +/- stddev, in ms)\n";
+    std::cout << std::string(80, '=') << "\n";
+    std::cout << "\n";
+
+    std::cout << "| Paths  |    Method |     Mean |   StdDev | Speedup |\n";
+    std::cout << "|-------:|----------:|---------:|---------:|--------:|\n";
+
+    for (size_t tc = 0; tc < config.pathCounts.size(); ++tc)
+    {
+        std::string pathLabel;
+        if (config.pathCounts[tc] >= 1000)
+            pathLabel = std::to_string(config.pathCounts[tc] / 1000) + "K";
+        else
+            pathLabel = std::to_string(config.pathCounts[tc]);
+
+        std::cout << std::fixed << std::setprecision(1);
+
+        // FD results (only for small path counts)
+        if (results[tc].fd_enabled)
+        {
+            std::cout << "| " << std::setw(6) << pathLabel << " |        FD |"
+                      << std::setw(9) << results[tc].fd_mean << " |"
+                      << std::setw(9) << results[tc].fd_std << " |     --- |\n";
+
+            double xad_speedup_vs_fd = results[tc].fd_mean / results[tc].xad_mean;
+            std::cout << "|        |       XAD |"
+                      << std::setw(9) << results[tc].xad_mean << " |"
+                      << std::setw(9) << results[tc].xad_std << " |"
+                      << std::setw(7) << std::setprecision(2) << xad_speedup_vs_fd << "x |\n";
+        }
+        else
+        {
+            std::cout << "| " << std::setw(6) << pathLabel << " |       XAD |"
+                      << std::setw(9) << results[tc].xad_mean << " |"
+                      << std::setw(9) << results[tc].xad_std << " |     --- |\n";
+        }
+
+#if defined(QLRISKS_HAS_FORGE)
+        double baseline = results[tc].fd_enabled ? results[tc].fd_mean : results[tc].xad_mean;
+        double jit_speedup = baseline / results[tc].jit_mean;
+        double avx_speedup = baseline / results[tc].jit_avx_mean;
+
+        std::cout << std::setprecision(1);
+        std::cout << "|        |       JIT |"
+                  << std::setw(9) << results[tc].jit_mean << " |"
+                  << std::setw(9) << results[tc].jit_std << " |"
+                  << std::setw(7) << std::setprecision(2) << jit_speedup << "x |\n";
+
+        std::cout << "|        |   JIT-AVX |"
+                  << std::setw(9) << std::setprecision(1) << results[tc].jit_avx_mean << " |"
+                  << std::setw(9) << results[tc].jit_avx_std << " |"
+                  << std::setw(7) << std::setprecision(2) << avx_speedup << "x |\n";
+#endif
+
+        if (tc < config.pathCounts.size() - 1)
+            std::cout << "|--------+-----------+----------+----------+---------|\n";
+    }
+
+    std::cout << "\n";
+    std::cout << "  Speedup = FD / Method (or XAD / Method when FD not available). All times in ms.\n";
+    std::cout << "  FD only runs for paths <= " << FD_MAX_PATHS << " due to O(n) cost per path.\n";
+    std::cout << "\n";
+}
+
+// ============================================================================
+// Performance Decomposition
+// ============================================================================
+
+void runDecomposition(const BenchmarkConfig& config)
+{
+    std::cout << "\n";
+    std::cout << std::string(80, '=') << "\n";
+    std::cout << "  PERFORMANCE DECOMPOSITION (1K paths)\n";
+    std::cout << std::string(80, '=') << "\n";
+
+#if defined(QLRISKS_HAS_FORGE)
+    using Clock = std::chrono::high_resolution_clock;
+    using Duration = std::chrono::duration<double, std::milli>;
+    // Setup (simplified version for decomposition)
+    Calendar calendar = TARGET();
+    Date todaysDate(4, September, 2005);
+    Settings::instance().evaluationDate() = todaysDate;
+    Integer fixingDays = 2;
+    Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+    DayCounter dayCounter = Actual360();
+
+    // Build base curve (using first deposit rate and last swap rate as endpoints)
+    std::vector<Rate> baseZeroRates = {config.depoRates[0], config.swapRates.back()};
+    std::vector<Date> baseDates = {settlementDate, settlementDate + config.curveEndYears * Years};
+    auto baseIndex = makeIndex(baseDates, baseZeroRates);
+
+    ext::shared_ptr<LiborForwardModelProcess> baseProcess(
+        new LiborForwardModelProcess(config.size, baseIndex));
+    baseProcess->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(
+            ext::make_shared<LmLinearExponentialVolatilityModel>(baseProcess->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+            ext::make_shared<LmExponentialCorrelationModel>(config.size, 0.5))));
+
+    std::vector<Time> fixingTimes = baseProcess->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), config.steps);
+
+    Size numFactors = baseProcess->factors();
+    Size fullGridSteps = grid.size() - 1;
+    Size fullGridRandoms = fullGridSteps * numFactors;
+
+    // Accrual periods
+    std::vector<double> accrualStart(config.size), accrualEnd(config.size);
+    for (Size k = 0; k < config.size; ++k)
+    {
+        accrualStart[k] = value(baseProcess->accrualStartTimes()[k]);
+        accrualEnd[k] = value(baseProcess->accrualEndTimes()[k]);
+    }
+
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx)
+        location.push_back(std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    Size exerciseStep = location[config.i_opt];
+
+    // Swap schedule
+    BusinessDayConvention convention = baseIndex->businessDayConvention();
+    Date fwdStart = settlementDate + Period(6 * config.i_opt, Months);
+    Date fwdMaturity = fwdStart + Period(6 * config.j_opt, Months);
+    Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    // Build process for recording
+    RelinkableHandle<YieldTermStructure> termStructure;
+    ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+    index->addFixing(Date(2, September, 2005), 0.04);
+
+    std::vector<Date> curveDates = {settlementDate, settlementDate + config.curveEndYears * Years};
+    std::vector<Rate> zeroRates_ql = {config.depoRates[0], config.swapRates.back()};
+    termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+    ext::shared_ptr<LiborForwardModelProcess> process(
+        new LiborForwardModelProcess(config.size, index));
+    process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(
+            ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+            ext::make_shared<LmExponentialCorrelationModel>(config.size, 0.5))));
+
+    Array initRates = process->initialValues();
+
+    // Build JIT graph
+    auto t_graph_start = Clock::now();
+
+    xad::JITCompiler<double> jit;
+
+    std::vector<xad::AD> jit_initRates(config.size);
+    xad::AD jit_swapRate;
+    std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+    for (Size k = 0; k < config.size; ++k)
+    {
+        jit_initRates[k] = xad::AD(value(initRates[k]));
+        jit.registerInput(jit_initRates[k]);
+    }
+    jit_swapRate = xad::AD(0.05);  // Placeholder
+    jit.registerInput(jit_swapRate);
+    for (Size m = 0; m < fullGridRandoms; ++m)
+    {
+        jit_randoms[m] = xad::AD(0.0);
+        jit.registerInput(jit_randoms[m]);
+    }
+
+    jit.newRecording();
+
+    std::vector<xad::AD> asset_jit(config.size);
+    std::vector<xad::AD> assetAtExercise_jit(config.size);
+    for (Size k = 0; k < config.size; ++k) asset_jit[k] = jit_initRates[k];
+
+    for (Size step = 1; step <= fullGridSteps; ++step)
+    {
+        Size offset = (step - 1) * numFactors;
+        Time t = grid[step - 1];
+        Time dt = grid.dt(step - 1);
+
+        Array dw(numFactors);
+        for (Size f = 0; f < numFactors; ++f)
+            dw[f] = jit_randoms[offset + f];
+
+        Array asset_arr(config.size);
+        for (Size k = 0; k < config.size; ++k) asset_arr[k] = asset_jit[k];
+
+        Array evolved = process->evolve(t, asset_arr, dt, dw);
+        for (Size k = 0; k < config.size; ++k) asset_jit[k] = evolved[k];
+
+        if (step == exerciseStep)
+        {
+            for (Size k = 0; k < config.size; ++k)
+                assetAtExercise_jit[k] = asset_jit[k];
+        }
+    }
+
+    std::vector<xad::AD> dis_jit(config.size);
+    xad::AD df_jit = xad::AD(1.0);
+    for (Size k = 0; k < config.size; ++k)
+    {
+        double accrual = accrualEnd[k] - accrualStart[k];
+        df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+        dis_jit[k] = df_jit;
+    }
+
+    xad::AD jit_npv = xad::AD(0.0);
+    for (Size m = config.i_opt; m < config.i_opt + config.j_opt; ++m)
+    {
+        double accrual = accrualEnd[m] - accrualStart[m];
+        jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+    }
+
+    xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+    jit.registerOutput(jit_payoff);
+
+    auto t_graph_end = Clock::now();
+    double graphTimeMs = Duration(t_graph_end - t_graph_start).count();
+
+    // Compile with ForgeBackend
+    auto t_compile_start = Clock::now();
+    const auto& jitGraph = jit.getGraph();
+    xad::forge::ForgeBackendAVX<double> avxBackend(false);
+    avxBackend.compile(jitGraph);
+    auto t_compile_end = Clock::now();
+    double compileTimeMs = Duration(t_compile_end - t_compile_start).count();
+
+    // Run MC loop for timing
+    Size nrTrails = 1000;
+    constexpr int BATCH_SIZE = xad::forge::ForgeBackendAVX<double>::VECTOR_WIDTH;
+
+    // Generate random numbers
+    typedef PseudoRandom::rsg_type rsg_type;
+    rsg_type rsg_base = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+
+    std::vector<std::vector<double>> allRandoms(nrTrails);
+    for (Size n = 0; n < nrTrails; ++n)
+    {
+        allRandoms[n].resize(fullGridRandoms);
+        const auto& seq = rsg_base.nextSequence();
+        for (Size m = 0; m < fullGridRandoms; ++m)
+            allRandoms[n][m] = value(seq.value[m]);
+    }
+
+    // Time each phase
+    double setInputTime = 0.0;
+    double forwardTime = 0.0;
+    double accumulateTime = 0.0;
+
+    Size numBatches = (nrTrails + BATCH_SIZE - 1) / BATCH_SIZE;
+    std::vector<double> inputBatch(BATCH_SIZE);
+    std::vector<double> outputBatch(BATCH_SIZE);
+
+    for (Size batch = 0; batch < numBatches; ++batch)
+    {
+        Size batchStart = batch * BATCH_SIZE;
+        Size actualBatchSize = std::min(static_cast<Size>(BATCH_SIZE), nrTrails - batchStart);
+
+        // Set inputs
+        auto t1 = Clock::now();
+        for (Size k = 0; k < config.size; ++k)
+        {
+            for (int lane = 0; lane < BATCH_SIZE; ++lane)
+                inputBatch[lane] = value(initRates[k]);
+            avxBackend.setInput(k, inputBatch.data());
+        }
+        for (int lane = 0; lane < BATCH_SIZE; ++lane)
+            inputBatch[lane] = 0.05;
+        avxBackend.setInput(config.size, inputBatch.data());
+        for (Size m = 0; m < fullGridRandoms; ++m)
+        {
+            for (int lane = 0; lane < BATCH_SIZE; ++lane)
+            {
+                Size pathIdx = batchStart + lane;
+                inputBatch[lane] = (pathIdx < nrTrails) ? allRandoms[pathIdx][m] : 0.0;
+            }
+            avxBackend.setInput(config.size + 1 + m, inputBatch.data());
+        }
+        auto t2 = Clock::now();
+        setInputTime += Duration(t2 - t1).count();
+
+        // Forward + backward (combined for AVX backend)
+        auto t3 = Clock::now();
+        std::size_t numInputs = avxBackend.numInputs();
+        std::vector<double> inputGradients(numInputs * BATCH_SIZE);
+        avxBackend.forwardAndBackward(outputBatch.data(), inputGradients.data());
+        auto t4 = Clock::now();
+        forwardTime += Duration(t4 - t3).count();
+
+        // Accumulate results (simplified)
+        auto t5 = Clock::now();
+        double dummy = 0.0;
+        for (Size lane = 0; lane < actualBatchSize; ++lane)
+            dummy += outputBatch[lane];
+        auto t6 = Clock::now();
+        accumulateTime += Duration(t6 - t5).count();
+        (void)dummy;
+    }
+
+    double totalTime = graphTimeMs + compileTimeMs + setInputTime + forwardTime + accumulateTime;
+    double execTime = totalTime - graphTimeMs - compileTimeMs;
+
+    // Print in xad-jit style
+    std::cout << "\n  JIT-AVX (Forge + AVX2 SIMD)\n";
+    std::cout << std::string(80, '-') << "\n";
+
+    std::cout << std::fixed << std::setprecision(2);
+    std::cout << "  Total time:              " << std::setw(10) << totalTime << " ms (100.0%)\n";
+    std::cout << "  -------------------------\n";
+    std::cout << "  Graph build (one-time):  " << std::setw(10) << graphTimeMs << " ms ("
+              << std::setw(5) << std::setprecision(1) << (graphTimeMs / totalTime * 100) << "%)\n";
+    std::cout << "  Compile (one-time):      " << std::setw(10) << std::setprecision(2) << compileTimeMs << " ms ("
+              << std::setw(5) << std::setprecision(1) << (compileTimeMs / totalTime * 100) << "%)\n";
+    std::cout << "  Set inputs:              " << std::setw(10) << std::setprecision(2) << setInputTime << " ms ("
+              << std::setw(5) << std::setprecision(1) << (setInputTime / totalTime * 100) << "%)\n";
+    std::cout << "  Forward+Backward:        " << std::setw(10) << std::setprecision(2) << forwardTime << " ms ("
+              << std::setw(5) << std::setprecision(1) << (forwardTime / totalTime * 100) << "%)\n";
+    std::cout << "  Accumulate results:      " << std::setw(10) << std::setprecision(2) << accumulateTime << " ms ("
+              << std::setw(5) << std::setprecision(1) << (accumulateTime / totalTime * 100) << "%)\n";
+    std::cout << "  -------------------------\n";
+    std::cout << "  Execution (excl compile):" << std::setw(10) << std::setprecision(2) << execTime << " ms\n";
+    std::cout << "  Batches (4 paths each):  " << std::setw(10) << numBatches << "\n";
+    std::cout << "  Time per batch:          " << std::setw(10) << std::setprecision(2) << (execTime / numBatches * 1000) << " us\n";
+    std::cout << "  Time per path:           " << std::setw(10) << std::setprecision(2) << (execTime / nrTrails * 1000) << " us\n";
+
+#else
+    std::cout << "\n  [Decomposition requires Forge JIT support]\n";
+#endif
+
+    std::cout << "\n";
+}
+
+// ============================================================================
+// Pricing-Only Benchmark (No Derivatives)
+// ============================================================================
+// This measures the overhead of using xad::AReal<double> vs plain double
+// when NOT computing derivatives. It runs the same MC simulation but without
+// any tape recording or derivative computation.
+
+void runPricingOnlyBenchmark(const BenchmarkConfig& config, bool quickMode)
+{
+    using Clock = std::chrono::high_resolution_clock;
+    using Duration = std::chrono::duration<double, std::milli>;
+
+    Calendar calendar = TARGET();
+    Date todaysDate(4, September, 2005);
+    Settings::instance().evaluationDate() = todaysDate;
+    Integer fixingDays = 2;
+    Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+    DayCounter dayCounter = Actual360();
+
+    // Build base curve
+    std::vector<Rate> baseZeroRates = {config.depoRates[0], config.swapRates.back()};
+    std::vector<Date> baseDates = {settlementDate, settlementDate + config.curveEndYears * Years};
+    auto baseIndex = makeIndex(baseDates, baseZeroRates);
+
+    ext::shared_ptr<LiborForwardModelProcess> baseProcess(
+        new LiborForwardModelProcess(config.size, baseIndex));
+    ext::shared_ptr<LmCorrelationModel> baseCorrModel(
+        new LmExponentialCorrelationModel(config.size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> baseVolaModel(
+        new LmLinearExponentialVolatilityModel(baseProcess->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    baseProcess->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(baseVolaModel, baseCorrModel)));
+
+    // Grid setup
+    std::vector<Time> fixingTimes = baseProcess->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), config.steps);
+
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx)
+    {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    Size numFactors = baseProcess->factors();
+    Size exerciseStep = location[config.i_opt];
+    Size fullGridSteps = grid.size() - 1;
+    Size fullGridRandoms = fullGridSteps * numFactors;
+
+    // Swap schedule
+    BusinessDayConvention convention = baseIndex->businessDayConvention();
+    Date fwdStart = settlementDate + Period(6 * config.i_opt, Months);
+    Date fwdMaturity = fwdStart + Period(6 * config.j_opt, Months);
+    Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    // Accrual periods
+    std::vector<double> accrualStart(config.size), accrualEnd(config.size);
+    for (Size k = 0; k < config.size; ++k)
+    {
+        accrualStart[k] = value(baseProcess->accrualStartTimes()[k]);
+        accrualEnd[k] = value(baseProcess->accrualEndTimes()[k]);
+    }
+
+    // Pre-generate random numbers
+    Size maxPaths = static_cast<Size>(*std::max_element(config.pathCounts.begin(), config.pathCounts.end()));
+    std::cout << "  Generating " << maxPaths << " x " << fullGridRandoms << " random numbers..." << std::flush;
+
+    typedef PseudoRandom::rsg_type rsg_type;
+    rsg_type rsg_base = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+
+    std::vector<std::vector<double>> allRandoms(maxPaths);
+    for (Size n = 0; n < maxPaths; ++n)
+    {
+        allRandoms[n].resize(fullGridRandoms);
+        const auto& seq = rsg_base.nextSequence();
+        for (Size m = 0; m < fullGridRandoms; ++m)
+        {
+            allRandoms[n][m] = value(seq.value[m]);
+        }
+    }
+    std::cout << " Done." << std::endl;
+
+    // Build curve and process for pricing
+    RelinkableHandle<YieldTermStructure> euriborTS;
+    auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+    euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+    std::vector<ext::shared_ptr<RateHelper>> instruments;
+    for (Size idx = 0; idx < config.numDeposits; ++idx)
+    {
+        auto depoQuote = ext::make_shared<SimpleQuote>(config.depoRates[idx]);
+        instruments.push_back(ext::make_shared<DepositRateHelper>(
+            Handle<Quote>(depoQuote), config.depoTenors[idx], fixingDays,
+            calendar, ModifiedFollowing, true, dayCounter));
+    }
+    for (Size idx = 0; idx < config.numSwaps; ++idx)
+    {
+        auto swapQuote = ext::make_shared<SimpleQuote>(config.swapRates[idx]);
+        instruments.push_back(ext::make_shared<SwapRateHelper>(
+            Handle<Quote>(swapQuote), config.swapTenors[idx],
+            calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+            euribor6m));
+    }
+
+    auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+        settlementDate, instruments, dayCounter);
+    yieldCurve->enableExtrapolation();
+
+    std::vector<Date> curveDates;
+    std::vector<Rate> zeroRates;
+    curveDates.push_back(settlementDate);
+    zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+    Date endDate = settlementDate + config.curveEndYears * Years;
+    curveDates.push_back(endDate);
+    zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+    RelinkableHandle<YieldTermStructure> termStructure;
+    ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+    index->addFixing(Date(2, September, 2005), 0.04);
+    termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates, dayCounter));
+
+    ext::shared_ptr<LiborForwardModelProcess> process(
+        new LiborForwardModelProcess(config.size, index));
+    process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(
+            ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+            ext::make_shared<LmExponentialCorrelationModel>(config.size, 0.5))));
+
+    // Get swap rate
+    ext::shared_ptr<VanillaSwap> fwdSwap(
+        new VanillaSwap(Swap::Receiver, 1.0,
+                        schedule, 0.05, dayCounter,
+                        schedule, index, 0.0, index->dayCounter()));
+    fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+        index->forwardingTermStructure()));
+    Real swapRate = fwdSwap->fairRate();
+
+    // Get initial rates
+    Array initRates = process->initialValues();
+
+    // Results storage
+    std::vector<double> results_mean(config.pathCounts.size());
+    std::vector<double> results_std(config.pathCounts.size());
+
+    // Run benchmarks for each path count
+    for (size_t tc = 0; tc < config.pathCounts.size(); ++tc)
+    {
+        Size nrTrails = static_cast<Size>(config.pathCounts[tc]);
+
+        std::cout << "  [" << (tc + 1) << "/" << config.pathCounts.size() << "] ";
+        if (config.pathCounts[tc] >= 1000)
+            std::cout << (config.pathCounts[tc] / 1000) << "K";
+        else
+            std::cout << config.pathCounts[tc];
+        std::cout << " paths " << std::flush;
+
+        std::vector<double> times;
+
+        for (size_t iter = 0; iter < config.warmupIterations + config.benchmarkIterations; ++iter)
+        {
+            bool recordTiming = (iter >= config.warmupIterations);
+
+            auto t_start = Clock::now();
+
+            // MC simulation - pricing only (no tape, no derivatives)
+            Real price = 0.0;
+            for (Size n = 0; n < nrTrails; ++n)
+            {
+                Array asset(config.size);
+                for (Size k = 0; k < config.size; ++k)
+                    asset[k] = initRates[k];
+
+                Array assetAtExercise(config.size);
+                for (Size step = 1; step <= fullGridSteps; ++step)
+                {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f)
+                        dw[f] = allRandoms[n][offset + f];
+
+                    asset = process->evolve(t, asset, dt, dw);
+
+                    if (step == exerciseStep)
+                    {
+                        for (Size k = 0; k < config.size; ++k)
+                            assetAtExercise[k] = asset[k];
+                    }
+                }
+
+                // Discount factors
+                Array dis(config.size);
+                Real df = 1.0;
+                for (Size k = 0; k < config.size; ++k)
+                {
+                    Real accrual = accrualEnd[k] - accrualStart[k];
+                    df = df / (1.0 + assetAtExercise[k] * accrual);
+                    dis[k] = df;
+                }
+
+                // NPV
+                Real npv = 0.0;
+                for (Size m = config.i_opt; m < config.i_opt + config.j_opt; ++m)
+                {
+                    Real accrual = accrualEnd[m] - accrualStart[m];
+                    npv += (swapRate - assetAtExercise[m]) * accrual * dis[m];
+                }
+
+                if (value(npv) > 0.0)
+                    price += npv;
+            }
+            price /= static_cast<Real>(nrTrails);
+
+            auto t_end = Clock::now();
+            if (recordTiming)
+            {
+                times.push_back(Duration(t_end - t_start).count());
+            }
+
+            // Suppress unused variable warning
+            (void)price;
+        }
+
+        results_mean[tc] = computeMean(times);
+        results_std[tc] = computeStddev(times);
+
+        std::cout << "done\n";
+    }
+
+    // Print results table
+    std::cout << "\n";
+    std::cout << std::string(80, '=') << "\n";
+    std::cout << "  RESULTS (mean +/- stddev, in ms)\n";
+    std::cout << std::string(80, '=') << "\n";
+    std::cout << "\n";
+
+    std::cout << "| Paths  |    Method |     Mean |   StdDev |\n";
+    std::cout << "|-------:|----------:|---------:|---------:|\n";
+
+    for (size_t tc = 0; tc < config.pathCounts.size(); ++tc)
+    {
+        std::string pathLabel;
+        if (config.pathCounts[tc] >= 1000)
+            pathLabel = std::to_string(config.pathCounts[tc] / 1000) + "K";
+        else
+            pathLabel = std::to_string(config.pathCounts[tc]);
+
+        std::cout << std::fixed << std::setprecision(1);
+        std::cout << "| " << std::setw(6) << pathLabel << " |   Pricing |"
+                  << std::setw(9) << results_mean[tc] << " |"
+                  << std::setw(9) << results_std[tc] << " |\n";
+
+        if (tc < config.pathCounts.size() - 1)
+            std::cout << "|--------+-----------+----------+----------|\n";
+    }
+
+    std::cout << "\n";
+    std::cout << "  Pricing-only mode: No tape recording, no derivative computation.\n";
+    std::cout << "  This measures the overhead of using xad::AReal<double> vs plain double.\n";
+    std::cout << "\n";
+}
+
+// ============================================================================
+// Main
+// ============================================================================
+
+void printUsage(const char* progName)
+{
+    std::cout << "Usage: " << progName << " [options]\n\n";
+    std::cout << "Options:\n";
+    std::cout << "  --help, -h        Show this help message\n";
+    std::cout << "  --quick           Run quick benchmark (fewer iterations, fewer path counts)\n";
+    std::cout << "  --small-only      Run only the small swaption benchmark (1Y into 1Y)\n";
+    std::cout << "  --large-only      Run only the large swaption benchmark (5Y into 5Y)\n";
+    std::cout << "  --decomposition   Run performance decomposition analysis\n";
+    std::cout << "  --pricing-only    Run pricing-only benchmark (no derivatives, measures type overhead)\n";
+    std::cout << "\nBenchmarks (both run by default):\n";
+    std::cout << "  Small:  1Y into 1Y swaption (10 forward rates, 8 time steps)\n";
+    std::cout << "  Large:  5Y into 5Y swaption (20 forward rates, 20 time steps)\n";
+    std::cout << "\nThis benchmark compares AD approaches for swaption pricing.\n";
+    std::cout << "The --pricing-only mode measures overhead of xad::AReal<double> vs double.\n";
+#if defined(QLRISKS_HAS_FORGE)
+    std::cout << "Build: With Forge JIT support\n";
+#else
+    std::cout << "Build: Without Forge JIT (XAD tape only)\n";
+#endif
+}
+
+void runSingleBenchmark(const BenchmarkConfig& config, bool quickMode)
+{
+    std::cout << "\n  INSTRUMENT\n";
+    std::cout << std::string(80, '-') << "\n";
+    std::cout << "  Instrument:   " << config.instrumentDesc << "\n";
+    std::cout << "  Model:        LIBOR Market Model (LMM)\n";
+    std::cout << "  Forward rates:" << config.size << " (semi-annual)\n";
+    std::cout << "  Time steps:   " << config.steps << "\n";
+    std::cout << "  Inputs:       " << (config.numDeposits + config.numSwaps) << " market quotes\n";
+
+    std::cout << "\n  BENCHMARK CONFIGURATION\n";
+    std::cout << std::string(80, '-') << "\n";
+    std::cout << "  Path counts:  ";
+    for (size_t i = 0; i < config.pathCounts.size(); ++i)
+    {
+        if (i > 0) std::cout << ", ";
+        if (config.pathCounts[i] >= 1000)
+            std::cout << (config.pathCounts[i] / 1000) << "K";
+        else
+            std::cout << config.pathCounts[i];
+    }
+    std::cout << "\n";
+    std::cout << "  Warmup:       " << config.warmupIterations << " iterations\n";
+    std::cout << "  Measured:     " << config.benchmarkIterations << " iterations\n";
+
+    std::cout << "\n  METHODS\n";
+    std::cout << std::string(80, '-') << "\n";
+    std::cout << "  FD       Finite Differences (bump-and-revalue, paths <= " << FD_MAX_PATHS << " only)\n";
+    std::cout << "  XAD      XAD tape-based reverse-mode AAD\n";
+#if defined(QLRISKS_HAS_FORGE)
+    std::cout << "  JIT      Forge JIT-compiled native code\n";
+    std::cout << "  JIT-AVX  Forge JIT + AVX2 SIMD (4 paths/instruction)\n";
+#endif
+
+    std::cout << "\n";
+    std::cout << std::string(80, '=') << "\n";
+    std::cout << "  RUNNING BENCHMARKS\n";
+    std::cout << std::string(80, '=') << "\n";
+    std::cout << "\n";
+
+    runBenchmark(config, quickMode);
+}
+
+int main(int argc, char** argv)
+{
+    bool quickMode = false;
+    bool smallOnly = false;
+    bool largeOnly = false;
+    bool decompositionMode = false;
+    bool pricingOnlyMode = false;
+
+    for (int i = 1; i < argc; ++i)
+    {
+        std::string arg = argv[i];
+        if (arg == "--help" || arg == "-h")
+        {
+            printUsage(argv[0]);
+            return 0;
+        }
+        else if (arg == "--quick")
+            quickMode = true;
+        else if (arg == "--small-only")
+            smallOnly = true;
+        else if (arg == "--large-only" || arg == "--large")
+            largeOnly = true;
+        else if (arg == "--decomposition")
+            decompositionMode = true;
+        else if (arg == "--pricing-only")
+            pricingOnlyMode = true;
+    }
+
+    // Print header
+    std::cout << "\n";
+    std::cout << std::string(80, '=') << "\n";
+    std::cout << "  QuantLib-Risks Swaption Benchmark\n";
+    std::cout << std::string(80, '=') << "\n";
+
+    std::cout << "\n  ENVIRONMENT\n";
+    std::cout << std::string(80, '-') << "\n";
+    std::cout << "  Platform:     " << getPlatformInfo() << "\n";
+    std::cout << "  CPU:          " << getCpuInfo() << "\n";
+    std::cout << "  RAM:          " << getMemoryInfo() << "\n";
+    std::cout << "  SIMD:         " << getSimdInfo() << "\n";
+    std::cout << "  Compiler:     " << getCompilerInfo() << "\n";
+
+    if (pricingOnlyMode)
+    {
+        // Run pricing-only benchmark (no derivatives)
+        // This measures the overhead of xad::AReal<double> vs plain double
+        bool runSmall = !largeOnly;
+        bool runLarge = !smallOnly;
+
+        if (runSmall)
+        {
+            BenchmarkConfig smallConfig;
+            if (quickMode)
+            {
+                smallConfig.pathCounts = {100, 1000};
+                smallConfig.warmupIterations = 1;
+                smallConfig.benchmarkIterations = 2;
+            }
+
+            std::cout << "\n";
+            std::cout << std::string(80, '=') << "\n";
+            std::cout << "  PRICING-ONLY: Small Swaption (1Y into 1Y)\n";
+            std::cout << std::string(80, '=') << "\n";
+
+            std::cout << "\n  INSTRUMENT\n";
+            std::cout << std::string(80, '-') << "\n";
+            std::cout << "  Instrument:   " << smallConfig.instrumentDesc << "\n";
+            std::cout << "  Model:        LIBOR Market Model (LMM)\n";
+            std::cout << "  Forward rates:" << smallConfig.size << " (semi-annual)\n";
+            std::cout << "  Time steps:   " << smallConfig.steps << "\n";
+            std::cout << "  Mode:         Pricing only (no derivatives)\n";
+
+            std::cout << "\n  BENCHMARK CONFIGURATION\n";
+            std::cout << std::string(80, '-') << "\n";
+            std::cout << "  Path counts:  ";
+            for (size_t i = 0; i < smallConfig.pathCounts.size(); ++i)
+            {
+                if (i > 0) std::cout << ", ";
+                if (smallConfig.pathCounts[i] >= 1000)
+                    std::cout << (smallConfig.pathCounts[i] / 1000) << "K";
+                else
+                    std::cout << smallConfig.pathCounts[i];
+            }
+            std::cout << "\n";
+            std::cout << "  Warmup:       " << smallConfig.warmupIterations << " iterations\n";
+            std::cout << "  Measured:     " << smallConfig.benchmarkIterations << " iterations\n";
+
+            std::cout << "\n";
+            std::cout << std::string(80, '=') << "\n";
+            std::cout << "  RUNNING PRICING-ONLY BENCHMARK\n";
+            std::cout << std::string(80, '=') << "\n";
+            std::cout << "\n";
+
+            runPricingOnlyBenchmark(smallConfig, quickMode);
+        }
+
+        if (runLarge)
+        {
+            BenchmarkConfig largeConfig;
+            largeConfig.setLargeConfig();
+            if (quickMode)
+            {
+                largeConfig.pathCounts = {100, 1000};
+                largeConfig.warmupIterations = 1;
+                largeConfig.benchmarkIterations = 2;
+            }
+
+            std::cout << "\n";
+            std::cout << std::string(80, '=') << "\n";
+            std::cout << "  PRICING-ONLY: Large Swaption (5Y into 5Y)\n";
+            std::cout << std::string(80, '=') << "\n";
+
+            std::cout << "\n  INSTRUMENT\n";
+            std::cout << std::string(80, '-') << "\n";
+            std::cout << "  Instrument:   " << largeConfig.instrumentDesc << "\n";
+            std::cout << "  Model:        LIBOR Market Model (LMM)\n";
+            std::cout << "  Forward rates:" << largeConfig.size << " (semi-annual)\n";
+            std::cout << "  Time steps:   " << largeConfig.steps << "\n";
+            std::cout << "  Mode:         Pricing only (no derivatives)\n";
+
+            std::cout << "\n  BENCHMARK CONFIGURATION\n";
+            std::cout << std::string(80, '-') << "\n";
+            std::cout << "  Path counts:  ";
+            for (size_t i = 0; i < largeConfig.pathCounts.size(); ++i)
+            {
+                if (i > 0) std::cout << ", ";
+                if (largeConfig.pathCounts[i] >= 1000)
+                    std::cout << (largeConfig.pathCounts[i] / 1000) << "K";
+                else
+                    std::cout << largeConfig.pathCounts[i];
+            }
+            std::cout << "\n";
+            std::cout << "  Warmup:       " << largeConfig.warmupIterations << " iterations\n";
+            std::cout << "  Measured:     " << largeConfig.benchmarkIterations << " iterations\n";
+
+            std::cout << "\n";
+            std::cout << std::string(80, '=') << "\n";
+            std::cout << "  RUNNING PRICING-ONLY BENCHMARK\n";
+            std::cout << std::string(80, '=') << "\n";
+            std::cout << "\n";
+
+            runPricingOnlyBenchmark(largeConfig, quickMode);
+        }
+    }
+    else if (decompositionMode)
+    {
+        // Run decomposition for both configs
+        BenchmarkConfig smallConfig;
+        if (quickMode)
+        {
+            smallConfig.pathCounts = {100, 1000};
+            smallConfig.warmupIterations = 1;
+            smallConfig.benchmarkIterations = 2;
+        }
+
+        if (!largeOnly)
+        {
+            std::cout << "\n";
+            std::cout << std::string(80, '=') << "\n";
+            std::cout << "  DECOMPOSITION: Small Swaption (1Y into 1Y)\n";
+            std::cout << std::string(80, '=') << "\n";
+            runDecomposition(smallConfig);
+        }
+
+        if (!smallOnly)
+        {
+            BenchmarkConfig largeConfig;
+            largeConfig.setLargeConfig();
+            if (quickMode)
+            {
+                largeConfig.pathCounts = {100, 1000};
+                largeConfig.warmupIterations = 1;
+                largeConfig.benchmarkIterations = 2;
+            }
+
+            std::cout << "\n";
+            std::cout << std::string(80, '=') << "\n";
+            std::cout << "  DECOMPOSITION: Large Swaption (5Y into 5Y)\n";
+            std::cout << std::string(80, '=') << "\n";
+            runDecomposition(largeConfig);
+        }
+    }
+    else
+    {
+        // Run benchmarks
+        bool runSmall = !largeOnly;
+        bool runLarge = !smallOnly;
+
+        if (runSmall)
+        {
+            BenchmarkConfig smallConfig;
+            if (quickMode)
+            {
+                smallConfig.pathCounts = {100, 1000};
+                smallConfig.warmupIterations = 1;
+                smallConfig.benchmarkIterations = 2;
+            }
+
+            std::cout << "\n";
+            std::cout << std::string(80, '=') << "\n";
+            std::cout << "  BENCHMARK 1: Small Swaption (1Y into 1Y)\n";
+            std::cout << std::string(80, '=') << "\n";
+
+            runSingleBenchmark(smallConfig, quickMode);
+        }
+
+        if (runLarge)
+        {
+            BenchmarkConfig largeConfig;
+            largeConfig.setLargeConfig();
+            if (quickMode)
+            {
+                largeConfig.pathCounts = {100, 1000};
+                largeConfig.warmupIterations = 1;
+                largeConfig.benchmarkIterations = 2;
+            }
+
+            std::cout << "\n";
+            std::cout << std::string(80, '=') << "\n";
+            std::cout << "  BENCHMARK 2: Large Swaption (5Y into 5Y)\n";
+            std::cout << std::string(80, '=') << "\n";
+
+            runSingleBenchmark(largeConfig, quickMode);
+        }
+    }
+
+    std::cout << "\n";
+    std::cout << std::string(80, '=') << "\n";
+    std::cout << "  All benchmarks complete.\n";
+    std::cout << std::string(80, '=') << "\n";
+    std::cout << "\n";
+
+    return 0;
+}
diff --git a/test-suite/benchmark_utils.hpp b/test-suite/benchmark_utils.hpp
new file mode 100644
index 0000000..408b602
--- /dev/null
+++ b/test-suite/benchmark_utils.hpp
@@ -0,0 +1,213 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2025 Xcelerit Computing Limited
+
+ Benchmark utilities for QuantLib-Risks / XAD / Forge benchmarks.
+ Provides environment detection and output formatting similar to BenchmarkDotNet.
+*/
+
+#pragma once
+
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#ifdef _WIN32
+#include <intrin.h>
+#include <windows.h>
+#else
+#include <sys/utsname.h>
+#include <unistd.h>
+#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
+#include <cpuid.h>
+#endif
+#endif
+
+#include <cstring>
+
+namespace BenchmarkUtils {
+
+inline std::string getCpuInfo()
+{
+#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
+    char brand[49] = {0};
+    unsigned int regs[4];
+
+#ifdef _WIN32
+    __cpuid(reinterpret_cast<int*>(regs), 0x80000000);
+#else
+    __get_cpuid(0x80000000, &regs[0], &regs[1], &regs[2], &regs[3]);
+#endif
+
+    if (regs[0] >= 0x80000004)
+    {
+        for (unsigned int i = 0; i < 3; ++i)
+        {
+#ifdef _WIN32
+            __cpuid(reinterpret_cast<int*>(regs), 0x80000002 + i);
+#else
+            __get_cpuid(0x80000002 + i, &regs[0], &regs[1], &regs[2], &regs[3]);
+#endif
+            std::memcpy(brand + i * 16, regs, 16);
+        }
+        std::string result(brand);
+        size_t start = result.find_first_not_of(' ');
+        if (start != std::string::npos)
+            result = result.substr(start);
+        return result;
+    }
+#endif
+    return "Unknown CPU";
+}
+
+inline std::string getPlatformInfo()
+{
+#ifdef _WIN32
+    typedef LONG(WINAPI * RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);
+    HMODULE hMod = GetModuleHandleW(L"ntdll.dll");
+    if (hMod)
+    {
+        auto RtlGetVersion = (RtlGetVersionPtr)GetProcAddress(hMod, "RtlGetVersion");
+        if (RtlGetVersion)
+        {
+            RTL_OSVERSIONINFOW rovi = {0};
+            rovi.dwOSVersionInfoSize = sizeof(rovi);
+            if (RtlGetVersion(&rovi) == 0)
+            {
+                std::ostringstream oss;
+                oss << "Windows " << rovi.dwMajorVersion << "." << rovi.dwMinorVersion
+                    << " (Build " << rovi.dwBuildNumber << ")";
+                return oss.str();
+            }
+        }
+    }
+    return "Windows";
+#else
+    struct utsname buf;
+    if (uname(&buf) == 0)
+    {
+        std::ostringstream oss;
+        oss << buf.sysname << " " << buf.release;
+        return oss.str();
+    }
+    return "Unknown";
+#endif
+}
+
+inline std::string getMemoryInfo()
+{
+#ifdef _WIN32
+    MEMORYSTATUSEX memInfo;
+    memInfo.dwLength = sizeof(MEMORYSTATUSEX);
+    if (GlobalMemoryStatusEx(&memInfo))
+    {
+        double gb = static_cast<double>(memInfo.ullTotalPhys) / (1024.0 * 1024.0 * 1024.0);
+        std::ostringstream oss;
+        oss << std::fixed << std::setprecision(0) << gb << " GB";
+        return oss.str();
+    }
+#else
+    long pages = sysconf(_SC_PHYS_PAGES);
+    long page_size = sysconf(_SC_PAGE_SIZE);
+    if (pages > 0 && page_size > 0)
+    {
+        double gb = static_cast<double>(pages) * page_size / (1024.0 * 1024.0 * 1024.0);
+        std::ostringstream oss;
+        oss << std::fixed << std::setprecision(0) << gb << " GB";
+        return oss.str();
+    }
+#endif
+    return "Unknown";
+}
+
+inline std::string getCompilerInfo()
+{
+#if defined(_MSC_VER)
+    std::ostringstream oss;
+    oss << "MSVC " << _MSC_VER / 100 << "." << _MSC_VER % 100;
+#if defined(_DEBUG)
+    oss << " Debug";
+#else
+    oss << " Release";
+#endif
+    return oss.str();
+#elif defined(__clang__)
+    std::ostringstream oss;
+    oss << "Clang " << __clang_major__ << "." << __clang_minor__ << "." << __clang_patchlevel__;
+    return oss.str();
+#elif defined(__GNUC__)
+    std::ostringstream oss;
+    oss << "GCC " << __GNUC__ << "." << __GNUC_MINOR__ << "." << __GNUC_PATCHLEVEL__;
+    return oss.str();
+#else
+    return "Unknown Compiler";
+#endif
+}
+
+inline std::string getSimdInfo()
+{
+#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
+    unsigned int regs[4];
+    std::vector<std::string> features;
+
+#ifdef _WIN32
+    __cpuid(reinterpret_cast<int*>(regs), 1);
+#else
+    __get_cpuid(1, &regs[0], &regs[1], &regs[2], &regs[3]);
+#endif
+
+    if (regs[2] & (1 << 0)) features.push_back("SSE3");
+    if (regs[2] & (1 << 19)) features.push_back("SSE4.1");
+    if (regs[2] & (1 << 20)) features.push_back("SSE4.2");
+    if (regs[2] & (1 << 28)) features.push_back("AVX");
+
+#ifdef _WIN32
+    __cpuidex(reinterpret_cast<int*>(regs), 7, 0);
+#else
+    __get_cpuid_count(7, 0, &regs[0], &regs[1], &regs[2], &regs[3]);
+#endif
+
+    if (regs[1] & (1 << 5)) features.push_back("AVX2");
+    if (regs[1] & (1 << 16)) features.push_back("AVX512F");
+    if (regs[1] & (1 << 30)) features.push_back("AVX512BW");
+
+    if (features.empty())
+        return "None detected";
+
+    std::ostringstream oss;
+    for (size_t i = 0; i < features.size(); ++i)
+    {
+        if (i > 0) oss << ", ";
+        oss << features[i];
+    }
+    return oss.str();
+#else
+    return "N/A (non-x86)";
+#endif
+}
+
+/// Print BenchmarkDotNet-style environment header
+inline void printEnvironmentHeader()
+{
+    std::cout << "\n";
+    std::cout << "// * Environment *\n";
+    std::cout << "Platform=" << getPlatformInfo() << "\n";
+    std::cout << "CPU=" << getCpuInfo() << "\n";
+    std::cout << "RAM=" << getMemoryInfo() << "\n";
+    std::cout << "SIMD=" << getSimdInfo() << "\n";
+    std::cout << "Compiler=" << getCompilerInfo() << "\n";
+    std::cout << "\n";
+}
+
+/// Format path count for display (e.g., 10000 -> "10K")
+inline std::string formatPathCount(int paths)
+{
+    if (paths >= 1000)
+        return std::to_string(paths / 1000) + "K";
+    return std::to_string(paths);
+}
+
+} // namespace BenchmarkUtils
diff --git a/test-suite/forgebackend_xad.cpp b/test-suite/forgebackend_xad.cpp
new file mode 100644
index 0000000..633af71
--- /dev/null
+++ b/test-suite/forgebackend_xad.cpp
@@ -0,0 +1,302 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ This file is part of QuantLib-Risks, a C++ library for AAD-enabled
+ quantitative finance using QuantLib and XAD.
+
+ This file tests the Forge JIT backend integration with XAD.
+ Unlike jit_xad.cpp which uses the C++ interpreter, this tests
+ the actual native code generation via Forge.
+*/
+
+#include "toplevelfixture.hpp"
+#include "utilities_xad.hpp"
+#include <ql/quantlib.hpp>
+#include <XAD/XAD.hpp>
+#include <xad-forge/ForgeBackend.hpp>
+#include <boost/test/unit_test.hpp>
+#include <cmath>
+#include <vector>
+
+using namespace QuantLib;
+using namespace boost::unit_test_framework;
+
+BOOST_FIXTURE_TEST_SUITE(QuantLibRisksForgeTests, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(ForgeBackendTests)
+
+namespace {
+
+// f1: Simple linear function
+// f(x) = x * 3 + 2, f'(x) = 3
+template <class T>
+T f1(const T& x)
+{
+    return x * 3.0 + 2.0;
+}
+
+// f2: Function with supported math operations
+// Uses: sin, cos, exp, log, sqrt, abs
+template <class T>
+T f2(const T& x)
+{
+    using std::sin; using std::cos; using std::exp; using std::log;
+    using std::sqrt; using std::abs;
+
+    T result = sin(x) + cos(x) * 2.0;
+    result = result + exp(x / 10.0) + log(x + 5.0);
+    result = result + sqrt(x + 1.0);
+    result = result + abs(x - 1.0) + x * x;
+    result = result + 1.0 / (x + 2.0);
+    return result;
+}
+
+// f3ABool: Branching with ABool::If for trackable branches
+xad::AD f3ABool(const xad::AD& x)
+{
+    return xad::less(x, 2.0).If(2.0 * x, 10.0 * x);
+}
+
+double f3ABool_double(double x)
+{
+    return (x < 2.0) ? 2.0 * x : 10.0 * x;
+}
+
+} // anonymous namespace
+
+BOOST_AUTO_TEST_CASE(testForgeBackendLinearFunction)
+{
+    BOOST_TEST_MESSAGE("Testing ForgeBackend with linear function...");
+    std::cout << "\n=== ForgeBackend Linear Function Test: f(x) = 3x + 2 ===" << std::endl;
+
+    std::vector<double> inputs = {2.0, 0.5, -1.0};
+
+    // Compute with Tape
+    std::vector<double> tapeOutputs, tapeDerivatives;
+    {
+        xad::Tape<double> tape;
+        for (double input : inputs)
+        {
+            xad::AD x(input);
+            tape.registerInput(x);
+            tape.newRecording();
+            xad::AD y = f1(x);
+            tape.registerOutput(y);
+            derivative(y) = 1.0;
+            tape.computeAdjoints();
+            tapeOutputs.push_back(value(y));
+            tapeDerivatives.push_back(derivative(x));
+            tape.clearAll();
+        }
+    }
+
+    // Compute with ForgeBackend (native JIT)
+    std::vector<double> forgeOutputs, forgeDerivatives;
+    {
+        xad::JITCompiler<double, 1> jit(
+            std::make_unique<xad::forge::ForgeBackend<double>>());
+
+        xad::AD x(inputs[0]);
+        jit.registerInput(x);
+        jit.newRecording();
+        xad::AD y = f1(x);
+        jit.registerOutput(y);
+        jit.compile();  // Compile before forward
+
+        for (double input : inputs)
+        {
+            value(x) = input;
+            double output;
+            jit.forward(&output);
+            forgeOutputs.push_back(output);
+
+            jit.clearDerivatives();
+            derivative(y) = 1.0;
+            jit.computeAdjoints();
+            forgeDerivatives.push_back(derivative(x));
+        }
+    }
+
+    // Compare results
+    for (std::size_t i = 0; i < inputs.size(); ++i)
+    {
+        double expected = f1(inputs[i]);
+        std::cout << "  x=" << inputs[i]
+                  << ": tape=" << tapeOutputs[i] << " (deriv=" << tapeDerivatives[i] << ")"
+                  << ", forge=" << forgeOutputs[i] << " (deriv=" << forgeDerivatives[i] << ")"
+                  << std::endl;
+        BOOST_CHECK_CLOSE(expected, tapeOutputs[i], 1e-10);
+        BOOST_CHECK_CLOSE(expected, forgeOutputs[i], 1e-10);
+        BOOST_CHECK_CLOSE(tapeDerivatives[i], forgeDerivatives[i], 1e-10);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(testForgeBackendMathFunctions)
+{
+    BOOST_TEST_MESSAGE("Testing ForgeBackend with math functions...");
+    std::cout << "\n=== ForgeBackend Math Functions Test: sin, cos, exp, log, sqrt, abs ===" << std::endl;
+
+    std::vector<double> inputs = {2.0, 0.5};
+
+    // Compute with Tape
+    std::vector<double> tapeOutputs, tapeDerivatives;
+    {
+        xad::Tape<double> tape;
+        for (double input : inputs)
+        {
+            xad::AD x(input);
+            tape.registerInput(x);
+            tape.newRecording();
+            xad::AD y = f2(x);
+            tape.registerOutput(y);
+            derivative(y) = 1.0;
+            tape.computeAdjoints();
+            tapeOutputs.push_back(value(y));
+            tapeDerivatives.push_back(derivative(x));
+            tape.clearAll();
+        }
+    }
+
+    // Compute with ForgeBackend
+    std::vector<double> forgeOutputs, forgeDerivatives;
+    {
+        xad::JITCompiler<double, 1> jit(
+            std::make_unique<xad::forge::ForgeBackend<double>>());
+
+        xad::AD x(inputs[0]);
+        jit.registerInput(x);
+        jit.newRecording();
+        xad::AD y = f2(x);
+        jit.registerOutput(y);
+        jit.compile();  // Compile before forward
+
+        for (double input : inputs)
+        {
+            value(x) = input;
+            double output;
+            jit.forward(&output);
+            forgeOutputs.push_back(output);
+
+            jit.clearDerivatives();
+            derivative(y) = 1.0;
+            jit.computeAdjoints();
+            forgeDerivatives.push_back(derivative(x));
+        }
+    }
+
+    // Compare results
+    for (std::size_t i = 0; i < inputs.size(); ++i)
+    {
+        double expected = f2(inputs[i]);
+        std::cout << "  x=" << inputs[i]
+                  << ": tape=" << tapeOutputs[i] << " (deriv=" << tapeDerivatives[i] << ")"
+                  << ", forge=" << forgeOutputs[i] << " (deriv=" << forgeDerivatives[i] << ")"
+                  << std::endl;
+        BOOST_CHECK_CLOSE(expected, tapeOutputs[i], 1e-10);
+        BOOST_CHECK_CLOSE(expected, forgeOutputs[i], 1e-10);
+        BOOST_CHECK_CLOSE(tapeDerivatives[i], forgeDerivatives[i], 1e-10);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(testForgeBackendABoolBranching)
+{
+    BOOST_TEST_MESSAGE("Testing ForgeBackend with ABool::If branching...");
+    std::cout << "\n=== ForgeBackend ABool::If Test: if(x<2) 2*x else 10*x ===" << std::endl;
+
+    std::vector<double> inputs = {1.0, 3.0};
+
+    // Compute with Tape
+    std::vector<double> tapeOutputs, tapeDerivatives;
+    {
+        xad::Tape<double> tape;
+        for (double input : inputs)
+        {
+            xad::AD x(input);
+            tape.registerInput(x);
+            tape.newRecording();
+            xad::AD y = f3ABool(x);
+            tape.registerOutput(y);
+            derivative(y) = 1.0;
+            tape.computeAdjoints();
+            tapeOutputs.push_back(value(y));
+            tapeDerivatives.push_back(derivative(x));
+            tape.clearAll();
+        }
+    }
+
+    // Compute with ForgeBackend
+    std::vector<double> forgeOutputs, forgeDerivatives;
+    {
+        xad::JITCompiler<double, 1> jit(
+            std::make_unique<xad::forge::ForgeBackend<double>>());
+
+        xad::AD x(inputs[0]);
+        jit.registerInput(x);
+        jit.newRecording();
+        xad::AD y = f3ABool(x);
+        jit.registerOutput(y);
+        jit.compile();  // Compile before forward
+
+        for (double input : inputs)
+        {
+            value(x) = input;
+            double output;
+            jit.forward(&output);
+            forgeOutputs.push_back(output);
+
+            jit.clearDerivatives();
+            derivative(y) = 1.0;
+            jit.computeAdjoints();
+            forgeDerivatives.push_back(derivative(x));
+        }
+    }
+
+    // Compare results - ABool::If should track both branches
+    for (std::size_t i = 0; i < inputs.size(); ++i)
+    {
+        double expected = f3ABool_double(inputs[i]);
+        std::cout << "  x=" << inputs[i]
+                  << ": tape=" << tapeOutputs[i] << " (deriv=" << tapeDerivatives[i] << ")"
+                  << ", forge=" << forgeOutputs[i] << " (deriv=" << forgeDerivatives[i] << ")"
+                  << " - MATCH!" << std::endl;
+        BOOST_CHECK_CLOSE(expected, tapeOutputs[i], 1e-10);
+        BOOST_CHECK_CLOSE(expected, forgeOutputs[i], 1e-10);
+        BOOST_CHECK_CLOSE(tapeDerivatives[i], forgeDerivatives[i], 1e-10);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(testForgeBackendBasicInstantiation)
+{
+    BOOST_TEST_MESSAGE("Testing ForgeBackend basic instantiation...");
+    std::cout << "\n=== ForgeBackend Basic Test: f(x) = x^2 + 3x ===" << std::endl;
+
+    xad::JITCompiler<double, 1> jit(
+        std::make_unique<xad::forge::ForgeBackend<double>>());
+
+    xad::AD x(2.0);
+    jit.registerInput(x);
+    jit.newRecording();
+    xad::AD y = x * x + 3.0 * x;  // f(x) = x^2 + 3x, f'(x) = 2x + 3
+    jit.registerOutput(y);
+    jit.compile();  // Compile before forward
+
+    double output;
+    jit.forward(&output);
+    std::cout << "  f(2) = " << output << " (expected: 10)" << std::endl;
+    BOOST_CHECK_CLOSE(10.0, output, 1e-10);  // f(2) = 4 + 6 = 10
+
+    value(x) = 5.0;
+    jit.forward(&output);
+    std::cout << "  f(5) = " << output << " (expected: 40)" << std::endl;
+    BOOST_CHECK_CLOSE(40.0, output, 1e-10);  // f(5) = 25 + 15 = 40
+
+    jit.clearDerivatives();
+    derivative(y) = 1.0;
+    jit.computeAdjoints();
+    std::cout << "  f'(5) = " << derivative(x) << " (expected: 13)" << std::endl;
+    BOOST_CHECK_CLOSE(13.0, derivative(x), 1e-10);  // f'(5) = 10 + 3 = 13
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test-suite/jit_xad.cpp b/test-suite/jit_xad.cpp
new file mode 100644
index 0000000..77dd3ea
--- /dev/null
+++ b/test-suite/jit_xad.cpp
@@ -0,0 +1,345 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ This file is part of QuantLib-Risks, a C++ library for AAD-enabled
+ quantitative finance using QuantLib and XAD.
+
+ QuantLib-Risks is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib-Risks license.  You should have received a
+ copy of the license along with this program; if not, please visit
+ <https://github.com/auto-differentiation/QuantLib-Risks-Cpp>.
+
+ This file tests the XAD JIT compilation infrastructure.
+*/
+
+#include "toplevelfixture.hpp"
+#include "utilities_xad.hpp"
+#include <ql/quantlib.hpp>
+#include <XAD/XAD.hpp>
+#include <boost/test/unit_test.hpp>
+#include <cmath>
+#include <vector>
+
+using namespace QuantLib;
+using namespace boost::unit_test_framework;
+
+BOOST_FIXTURE_TEST_SUITE(QuantLibRisksJITTests, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(JITTests)
+
+namespace {
+
+// f1: Simple linear function
+// f(x) = x * 3 + 2, f'(x) = 3
+template <class T>
+T f1(const T& x)
+{
+    return x * 3.0 + 2.0;
+}
+
+// f2: Function with supported math operations
+// Uses: sin, cos, exp, log, sqrt, abs
+template <class T>
+T f2(const T& x)
+{
+    using std::sin; using std::cos; using std::exp; using std::log;
+    using std::sqrt; using std::abs;
+
+    T result = sin(x) + cos(x) * 2.0;
+    result = result + exp(x / 10.0) + log(x + 5.0);
+    result = result + sqrt(x + 1.0);
+    result = result + abs(x - 1.0) + x * x;
+    result = result + 1.0 / (x + 2.0);
+    return result;
+}
+
+// Helper to get value for both double and AD types
+inline double getValue(double x) { return x; }
+template <class T>
+double getValue(const T& x) { return value(x); }
+
+// f3: Branching function (regular if/else - JIT records one branch)
+template <class T>
+T f3(const T& x)
+{
+    if (getValue(x) < 2.0)
+        return 2.0 * x;
+    else
+        return 10.0 * x;
+}
+
+// f3ABool: Branching with ABool::If (JIT records both branches)
+xad::AD f3ABool(const xad::AD& x)
+{
+    return xad::less(x, 2.0).If(2.0 * x, 10.0 * x);
+}
+
+double f3ABool_double(double x)
+{
+    return (x < 2.0) ? 2.0 * x : 10.0 * x;
+}
+
+} // anonymous namespace
+
+BOOST_AUTO_TEST_CASE(testJITLinearFunction)
+{
+    BOOST_TEST_MESSAGE("Testing JIT compilation with linear function...");
+    std::cout << "\n=== JIT Linear Function Test: f(x) = 3x + 2 ===" << std::endl;
+
+    std::vector<double> inputs = {2.0, 0.5, -1.0};
+
+    // Compute with Tape
+    std::vector<double> tapeOutputs, tapeDerivatives;
+    {
+        xad::Tape<double> tape;
+        for (double input : inputs)
+        {
+            xad::AD x(input);
+            tape.registerInput(x);
+            tape.newRecording();
+            xad::AD y = f1(x);
+            tape.registerOutput(y);
+            derivative(y) = 1.0;
+            tape.computeAdjoints();
+            tapeOutputs.push_back(value(y));
+            tapeDerivatives.push_back(derivative(x));
+            tape.clearAll();
+        }
+    }
+
+    // Compute with JIT (record once, reuse)
+    std::vector<double> jitOutputs, jitDerivatives;
+    {
+        xad::JITCompiler<double> jit;
+
+        xad::AD x(inputs[0]);
+        jit.registerInput(x);
+        jit.newRecording();
+        xad::AD y = f1(x);
+        jit.registerOutput(y);
+        jit.compile();  // Compile before forward
+
+        for (double input : inputs)
+        {
+            value(x) = input;
+            double output;
+            jit.forward(&output);
+            jitOutputs.push_back(output);
+
+            jit.clearDerivatives();
+            derivative(y) = 1.0;
+            jit.computeAdjoints();
+            jitDerivatives.push_back(derivative(x));
+        }
+    }
+
+    // Compare results
+    for (std::size_t i = 0; i < inputs.size(); ++i)
+    {
+        double expected = f1(inputs[i]);
+        std::cout << "  x=" << inputs[i]
+                  << ": tape=" << tapeOutputs[i] << " (deriv=" << tapeDerivatives[i] << ")"
+                  << ", jit=" << jitOutputs[i] << " (deriv=" << jitDerivatives[i] << ")"
+                  << std::endl;
+        BOOST_CHECK_CLOSE(expected, tapeOutputs[i], 1e-10);
+        BOOST_CHECK_CLOSE(expected, jitOutputs[i], 1e-10);
+        BOOST_CHECK_CLOSE(tapeDerivatives[i], jitDerivatives[i], 1e-10);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(testJITMathFunctions)
+{
+    BOOST_TEST_MESSAGE("Testing JIT compilation with math functions...");
+    std::cout << "\n=== JIT Math Functions Test: sin, cos, exp, log, sqrt, abs ===" << std::endl;
+
+    std::vector<double> inputs = {2.0, 0.5};
+
+    // Compute with Tape
+    std::vector<double> tapeOutputs, tapeDerivatives;
+    {
+        xad::Tape<double> tape;
+        for (double input : inputs)
+        {
+            xad::AD x(input);
+            tape.registerInput(x);
+            tape.newRecording();
+            xad::AD y = f2(x);
+            tape.registerOutput(y);
+            derivative(y) = 1.0;
+            tape.computeAdjoints();
+            tapeOutputs.push_back(value(y));
+            tapeDerivatives.push_back(derivative(x));
+            tape.clearAll();
+        }
+    }
+
+    // Compute with JIT
+    std::vector<double> jitOutputs, jitDerivatives;
+    {
+        xad::JITCompiler<double> jit;
+
+        xad::AD x(inputs[0]);
+        jit.registerInput(x);
+        jit.newRecording();
+        xad::AD y = f2(x);
+        jit.registerOutput(y);
+        jit.compile();  // Compile before forward
+
+        for (double input : inputs)
+        {
+            value(x) = input;
+            double output;
+            jit.forward(&output);
+            jitOutputs.push_back(output);
+
+            jit.clearDerivatives();
+            derivative(y) = 1.0;
+            jit.computeAdjoints();
+            jitDerivatives.push_back(derivative(x));
+        }
+    }
+
+    // Compare results
+    for (std::size_t i = 0; i < inputs.size(); ++i)
+    {
+        double expected = f2(inputs[i]);
+        std::cout << "  x=" << inputs[i]
+                  << ": tape=" << tapeOutputs[i] << " (deriv=" << tapeDerivatives[i] << ")"
+                  << ", jit=" << jitOutputs[i] << " (deriv=" << jitDerivatives[i] << ")"
+                  << std::endl;
+        BOOST_CHECK_CLOSE(expected, tapeOutputs[i], 1e-10);
+        BOOST_CHECK_CLOSE(expected, jitOutputs[i], 1e-10);
+        BOOST_CHECK_CLOSE(tapeDerivatives[i], jitDerivatives[i], 1e-10);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(testJITBranchingRegularIf)
+{
+    BOOST_TEST_MESSAGE("Testing JIT with regular if/else (graph reuse behavior)...");
+    std::cout << "\n=== JIT Branching Test: Regular if/else (demonstrates graph reuse) ===" << std::endl;
+    std::cout << "  Formula: if (x < 2) 2*x else 10*x" << std::endl;
+
+    // With regular if/else, JIT records the branch taken during recording
+    // and will use that branch for all subsequent evaluations
+    std::vector<double> inputs = {1.0, 3.0};
+
+    // Compute with Tape (re-records each time, follows actual branch)
+    std::vector<double> tapeOutputs;
+    {
+        xad::Tape<double> tape;
+        for (double input : inputs)
+        {
+            xad::AD x(input);
+            tape.registerInput(x);
+            tape.newRecording();
+            xad::AD y = f3(x);
+            tape.registerOutput(y);
+            tapeOutputs.push_back(value(y));
+            tape.clearAll();
+        }
+    }
+
+    // Compute with JIT (records branch at x=1, uses it for all)
+    std::vector<double> jitOutputs;
+    {
+        xad::JITCompiler<double> jit;
+
+        xad::AD x(inputs[0]);  // x=1 -> takes first branch (2*x)
+        jit.registerInput(x);
+        jit.newRecording();
+        xad::AD y = f3(x);
+        jit.registerOutput(y);
+        jit.compile();  // Compile before forward
+
+        for (double input : inputs)
+        {
+            value(x) = input;
+            double output;
+            jit.forward(&output);
+            jitOutputs.push_back(output);
+        }
+    }
+
+    std::cout << "  x=1: tape=" << tapeOutputs[0] << " (correct: 2*1=2), jit=" << jitOutputs[0] << std::endl;
+    std::cout << "  x=3: tape=" << tapeOutputs[1] << " (correct: 10*3=30), jit=" << jitOutputs[1] << " (uses recorded 2*x branch!)" << std::endl;
+
+    // Tape follows actual branches: f(1)=2, f(3)=30
+    BOOST_CHECK_CLOSE(tapeOutputs[0], 2.0, 1e-10);   // 2*1 = 2
+    BOOST_CHECK_CLOSE(tapeOutputs[1], 30.0, 1e-10); // 10*3 = 30
+
+    // JIT recorded first branch (2*x), uses it for both: f(1)=2, f(3)=6
+    BOOST_CHECK_CLOSE(jitOutputs[0], 2.0, 1e-10);  // 2*1 = 2
+    BOOST_CHECK_CLOSE(jitOutputs[1], 6.0, 1e-10);  // 2*3 = 6 (uses recorded branch!)
+}
+
+BOOST_AUTO_TEST_CASE(testJITBranchingABool)
+{
+    BOOST_TEST_MESSAGE("Testing JIT with ABool::If (tracks both branches)...");
+    std::cout << "\n=== JIT Branching Test: ABool::If (tracks both branches correctly) ===" << std::endl;
+    std::cout << "  Formula: ABool::If(x < 2, 2*x, 10*x)" << std::endl;
+
+    // With ABool::If, JIT records both branches and selects at runtime
+    std::vector<double> inputs = {1.0, 3.0};
+
+    // Compute with Tape
+    std::vector<double> tapeOutputs, tapeDerivatives;
+    {
+        xad::Tape<double> tape;
+        for (double input : inputs)
+        {
+            xad::AD x(input);
+            tape.registerInput(x);
+            tape.newRecording();
+            xad::AD y = f3ABool(x);
+            tape.registerOutput(y);
+            derivative(y) = 1.0;
+            tape.computeAdjoints();
+            tapeOutputs.push_back(value(y));
+            tapeDerivatives.push_back(derivative(x));
+            tape.clearAll();
+        }
+    }
+
+    // Compute with JIT
+    std::vector<double> jitOutputs, jitDerivatives;
+    {
+        xad::JITCompiler<double> jit;
+
+        xad::AD x(inputs[0]);
+        jit.registerInput(x);
+        jit.newRecording();
+        xad::AD y = f3ABool(x);
+        jit.registerOutput(y);
+        jit.compile();  // Compile before forward
+
+        for (double input : inputs)
+        {
+            value(x) = input;
+            double output;
+            jit.forward(&output);
+            jitOutputs.push_back(output);
+
+            jit.clearDerivatives();
+            derivative(y) = 1.0;
+            jit.computeAdjoints();
+            jitDerivatives.push_back(derivative(x));
+        }
+    }
+
+    // Both should match: ABool::If allows JIT to track both branches
+    for (std::size_t i = 0; i < inputs.size(); ++i)
+    {
+        double expected = f3ABool_double(inputs[i]);
+        std::cout << "  x=" << inputs[i]
+                  << ": tape=" << tapeOutputs[i] << " (deriv=" << tapeDerivatives[i] << ")"
+                  << ", jit=" << jitOutputs[i] << " (deriv=" << jitDerivatives[i] << ")"
+                  << " - MATCH!" << std::endl;
+        BOOST_CHECK_CLOSE(expected, tapeOutputs[i], 1e-10);
+        BOOST_CHECK_CLOSE(expected, jitOutputs[i], 1e-10);
+        BOOST_CHECK_CLOSE(tapeDerivatives[i], jitDerivatives[i], 1e-10);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test-suite/quantlibrisks_benchmark.cpp b/test-suite/quantlibrisks_benchmark.cpp
new file mode 100644
index 0000000..44b220b
--- /dev/null
+++ b/test-suite/quantlibrisks_benchmark.cpp
@@ -0,0 +1,20 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2025 Xcelerit Computing Limited
+
+ This file is part of QuantLib-Risks / XAD / Forge integration.
+
+ Main entry point for the QuantLib-Risks benchmark suite.
+*/
+
+#define BOOST_TEST_MODULE QuantLibRisksBenchmark
+
+#include <boost/test/included/unit_test.hpp>
+
+/* Use BOOST_MSVC instead of _MSC_VER since some other vendors (Metrowerks,
+   for example) also #define _MSC_VER
+*/
+#if !defined(BOOST_ALL_NO_LIB) && defined(BOOST_MSVC)
+#    include <ql/auto_link.hpp>
+#endif
diff --git a/test-suite/swaption_benchmark.cpp b/test-suite/swaption_benchmark.cpp
new file mode 100644
index 0000000..9a7025d
--- /dev/null
+++ b/test-suite/swaption_benchmark.cpp
@@ -0,0 +1,2524 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2025 Xcelerit Computing Limited
+
+ This file is part of QuantLib-Risks / XAD / Forge integration.
+
+ Swaption JIT Benchmark - Performance comparison of AD approaches:
+ - XAD Tape: Traditional tape-based reverse-mode AD
+ - JIT (Forge): Just-In-Time compiled native code for AD
+ - JIT-AVX: JIT with AVX2 SIMD vectorization (4 paths per instruction)
+
+ Benchmarks:
+ 1. Simple Swaption (1Y into 1Y) - basic scaling test
+ 2. Larger Swaption (5Y into 5Y) - attempts to approximate a realistic setup
+
+ Reference: https://github.com/auto-differentiation/xad/issues/70
+*/
+
+#include "toplevelfixture.hpp"
+#include "utilities_xad.hpp"
+
+// QuantLib includes
+#include <ql/indexes/ibor/eonia.hpp>
+#include <ql/indexes/ibor/euribor.hpp>
+#include <ql/instruments/vanillaswap.hpp>
+#include <ql/instruments/swaption.hpp>
+#include <ql/math/interpolations/cubicinterpolation.hpp>
+#include <ql/pricingengines/swap/discountingswapengine.hpp>
+#include <ql/termstructures/yield/oisratehelper.hpp>
+#include <ql/termstructures/yield/piecewiseyieldcurve.hpp>
+#include <ql/termstructures/yield/ratehelpers.hpp>
+#include <ql/termstructures/yield/zerocurve.hpp>
+#include <ql/time/calendars/target.hpp>
+#include <ql/time/daycounters/actual360.hpp>
+#include <ql/time/daycounters/actual365fixed.hpp>
+#include <ql/time/daycounters/thirty360.hpp>
+
+// LMM Monte Carlo includes
+#include <ql/legacy/libormarketmodels/lfmcovarproxy.hpp>
+#include <ql/legacy/libormarketmodels/lfmswaptionengine.hpp>
+#include <ql/legacy/libormarketmodels/liborforwardmodel.hpp>
+#include <ql/legacy/libormarketmodels/lmexpcorrmodel.hpp>
+#include <ql/legacy/libormarketmodels/lmlinexpvolmodel.hpp>
+#include <ql/math/randomnumbers/rngtraits.hpp>
+#include <ql/math/statistics/generalstatistics.hpp>
+#include <ql/methods/montecarlo/multipathgenerator.hpp>
+
+#include <boost/test/unit_test.hpp>
+#include <chrono>
+#include <iostream>
+#include <iomanip>
+#include <vector>
+#include <map>
+
+// Benchmark utilities (environment detection, formatting)
+#include "benchmark_utils.hpp"
+
+// Forge JIT backends
+#include <xad-forge/ForgeBackend.hpp>
+#include <xad-forge/ForgeBackendAVX.hpp>
+
+using namespace QuantLib;
+using namespace boost::unit_test_framework;
+
+BOOST_FIXTURE_TEST_SUITE(QuantLibRisksTests, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(SwaptionBenchmarkTests)
+
+//////////////////////////////////////////////////////////////////////////////
+// Helper: Create IborIndex with ZeroCurve (from libormarketmodel.cpp)
+//////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+ext::shared_ptr<IborIndex> makeIndex(std::vector<Date> dates,
+                                     const std::vector<Rate>& rates) {
+    DayCounter dayCounter = Actual360();
+    RelinkableHandle<YieldTermStructure> termStructure;
+    ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+
+    Date todaysDate = index->fixingCalendar().adjust(Date(4, September, 2005));
+    Settings::instance().evaluationDate() = todaysDate;
+
+    dates[0] = index->fixingCalendar().advance(todaysDate,
+                                                index->fixingDays(), Days);
+
+    termStructure.linkTo(ext::shared_ptr<YieldTermStructure>(
+        new ZeroCurve(dates, rates, dayCounter)));
+
+    return index;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// High-performance chain rule: result = jacobian^T * derivatives
+// For hybrid AD workflows: JIT computes dOutput/dIntermediate,
+// Tape computes dIntermediate/dInput, chain rule gives dOutput/dInput.
+//////////////////////////////////////////////////////////////////////////////
+
+/// Apply chain rule: result[j] = sum_i(derivatives[i] * jacobian[i * numInputs + j])
+/// @param jacobian      Row-major flat array [numIntermediates x numInputs]
+/// @param derivatives   Vector [numIntermediates] (dOutput/dIntermediate)
+/// @param result        Output vector [numInputs] (dOutput/dInput) - zeroed first
+/// @param numIntermediates  Number of intermediate variables
+/// @param numInputs     Number of input variables
+inline void applyChainRule(const double* __restrict jacobian,
+                           const double* __restrict derivatives,
+                           double* __restrict result,
+                           std::size_t numIntermediates,
+                           std::size_t numInputs)
+{
+    // Zero result
+    for (std::size_t j = 0; j < numInputs; ++j)
+        result[j] = 0.0;
+
+    // Accumulate: result[j] += derivatives[i] * jacobian[i,j]
+    for (std::size_t i = 0; i < numIntermediates; ++i)
+    {
+        const double deriv_i = derivatives[i];
+        const double* jac_row = jacobian + i * numInputs;
+        for (std::size_t j = 0; j < numInputs; ++j)
+        {
+            result[j] += deriv_i * jac_row[j];
+        }
+    }
+}
+
+} // anonymous namespace
+
+//////////////////////////////////////////////////////////////////////////////
+// Benchmark 1: Simple Swaption Scaling (1Y into 1Y)
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testBenchmark_SimpleSwaptionScaling)
+{
+    BOOST_TEST_MESSAGE("Running Simple Swaption Scaling Benchmark...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  XAD JIT BENCHMARK: Simple Swaption (1Y into 1Y)\n";
+    std::cout << "=============================================================================\n";
+
+    // BenchmarkDotNet-style environment info
+    BenchmarkUtils::printEnvironmentHeader();
+
+    std::cout << "// * Benchmark Description *\n";
+    std::cout << "  This benchmark compares Algorithmic Differentiation approaches for\n";
+    std::cout << "  computing sensitivities in Monte Carlo swaption pricing.\n";
+    std::cout << std::endl;
+    std::cout << "// * MC Implementations *\n";
+    std::cout << "  QL = QuantLib's MultiPathGenerator (full path storage)\n";
+    std::cout << "  RR = Direct process->evolve() calls (JIT-compatible)\n";
+    std::cout << std::endl;
+    std::cout << "// * Approaches Tested *\n";
+    std::cout << "  XAD(QL)   - XAD tape + QuantLib MultiPathGenerator\n";
+    std::cout << "  XAD(RR)   - XAD tape + direct evolve (baseline for JIT)\n";
+    std::cout << "  JIT(RR)   - Forge JIT-compiled kernel\n";
+    std::cout << "  JIT-Intrp - XAD JIT graph interpreter (no native code)\n";
+    std::cout << "  JIT-AVX   - Forge JIT + AVX2 SIMD (4 paths/instruction)\n";
+    std::cout << std::endl;
+    std::cout << "// * Instrument *\n";
+    std::cout << "  European payer swaption: 1Y option into 1Y swap\n";
+    std::cout << "  Model: LIBOR Market Model (LMM) with lognormal forwards\n";
+    std::cout << "  Sensitivities: dPrice/dMarketQuotes (9 inputs)\n";
+    std::cout << std::endl;
+
+    using Clock = std::chrono::high_resolution_clock;
+    using Duration = std::chrono::duration<double, std::milli>;
+
+    // Market data setup (same as Stage 4)
+    Calendar calendar = TARGET();
+    Date todaysDate(4, September, 2005);
+    Settings::instance().evaluationDate() = todaysDate;
+    Integer fixingDays = 2;
+    Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+    DayCounter dayCounter = Actual360();
+
+    Size numDeposits = 4;
+    Size numSwaps = 5;
+    std::vector<Period> depoTenors = {1 * Days, 1 * Months, 3 * Months, 6 * Months};
+    std::vector<Period> swapTenors = {1 * Years, 2 * Years, 3 * Years, 4 * Years, 5 * Years};
+
+    std::vector<double> depoRates_val = {0.0350, 0.0365, 0.0380, 0.0400};
+    std::vector<double> swapRates_val = {0.0420, 0.0480, 0.0520, 0.0550, 0.0575};
+
+    Size numMarketQuotes = numDeposits + numSwaps;
+
+    // LMM parameters
+    Size size = 10;
+    Size i_opt = 2;
+    Size j_opt = 2;
+    Size steps = 8;
+
+    // Build base curve and process setup
+    std::vector<Rate> baseZeroRates = {0.0350, 0.0575};
+    std::vector<Date> baseDates = {settlementDate, settlementDate + 6 * Years};
+    auto baseIndex = makeIndex(baseDates, baseZeroRates);
+
+    ext::shared_ptr<LiborForwardModelProcess> baseProcess(
+        new LiborForwardModelProcess(size, baseIndex));
+    ext::shared_ptr<LmCorrelationModel> baseCorrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> baseVolaModel(
+        new LmLinearExponentialVolatilityModel(baseProcess->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    baseProcess->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(baseVolaModel, baseCorrModel)));
+
+    // Grid and timing setup
+    std::vector<Time> fixingTimes = baseProcess->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    Size numFactors = baseProcess->factors();
+    Size exerciseStep = location[i_opt];
+    Size fullGridSteps = grid.size() - 1;
+    Size fullGridRandoms = fullGridSteps * numFactors;
+
+    // Types for MC generators
+    typedef PseudoRandom::rsg_type rsg_type;
+    typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+
+    // Get fair swap rate (same approach as Stage 4)
+    BusinessDayConvention convention = baseIndex->businessDayConvention();
+    Date settlement = baseIndex->forwardingTermStructure()->referenceDate();
+    Date fwdStart = settlement + Period(6 * i_opt, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j_opt, Months);
+
+    Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    // Accrual periods
+    std::vector<double> accrualStart(size), accrualEnd(size);
+    for (Size k = 0; k < size; ++k) {
+        accrualStart[k] = value(baseProcess->accrualStartTimes()[k]);
+        accrualEnd[k] = value(baseProcess->accrualEndTimes()[k]);
+    }
+
+    Size numIntermediates = size + 1;
+
+    // Helper lambda for curve building
+    auto buildCurveAndProcess = [&](const std::vector<double>& depoRates,
+                                    const std::vector<double>& swapRates,
+                                    std::vector<Date>& curveDates,
+                                    std::vector<Rate>& zeroRates) {
+        RelinkableHandle<YieldTermStructure> euriborTS;
+        auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+        euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+        std::vector<ext::shared_ptr<RateHelper>> instruments;
+        for (Size idx = 0; idx < numDeposits; ++idx) {
+            auto depoQuote = ext::make_shared<SimpleQuote>(depoRates[idx]);
+            instruments.push_back(ext::make_shared<DepositRateHelper>(
+                Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                calendar, ModifiedFollowing, true, dayCounter));
+        }
+        for (Size idx = 0; idx < numSwaps; ++idx) {
+            auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+            instruments.push_back(ext::make_shared<SwapRateHelper>(
+                Handle<Quote>(swapQuote), swapTenors[idx],
+                calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                euribor6m));
+        }
+
+        auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+            settlementDate, instruments, dayCounter);
+        yieldCurve->enableExtrapolation();
+
+        curveDates.clear();
+        zeroRates.clear();
+        curveDates.push_back(settlementDate);
+        zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+        Date endDate = settlementDate + 6 * Years;
+        curveDates.push_back(endDate);
+        zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+    };
+
+    // Test cases: different path counts
+    std::vector<Size> pathCounts = {10, 100, 1000, 10000};
+    std::vector<std::string> testCaseNames = {"10", "100", "1K", "10K"};
+
+    // Results storage
+    struct ScalingResult {
+        double xad_ql_total;
+        double xad_rrs_total;
+        double jit_rrs_total;
+        double jit_interp_total;
+        double jit_avx_total;
+        double xad_ql_std;
+        double xad_rrs_std;
+        double jit_rrs_std;
+        double jit_interp_std;
+        double jit_avx_std;
+    };
+    std::vector<ScalingResult> results(pathCounts.size());
+
+    Size warmupIterations = 5;
+    Size benchmarkIterations = 10;
+
+    std::cout << "  CONFIGURATION:\n";
+    std::cout << "    Market inputs:    " << numMarketQuotes << " (4 deposits + 5 swaps)\n";
+    std::cout << "    Forward rates:    " << size << " (semi-annual to 5Y)\n";
+    std::cout << "    Time steps:       " << fullGridSteps << "\n";
+    std::cout << "    MC paths tested:  10, 100, 1K, 10K\n";
+    std::cout << "    Warmup/Bench:     " << warmupIterations << "/" << benchmarkIterations << " iterations\n";
+    std::cout << std::endl;
+
+    for (Size tc = 0; tc < pathCounts.size(); ++tc) {
+        Size nrTrails = pathCounts[tc];
+        std::cout << "  Running test case: " << testCaseNames[tc] << " (" << nrTrails << " paths)..." << std::flush;
+
+        // Pre-generate random numbers for this path count
+        rsg_type rsg_base = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+        std::vector<std::vector<double>> allRandoms(nrTrails);
+        for (Size n = 0; n < nrTrails; ++n) {
+            allRandoms[n].resize(fullGridRandoms);
+            const auto& seq = rsg_base.nextSequence();
+            for (Size m = 0; m < fullGridRandoms; ++m) {
+                allRandoms[n][m] = value(seq.value[m]);
+            }
+        }
+
+        // Timing accumulators
+        std::vector<double> xad_ql_times, xad_rrs_times, jit_rrs_times, jit_interp_times, jit_avx_times;
+
+        for (Size iter = 0; iter < warmupIterations + benchmarkIterations; ++iter) {
+            bool recordTiming = (iter >= warmupIterations);
+
+            // =================================================================
+            // XAD (QuantLib) - MultiPathGenerator with XAD tape
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(numDeposits);
+                std::vector<Real> swapRates(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRates);
+                tape.newRecording();
+
+                std::vector<Date> curveDates;
+                std::vector<Rate> zeroRates;
+                std::vector<double> depoRates_dbl(numDeposits), swapRates_dbl(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depoRates_dbl[idx] = value(depositRates[idx]);
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates_dbl[idx] = value(swapRates[idx]);
+                buildCurveAndProcess(depoRates_dbl, swapRates_dbl, curveDates, zeroRates);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<Real> zeroRates_real(zeroRates.begin(), zeroRates.end());
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_real, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate = fwdSwap->fairRate();
+
+                rsg_type rsg_ql = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+                MultiPathGenerator<rsg_type> generator_ql(process, grid, rsg_ql, false);
+
+                Real price = Real(0.0);
+                for (Size n = 0; n < nrTrails; ++n) {
+                    sample_type path = (n % 2) != 0U ? generator_ql.antithetic() : generator_ql.next();
+
+                    Array mcRates(size);
+                    for (Size k = 0; k < size; ++k) {
+                        mcRates[k] = path.value[k][exerciseStep];
+                    }
+
+                    Array dis(size);
+                    Real df = Real(1.0);
+                    for (Size k = 0; k < size; ++k) {
+                        Real accrual = accrualEnd[k] - accrualStart[k];
+                        df = df / (Real(1.0) + mcRates[k] * accrual);
+                        dis[k] = df;
+                    }
+
+                    Real npv = Real(0.0);
+                    for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                        Real accrual = accrualEnd[m] - accrualStart[m];
+                        npv += (swapRate - mcRates[m]) * accrual * dis[m];
+                    }
+                    price += max(npv, Real(0.0));
+                }
+                price /= Real(static_cast<double>(nrTrails));
+
+                tape.registerOutput(price);
+                derivative(price) = 1.0;
+                tape.computeAdjoints();
+
+                auto t_end = Clock::now();
+                if (recordTiming) {
+                    xad_ql_times.push_back(Duration(t_end - t_start).count());
+                }
+                tape.deactivate();
+            }
+
+            // =================================================================
+            // XAD (RR) - Full grid with XAD tape
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(numDeposits);
+                std::vector<Real> swapRates(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRates);
+                tape.newRecording();
+
+                RelinkableHandle<YieldTermStructure> euriborTS;
+                auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<ext::shared_ptr<RateHelper>> instruments;
+                for (Size idx = 0; idx < numDeposits; ++idx) {
+                    auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                    instruments.push_back(ext::make_shared<DepositRateHelper>(
+                        Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                        calendar, ModifiedFollowing, true, dayCounter));
+                }
+                for (Size idx = 0; idx < numSwaps; ++idx) {
+                    auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                    instruments.push_back(ext::make_shared<SwapRateHelper>(
+                        Handle<Quote>(swapQuote), swapTenors[idx],
+                        calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                        euribor6m));
+                }
+
+                auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                    settlementDate, instruments, dayCounter);
+                yieldCurve->enableExtrapolation();
+
+                std::vector<Date> curveDates;
+                std::vector<Real> zeroRates;
+                curveDates.push_back(settlementDate);
+                zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                Date endDate = settlementDate + 6 * Years;
+                curveDates.push_back(endDate);
+                zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                std::vector<Rate> zeroRates_ql;
+                for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate = fwdSwap->fairRate();
+
+                Array initRates = process->initialValues();
+
+                Real price = Real(0.0);
+                for (Size n = 0; n < nrTrails; ++n) {
+                    Array asset(size);
+                    for (Size k = 0; k < size; ++k) asset[k] = initRates[k];
+
+                    Array assetAtExercise(size);
+                    for (Size step = 1; step <= fullGridSteps; ++step) {
+                        Size offset = (step - 1) * numFactors;
+                        Time t = grid[step - 1];
+                        Time dt = grid.dt(step - 1);
+
+                        Array dw(numFactors);
+                        for (Size f = 0; f < numFactors; ++f) {
+                            dw[f] = allRandoms[n][offset + f];
+                        }
+
+                        asset = process->evolve(t, asset, dt, dw);
+
+                        if (step == exerciseStep) {
+                            for (Size k = 0; k < size; ++k) assetAtExercise[k] = asset[k];
+                        }
+                    }
+
+                    Array dis(size);
+                    Real df = Real(1.0);
+                    for (Size k = 0; k < size; ++k) {
+                        Real accrual = accrualEnd[k] - accrualStart[k];
+                        df = df / (Real(1.0) + assetAtExercise[k] * accrual);
+                        dis[k] = df;
+                    }
+
+                    Real npv = Real(0.0);
+                    for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                        Real accrual = accrualEnd[m] - accrualStart[m];
+                        npv += (swapRate - assetAtExercise[m]) * accrual * dis[m];
+                    }
+                    price += max(npv, Real(0.0));
+                }
+                price /= Real(static_cast<double>(nrTrails));
+
+                tape.registerOutput(price);
+                derivative(price) = 1.0;
+                tape.computeAdjoints();
+
+                auto t_end = Clock::now();
+                if (recordTiming) {
+                    xad_rrs_times.push_back(Duration(t_end - t_start).count());
+                }
+                tape.deactivate();
+            }
+
+            // =================================================================
+            // JIT (RR) - ForgeBackend with full grid
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(numDeposits);
+                std::vector<Real> swapRates(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRates);
+                tape.newRecording();
+
+                RelinkableHandle<YieldTermStructure> euriborTS;
+                auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<ext::shared_ptr<RateHelper>> instruments;
+                for (Size idx = 0; idx < numDeposits; ++idx) {
+                    auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                    instruments.push_back(ext::make_shared<DepositRateHelper>(
+                        Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                        calendar, ModifiedFollowing, true, dayCounter));
+                }
+                for (Size idx = 0; idx < numSwaps; ++idx) {
+                    auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                    instruments.push_back(ext::make_shared<SwapRateHelper>(
+                        Handle<Quote>(swapQuote), swapTenors[idx],
+                        calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                        euribor6m));
+                }
+
+                auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                    settlementDate, instruments, dayCounter);
+                yieldCurve->enableExtrapolation();
+
+                std::vector<Date> curveDates;
+                std::vector<Real> zeroRates;
+                curveDates.push_back(settlementDate);
+                zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                Date endDate = settlementDate + 6 * Years;
+                curveDates.push_back(endDate);
+                zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                std::vector<Rate> zeroRates_ql;
+                for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate_tape = fwdSwap->fairRate();
+
+                Array initRates = process->initialValues();
+
+                // Jacobian computation
+                std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+                for (Size k = 0; k < size; ++k) {
+                    if (initRates[k].shouldRecord()) {
+                        tape.clearDerivatives();
+                        tape.registerOutput(initRates[k]);
+                        derivative(initRates[k]) = 1.0;
+                        tape.computeAdjoints();
+
+                        double* jac_row = jacobian.data() + k * numMarketQuotes;
+                        for (Size m = 0; m < numDeposits; ++m)
+                            jac_row[m] = derivative(depositRates[m]);
+                        for (Size m = 0; m < numSwaps; ++m)
+                            jac_row[numDeposits + m] = derivative(swapRates[m]);
+                    }
+                }
+                if (swapRate_tape.shouldRecord()) {
+                    tape.clearDerivatives();
+                    tape.registerOutput(swapRate_tape);
+                    derivative(swapRate_tape) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + size * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates[m]);
+                }
+                tape.deactivate();
+
+                // JIT kernel creation
+                auto forgeBackend = std::make_unique<xad::forge::ForgeBackend<double>>(false);
+                xad::JITCompiler<double> jit(std::move(forgeBackend));
+
+                std::vector<xad::AD> jit_initRates(size);
+                xad::AD jit_swapRate;
+                std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+                for (Size k = 0; k < size; ++k) {
+                    jit_initRates[k] = xad::AD(value(initRates[k]));
+                    jit.registerInput(jit_initRates[k]);
+                }
+                jit_swapRate = xad::AD(value(swapRate_tape));
+                jit.registerInput(jit_swapRate);
+                for (Size m = 0; m < fullGridRandoms; ++m) {
+                    jit_randoms[m] = xad::AD(0.0);
+                    jit.registerInput(jit_randoms[m]);
+                }
+
+                jit.newRecording();
+
+                std::vector<xad::AD> asset_jit(size);
+                std::vector<xad::AD> assetAtExercise_jit(size);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = jit_initRates[k];
+
+                for (Size step = 1; step <= fullGridSteps; ++step) {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f) dw[f] = jit_randoms[offset + f];
+
+                    Array asset_arr(size);
+                    for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                    Array evolved = process->evolve(t, asset_arr, dt, dw);
+                    for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                    if (step == exerciseStep) {
+                        for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                    }
+                }
+
+                std::vector<xad::AD> dis_jit(size);
+                xad::AD df_jit = xad::AD(1.0);
+                for (Size k = 0; k < size; ++k) {
+                    double accrual = accrualEnd[k] - accrualStart[k];
+                    df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                    dis_jit[k] = df_jit;
+                }
+
+                xad::AD jit_npv = xad::AD(0.0);
+                for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                    double accrual = accrualEnd[m] - accrualStart[m];
+                    jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+                }
+
+                xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+                jit.registerOutput(jit_payoff);
+
+                // Compile the JIT kernel before MC loop
+                jit.compile();
+
+                // MC execution
+                double mcPrice = 0.0;
+                std::vector<double> dPrice_dInitRates(size, 0.0);
+                double dPrice_dSwapRate = 0.0;
+
+                const auto& graph = jit.getGraph();
+                uint32_t outputSlot = graph.output_ids[0];
+
+                for (Size n = 0; n < nrTrails; ++n) {
+                    for (Size k = 0; k < size; ++k) value(jit_initRates[k]) = value(initRates[k]);
+                    value(jit_swapRate) = value(swapRate_tape);
+                    for (Size m = 0; m < fullGridRandoms; ++m) value(jit_randoms[m]) = allRandoms[n][m];
+
+                    double payoff_value;
+                    jit.forward(&payoff_value);
+                    mcPrice += payoff_value;
+
+                    jit.clearDerivatives();
+                    jit.setDerivative(outputSlot, 1.0);
+                    jit.computeAdjoints();
+
+                    for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] += jit.derivative(graph.input_ids[k]);
+                    dPrice_dSwapRate += jit.derivative(graph.input_ids[size]);
+                }
+
+                mcPrice /= static_cast<double>(nrTrails);
+                for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+                dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+                // Chain rule
+                std::vector<double> dPrice_dIntermediates(numIntermediates);
+                for (Size k = 0; k < size; ++k) dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+                dPrice_dIntermediates[size] = dPrice_dSwapRate;
+
+                std::vector<double> dPrice_market(numMarketQuotes);
+                applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                               numIntermediates, numMarketQuotes);
+
+                auto t_end = Clock::now();
+                if (recordTiming) {
+                    jit_rrs_times.push_back(Duration(t_end - t_start).count());
+                }
+            }
+
+            // =================================================================
+            // JIT Interpreter (RR) - JITGraphInterpreter with full grid
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(numDeposits);
+                std::vector<Real> swapRates(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRates);
+                tape.newRecording();
+
+                RelinkableHandle<YieldTermStructure> euriborTS;
+                auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<ext::shared_ptr<RateHelper>> instruments;
+                for (Size idx = 0; idx < numDeposits; ++idx) {
+                    auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                    instruments.push_back(ext::make_shared<DepositRateHelper>(
+                        Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                        calendar, ModifiedFollowing, true, dayCounter));
+                }
+                for (Size idx = 0; idx < numSwaps; ++idx) {
+                    auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                    instruments.push_back(ext::make_shared<SwapRateHelper>(
+                        Handle<Quote>(swapQuote), swapTenors[idx],
+                        calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                        euribor6m));
+                }
+
+                auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                    settlementDate, instruments, dayCounter);
+                yieldCurve->enableExtrapolation();
+
+                std::vector<Date> curveDates;
+                std::vector<Real> zeroRates;
+                curveDates.push_back(settlementDate);
+                zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                Date endDate = settlementDate + 6 * Years;
+                curveDates.push_back(endDate);
+                zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                std::vector<Rate> zeroRates_ql;
+                for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate_tape = fwdSwap->fairRate();
+
+                Array initRates = process->initialValues();
+
+                // Jacobian computation
+                std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+                for (Size k = 0; k < size; ++k) {
+                    if (initRates[k].shouldRecord()) {
+                        tape.clearDerivatives();
+                        tape.registerOutput(initRates[k]);
+                        derivative(initRates[k]) = 1.0;
+                        tape.computeAdjoints();
+
+                        double* jac_row = jacobian.data() + k * numMarketQuotes;
+                        for (Size m = 0; m < numDeposits; ++m)
+                            jac_row[m] = derivative(depositRates[m]);
+                        for (Size m = 0; m < numSwaps; ++m)
+                            jac_row[numDeposits + m] = derivative(swapRates[m]);
+                    }
+                }
+                if (swapRate_tape.shouldRecord()) {
+                    tape.clearDerivatives();
+                    tape.registerOutput(swapRate_tape);
+                    derivative(swapRate_tape) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + size * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates[m]);
+                }
+                tape.deactivate();
+
+                // JIT kernel creation with interpreter
+                xad::JITCompiler<double> jit;  // Default: JITGraphInterpreter
+
+                std::vector<xad::AD> jit_initRates(size);
+                xad::AD jit_swapRate;
+                std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+                for (Size k = 0; k < size; ++k) {
+                    jit_initRates[k] = xad::AD(value(initRates[k]));
+                    jit.registerInput(jit_initRates[k]);
+                }
+                jit_swapRate = xad::AD(value(swapRate_tape));
+                jit.registerInput(jit_swapRate);
+                for (Size m = 0; m < fullGridRandoms; ++m) {
+                    jit_randoms[m] = xad::AD(0.0);
+                    jit.registerInput(jit_randoms[m]);
+                }
+
+                jit.newRecording();
+
+                std::vector<xad::AD> asset_jit(size);
+                std::vector<xad::AD> assetAtExercise_jit(size);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = jit_initRates[k];
+
+                for (Size step = 1; step <= fullGridSteps; ++step) {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f) dw[f] = jit_randoms[offset + f];
+
+                    Array asset_arr(size);
+                    for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                    Array evolved = process->evolve(t, asset_arr, dt, dw);
+                    for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                    if (step == exerciseStep) {
+                        for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                    }
+                }
+
+                std::vector<xad::AD> dis_jit(size);
+                xad::AD df_jit = xad::AD(1.0);
+                for (Size k = 0; k < size; ++k) {
+                    double accrual = accrualEnd[k] - accrualStart[k];
+                    df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                    dis_jit[k] = df_jit;
+                }
+
+                xad::AD jit_npv = xad::AD(0.0);
+                for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                    double accrual = accrualEnd[m] - accrualStart[m];
+                    jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+                }
+
+                xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+                jit.registerOutput(jit_payoff);
+
+                // Compile the JIT kernel before MC loop
+                jit.compile();
+
+                // MC execution
+                double mcPrice = 0.0;
+                std::vector<double> dPrice_dInitRates(size, 0.0);
+                double dPrice_dSwapRate = 0.0;
+
+                const auto& graph = jit.getGraph();
+                uint32_t outputSlot = graph.output_ids[0];
+
+                for (Size n = 0; n < nrTrails; ++n) {
+                    for (Size k = 0; k < size; ++k) value(jit_initRates[k]) = value(initRates[k]);
+                    value(jit_swapRate) = value(swapRate_tape);
+                    for (Size m = 0; m < fullGridRandoms; ++m) value(jit_randoms[m]) = allRandoms[n][m];
+
+                    double payoff_value;
+                    jit.forward(&payoff_value);
+                    mcPrice += payoff_value;
+
+                    jit.clearDerivatives();
+                    jit.setDerivative(outputSlot, 1.0);
+                    jit.computeAdjoints();
+
+                    for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] += jit.derivative(graph.input_ids[k]);
+                    dPrice_dSwapRate += jit.derivative(graph.input_ids[size]);
+                }
+
+                mcPrice /= static_cast<double>(nrTrails);
+                for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+                dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+                // Chain rule
+                std::vector<double> dPrice_dIntermediates(numIntermediates);
+                for (Size k = 0; k < size; ++k) dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+                dPrice_dIntermediates[size] = dPrice_dSwapRate;
+
+                std::vector<double> dPrice_market(numMarketQuotes);
+                applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                               numIntermediates, numMarketQuotes);
+
+                auto t_end = Clock::now();
+                if (recordTiming) {
+                    jit_interp_times.push_back(Duration(t_end - t_start).count());
+                }
+            }
+
+            // =================================================================
+            // JIT AVX (RR) - ForgeBackendAVX with 4-path batching
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(numDeposits);
+                std::vector<Real> swapRates(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRates);
+                tape.newRecording();
+
+                RelinkableHandle<YieldTermStructure> euriborTS;
+                auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<ext::shared_ptr<RateHelper>> instruments;
+                for (Size idx = 0; idx < numDeposits; ++idx) {
+                    auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                    instruments.push_back(ext::make_shared<DepositRateHelper>(
+                        Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                        calendar, ModifiedFollowing, true, dayCounter));
+                }
+                for (Size idx = 0; idx < numSwaps; ++idx) {
+                    auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                    instruments.push_back(ext::make_shared<SwapRateHelper>(
+                        Handle<Quote>(swapQuote), swapTenors[idx],
+                        calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                        euribor6m));
+                }
+
+                auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                    settlementDate, instruments, dayCounter);
+                yieldCurve->enableExtrapolation();
+
+                std::vector<Date> curveDates;
+                std::vector<Real> zeroRates;
+                curveDates.push_back(settlementDate);
+                zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                Date endDate = settlementDate + 6 * Years;
+                curveDates.push_back(endDate);
+                zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                std::vector<Rate> zeroRates_ql;
+                for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate_tape = fwdSwap->fairRate();
+
+                Array initRates = process->initialValues();
+
+                // Jacobian computation
+                std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+                for (Size k = 0; k < size; ++k) {
+                    if (initRates[k].shouldRecord()) {
+                        tape.clearDerivatives();
+                        tape.registerOutput(initRates[k]);
+                        derivative(initRates[k]) = 1.0;
+                        tape.computeAdjoints();
+
+                        double* jac_row = jacobian.data() + k * numMarketQuotes;
+                        for (Size m = 0; m < numDeposits; ++m)
+                            jac_row[m] = derivative(depositRates[m]);
+                        for (Size m = 0; m < numSwaps; ++m)
+                            jac_row[numDeposits + m] = derivative(swapRates[m]);
+                    }
+                }
+                if (swapRate_tape.shouldRecord()) {
+                    tape.clearDerivatives();
+                    tape.registerOutput(swapRate_tape);
+                    derivative(swapRate_tape) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + size * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates[m]);
+                }
+                tape.deactivate();
+
+                // JIT kernel creation for AVX
+                xad::JITCompiler<double> jit;
+
+                std::vector<xad::AD> jit_initRates(size);
+                xad::AD jit_swapRate;
+                std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+                for (Size k = 0; k < size; ++k) {
+                    jit_initRates[k] = xad::AD(value(initRates[k]));
+                    jit.registerInput(jit_initRates[k]);
+                }
+                jit_swapRate = xad::AD(value(swapRate_tape));
+                jit.registerInput(jit_swapRate);
+                for (Size m = 0; m < fullGridRandoms; ++m) {
+                    jit_randoms[m] = xad::AD(0.0);
+                    jit.registerInput(jit_randoms[m]);
+                }
+
+                jit.newRecording();
+
+                std::vector<xad::AD> asset_jit(size);
+                std::vector<xad::AD> assetAtExercise_jit(size);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = jit_initRates[k];
+
+                for (Size step = 1; step <= fullGridSteps; ++step) {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f) dw[f] = jit_randoms[offset + f];
+
+                    Array asset_arr(size);
+                    for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                    Array evolved = process->evolve(t, asset_arr, dt, dw);
+                    for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                    if (step == exerciseStep) {
+                        for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                    }
+                }
+
+                std::vector<xad::AD> dis_jit(size);
+                xad::AD df_jit = xad::AD(1.0);
+                for (Size k = 0; k < size; ++k) {
+                    double accrual = accrualEnd[k] - accrualStart[k];
+                    df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                    dis_jit[k] = df_jit;
+                }
+
+                xad::AD jit_npv = xad::AD(0.0);
+                for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                    double accrual = accrualEnd[m] - accrualStart[m];
+                    jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+                }
+
+                xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+                jit.registerOutput(jit_payoff);
+
+                // Get the JIT graph
+                const auto& jitGraph = jit.getGraph();
+
+                // Deactivate jit - we still use it for adjoints but don't need it active
+                jit.deactivate();
+
+                // AVX backend with 4-path batching - compiles directly from JITGraph
+                xad::forge::ForgeBackendAVX<double> avxBackend(false);
+                avxBackend.compile(jitGraph);
+
+                // MC execution with 4-path batching
+                double mcPrice = 0.0;
+                std::vector<double> dPrice_dInitRates(size, 0.0);
+                double dPrice_dSwapRate = 0.0;
+
+                constexpr int BATCH_SIZE = xad::forge::ForgeBackendAVX<double>::VECTOR_WIDTH;
+                Size numBatches = (nrTrails + BATCH_SIZE - 1) / BATCH_SIZE;
+
+                std::vector<double> inputBatch(BATCH_SIZE);
+                std::vector<double> outputBatch(BATCH_SIZE);
+
+                // Pre-compute input buffer indices for gradient retrieval
+                std::vector<size_t> inputBufferIndices;
+                inputBufferIndices.reserve(avxBackend.numInputs());
+                for (auto inputId : avxBackend.inputIds()) {
+                    inputBufferIndices.push_back(avxBackend.buffer()->getBufferIndex(inputId));
+                }
+
+                for (Size batch = 0; batch < numBatches; ++batch) {
+                    Size batchStart = batch * BATCH_SIZE;
+                    Size actualBatchSize = std::min(static_cast<Size>(BATCH_SIZE), nrTrails - batchStart);
+
+                    // Set initRates (same for all paths in batch)
+                    for (Size k = 0; k < size; ++k) {
+                        for (int lane = 0; lane < BATCH_SIZE; ++lane)
+                            inputBatch[lane] = value(initRates[k]);
+                        avxBackend.setInput(k, inputBatch.data());
+                    }
+
+                    // Set swapRate (same for all paths in batch)
+                    for (int lane = 0; lane < BATCH_SIZE; ++lane)
+                        inputBatch[lane] = value(swapRate_tape);
+                    avxBackend.setInput(size, inputBatch.data());
+
+                    // Set random numbers (different for each path in batch)
+                    for (Size m = 0; m < fullGridRandoms; ++m) {
+                        for (int lane = 0; lane < BATCH_SIZE; ++lane) {
+                            Size pathIdx = batchStart + lane;
+                            inputBatch[lane] = (pathIdx < nrTrails) ? allRandoms[pathIdx][m] : 0.0;
+                        }
+                        avxBackend.setInput(size + 1 + m, inputBatch.data());
+                    }
+
+                    // Execute forward + backward in one call
+                    // Gradients are laid out as: numInputs * VECTOR_WIDTH doubles
+                    std::size_t numInputs = avxBackend.numInputs();
+                    std::vector<double> inputGradients(numInputs * BATCH_SIZE);
+                    avxBackend.forwardAndBackward(outputBatch.data(), inputGradients.data());
+
+                    // Accumulate MC price
+                    for (Size lane = 0; lane < actualBatchSize; ++lane) {
+                        mcPrice += outputBatch[lane];
+                    }
+
+                    // Accumulate gradients for initRates
+                    for (Size k = 0; k < size; ++k) {
+                        for (Size lane = 0; lane < actualBatchSize; ++lane) {
+                            dPrice_dInitRates[k] += inputGradients[k * BATCH_SIZE + lane];
+                        }
+                    }
+
+                    // Accumulate gradient for swap rate
+                    for (Size lane = 0; lane < actualBatchSize; ++lane) {
+                        dPrice_dSwapRate += inputGradients[size * BATCH_SIZE + lane];
+                    }
+                }
+
+                mcPrice /= static_cast<double>(nrTrails);
+                for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+                dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+                // Chain rule
+                std::vector<double> dPrice_dIntermediates(numIntermediates);
+                for (Size k = 0; k < size; ++k) dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+                dPrice_dIntermediates[size] = dPrice_dSwapRate;
+
+                std::vector<double> dPrice_market(numMarketQuotes);
+                applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                               numIntermediates, numMarketQuotes);
+
+                auto t_end = Clock::now();
+                if (recordTiming) {
+                    jit_avx_times.push_back(Duration(t_end - t_start).count());
+                }
+            }
+        }
+
+        // Compute averages
+        auto avg = [](const std::vector<double>& v) {
+            if (v.empty()) return 0.0;
+            double sum = 0.0;
+            for (double x : v) sum += x;
+            return sum / static_cast<double>(v.size());
+        };
+
+        auto stddev = [&avg](const std::vector<double>& v) {
+            if (v.size() <= 1) return 0.0;
+            double mean = avg(v);
+            double sq_sum = 0.0;
+            for (double x : v) {
+                double diff = x - mean;
+                sq_sum += diff * diff;
+            }
+            return std::sqrt(sq_sum / (v.size() - 1));
+        };
+
+        results[tc].xad_ql_total = avg(xad_ql_times);
+        results[tc].xad_rrs_total = avg(xad_rrs_times);
+        results[tc].jit_rrs_total = avg(jit_rrs_times);
+        results[tc].jit_interp_total = avg(jit_interp_times);
+        results[tc].jit_avx_total = avg(jit_avx_times);
+        results[tc].xad_ql_std = stddev(xad_ql_times);
+        results[tc].xad_rrs_std = stddev(xad_rrs_times);
+        results[tc].jit_rrs_std = stddev(jit_rrs_times);
+        results[tc].jit_interp_std = stddev(jit_interp_times);
+        results[tc].jit_avx_std = stddev(jit_avx_times);
+
+        std::cout << " Done." << std::endl;
+    }
+
+    // Print results table (BenchmarkDotNet-style)
+    std::cout << std::endl;
+    std::cout << "// * Results: Simple Swaption *\n";
+    std::cout << std::endl;
+
+    std::cout << "| Paths  | XAD(QL) | XAD(RR) | JIT(RR) | JIT-Intrp | JIT-AVX | Speedup |\n";
+    std::cout << "|-------:|--------:|--------:|--------:|----------:|--------:|--------:|\n";
+
+    for (Size tc = 0; tc < pathCounts.size(); ++tc) {
+        double speedup = results[tc].xad_rrs_total / results[tc].jit_rrs_total;
+        std::string pathStr = BenchmarkUtils::formatPathCount(static_cast<int>(pathCounts[tc]));
+        std::cout << "| " << std::setw(6) << pathStr << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(8) << results[tc].xad_ql_total << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(8) << results[tc].xad_rrs_total << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(8) << results[tc].jit_rrs_total << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(10) << results[tc].jit_interp_total << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(8) << results[tc].jit_avx_total << " |"
+                  << std::fixed << std::setprecision(2) << std::setw(7) << speedup << "x |\n";
+    }
+
+    std::cout << std::endl;
+    std::cout << "Speedup = XAD(RR) / JIT(RR). All times in ms.\n";
+    std::cout << std::endl;
+
+    // Basic verification
+    BOOST_CHECK(results[0].xad_ql_total > 0.0);
+    BOOST_CHECK(results[0].jit_rrs_total > 0.0);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Larger Swaption Benchmark (5Y into 5Y)
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testBenchmark_LargerSwaptionScaling)
+{
+    BOOST_TEST_MESSAGE("Running Larger Swaption Scaling Benchmark...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  XAD JIT BENCHMARK: Larger Swaption (5Y into 5Y)\n";
+    std::cout << "=============================================================================\n";
+
+    // BenchmarkDotNet-style environment info
+    BenchmarkUtils::printEnvironmentHeader();
+
+    std::cout << "// * Benchmark Description *\n";
+    std::cout << "  Approximates a more realistic scenario: larger computation graph,\n";
+    std::cout << "  more forward rates, longer simulation.\n";
+    std::cout << std::endl;
+    std::cout << "// * MC Implementation *\n";
+    std::cout << "  All approaches use direct process->evolve() calls (JIT-compatible).\n";
+    std::cout << "  The JIT kernel is recorded once and reused for all MC paths.\n";
+    std::cout << std::endl;
+    std::cout << "// * Approaches Tested *\n";
+    std::cout << "  XAD       - XAD tape + direct evolve\n";
+    std::cout << "  JIT       - Forge JIT-compiled kernel\n";
+    std::cout << "  JIT-Intrp - XAD JIT graph interpreter (no native code)\n";
+    std::cout << "  JIT-AVX   - Forge JIT + AVX2 SIMD (4 paths/instruction)\n";
+    std::cout << std::endl;
+    std::cout << "// * Instrument *\n";
+    std::cout << "  European receiver swaption: 5Y option into 5Y swap (10Y total)\n";
+    std::cout << "  Model: LIBOR Market Model (LMM) with 20 forward rates\n";
+    std::cout << "  Sensitivities: dPrice/dMarketQuotes (14 inputs)\n";
+    std::cout << std::endl;
+
+    using Clock = std::chrono::high_resolution_clock;
+    using Duration = std::chrono::duration<double, std::milli>;
+
+    // Market data setup - PRODUCTION-LIKE CONFIGURATION
+    Calendar calendar = TARGET();
+    Date todaysDate(4, September, 2005);
+    Settings::instance().evaluationDate() = todaysDate;
+    Integer fixingDays = 2;
+    Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+    DayCounter dayCounter = Actual360();
+
+    // Larger setup: 4 deposits + 10 swaps = 14 market inputs (up to 10Y)
+    Size numDeposits = 4;
+    Size numSwaps = 10;
+    std::vector<Period> depoTenors = {1 * Days, 1 * Months, 3 * Months, 6 * Months};
+    std::vector<Period> swapTenors = {1 * Years, 2 * Years, 3 * Years, 4 * Years, 5 * Years,
+                                      6 * Years, 7 * Years, 8 * Years, 9 * Years, 10 * Years};
+
+    // Realistic deposit rates (upward sloping short end)
+    std::vector<double> depoRates_val = {0.0320, 0.0335, 0.0355, 0.0375};
+    // Realistic swap rates (upward sloping curve to 10Y)
+    std::vector<double> swapRates_val = {0.0400, 0.0435, 0.0460, 0.0480, 0.0495,
+                                         0.0505, 0.0515, 0.0522, 0.0528, 0.0532};
+
+    Size numMarketQuotes = numDeposits + numSwaps;
+
+    // LMM parameters: 20 forward rates (semi-annual to 10Y)
+    // Swaption: 5Y option into 5Y swap (exercises at 5Y, underlying matures at 10Y)
+    Size size = 20;      // Semi-annual rates to 10Y
+    Size i_opt = 10;     // Option starts at 5Y (10 × 6 months)
+    Size j_opt = 10;     // 5Y swap (10 × 6 months)
+    Size steps = 20;     // Time steps for 5Y simulation
+
+    // Build base curve and process setup - to 12Y (extra buffer for accrual periods)
+    std::vector<Rate> baseZeroRates = {0.0320, 0.0535};
+    std::vector<Date> baseDates = {settlementDate, settlementDate + 12 * Years};
+    auto baseIndex = makeIndex(baseDates, baseZeroRates);
+
+    ext::shared_ptr<LiborForwardModelProcess> baseProcess(
+        new LiborForwardModelProcess(size, baseIndex));
+    ext::shared_ptr<LmCorrelationModel> baseCorrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> baseVolaModel(
+        new LmLinearExponentialVolatilityModel(baseProcess->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    baseProcess->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(baseVolaModel, baseCorrModel)));
+
+    // Grid and timing setup
+    std::vector<Time> fixingTimes = baseProcess->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    Size numFactors = baseProcess->factors();
+    Size exerciseStep = location[i_opt];
+    Size fullGridSteps = grid.size() - 1;
+    Size fullGridRandoms = fullGridSteps * numFactors;
+
+    // Types for MC generators
+    typedef PseudoRandom::rsg_type rsg_type;
+    typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+
+    // Get fair swap rate
+    BusinessDayConvention convention = baseIndex->businessDayConvention();
+    Date settlement = baseIndex->forwardingTermStructure()->referenceDate();
+    Date fwdStart = settlement + Period(6 * i_opt, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j_opt, Months);
+
+    Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    // Accrual periods
+    std::vector<double> accrualStart(size), accrualEnd(size);
+    for (Size k = 0; k < size; ++k) {
+        accrualStart[k] = value(baseProcess->accrualStartTimes()[k]);
+        accrualEnd[k] = value(baseProcess->accrualEndTimes()[k]);
+    }
+
+    Size numIntermediates = size + 1;
+
+    // Helper lambda for curve building
+    auto buildCurveAndProcess = [&](const std::vector<double>& depoRates,
+                                    const std::vector<double>& swapRates,
+                                    std::vector<Date>& curveDates,
+                                    std::vector<Rate>& zeroRates) {
+        RelinkableHandle<YieldTermStructure> euriborTS;
+        auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+        euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+        std::vector<ext::shared_ptr<RateHelper>> instruments;
+        for (Size idx = 0; idx < numDeposits; ++idx) {
+            auto depoQuote = ext::make_shared<SimpleQuote>(depoRates[idx]);
+            instruments.push_back(ext::make_shared<DepositRateHelper>(
+                Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                calendar, ModifiedFollowing, true, dayCounter));
+        }
+        for (Size idx = 0; idx < numSwaps; ++idx) {
+            auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+            instruments.push_back(ext::make_shared<SwapRateHelper>(
+                Handle<Quote>(swapQuote), swapTenors[idx],
+                calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                euribor6m));
+        }
+
+        auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+            settlementDate, instruments, dayCounter);
+        yieldCurve->enableExtrapolation();
+
+        curveDates.clear();
+        zeroRates.clear();
+        curveDates.push_back(settlementDate);
+        zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+        Date endDate = settlementDate + 12 * Years;  // Extended for 10Y instrument + buffer
+        curveDates.push_back(endDate);
+        zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+    };
+
+    // Test configuration - scaling over different path counts
+    std::vector<Size> pathCounts = {10, 100, 1000, 10000};
+    Size maxPaths = pathCounts.back();
+    Size warmupIterations = 2;
+    Size benchmarkIterations = 3;
+
+    std::cout << "  CONFIGURATION:\n";
+    std::cout << "    Market inputs:    " << numMarketQuotes << " (" << numDeposits << " deposits + " << numSwaps << " swaps)\n";
+    std::cout << "    Forward rates:    " << size << " (semi-annual to 10Y)\n";
+    std::cout << "    Time steps:       " << fullGridSteps << "\n";
+    std::cout << "    MC paths tested:  10, 100, 1K, 10K\n";
+    std::cout << "    Warmup/Bench:     " << warmupIterations << "/" << benchmarkIterations << " iterations\n";
+    std::cout << std::endl;
+
+    // Pre-generate random numbers for max paths
+    std::cout << "  Generating " << maxPaths << " x " << fullGridRandoms << " random numbers..." << std::flush;
+    rsg_type rsg_base = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+    std::vector<std::vector<double>> allRandoms(maxPaths);
+    for (Size n = 0; n < maxPaths; ++n) {
+        allRandoms[n].resize(fullGridRandoms);
+        const auto& seq = rsg_base.nextSequence();
+        for (Size m = 0; m < fullGridRandoms; ++m) {
+            allRandoms[n][m] = value(seq.value[m]);
+        }
+    }
+    std::cout << " Done." << std::endl;
+
+    // Results storage for scaling table
+    struct ScalingResult {
+        double xad_time;
+        double jit_time;
+        double jit_interp_time;
+        double jit_avx_time;
+    };
+    std::vector<ScalingResult> scalingResults(pathCounts.size());
+
+    // Store final prices/derivs from largest path count
+    double xad_price = 0.0, jit_price = 0.0, jit_avx_price = 0.0;
+    std::vector<double> xad_derivs, jit_derivs, jit_avx_derivs;
+
+    // Run benchmarks for each path count
+    for (Size pathIdx = 0; pathIdx < pathCounts.size(); ++pathIdx) {
+        Size nrTrails = pathCounts[pathIdx];
+        std::cout << "\n  --- Running with " << nrTrails << " paths ---\n";
+
+        // Timing accumulators for this path count
+        std::vector<double> xad_rrs_times, jit_rrs_times, jit_interp_times, jit_avx_times;
+
+        for (Size iter = 0; iter < warmupIterations + benchmarkIterations; ++iter) {
+            bool recordTiming = (iter >= warmupIterations);
+            bool isLast = (iter == warmupIterations + benchmarkIterations - 1) &&
+                          (pathIdx == pathCounts.size() - 1);  // Only save details for largest path count
+
+            std::cout << "  [" << (iter < warmupIterations ? "Warmup" : "Bench") << " "
+                      << (iter < warmupIterations ? iter + 1 : iter - warmupIterations + 1) << "/"
+                      << (iter < warmupIterations ? warmupIterations : benchmarkIterations) << "] ";
+
+        // =================================================================
+        // XAD (RR) - Full grid with XAD tape (with granular timing)
+        // =================================================================
+        std::cout << "XAD..." << std::flush;
+        {
+            auto t_start = Clock::now();
+            auto t_phase = Clock::now();
+
+            // Phase timing accumulators (only for last iteration)
+            double t_bootstrap_fwd = 0, t_mc_fwd = 0, t_backward = 0;
+
+            using tape_type = Real::tape_type;
+            tape_type tape;
+
+            std::vector<Real> depositRates(numDeposits);
+            std::vector<Real> swapRates(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+            tape.registerInputs(depositRates);
+            tape.registerInputs(swapRates);
+            tape.newRecording();
+
+            RelinkableHandle<YieldTermStructure> euriborTS;
+            auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+            euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                instruments.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                instruments.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m));
+            }
+
+            auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments, dayCounter);
+            yieldCurve->enableExtrapolation();
+
+            std::vector<Date> curveDates;
+            std::vector<Real> zeroRates;
+            curveDates.push_back(settlementDate);
+            zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate = settlementDate + 12 * Years;  // Extended for 10Y instrument + buffer
+            curveDates.push_back(endDate);
+            zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates_ql;
+            for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure;
+            ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+            index->addFixing(Date(2, September, 2005), 0.04);
+            termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process(
+                new LiborForwardModelProcess(size, index));
+            process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(
+                    ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                    ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index, 0.0, index->dayCounter()));
+            fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index->forwardingTermStructure()));
+            Real swapRate = fwdSwap->fairRate();
+
+            Array initRates = process->initialValues();
+
+            if (isLast) {
+                t_bootstrap_fwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // MC pricing with full grid
+            Real price = Real(0.0);
+            for (Size n = 0; n < nrTrails; ++n) {
+                Array asset(size);
+                for (Size k = 0; k < size; ++k) asset[k] = initRates[k];
+
+                Array assetAtExercise(size);
+                for (Size step = 1; step <= fullGridSteps; ++step) {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f)
+                        dw[f] = Real(allRandoms[n][offset + f]);
+
+                    asset = process->evolve(t, asset, dt, dw);
+
+                    if (step == exerciseStep) {
+                        for (Size k = 0; k < size; ++k) assetAtExercise[k] = asset[k];
+                    }
+                }
+
+                Array dis(size);
+                Real df = Real(1.0);
+                for (Size k = 0; k < size; ++k) {
+                    Real accrual = accrualEnd[k] - accrualStart[k];
+                    df = df / (Real(1.0) + assetAtExercise[k] * accrual);
+                    dis[k] = df;
+                }
+
+                Real npv = Real(0.0);
+                for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                    Real accrual = accrualEnd[m] - accrualStart[m];
+                    npv += (swapRate - assetAtExercise[m]) * accrual * dis[m];
+                }
+                price += max(npv, Real(0.0));
+            }
+            price /= Real(static_cast<double>(nrTrails));
+
+            if (isLast) {
+                t_mc_fwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            tape.registerOutput(price);
+            derivative(price) = 1.0;
+            tape.computeAdjoints();
+
+            if (isLast) {
+                t_backward = Duration(Clock::now() - t_phase).count();
+
+                // Report XAD timing breakdown
+                std::cout << "\n    [XAD Details: " << tape.getNumStatements() << " tape statements]\n";
+                std::cout << "      Bootstrap fwd:   " << std::fixed << std::setprecision(1) << t_bootstrap_fwd << " ms\n";
+                std::cout << "      MC fwd (" << nrTrails << " paths): " << std::fixed << std::setprecision(1) << t_mc_fwd << " ms\n";
+                std::cout << "      Backward:        " << std::fixed << std::setprecision(1) << t_backward << " ms\n";
+
+                xad_price = value(price);
+                xad_derivs.resize(numMarketQuotes);
+                for (Size m = 0; m < numDeposits; ++m)
+                    xad_derivs[m] = derivative(depositRates[m]);
+                for (Size m = 0; m < numSwaps; ++m)
+                    xad_derivs[numDeposits + m] = derivative(swapRates[m]);
+            }
+
+            auto t_end = Clock::now();
+            if (recordTiming) {
+                xad_rrs_times.push_back(Duration(t_end - t_start).count());
+            }
+            tape.deactivate();
+        }
+
+        // =================================================================
+        // JIT (RR) - Full grid with JIT compilation (with granular timing)
+        // =================================================================
+        std::cout << " JIT..." << std::flush;
+        {
+            auto t_start = Clock::now();
+            auto t_phase = Clock::now();
+
+            // Phase timing accumulators (only for last iteration to avoid overhead)
+            double t_bootstrap_fwd = 0, t_bootstrap_bwd = 0, t_kernel_record = 0;
+            double t_kernel_compile = 0, t_mc_exec = 0, t_chain_rule = 0;
+
+            using tape_type = Real::tape_type;
+            tape_type tape;
+
+            std::vector<Real> depositRates(numDeposits);
+            std::vector<Real> swapRates(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+            tape.registerInputs(depositRates);
+            tape.registerInputs(swapRates);
+            tape.newRecording();
+
+            RelinkableHandle<YieldTermStructure> euriborTS;
+            auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+            euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                instruments.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                instruments.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m));
+            }
+
+            auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments, dayCounter);
+            yieldCurve->enableExtrapolation();
+
+            std::vector<Date> curveDates;
+            std::vector<Real> zeroRates;
+            curveDates.push_back(settlementDate);
+            zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate = settlementDate + 12 * Years;  // Extended for 10Y instrument + buffer
+            curveDates.push_back(endDate);
+            zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates_ql;
+            for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure;
+            ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+            index->addFixing(Date(2, September, 2005), 0.04);
+            termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process(
+                new LiborForwardModelProcess(size, index));
+            process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(
+                    ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                    ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index, 0.0, index->dayCounter()));
+            fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index->forwardingTermStructure()));
+            Real swapRate_tape = fwdSwap->fairRate();
+
+            Array initRates = process->initialValues();
+
+            if (isLast) {
+                t_bootstrap_fwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // Jacobian computation (bootstrap backward)
+            std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+            for (Size k = 0; k < size; ++k) {
+                if (initRates[k].shouldRecord()) {
+                    tape.clearDerivatives();
+                    tape.registerOutput(initRates[k]);
+                    derivative(initRates[k]) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + k * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates[m]);
+                }
+            }
+            if (swapRate_tape.shouldRecord()) {
+                tape.clearDerivatives();
+                tape.registerOutput(swapRate_tape);
+                derivative(swapRate_tape) = 1.0;
+                tape.computeAdjoints();
+
+                double* jac_row = jacobian.data() + size * numMarketQuotes;
+                for (Size m = 0; m < numDeposits; ++m)
+                    jac_row[m] = derivative(depositRates[m]);
+                for (Size m = 0; m < numSwaps; ++m)
+                    jac_row[numDeposits + m] = derivative(swapRates[m]);
+            }
+            tape.deactivate();
+
+            if (isLast) {
+                t_bootstrap_bwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // JIT kernel creation (recording)
+            auto forgeBackend = std::make_unique<xad::forge::ForgeBackend<double>>(false);
+            xad::JITCompiler<double> jit(std::move(forgeBackend));
+
+            std::vector<xad::AD> jit_initRates(size);
+            xad::AD jit_swapRate;
+            std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+            for (Size k = 0; k < size; ++k) {
+                jit_initRates[k] = xad::AD(value(initRates[k]));
+                jit.registerInput(jit_initRates[k]);
+            }
+            jit_swapRate = xad::AD(value(swapRate_tape));
+            jit.registerInput(jit_swapRate);
+            for (Size m = 0; m < fullGridRandoms; ++m) {
+                jit_randoms[m] = xad::AD(0.0);
+                jit.registerInput(jit_randoms[m]);
+            }
+
+            jit.newRecording();
+
+            std::vector<xad::AD> asset_jit(size);
+            std::vector<xad::AD> assetAtExercise_jit(size);
+            for (Size k = 0; k < size; ++k) asset_jit[k] = jit_initRates[k];
+
+            for (Size step = 1; step <= fullGridSteps; ++step) {
+                Size offset = (step - 1) * numFactors;
+                Time t = grid[step - 1];
+                Time dt = grid.dt(step - 1);
+
+                Array dw(numFactors);
+                for (Size f = 0; f < numFactors; ++f) dw[f] = jit_randoms[offset + f];
+
+                Array asset_arr(size);
+                for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                Array evolved = process->evolve(t, asset_arr, dt, dw);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                if (step == exerciseStep) {
+                    for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                }
+            }
+
+            std::vector<xad::AD> dis_jit(size);
+            xad::AD df_jit = xad::AD(1.0);
+            for (Size k = 0; k < size; ++k) {
+                double accrual = accrualEnd[k] - accrualStart[k];
+                df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                dis_jit[k] = df_jit;
+            }
+
+            xad::AD jit_npv = xad::AD(0.0);
+            for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                double accrual = accrualEnd[m] - accrualStart[m];
+                jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+            }
+
+            xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+            jit.registerOutput(jit_payoff);
+
+            if (isLast) {
+                t_kernel_record = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // Compile the JIT kernel
+            jit.compile();
+
+            if (isLast) {
+                t_kernel_compile = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // MC execution
+            double mcPrice = 0.0;
+            std::vector<double> dPrice_dInitRates(size, 0.0);
+            double dPrice_dSwapRate = 0.0;
+
+            const auto& graph = jit.getGraph();
+            uint32_t outputSlot = graph.output_ids[0];
+
+            for (Size n = 0; n < nrTrails; ++n) {
+                for (Size k = 0; k < size; ++k) value(jit_initRates[k]) = value(initRates[k]);
+                value(jit_swapRate) = value(swapRate_tape);
+                for (Size m = 0; m < fullGridRandoms; ++m) value(jit_randoms[m]) = allRandoms[n][m];
+
+                double payoff_value;
+                jit.forward(&payoff_value);
+                mcPrice += payoff_value;
+
+                jit.clearDerivatives();
+                jit.setDerivative(outputSlot, 1.0);
+                jit.computeAdjoints();
+
+                for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] += jit.derivative(graph.input_ids[k]);
+                dPrice_dSwapRate += jit.derivative(graph.input_ids[size]);
+            }
+
+            mcPrice /= static_cast<double>(nrTrails);
+            for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+            dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+            if (isLast) {
+                t_mc_exec = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // Chain rule
+            std::vector<double> dPrice_dIntermediates(numIntermediates);
+            for (Size k = 0; k < size; ++k) dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+            dPrice_dIntermediates[size] = dPrice_dSwapRate;
+
+            std::vector<double> dPrice_market(numMarketQuotes);
+            applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                           numIntermediates, numMarketQuotes);
+
+            if (isLast) {
+                t_chain_rule = Duration(Clock::now() - t_phase).count();
+
+                // Report graph size and timing breakdown
+                std::cout << "\n    [JIT Details: " << graph.nodeCount() << " nodes, "
+                          << graph.input_ids.size() << " inputs]\n";
+                std::cout << "      Bootstrap fwd:   " << std::fixed << std::setprecision(1) << t_bootstrap_fwd << " ms\n";
+                std::cout << "      Bootstrap bwd:   " << std::fixed << std::setprecision(1) << t_bootstrap_bwd << " ms\n";
+                std::cout << "      Kernel record:   " << std::fixed << std::setprecision(1) << t_kernel_record << " ms\n";
+                std::cout << "      Kernel compile:  " << std::fixed << std::setprecision(1) << t_kernel_compile << " ms\n";
+                std::cout << "      MC exec (" << nrTrails << " paths): " << std::fixed << std::setprecision(1) << t_mc_exec << " ms\n";
+                std::cout << "      Chain rule:      " << std::fixed << std::setprecision(1) << t_chain_rule << " ms\n";
+
+                jit_price = mcPrice;
+                jit_derivs = dPrice_market;
+            }
+
+            auto t_end = Clock::now();
+            if (recordTiming) {
+                jit_rrs_times.push_back(Duration(t_end - t_start).count());
+            }
+        }
+
+        // =================================================================
+        // JIT Interpreter (RR) - JITGraphInterpreter with full grid
+        // =================================================================
+        std::cout << " JIT-Interp..." << std::flush;
+        {
+            auto t_start = Clock::now();
+
+            using tape_type = Real::tape_type;
+            tape_type tape;
+
+            std::vector<Real> depositRates(numDeposits);
+            std::vector<Real> swapRates(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+            tape.registerInputs(depositRates);
+            tape.registerInputs(swapRates);
+            tape.newRecording();
+
+            RelinkableHandle<YieldTermStructure> euriborTS;
+            auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+            euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                instruments.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                instruments.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m));
+            }
+
+            auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments, dayCounter);
+            yieldCurve->enableExtrapolation();
+
+            std::vector<Date> curveDates;
+            std::vector<Real> zeroRates;
+            curveDates.push_back(settlementDate);
+            zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate = settlementDate + 12 * Years;
+            curveDates.push_back(endDate);
+            zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates_ql;
+            for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure;
+            ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+            index->addFixing(Date(2, September, 2005), 0.04);
+            termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process(
+                new LiborForwardModelProcess(size, index));
+            process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(
+                    ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                    ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index, 0.0, index->dayCounter()));
+            fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index->forwardingTermStructure()));
+            Real swapRate_tape = fwdSwap->fairRate();
+
+            Array initRates = process->initialValues();
+
+            // Jacobian computation
+            std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+            for (Size k = 0; k < size; ++k) {
+                if (initRates[k].shouldRecord()) {
+                    tape.clearDerivatives();
+                    tape.registerOutput(initRates[k]);
+                    derivative(initRates[k]) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + k * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates[m]);
+                }
+            }
+            if (swapRate_tape.shouldRecord()) {
+                tape.clearDerivatives();
+                tape.registerOutput(swapRate_tape);
+                derivative(swapRate_tape) = 1.0;
+                tape.computeAdjoints();
+
+                double* jac_row = jacobian.data() + size * numMarketQuotes;
+                for (Size m = 0; m < numDeposits; ++m)
+                    jac_row[m] = derivative(depositRates[m]);
+                for (Size m = 0; m < numSwaps; ++m)
+                    jac_row[numDeposits + m] = derivative(swapRates[m]);
+            }
+            tape.deactivate();
+
+            // JIT kernel creation with interpreter (default backend)
+            xad::JITCompiler<double> jit;  // Default: JITGraphInterpreter
+
+            std::vector<xad::AD> jit_initRates(size);
+            xad::AD jit_swapRate;
+            std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+            for (Size k = 0; k < size; ++k) {
+                jit_initRates[k] = xad::AD(value(initRates[k]));
+                jit.registerInput(jit_initRates[k]);
+            }
+            jit_swapRate = xad::AD(value(swapRate_tape));
+            jit.registerInput(jit_swapRate);
+            for (Size m = 0; m < fullGridRandoms; ++m) {
+                jit_randoms[m] = xad::AD(0.0);
+                jit.registerInput(jit_randoms[m]);
+            }
+
+            jit.newRecording();
+
+            std::vector<xad::AD> asset_jit(size);
+            std::vector<xad::AD> assetAtExercise_jit(size);
+            for (Size k = 0; k < size; ++k) asset_jit[k] = jit_initRates[k];
+
+            for (Size step = 1; step <= fullGridSteps; ++step) {
+                Size offset = (step - 1) * numFactors;
+                Time t = grid[step - 1];
+                Time dt = grid.dt(step - 1);
+
+                Array dw(numFactors);
+                for (Size f = 0; f < numFactors; ++f) dw[f] = jit_randoms[offset + f];
+
+                Array asset_arr(size);
+                for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                Array evolved = process->evolve(t, asset_arr, dt, dw);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                if (step == exerciseStep) {
+                    for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                }
+            }
+
+            std::vector<xad::AD> dis_jit(size);
+            xad::AD df_jit = xad::AD(1.0);
+            for (Size k = 0; k < size; ++k) {
+                double accrual = accrualEnd[k] - accrualStart[k];
+                df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                dis_jit[k] = df_jit;
+            }
+
+            xad::AD jit_npv = xad::AD(0.0);
+            for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                double accrual = accrualEnd[m] - accrualStart[m];
+                jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+            }
+
+            xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+            jit.registerOutput(jit_payoff);
+
+            // Compile the JIT kernel
+            jit.compile();
+
+            // MC execution
+            double mcPrice = 0.0;
+            std::vector<double> dPrice_dInitRates(size, 0.0);
+            double dPrice_dSwapRate = 0.0;
+
+            const auto& graph = jit.getGraph();
+            uint32_t outputSlot = graph.output_ids[0];
+
+            for (Size n = 0; n < nrTrails; ++n) {
+                for (Size k = 0; k < size; ++k) value(jit_initRates[k]) = value(initRates[k]);
+                value(jit_swapRate) = value(swapRate_tape);
+                for (Size m = 0; m < fullGridRandoms; ++m) value(jit_randoms[m]) = allRandoms[n][m];
+
+                double payoff_value;
+                jit.forward(&payoff_value);
+                mcPrice += payoff_value;
+
+                jit.clearDerivatives();
+                jit.setDerivative(outputSlot, 1.0);
+                jit.computeAdjoints();
+
+                for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] += jit.derivative(graph.input_ids[k]);
+                dPrice_dSwapRate += jit.derivative(graph.input_ids[size]);
+            }
+
+            mcPrice /= static_cast<double>(nrTrails);
+            for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+            dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+            // Chain rule
+            std::vector<double> dPrice_dIntermediates(numIntermediates);
+            for (Size k = 0; k < size; ++k) dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+            dPrice_dIntermediates[size] = dPrice_dSwapRate;
+
+            std::vector<double> dPrice_market(numMarketQuotes);
+            applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                           numIntermediates, numMarketQuotes);
+
+            auto t_end = Clock::now();
+            if (recordTiming) {
+                jit_interp_times.push_back(Duration(t_end - t_start).count());
+            }
+        }
+
+        // =================================================================
+        // JIT AVX (RR) - ForgeBackendAVX with 4-path batching (with granular timing)
+        // =================================================================
+        std::cout << " JIT-AVX..." << std::flush;
+        {
+            auto t_start = Clock::now();
+            auto t_phase = Clock::now();
+
+            // Phase timing accumulators (only for last iteration)
+            double t_bootstrap_fwd = 0, t_bootstrap_bwd = 0, t_kernel_record = 0;
+            double t_kernel_compile = 0, t_mc_exec = 0, t_chain_rule = 0;
+
+            using tape_type = Real::tape_type;
+            tape_type tape;
+
+            std::vector<Real> depositRates(numDeposits);
+            std::vector<Real> swapRates(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+            tape.registerInputs(depositRates);
+            tape.registerInputs(swapRates);
+            tape.newRecording();
+
+            RelinkableHandle<YieldTermStructure> euriborTS;
+            auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+            euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                instruments.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                instruments.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m));
+            }
+
+            auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments, dayCounter);
+            yieldCurve->enableExtrapolation();
+
+            std::vector<Date> curveDates;
+            std::vector<Real> zeroRates;
+            curveDates.push_back(settlementDate);
+            zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate = settlementDate + 12 * Years;  // Extended for 10Y instrument + buffer
+            curveDates.push_back(endDate);
+            zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates_ql;
+            for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure;
+            ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+            index->addFixing(Date(2, September, 2005), 0.04);
+            termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process(
+                new LiborForwardModelProcess(size, index));
+            process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(
+                    ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                    ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index, 0.0, index->dayCounter()));
+            fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index->forwardingTermStructure()));
+            Real swapRate_tape = fwdSwap->fairRate();
+
+            Array initRates = process->initialValues();
+
+            if (isLast) {
+                t_bootstrap_fwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // Jacobian computation
+            std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+            for (Size k = 0; k < size; ++k) {
+                if (initRates[k].shouldRecord()) {
+                    tape.clearDerivatives();
+                    tape.registerOutput(initRates[k]);
+                    derivative(initRates[k]) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + k * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates[m]);
+                }
+            }
+            if (swapRate_tape.shouldRecord()) {
+                tape.clearDerivatives();
+                tape.registerOutput(swapRate_tape);
+                derivative(swapRate_tape) = 1.0;
+                tape.computeAdjoints();
+
+                double* jac_row = jacobian.data() + size * numMarketQuotes;
+                for (Size m = 0; m < numDeposits; ++m)
+                    jac_row[m] = derivative(depositRates[m]);
+                for (Size m = 0; m < numSwaps; ++m)
+                    jac_row[numDeposits + m] = derivative(swapRates[m]);
+            }
+            tape.deactivate();
+
+            if (isLast) {
+                t_bootstrap_bwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // JIT kernel creation for AVX
+            xad::JITCompiler<double> jit;
+
+            std::vector<xad::AD> jit_initRates(size);
+            xad::AD jit_swapRate;
+            std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+            for (Size k = 0; k < size; ++k) {
+                jit_initRates[k] = xad::AD(value(initRates[k]));
+                jit.registerInput(jit_initRates[k]);
+            }
+            jit_swapRate = xad::AD(value(swapRate_tape));
+            jit.registerInput(jit_swapRate);
+            for (Size m = 0; m < fullGridRandoms; ++m) {
+                jit_randoms[m] = xad::AD(0.0);
+                jit.registerInput(jit_randoms[m]);
+            }
+
+            jit.newRecording();
+
+            std::vector<xad::AD> asset_jit(size);
+            std::vector<xad::AD> assetAtExercise_jit(size);
+            for (Size k = 0; k < size; ++k) asset_jit[k] = jit_initRates[k];
+
+            for (Size step = 1; step <= fullGridSteps; ++step) {
+                Size offset = (step - 1) * numFactors;
+                Time t = grid[step - 1];
+                Time dt = grid.dt(step - 1);
+
+                Array dw(numFactors);
+                for (Size f = 0; f < numFactors; ++f) dw[f] = jit_randoms[offset + f];
+
+                Array asset_arr(size);
+                for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                Array evolved = process->evolve(t, asset_arr, dt, dw);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                if (step == exerciseStep) {
+                    for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                }
+            }
+
+            std::vector<xad::AD> dis_jit(size);
+            xad::AD df_jit = xad::AD(1.0);
+            for (Size k = 0; k < size; ++k) {
+                double accrual = accrualEnd[k] - accrualStart[k];
+                df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                dis_jit[k] = df_jit;
+            }
+
+            xad::AD jit_npv = xad::AD(0.0);
+            for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                double accrual = accrualEnd[m] - accrualStart[m];
+                jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+            }
+
+            xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+            jit.registerOutput(jit_payoff);
+
+            if (isLast) {
+                t_kernel_record = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // Get the JIT graph
+            const auto& jitGraph = jit.getGraph();
+            jit.deactivate();
+
+            // AVX backend with 4-path batching
+            xad::forge::ForgeBackendAVX<double> avxBackend(false);
+            avxBackend.compile(jitGraph);
+
+            if (isLast) {
+                t_kernel_compile = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // MC execution with 4-path batching
+            double mcPrice = 0.0;
+            std::vector<double> dPrice_dInitRates(size, 0.0);
+            double dPrice_dSwapRate = 0.0;
+
+            constexpr int BATCH_SIZE = xad::forge::ForgeBackendAVX<double>::VECTOR_WIDTH;
+            Size numBatches = (nrTrails + BATCH_SIZE - 1) / BATCH_SIZE;
+
+            std::vector<double> inputBatch(BATCH_SIZE);
+            std::vector<double> outputBatch(BATCH_SIZE);
+
+            // Pre-compute input buffer indices
+            std::vector<size_t> inputBufferIndices;
+            inputBufferIndices.reserve(avxBackend.numInputs());
+            for (auto inputId : avxBackend.inputIds()) {
+                inputBufferIndices.push_back(avxBackend.buffer()->getBufferIndex(inputId));
+            }
+
+            for (Size batch = 0; batch < numBatches; ++batch) {
+                Size batchStart = batch * BATCH_SIZE;
+                Size actualBatchSize = std::min(static_cast<Size>(BATCH_SIZE), nrTrails - batchStart);
+
+                // Set initRates
+                for (Size k = 0; k < size; ++k) {
+                    for (int lane = 0; lane < BATCH_SIZE; ++lane)
+                        inputBatch[lane] = value(initRates[k]);
+                    avxBackend.setInput(k, inputBatch.data());
+                }
+
+                // Set swapRate
+                for (int lane = 0; lane < BATCH_SIZE; ++lane)
+                    inputBatch[lane] = value(swapRate_tape);
+                avxBackend.setInput(size, inputBatch.data());
+
+                // Set random numbers
+                for (Size m = 0; m < fullGridRandoms; ++m) {
+                    for (int lane = 0; lane < BATCH_SIZE; ++lane) {
+                        Size pathIdx = batchStart + lane;
+                        inputBatch[lane] = (pathIdx < nrTrails) ? allRandoms[pathIdx][m] : 0.0;
+                    }
+                    avxBackend.setInput(size + 1 + m, inputBatch.data());
+                }
+
+                // Execute forward + backward
+                // Gradients are laid out as: numInputs * VECTOR_WIDTH doubles
+                std::size_t numInputs = avxBackend.numInputs();
+                std::vector<double> inputGradients(numInputs * BATCH_SIZE);
+                avxBackend.forwardAndBackward(outputBatch.data(), inputGradients.data());
+
+                // Accumulate MC price
+                for (Size lane = 0; lane < actualBatchSize; ++lane) {
+                    mcPrice += outputBatch[lane];
+                }
+
+                // Accumulate gradients
+                for (Size k = 0; k < size; ++k) {
+                    for (Size lane = 0; lane < actualBatchSize; ++lane) {
+                        dPrice_dInitRates[k] += inputGradients[k * BATCH_SIZE + lane];
+                    }
+                }
+
+                for (Size lane = 0; lane < actualBatchSize; ++lane) {
+                    dPrice_dSwapRate += inputGradients[size * BATCH_SIZE + lane];
+                }
+            }
+
+            mcPrice /= static_cast<double>(nrTrails);
+            for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+            dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+            if (isLast) {
+                t_mc_exec = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // Chain rule
+            std::vector<double> dPrice_dIntermediates(numIntermediates);
+            for (Size k = 0; k < size; ++k) dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+            dPrice_dIntermediates[size] = dPrice_dSwapRate;
+
+            std::vector<double> dPrice_market(numMarketQuotes);
+            applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                           numIntermediates, numMarketQuotes);
+
+            if (isLast) {
+                t_chain_rule = Duration(Clock::now() - t_phase).count();
+
+                // Report timing breakdown for JIT-AVX
+                std::cout << "\n    [JIT-AVX Details: " << jitGraph.nodeCount() << " nodes]\n";
+                std::cout << "      Bootstrap fwd:   " << std::fixed << std::setprecision(1) << t_bootstrap_fwd << " ms\n";
+                std::cout << "      Bootstrap bwd:   " << std::fixed << std::setprecision(1) << t_bootstrap_bwd << " ms\n";
+                std::cout << "      Kernel record:   " << std::fixed << std::setprecision(1) << t_kernel_record << " ms\n";
+                std::cout << "      Kernel compile:  " << std::fixed << std::setprecision(1) << t_kernel_compile << " ms\n";
+                std::cout << "      MC exec (" << nrTrails << " paths): " << std::fixed << std::setprecision(1) << t_mc_exec << " ms\n";
+                std::cout << "      Chain rule:      " << std::fixed << std::setprecision(1) << t_chain_rule << " ms\n";
+
+                jit_avx_price = mcPrice;
+                jit_avx_derivs = dPrice_market;
+            }
+
+            auto t_end = Clock::now();
+            if (recordTiming) {
+                jit_avx_times.push_back(Duration(t_end - t_start).count());
+            }
+        }
+
+        std::cout << " Done." << std::endl;
+        }  // end iteration loop
+
+        // Compute averages for this path count
+        auto avg = [](const std::vector<double>& v) {
+            if (v.empty()) return 0.0;
+            double sum = 0.0;
+            for (double x : v) sum += x;
+            return sum / static_cast<double>(v.size());
+        };
+
+        scalingResults[pathIdx].xad_time = avg(xad_rrs_times);
+        scalingResults[pathIdx].jit_time = avg(jit_rrs_times);
+        scalingResults[pathIdx].jit_interp_time = avg(jit_interp_times);
+        scalingResults[pathIdx].jit_avx_time = avg(jit_avx_times);
+
+        std::cout << "    Avg times: XAD=" << std::fixed << std::setprecision(1) << scalingResults[pathIdx].xad_time
+                  << "ms, JIT=" << scalingResults[pathIdx].jit_time
+                  << "ms, JIT-Interp=" << scalingResults[pathIdx].jit_interp_time
+                  << "ms, JIT-AVX=" << scalingResults[pathIdx].jit_avx_time << "ms\n";
+    }  // end path count loop
+
+    // Print scaling table (BenchmarkDotNet-style)
+    std::cout << std::endl;
+    std::cout << "// * Results: Larger Swaption *\n";
+    std::cout << std::endl;
+
+    std::cout << "| Paths  |     XAD |     JIT | JIT-Intrp | JIT-AVX | Speedup |\n";
+    std::cout << "|-------:|--------:|--------:|----------:|--------:|--------:|\n";
+    for (Size i = 0; i < pathCounts.size(); ++i) {
+        std::string pathStr = BenchmarkUtils::formatPathCount(static_cast<int>(pathCounts[i]));
+
+        double speedup = scalingResults[i].xad_time / scalingResults[i].jit_avx_time;
+        std::cout << "| " << std::setw(6) << pathStr << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(8) << scalingResults[i].xad_time << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(8) << scalingResults[i].jit_time << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(10) << scalingResults[i].jit_interp_time << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(8) << scalingResults[i].jit_avx_time << " |"
+                  << std::fixed << std::setprecision(2) << std::setw(7) << speedup << "x |\n";
+    }
+    std::cout << std::endl;
+    std::cout << "Speedup = XAD / JIT-AVX. All times in ms.\n";
+    std::cout << std::endl;
+
+    // Validation section
+    std::cout << "// * Validation (10K paths) *\n";
+    std::cout << std::endl;
+
+    std::cout << "MC Price:\n";
+    std::cout << "  XAD:     " << std::fixed << std::setprecision(8) << xad_price << "\n";
+    std::cout << "  JIT:     " << std::fixed << std::setprecision(8) << jit_price << "\n";
+    std::cout << "  JIT-AVX: " << std::fixed << std::setprecision(8) << jit_avx_price << "\n";
+    std::cout << std::endl;
+
+    std::cout << "Derivatives (first 5 market quotes):\n";
+    std::cout << "|       Quote |            XAD |            JIT |        JIT-AVX |\n";
+    std::cout << "|------------:|---------------:|---------------:|---------------:|\n";
+    for (Size i = 0; i < std::min(Size(5), numMarketQuotes); ++i) {
+        std::string label = (i < numDeposits) ? "Depo " + std::to_string(i) : "Swap " + std::to_string(i - numDeposits);
+        std::cout << "| " << std::setw(11) << label << " |"
+                  << std::scientific << std::setprecision(4) << std::setw(15) << xad_derivs[i] << " |"
+                  << std::scientific << std::setprecision(4) << std::setw(15) << jit_derivs[i] << " |"
+                  << std::scientific << std::setprecision(4) << std::setw(15) << jit_avx_derivs[i] << " |\n";
+    }
+    std::cout << std::endl;
+
+    // Final speedup summary
+    double final_speedup_jit = scalingResults.back().xad_time / scalingResults.back().jit_time;
+    double final_speedup_avx = scalingResults.back().xad_time / scalingResults.back().jit_avx_time;
+    std::cout << "// * Speedup Summary (10K paths) *\n";
+    std::cout << "  JIT:     " << std::fixed << std::setprecision(2) << final_speedup_jit << "x\n";
+    std::cout << "  JIT-AVX: " << std::fixed << std::setprecision(2) << final_speedup_avx << "x\n";
+    std::cout << std::endl;
+
+    // Verification
+    double price_diff = std::abs(xad_price - jit_price);
+    BOOST_CHECK_SMALL(price_diff, 1e-10);
+    BOOST_CHECK(scalingResults.back().xad_time > 0.0);
+    BOOST_CHECK(scalingResults.back().jit_time > 0.0);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
+
diff --git a/test-suite/swaption_benchmark_baseline.cpp b/test-suite/swaption_benchmark_baseline.cpp
new file mode 100644
index 0000000..bbf73b8
--- /dev/null
+++ b/test-suite/swaption_benchmark_baseline.cpp
@@ -0,0 +1,1006 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2025 Xcelerit Computing Limited
+
+ This file is part of QuantLib-Risks / XAD integration.
+
+ Swaption Baseline Benchmark - XAD tape-based reverse-mode AD performance.
+ This benchmark uses only standard XAD tape operations (no JIT/Forge).
+
+ Benchmarks:
+ 1. Simple Swaption (1Y into 1Y) - basic scaling test
+ 2. Larger Swaption (5Y into 5Y) - attempts to approximate a realistic setup
+
+ This serves as a baseline for comparison with JIT-accelerated versions.
+*/
+
+#include "toplevelfixture.hpp"
+#include "utilities_xad.hpp"
+
+// QuantLib includes
+#include <ql/indexes/ibor/eonia.hpp>
+#include <ql/indexes/ibor/euribor.hpp>
+#include <ql/instruments/vanillaswap.hpp>
+#include <ql/instruments/swaption.hpp>
+#include <ql/math/interpolations/cubicinterpolation.hpp>
+#include <ql/pricingengines/swap/discountingswapengine.hpp>
+#include <ql/termstructures/yield/oisratehelper.hpp>
+#include <ql/termstructures/yield/piecewiseyieldcurve.hpp>
+#include <ql/termstructures/yield/ratehelpers.hpp>
+#include <ql/termstructures/yield/zerocurve.hpp>
+#include <ql/time/calendars/target.hpp>
+#include <ql/time/daycounters/actual360.hpp>
+#include <ql/time/daycounters/actual365fixed.hpp>
+#include <ql/time/daycounters/thirty360.hpp>
+
+// LMM Monte Carlo includes
+#include <ql/legacy/libormarketmodels/lfmcovarproxy.hpp>
+#include <ql/legacy/libormarketmodels/lfmswaptionengine.hpp>
+#include <ql/legacy/libormarketmodels/liborforwardmodel.hpp>
+#include <ql/legacy/libormarketmodels/lmexpcorrmodel.hpp>
+#include <ql/legacy/libormarketmodels/lmlinexpvolmodel.hpp>
+#include <ql/math/randomnumbers/rngtraits.hpp>
+#include <ql/math/statistics/generalstatistics.hpp>
+#include <ql/methods/montecarlo/multipathgenerator.hpp>
+
+#include <boost/test/unit_test.hpp>
+#include <chrono>
+#include <iostream>
+#include <iomanip>
+#include <vector>
+#include <map>
+
+// Benchmark utilities (environment detection, formatting)
+#include "benchmark_utils.hpp"
+
+using namespace QuantLib;
+using namespace boost::unit_test_framework;
+
+BOOST_FIXTURE_TEST_SUITE(QuantLibRisksTests, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(SwaptionBenchmarkTests)
+
+//////////////////////////////////////////////////////////////////////////////
+// Helper: Create IborIndex with ZeroCurve (from libormarketmodel.cpp)
+//////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+ext::shared_ptr<IborIndex> makeIndex(std::vector<Date> dates,
+                                     const std::vector<Rate>& rates) {
+    DayCounter dayCounter = Actual360();
+    RelinkableHandle<YieldTermStructure> termStructure;
+    ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+
+    Date todaysDate = index->fixingCalendar().adjust(Date(4, September, 2005));
+    Settings::instance().evaluationDate() = todaysDate;
+
+    dates[0] = index->fixingCalendar().advance(todaysDate,
+                                                index->fixingDays(), Days);
+
+    termStructure.linkTo(ext::shared_ptr<YieldTermStructure>(
+        new ZeroCurve(dates, rates, dayCounter)));
+
+    return index;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// High-performance chain rule: result = jacobian^T * derivatives
+// For hybrid AD workflows: one stage computes dOutput/dIntermediate,
+// Tape computes dIntermediate/dInput, chain rule gives dOutput/dInput.
+//////////////////////////////////////////////////////////////////////////////
+
+/// Apply chain rule: result[j] = sum_i(derivatives[i] * jacobian[i * numInputs + j])
+/// @param jacobian      Row-major flat array [numIntermediates x numInputs]
+/// @param derivatives   Vector [numIntermediates] (dOutput/dIntermediate)
+/// @param result        Output vector [numInputs] (dOutput/dInput) - zeroed first
+/// @param numIntermediates  Number of intermediate variables
+/// @param numInputs     Number of input variables
+inline void applyChainRule(const double* __restrict jacobian,
+                           const double* __restrict derivatives,
+                           double* __restrict result,
+                           std::size_t numIntermediates,
+                           std::size_t numInputs)
+{
+    // Zero result
+    for (std::size_t j = 0; j < numInputs; ++j)
+        result[j] = 0.0;
+
+    // Accumulate: result[j] += derivatives[i] * jacobian[i,j]
+    for (std::size_t i = 0; i < numIntermediates; ++i)
+    {
+        const double deriv_i = derivatives[i];
+        const double* jac_row = jacobian + i * numInputs;
+        for (std::size_t j = 0; j < numInputs; ++j)
+        {
+            result[j] += deriv_i * jac_row[j];
+        }
+    }
+}
+
+} // anonymous namespace
+
+//////////////////////////////////////////////////////////////////////////////
+// Benchmark 1: Simple Swaption Scaling (1Y into 1Y)
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testBenchmark_SimpleSwaptionScaling)
+{
+    BOOST_TEST_MESSAGE("Running Simple Swaption Scaling Benchmark...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  XAD BASELINE BENCHMARK: Simple Swaption (1Y into 1Y)\n";
+    std::cout << "=============================================================================\n";
+
+    // BenchmarkDotNet-style environment info
+    BenchmarkUtils::printEnvironmentHeader();
+
+    std::cout << "// * Benchmark Description *\n";
+    std::cout << "  XAD tape-based AD performance for computing sensitivities\n";
+    std::cout << "  in Monte Carlo swaption pricing.\n";
+    std::cout << std::endl;
+    std::cout << "// * MC Implementations *\n";
+    std::cout << "  QL = QuantLib's MultiPathGenerator (full path storage)\n";
+    std::cout << "  RR = Direct process->evolve() calls (explicit inputs)\n";
+    std::cout << std::endl;
+    std::cout << "// * Approaches Tested *\n";
+    std::cout << "  XAD(QL)   - XAD tape + QuantLib MultiPathGenerator\n";
+    std::cout << "  XAD(RR)   - XAD tape + direct evolve\n";
+    std::cout << std::endl;
+    std::cout << "// * Instrument *\n";
+    std::cout << "  European payer swaption: 1Y option into 1Y swap\n";
+    std::cout << "  Model: LIBOR Market Model (LMM) with lognormal forwards\n";
+    std::cout << "  Sensitivities: dPrice/dMarketQuotes (9 inputs)\n";
+    std::cout << std::endl;
+
+    using Clock = std::chrono::high_resolution_clock;
+    using Duration = std::chrono::duration<double, std::milli>;
+
+    // Market data setup (same as Stage 4)
+    Calendar calendar = TARGET();
+    Date todaysDate(4, September, 2005);
+    Settings::instance().evaluationDate() = todaysDate;
+    Integer fixingDays = 2;
+    Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+    DayCounter dayCounter = Actual360();
+
+    Size numDeposits = 4;
+    Size numSwaps = 5;
+    std::vector<Period> depoTenors = {1 * Days, 1 * Months, 3 * Months, 6 * Months};
+    std::vector<Period> swapTenors = {1 * Years, 2 * Years, 3 * Years, 4 * Years, 5 * Years};
+
+    std::vector<double> depoRates_val = {0.0350, 0.0365, 0.0380, 0.0400};
+    std::vector<double> swapRates_val = {0.0420, 0.0480, 0.0520, 0.0550, 0.0575};
+
+    Size numMarketQuotes = numDeposits + numSwaps;
+
+    // LMM parameters
+    Size size = 10;
+    Size i_opt = 2;
+    Size j_opt = 2;
+    Size steps = 8;
+
+    // Build base curve and process setup
+    std::vector<Rate> baseZeroRates = {0.0350, 0.0575};
+    std::vector<Date> baseDates = {settlementDate, settlementDate + 6 * Years};
+    auto baseIndex = makeIndex(baseDates, baseZeroRates);
+
+    ext::shared_ptr<LiborForwardModelProcess> baseProcess(
+        new LiborForwardModelProcess(size, baseIndex));
+    ext::shared_ptr<LmCorrelationModel> baseCorrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> baseVolaModel(
+        new LmLinearExponentialVolatilityModel(baseProcess->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    baseProcess->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(baseVolaModel, baseCorrModel)));
+
+    // Grid and timing setup
+    std::vector<Time> fixingTimes = baseProcess->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    Size numFactors = baseProcess->factors();
+    Size exerciseStep = location[i_opt];
+    Size fullGridSteps = grid.size() - 1;
+    Size fullGridRandoms = fullGridSteps * numFactors;
+
+    // Types for MC generators
+    typedef PseudoRandom::rsg_type rsg_type;
+    typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+
+    // Get fair swap rate (same approach as Stage 4)
+    BusinessDayConvention convention = baseIndex->businessDayConvention();
+    Date settlement = baseIndex->forwardingTermStructure()->referenceDate();
+    Date fwdStart = settlement + Period(6 * i_opt, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j_opt, Months);
+
+    Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    // Accrual periods
+    std::vector<double> accrualStart(size), accrualEnd(size);
+    for (Size k = 0; k < size; ++k) {
+        accrualStart[k] = value(baseProcess->accrualStartTimes()[k]);
+        accrualEnd[k] = value(baseProcess->accrualEndTimes()[k]);
+    }
+
+    Size numIntermediates = size + 1;
+
+    // Helper lambda for curve building
+    auto buildCurveAndProcess = [&](const std::vector<double>& depoRates,
+                                    const std::vector<double>& swapRates,
+                                    std::vector<Date>& curveDates,
+                                    std::vector<Rate>& zeroRates) {
+        RelinkableHandle<YieldTermStructure> euriborTS;
+        auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+        euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+        std::vector<ext::shared_ptr<RateHelper>> instruments;
+        for (Size idx = 0; idx < numDeposits; ++idx) {
+            auto depoQuote = ext::make_shared<SimpleQuote>(depoRates[idx]);
+            instruments.push_back(ext::make_shared<DepositRateHelper>(
+                Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                calendar, ModifiedFollowing, true, dayCounter));
+        }
+        for (Size idx = 0; idx < numSwaps; ++idx) {
+            auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+            instruments.push_back(ext::make_shared<SwapRateHelper>(
+                Handle<Quote>(swapQuote), swapTenors[idx],
+                calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                euribor6m));
+        }
+
+        auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+            settlementDate, instruments, dayCounter);
+        yieldCurve->enableExtrapolation();
+
+        curveDates.clear();
+        zeroRates.clear();
+        curveDates.push_back(settlementDate);
+        zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+        Date endDate = settlementDate + 6 * Years;
+        curveDates.push_back(endDate);
+        zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+    };
+
+    // Test cases: different path counts
+    std::vector<Size> pathCounts = {10, 100, 1000, 10000};
+    std::vector<std::string> testCaseNames = {"10", "100", "1K", "10K"};
+
+    // Results storage
+    struct ScalingResult {
+        double xad_ql_total;
+        double xad_rrs_total;
+        double xad_ql_std;
+        double xad_rrs_std;
+    };
+    std::vector<ScalingResult> results(pathCounts.size());
+
+    Size warmupIterations = 5;
+    Size benchmarkIterations = 10;
+
+    std::cout << "  CONFIGURATION:\n";
+    std::cout << "    Market inputs:    " << numMarketQuotes << " (4 deposits + 5 swaps)\n";
+    std::cout << "    Forward rates:    " << size << " (semi-annual to 5Y)\n";
+    std::cout << "    Time steps:       " << fullGridSteps << "\n";
+    std::cout << "    MC paths tested:  10, 100, 1K, 10K\n";
+    std::cout << "    Warmup/Bench:     " << warmupIterations << "/" << benchmarkIterations << " iterations\n";
+    std::cout << std::endl;
+
+    for (Size tc = 0; tc < pathCounts.size(); ++tc) {
+        Size nrTrails = pathCounts[tc];
+        std::cout << "  Running test case: " << testCaseNames[tc] << " (" << nrTrails << " paths)..." << std::flush;
+
+        // Pre-generate random numbers for this path count
+        rsg_type rsg_base = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+        std::vector<std::vector<double>> allRandoms(nrTrails);
+        for (Size n = 0; n < nrTrails; ++n) {
+            allRandoms[n].resize(fullGridRandoms);
+            const auto& seq = rsg_base.nextSequence();
+            for (Size m = 0; m < fullGridRandoms; ++m) {
+                allRandoms[n][m] = value(seq.value[m]);
+            }
+        }
+
+        // Timing accumulators
+        std::vector<double> xad_ql_times, xad_rrs_times;
+
+        for (Size iter = 0; iter < warmupIterations + benchmarkIterations; ++iter) {
+            bool recordTiming = (iter >= warmupIterations);
+
+            // =================================================================
+            // XAD (QuantLib) - MultiPathGenerator with XAD tape
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(numDeposits);
+                std::vector<Real> swapRates(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRates);
+                tape.newRecording();
+
+                std::vector<Date> curveDates;
+                std::vector<Rate> zeroRates;
+                std::vector<double> depoRates_dbl(numDeposits), swapRates_dbl(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depoRates_dbl[idx] = value(depositRates[idx]);
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates_dbl[idx] = value(swapRates[idx]);
+                buildCurveAndProcess(depoRates_dbl, swapRates_dbl, curveDates, zeroRates);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<Real> zeroRates_real(zeroRates.begin(), zeroRates.end());
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_real, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate = fwdSwap->fairRate();
+
+                rsg_type rsg_ql = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+                MultiPathGenerator<rsg_type> generator_ql(process, grid, rsg_ql, false);
+
+                Real price = Real(0.0);
+                for (Size n = 0; n < nrTrails; ++n) {
+                    sample_type path = (n % 2) != 0U ? generator_ql.antithetic() : generator_ql.next();
+
+                    Array mcRates(size);
+                    for (Size k = 0; k < size; ++k) {
+                        mcRates[k] = path.value[k][exerciseStep];
+                    }
+
+                    Array dis(size);
+                    Real df = Real(1.0);
+                    for (Size k = 0; k < size; ++k) {
+                        Real accrual = accrualEnd[k] - accrualStart[k];
+                        df = df / (Real(1.0) + mcRates[k] * accrual);
+                        dis[k] = df;
+                    }
+
+                    Real npv = Real(0.0);
+                    for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                        Real accrual = accrualEnd[m] - accrualStart[m];
+                        npv += (swapRate - mcRates[m]) * accrual * dis[m];
+                    }
+                    price += max(npv, Real(0.0));
+                }
+                price /= Real(static_cast<double>(nrTrails));
+
+                tape.registerOutput(price);
+                derivative(price) = 1.0;
+                tape.computeAdjoints();
+
+                auto t_end = Clock::now();
+                if (recordTiming) {
+                    xad_ql_times.push_back(Duration(t_end - t_start).count());
+                }
+                tape.deactivate();
+            }
+
+            // =================================================================
+            // XAD (RR) - Full grid with XAD tape
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(numDeposits);
+                std::vector<Real> swapRates(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRates);
+                tape.newRecording();
+
+                RelinkableHandle<YieldTermStructure> euriborTS;
+                auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<ext::shared_ptr<RateHelper>> instruments;
+                for (Size idx = 0; idx < numDeposits; ++idx) {
+                    auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                    instruments.push_back(ext::make_shared<DepositRateHelper>(
+                        Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                        calendar, ModifiedFollowing, true, dayCounter));
+                }
+                for (Size idx = 0; idx < numSwaps; ++idx) {
+                    auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                    instruments.push_back(ext::make_shared<SwapRateHelper>(
+                        Handle<Quote>(swapQuote), swapTenors[idx],
+                        calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                        euribor6m));
+                }
+
+                auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                    settlementDate, instruments, dayCounter);
+                yieldCurve->enableExtrapolation();
+
+                std::vector<Date> curveDates;
+                std::vector<Real> zeroRates;
+                curveDates.push_back(settlementDate);
+                zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                Date endDate = settlementDate + 6 * Years;
+                curveDates.push_back(endDate);
+                zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                std::vector<Rate> zeroRates_ql;
+                for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate = fwdSwap->fairRate();
+
+                Array initRates = process->initialValues();
+
+                Real price = Real(0.0);
+                for (Size n = 0; n < nrTrails; ++n) {
+                    Array asset(size);
+                    for (Size k = 0; k < size; ++k) asset[k] = initRates[k];
+
+                    Array assetAtExercise(size);
+                    for (Size step = 1; step <= fullGridSteps; ++step) {
+                        Size offset = (step - 1) * numFactors;
+                        Time t = grid[step - 1];
+                        Time dt = grid.dt(step - 1);
+
+                        Array dw(numFactors);
+                        for (Size f = 0; f < numFactors; ++f) {
+                            dw[f] = allRandoms[n][offset + f];
+                        }
+
+                        asset = process->evolve(t, asset, dt, dw);
+
+                        if (step == exerciseStep) {
+                            for (Size k = 0; k < size; ++k) assetAtExercise[k] = asset[k];
+                        }
+                    }
+
+                    Array dis(size);
+                    Real df = Real(1.0);
+                    for (Size k = 0; k < size; ++k) {
+                        Real accrual = accrualEnd[k] - accrualStart[k];
+                        df = df / (Real(1.0) + assetAtExercise[k] * accrual);
+                        dis[k] = df;
+                    }
+
+                    Real npv = Real(0.0);
+                    for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                        Real accrual = accrualEnd[m] - accrualStart[m];
+                        npv += (swapRate - assetAtExercise[m]) * accrual * dis[m];
+                    }
+                    price += max(npv, Real(0.0));
+                }
+                price /= Real(static_cast<double>(nrTrails));
+
+                tape.registerOutput(price);
+                derivative(price) = 1.0;
+                tape.computeAdjoints();
+
+                auto t_end = Clock::now();
+                if (recordTiming) {
+                    xad_rrs_times.push_back(Duration(t_end - t_start).count());
+                }
+                tape.deactivate();
+            }
+
+        }
+
+        // Compute averages
+        auto avg = [](const std::vector<double>& v) {
+            if (v.empty()) return 0.0;
+            double sum = 0.0;
+            for (double x : v) sum += x;
+            return sum / static_cast<double>(v.size());
+        };
+
+        auto stddev = [&avg](const std::vector<double>& v) {
+            if (v.size() <= 1) return 0.0;
+            double mean = avg(v);
+            double sq_sum = 0.0;
+            for (double x : v) {
+                double diff = x - mean;
+                sq_sum += diff * diff;
+            }
+            return std::sqrt(sq_sum / (v.size() - 1));
+        };
+
+        results[tc].xad_ql_total = avg(xad_ql_times);
+        results[tc].xad_rrs_total = avg(xad_rrs_times);
+        results[tc].xad_ql_std = stddev(xad_ql_times);
+        results[tc].xad_rrs_std = stddev(xad_rrs_times);
+
+        std::cout << " Done." << std::endl;
+    }
+
+    // Print results table (BenchmarkDotNet-style)
+    std::cout << std::endl;
+    std::cout << "// * Results: Simple Swaption *\n";
+    std::cout << std::endl;
+
+    std::cout << "| Paths  | XAD(QL) | XAD(RR) |\n";
+    std::cout << "|-------:|--------:|--------:|\n";
+
+    for (Size tc = 0; tc < pathCounts.size(); ++tc) {
+        std::string pathStr = BenchmarkUtils::formatPathCount(static_cast<int>(pathCounts[tc]));
+        std::cout << "| " << std::setw(6) << pathStr << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(8) << results[tc].xad_ql_total << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(8) << results[tc].xad_rrs_total << " |\n";
+    }
+
+    std::cout << std::endl;
+    std::cout << "All times in ms.\n";
+    std::cout << std::endl;
+
+    // Basic verification
+    BOOST_CHECK(results[0].xad_ql_total > 0.0);
+    BOOST_CHECK(results[0].xad_rrs_total > 0.0);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Larger Swaption Benchmark (5Y into 5Y)
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testBenchmark_LargerSwaptionScaling)
+{
+    BOOST_TEST_MESSAGE("Running Larger Swaption Scaling Benchmark...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  XAD BASELINE BENCHMARK: Larger Swaption (5Y into 5Y)\n";
+    std::cout << "=============================================================================\n";
+
+    // BenchmarkDotNet-style environment info
+    BenchmarkUtils::printEnvironmentHeader();
+
+    std::cout << "// * Benchmark Description *\n";
+    std::cout << "  Approximates a more realistic scenario: larger computation graph,\n";
+    std::cout << "  more forward rates, longer simulation.\n";
+    std::cout << std::endl;
+    std::cout << "// * Approach Tested *\n";
+    std::cout << "  XAD - XAD tape + direct evolve\n";
+    std::cout << std::endl;
+    std::cout << "// * Instrument *\n";
+    std::cout << "  European receiver swaption: 5Y option into 5Y swap (10Y total)\n";
+    std::cout << "  Model: LIBOR Market Model (LMM) with 20 forward rates\n";
+    std::cout << "  Sensitivities: dPrice/dMarketQuotes (14 inputs)\n";
+    std::cout << std::endl;
+
+    using Clock = std::chrono::high_resolution_clock;
+    using Duration = std::chrono::duration<double, std::milli>;
+
+    // Market data setup - PRODUCTION-LIKE CONFIGURATION
+    Calendar calendar = TARGET();
+    Date todaysDate(4, September, 2005);
+    Settings::instance().evaluationDate() = todaysDate;
+    Integer fixingDays = 2;
+    Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+    DayCounter dayCounter = Actual360();
+
+    // Larger setup: 4 deposits + 10 swaps = 14 market inputs (up to 10Y)
+    Size numDeposits = 4;
+    Size numSwaps = 10;
+    std::vector<Period> depoTenors = {1 * Days, 1 * Months, 3 * Months, 6 * Months};
+    std::vector<Period> swapTenors = {1 * Years, 2 * Years, 3 * Years, 4 * Years, 5 * Years,
+                                      6 * Years, 7 * Years, 8 * Years, 9 * Years, 10 * Years};
+
+    // Realistic deposit rates (upward sloping short end)
+    std::vector<double> depoRates_val = {0.0320, 0.0335, 0.0355, 0.0375};
+    // Realistic swap rates (upward sloping curve to 10Y)
+    std::vector<double> swapRates_val = {0.0400, 0.0435, 0.0460, 0.0480, 0.0495,
+                                         0.0505, 0.0515, 0.0522, 0.0528, 0.0532};
+
+    Size numMarketQuotes = numDeposits + numSwaps;
+
+    // LMM parameters: 20 forward rates (semi-annual to 10Y)
+    // Swaption: 5Y option into 5Y swap (exercises at 5Y, underlying matures at 10Y)
+    Size size = 20;      // Semi-annual rates to 10Y
+    Size i_opt = 10;     // Option starts at 5Y (10 × 6 months)
+    Size j_opt = 10;     // 5Y swap (10 × 6 months)
+    Size steps = 20;     // Time steps for 5Y simulation
+
+    // Build base curve and process setup - to 12Y (extra buffer for accrual periods)
+    std::vector<Rate> baseZeroRates = {0.0320, 0.0535};
+    std::vector<Date> baseDates = {settlementDate, settlementDate + 12 * Years};
+    auto baseIndex = makeIndex(baseDates, baseZeroRates);
+
+    ext::shared_ptr<LiborForwardModelProcess> baseProcess(
+        new LiborForwardModelProcess(size, baseIndex));
+    ext::shared_ptr<LmCorrelationModel> baseCorrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> baseVolaModel(
+        new LmLinearExponentialVolatilityModel(baseProcess->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    baseProcess->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(baseVolaModel, baseCorrModel)));
+
+    // Grid and timing setup
+    std::vector<Time> fixingTimes = baseProcess->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    Size numFactors = baseProcess->factors();
+    Size exerciseStep = location[i_opt];
+    Size fullGridSteps = grid.size() - 1;
+    Size fullGridRandoms = fullGridSteps * numFactors;
+
+    // Types for MC generators
+    typedef PseudoRandom::rsg_type rsg_type;
+    typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+
+    // Get fair swap rate
+    BusinessDayConvention convention = baseIndex->businessDayConvention();
+    Date settlement = baseIndex->forwardingTermStructure()->referenceDate();
+    Date fwdStart = settlement + Period(6 * i_opt, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j_opt, Months);
+
+    Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    // Accrual periods
+    std::vector<double> accrualStart(size), accrualEnd(size);
+    for (Size k = 0; k < size; ++k) {
+        accrualStart[k] = value(baseProcess->accrualStartTimes()[k]);
+        accrualEnd[k] = value(baseProcess->accrualEndTimes()[k]);
+    }
+
+    Size numIntermediates = size + 1;
+
+    // Helper lambda for curve building
+    auto buildCurveAndProcess = [&](const std::vector<double>& depoRates,
+                                    const std::vector<double>& swapRates,
+                                    std::vector<Date>& curveDates,
+                                    std::vector<Rate>& zeroRates) {
+        RelinkableHandle<YieldTermStructure> euriborTS;
+        auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+        euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+        std::vector<ext::shared_ptr<RateHelper>> instruments;
+        for (Size idx = 0; idx < numDeposits; ++idx) {
+            auto depoQuote = ext::make_shared<SimpleQuote>(depoRates[idx]);
+            instruments.push_back(ext::make_shared<DepositRateHelper>(
+                Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                calendar, ModifiedFollowing, true, dayCounter));
+        }
+        for (Size idx = 0; idx < numSwaps; ++idx) {
+            auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+            instruments.push_back(ext::make_shared<SwapRateHelper>(
+                Handle<Quote>(swapQuote), swapTenors[idx],
+                calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                euribor6m));
+        }
+
+        auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+            settlementDate, instruments, dayCounter);
+        yieldCurve->enableExtrapolation();
+
+        curveDates.clear();
+        zeroRates.clear();
+        curveDates.push_back(settlementDate);
+        zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+        Date endDate = settlementDate + 12 * Years;  // Extended for 10Y instrument + buffer
+        curveDates.push_back(endDate);
+        zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+    };
+
+    // Test configuration - scaling over different path counts
+    std::vector<Size> pathCounts = {10, 100, 1000, 10000};
+    Size maxPaths = pathCounts.back();
+    Size warmupIterations = 2;
+    Size benchmarkIterations = 3;
+
+    std::cout << "  CONFIGURATION:\n";
+    std::cout << "    Market inputs:    " << numMarketQuotes << " (" << numDeposits << " deposits + " << numSwaps << " swaps)\n";
+    std::cout << "    Forward rates:    " << size << " (semi-annual to 10Y)\n";
+    std::cout << "    Time steps:       " << fullGridSteps << "\n";
+    std::cout << "    MC paths tested:  10, 100, 1K, 10K\n";
+    std::cout << "    Warmup/Bench:     " << warmupIterations << "/" << benchmarkIterations << " iterations\n";
+    std::cout << std::endl;
+
+    // Pre-generate random numbers for max paths
+    std::cout << "  Generating " << maxPaths << " x " << fullGridRandoms << " random numbers..." << std::flush;
+    rsg_type rsg_base = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+    std::vector<std::vector<double>> allRandoms(maxPaths);
+    for (Size n = 0; n < maxPaths; ++n) {
+        allRandoms[n].resize(fullGridRandoms);
+        const auto& seq = rsg_base.nextSequence();
+        for (Size m = 0; m < fullGridRandoms; ++m) {
+            allRandoms[n][m] = value(seq.value[m]);
+        }
+    }
+    std::cout << " Done." << std::endl;
+
+    // Results storage for scaling table
+    struct ScalingResult {
+        double xad_time;
+    };
+    std::vector<ScalingResult> scalingResults(pathCounts.size());
+
+    // Store final prices/derivs from largest path count
+    double xad_price = 0.0;
+    std::vector<double> xad_derivs;
+
+    // Run benchmarks for each path count
+    for (Size pathIdx = 0; pathIdx < pathCounts.size(); ++pathIdx) {
+        Size nrTrails = pathCounts[pathIdx];
+        std::cout << "\n  --- Running with " << nrTrails << " paths ---\n";
+
+        // Timing accumulators for this path count
+        std::vector<double> xad_rrs_times;
+
+        for (Size iter = 0; iter < warmupIterations + benchmarkIterations; ++iter) {
+            bool recordTiming = (iter >= warmupIterations);
+            bool isLast = (iter == warmupIterations + benchmarkIterations - 1) &&
+                          (pathIdx == pathCounts.size() - 1);  // Only save details for largest path count
+
+            std::cout << "  [" << (iter < warmupIterations ? "Warmup" : "Bench") << " "
+                      << (iter < warmupIterations ? iter + 1 : iter - warmupIterations + 1) << "/"
+                      << (iter < warmupIterations ? warmupIterations : benchmarkIterations) << "] ";
+
+        // =================================================================
+        // XAD (RR) - Full grid with XAD tape (with granular timing)
+        // =================================================================
+        std::cout << "XAD..." << std::flush;
+        {
+            auto t_start = Clock::now();
+            auto t_phase = Clock::now();
+
+            // Phase timing accumulators (only for last iteration)
+            double t_bootstrap_fwd = 0, t_mc_fwd = 0, t_backward = 0;
+
+            using tape_type = Real::tape_type;
+            tape_type tape;
+
+            std::vector<Real> depositRates(numDeposits);
+            std::vector<Real> swapRates(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+            tape.registerInputs(depositRates);
+            tape.registerInputs(swapRates);
+            tape.newRecording();
+
+            RelinkableHandle<YieldTermStructure> euriborTS;
+            auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+            euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                instruments.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                instruments.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m));
+            }
+
+            auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments, dayCounter);
+            yieldCurve->enableExtrapolation();
+
+            std::vector<Date> curveDates;
+            std::vector<Real> zeroRates;
+            curveDates.push_back(settlementDate);
+            zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate = settlementDate + 12 * Years;  // Extended for 10Y instrument + buffer
+            curveDates.push_back(endDate);
+            zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates_ql;
+            for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure;
+            ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+            index->addFixing(Date(2, September, 2005), 0.04);
+            termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process(
+                new LiborForwardModelProcess(size, index));
+            process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(
+                    ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                    ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index, 0.0, index->dayCounter()));
+            fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index->forwardingTermStructure()));
+            Real swapRate = fwdSwap->fairRate();
+
+            Array initRates = process->initialValues();
+
+            if (isLast) {
+                t_bootstrap_fwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // MC pricing with full grid
+            Real price = Real(0.0);
+            for (Size n = 0; n < nrTrails; ++n) {
+                Array asset(size);
+                for (Size k = 0; k < size; ++k) asset[k] = initRates[k];
+
+                Array assetAtExercise(size);
+                for (Size step = 1; step <= fullGridSteps; ++step) {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f)
+                        dw[f] = Real(allRandoms[n][offset + f]);
+
+                    asset = process->evolve(t, asset, dt, dw);
+
+                    if (step == exerciseStep) {
+                        for (Size k = 0; k < size; ++k) assetAtExercise[k] = asset[k];
+                    }
+                }
+
+                Array dis(size);
+                Real df = Real(1.0);
+                for (Size k = 0; k < size; ++k) {
+                    Real accrual = accrualEnd[k] - accrualStart[k];
+                    df = df / (Real(1.0) + assetAtExercise[k] * accrual);
+                    dis[k] = df;
+                }
+
+                Real npv = Real(0.0);
+                for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                    Real accrual = accrualEnd[m] - accrualStart[m];
+                    npv += (swapRate - assetAtExercise[m]) * accrual * dis[m];
+                }
+                price += max(npv, Real(0.0));
+            }
+            price /= Real(static_cast<double>(nrTrails));
+
+            if (isLast) {
+                t_mc_fwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            tape.registerOutput(price);
+            derivative(price) = 1.0;
+            tape.computeAdjoints();
+
+            if (isLast) {
+                t_backward = Duration(Clock::now() - t_phase).count();
+
+                // Report XAD timing breakdown
+                std::cout << "\n    [XAD Details: " << tape.getNumStatements() << " tape statements]\n";
+                std::cout << "      Bootstrap fwd:   " << std::fixed << std::setprecision(1) << t_bootstrap_fwd << " ms\n";
+                std::cout << "      MC fwd (" << nrTrails << " paths): " << std::fixed << std::setprecision(1) << t_mc_fwd << " ms\n";
+                std::cout << "      Backward:        " << std::fixed << std::setprecision(1) << t_backward << " ms\n";
+
+                xad_price = value(price);
+                xad_derivs.resize(numMarketQuotes);
+                for (Size m = 0; m < numDeposits; ++m)
+                    xad_derivs[m] = derivative(depositRates[m]);
+                for (Size m = 0; m < numSwaps; ++m)
+                    xad_derivs[numDeposits + m] = derivative(swapRates[m]);
+            }
+
+            auto t_end = Clock::now();
+            if (recordTiming) {
+                xad_rrs_times.push_back(Duration(t_end - t_start).count());
+            }
+            tape.deactivate();
+        }
+
+
+        std::cout << " Done." << std::endl;
+        }  // end iteration loop
+
+        // Compute averages for this path count
+        auto avg = [](const std::vector<double>& v) {
+            if (v.empty()) return 0.0;
+            double sum = 0.0;
+            for (double x : v) sum += x;
+            return sum / static_cast<double>(v.size());
+        };
+
+        scalingResults[pathIdx].xad_time = avg(xad_rrs_times);
+
+        std::cout << "    Avg time: XAD=" << std::fixed << std::setprecision(1) << scalingResults[pathIdx].xad_time << "ms\n";
+    }  // end path count loop
+
+    // Print scaling table (BenchmarkDotNet-style)
+    std::cout << std::endl;
+    std::cout << "// * Results: Larger Swaption *\n";
+    std::cout << std::endl;
+
+    std::cout << "| Paths  |     XAD |\n";
+    std::cout << "|-------:|--------:|\n";
+    for (Size i = 0; i < pathCounts.size(); ++i) {
+        std::string pathStr = BenchmarkUtils::formatPathCount(static_cast<int>(pathCounts[i]));
+
+        std::cout << "| " << std::setw(6) << pathStr << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(8) << scalingResults[i].xad_time << " |\n";
+    }
+    std::cout << std::endl;
+    std::cout << "All times in ms.\n";
+    std::cout << std::endl;
+
+    // Validation section
+    std::cout << "// * Validation (10K paths) *\n";
+    std::cout << std::endl;
+
+    std::cout << "MC Price:\n";
+    std::cout << "  XAD: " << std::fixed << std::setprecision(8) << xad_price << "\n";
+    std::cout << std::endl;
+
+    std::cout << "Derivatives (first 5 market quotes):\n";
+    std::cout << "|       Quote |            XAD |\n";
+    std::cout << "|------------:|---------------:|\n";
+    for (Size i = 0; i < std::min(Size(5), numMarketQuotes); ++i) {
+        std::string label = (i < numDeposits) ? "Depo " + std::to_string(i) : "Swap " + std::to_string(i - numDeposits);
+        std::cout << "| " << std::setw(11) << label << " |"
+                  << std::scientific << std::setprecision(4) << std::setw(15) << xad_derivs[i] << " |\n";
+    }
+    std::cout << std::endl;
+
+    // Verification
+    BOOST_CHECK(scalingResults.back().xad_time > 0.0);
+    BOOST_CHECK(xad_price > 0.0);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
+
diff --git a/test-suite/swaption_jit_pipeline_xad.cpp b/test-suite/swaption_jit_pipeline_xad.cpp
new file mode 100644
index 0000000..9672d4b
--- /dev/null
+++ b/test-suite/swaption_jit_pipeline_xad.cpp
@@ -0,0 +1,7931 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2025 Xcelerit Computing Limited
+
+ This file is part of QuantLib-Risks / XAD / Forge integration.
+
+ Tests for the XAD-QuantLib JIT Integration Pipeline:
+ - Stage 1: Curve Bootstrapping (XAD Tape Mode)
+ - Stage 2: Monte Carlo Swaption Pricing (JIT Mode)
+ - Stage 3: Adjoint Relay (Reverse Sweep back to market inputs)
+
+ Reference: docs/examplewish.txt
+ Based on: Examples/AdjointMulticurveBootstrapping/AdjointMulticurveBootstrappingXAD.cpp
+           test-suite/libormarketmodel.cpp (testSwaptionPricing)
+*/
+
+#include "toplevelfixture.hpp"
+#include "utilities_xad.hpp"
+
+// Stage 1 includes
+#include <ql/indexes/ibor/eonia.hpp>
+#include <ql/indexes/ibor/euribor.hpp>
+#include <ql/instruments/vanillaswap.hpp>
+#include <ql/instruments/swaption.hpp>
+#include <ql/math/interpolations/cubicinterpolation.hpp>
+#include <ql/pricingengines/swap/discountingswapengine.hpp>
+#include <ql/termstructures/yield/oisratehelper.hpp>
+#include <ql/termstructures/yield/piecewiseyieldcurve.hpp>
+#include <ql/termstructures/yield/ratehelpers.hpp>
+#include <ql/termstructures/yield/zerocurve.hpp>
+#include <ql/time/calendars/target.hpp>
+#include <ql/time/daycounters/actual360.hpp>
+#include <ql/time/daycounters/actual365fixed.hpp>
+#include <ql/time/daycounters/thirty360.hpp>
+
+// Stage 2 includes (LMM Monte Carlo)
+#include <ql/legacy/libormarketmodels/lfmcovarproxy.hpp>
+#include <ql/legacy/libormarketmodels/lfmswaptionengine.hpp>
+#include <ql/legacy/libormarketmodels/liborforwardmodel.hpp>
+#include <ql/legacy/libormarketmodels/lmexpcorrmodel.hpp>
+#include <ql/legacy/libormarketmodels/lmlinexpvolmodel.hpp>
+#include <ql/math/randomnumbers/rngtraits.hpp>
+#include <ql/math/statistics/generalstatistics.hpp>
+#include <ql/methods/montecarlo/multipathgenerator.hpp>
+
+#include <boost/test/unit_test.hpp>
+#include <chrono>
+#include <iostream>
+#include <iomanip>
+#include <vector>
+#include <map>
+
+// Forge JIT backends
+#include <xad-forge/ForgeBackend.hpp>
+#include <xad-forge/ForgeBackendAVX.hpp>
+
+using namespace QuantLib;
+using namespace boost::unit_test_framework;
+
+BOOST_FIXTURE_TEST_SUITE(QuantLibRisksTests, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(SwaptionJITPipelineTests)
+
+//////////////////////////////////////////////////////////////////////////////
+// Helper: Create IborIndex with ZeroCurve (from libormarketmodel.cpp)
+//////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+ext::shared_ptr<IborIndex> makeIndex(std::vector<Date> dates,
+                                     const std::vector<Rate>& rates) {
+    DayCounter dayCounter = Actual360();
+    RelinkableHandle<YieldTermStructure> termStructure;
+    ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+
+    Date todaysDate = index->fixingCalendar().adjust(Date(4, September, 2005));
+    Settings::instance().evaluationDate() = todaysDate;
+
+    dates[0] = index->fixingCalendar().advance(todaysDate,
+                                                index->fixingDays(), Days);
+
+    termStructure.linkTo(ext::shared_ptr<YieldTermStructure>(
+        new ZeroCurve(dates, rates, dayCounter)));
+
+    return index;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// High-performance chain rule: result = jacobian^T * derivatives
+// For hybrid AD workflows: JIT computes dOutput/dIntermediate,
+// Tape computes dIntermediate/dInput, chain rule gives dOutput/dInput.
+//////////////////////////////////////////////////////////////////////////////
+
+/// Apply chain rule: result[j] = sum_i(derivatives[i] * jacobian[i * numInputs + j])
+/// @param jacobian      Row-major flat array [numIntermediates x numInputs]
+/// @param derivatives   Vector [numIntermediates] (dOutput/dIntermediate)
+/// @param result        Output vector [numInputs] (dOutput/dInput) - zeroed first
+/// @param numIntermediates  Number of intermediate variables
+/// @param numInputs     Number of input variables
+inline void applyChainRule(const double* __restrict jacobian,
+                           const double* __restrict derivatives,
+                           double* __restrict result,
+                           std::size_t numIntermediates,
+                           std::size_t numInputs)
+{
+    // Zero result
+    for (std::size_t j = 0; j < numInputs; ++j)
+        result[j] = 0.0;
+
+    // Accumulate: result[j] += derivatives[i] * jacobian[i,j]
+    for (std::size_t i = 0; i < numIntermediates; ++i)
+    {
+        const double deriv_i = derivatives[i];
+        const double* jac_row = jacobian + i * numInputs;
+        for (std::size_t j = 0; j < numInputs; ++j)
+        {
+            result[j] += deriv_i * jac_row[j];
+        }
+    }
+}
+
+} // anonymous namespace
+
+//////////////////////////////////////////////////////////////////////////////
+// Stage 1: Curve Bootstrapping with XAD Tape
+// Based on Examples/AdjointMulticurveBootstrapping/AdjointMulticurveBootstrappingXAD.cpp
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testStage1_CurveBootstrapping)
+{
+    BOOST_TEST_MESSAGE("Testing Stage 1: Curve Bootstrapping with XAD Tape...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  STAGE 1: Curve Bootstrapping - Original vs XAD Tape\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    std::cout << "  Setup: EONIA curve bootstrapping from market quotes\n";
+    std::cout << "    - Inputs: 30 market quotes (3 depo + 4 short OIS + 5 dated OIS + 18 long OIS)\n";
+    std::cout << "    - Output: Discount factors at various tenors\n";
+    std::cout << "    - XAD computes dDF/dQuote via reverse-mode AD\n";
+    std::cout << std::endl;
+
+    // Setup
+    Calendar calendar = TARGET();
+    Date todaysDate(11, December, 2012);
+    Settings::instance().evaluationDate() = todaysDate;
+    Integer fixingDays = 2;
+    Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+    DayCounter termStructureDayCounter = Actual365Fixed();
+
+    // Market Quotes
+    std::vector<Real> depos = {0.0004, 0.0004, 0.0004};
+    std::vector<Real> shortOis = {0.00070, 0.00069, 0.00078, 0.00074};
+    std::vector<Real> datedOIS = {0.000460, 0.000160, -0.000070, -0.000130, -0.000140};
+    std::vector<Real> longTermOIS = {
+        0.00002, 0.00008, 0.00021, 0.00036, 0.00127, 0.00274,
+        0.00456, 0.00647, 0.00827, 0.00996, 0.01147, 0.0128,
+        0.01404, 0.01516, 0.01764, 0.01939, 0.02003, 0.02038
+    };
+
+    // Store original values for comparison
+    std::vector<double> depos_orig(depos.size()), shortOis_orig(shortOis.size());
+    std::vector<double> datedOIS_orig(datedOIS.size()), longTermOIS_orig(longTermOIS.size());
+    for (size_t k = 0; k < depos.size(); ++k) depos_orig[k] = value(depos[k]);
+    for (size_t k = 0; k < shortOis.size(); ++k) shortOis_orig[k] = value(shortOis[k]);
+    for (size_t k = 0; k < datedOIS.size(); ++k) datedOIS_orig[k] = value(datedOIS[k]);
+    for (size_t k = 0; k < longTermOIS.size(); ++k) longTermOIS_orig[k] = value(longTermOIS[k]);
+
+    // XAD Tape Setup
+    using tape_type = Real::tape_type;
+    tape_type tape;
+    tape.registerInputs(depos);
+    tape.registerInputs(shortOis);
+    tape.registerInputs(datedOIS);
+    tape.registerInputs(longTermOIS);
+    tape.newRecording();
+
+    // Build curve helpers
+    auto eonia = ext::make_shared<Eonia>();
+    std::vector<ext::shared_ptr<RateHelper>> eoniaInstruments;
+
+    DayCounter depositDayCounter = Actual360();
+    std::vector<Natural> depoSettlementDays = {0, 1, 2};
+    for (size_t i = 0; i < depos.size(); ++i) {
+        auto quote = ext::make_shared<SimpleQuote>(depos[i]);
+        eoniaInstruments.push_back(ext::make_shared<DepositRateHelper>(
+            Handle<Quote>(quote), 1 * Days, depoSettlementDays[i],
+            calendar, Following, false, depositDayCounter));
+    }
+
+    std::vector<Period> shortOisTenors = {1 * Weeks, 2 * Weeks, 3 * Weeks, 1 * Months};
+    for (size_t i = 0; i < shortOis.size(); ++i) {
+        auto quote = ext::make_shared<SimpleQuote>(shortOis[i]);
+        eoniaInstruments.push_back(ext::make_shared<OISRateHelper>(
+            2, shortOisTenors[i], Handle<Quote>(quote), eonia));
+    }
+
+    std::vector<std::pair<Date, Date>> datedOisPeriods = {
+        {Date(16, January, 2013), Date(13, February, 2013)},
+        {Date(13, February, 2013), Date(13, March, 2013)},
+        {Date(13, March, 2013), Date(10, April, 2013)},
+        {Date(10, April, 2013), Date(8, May, 2013)},
+        {Date(8, May, 2013), Date(12, June, 2013)}
+    };
+    for (size_t i = 0; i < datedOIS.size(); ++i) {
+        auto quote = ext::make_shared<SimpleQuote>(datedOIS[i]);
+        eoniaInstruments.push_back(ext::make_shared<DatedOISRateHelper>(
+            datedOisPeriods[i].first, datedOisPeriods[i].second,
+            Handle<Quote>(quote), eonia));
+    }
+
+    std::vector<Period> longOisTenors = {
+        15 * Months, 18 * Months, 21 * Months, 2 * Years, 3 * Years, 4 * Years,
+        5 * Years, 6 * Years, 7 * Years, 8 * Years, 9 * Years, 10 * Years,
+        11 * Years, 12 * Years, 15 * Years, 20 * Years, 25 * Years, 30 * Years
+    };
+    for (size_t i = 0; i < longTermOIS.size(); ++i) {
+        auto quote = ext::make_shared<SimpleQuote>(longTermOIS[i]);
+        eoniaInstruments.push_back(ext::make_shared<OISRateHelper>(
+            2, longOisTenors[i], Handle<Quote>(quote), eonia));
+    }
+
+    // Bootstrap curve with XAD
+    auto eoniaTermStructure = ext::make_shared<PiecewiseYieldCurve<Discount, Cubic>>(
+        todaysDate, eoniaInstruments, termStructureDayCounter);
+    eoniaTermStructure->enableExtrapolation();
+
+    // Get XAD discount factors
+    std::vector<Period> sampleTenors = {1*Years, 2*Years, 5*Years, 10*Years, 30*Years};
+    std::vector<Real> df_xad(sampleTenors.size());
+    for (size_t i = 0; i < sampleTenors.size(); ++i) {
+        df_xad[i] = eoniaTermStructure->discount(todaysDate + sampleTenors[i]);
+    }
+
+    // Compute XAD derivatives for 5Y DF
+    Real df5Y = df_xad[2];
+    tape.registerOutput(df5Y);
+    derivative(df5Y) = 1.0;
+    tape.computeAdjoints();
+
+    std::vector<double> derivs_xad = {
+        derivative(depos[0]), derivative(shortOis[0]), derivative(longTermOIS[6])
+    };
+
+    tape.deactivate();
+
+    // =========================================================================
+    // Now compute "Original" (bump-and-reprice for derivatives)
+    // =========================================================================
+    auto buildCurve = [&](const std::vector<double>& d, const std::vector<double>& s,
+                          const std::vector<double>& dt, const std::vector<double>& lt) {
+        std::vector<ext::shared_ptr<RateHelper>> instruments;
+        for (size_t i = 0; i < d.size(); ++i) {
+            auto q = ext::make_shared<SimpleQuote>(d[i]);
+            instruments.push_back(ext::make_shared<DepositRateHelper>(
+                Handle<Quote>(q), 1 * Days, depoSettlementDays[i],
+                calendar, Following, false, depositDayCounter));
+        }
+        for (size_t i = 0; i < s.size(); ++i) {
+            auto q = ext::make_shared<SimpleQuote>(s[i]);
+            instruments.push_back(ext::make_shared<OISRateHelper>(
+                2, shortOisTenors[i], Handle<Quote>(q), eonia));
+        }
+        for (size_t i = 0; i < dt.size(); ++i) {
+            auto q = ext::make_shared<SimpleQuote>(dt[i]);
+            instruments.push_back(ext::make_shared<DatedOISRateHelper>(
+                datedOisPeriods[i].first, datedOisPeriods[i].second,
+                Handle<Quote>(q), eonia));
+        }
+        for (size_t i = 0; i < lt.size(); ++i) {
+            auto q = ext::make_shared<SimpleQuote>(lt[i]);
+            instruments.push_back(ext::make_shared<OISRateHelper>(
+                2, longOisTenors[i], Handle<Quote>(q), eonia));
+        }
+        auto curve = ext::make_shared<PiecewiseYieldCurve<Discount, Cubic>>(
+            todaysDate, instruments, termStructureDayCounter);
+        curve->enableExtrapolation();
+        return curve;
+    };
+
+    // Original discount factors
+    auto curve_orig = buildCurve(depos_orig, shortOis_orig, datedOIS_orig, longTermOIS_orig);
+    std::vector<double> df_orig(sampleTenors.size());
+    for (size_t i = 0; i < sampleTenors.size(); ++i) {
+        df_orig[i] = value(curve_orig->discount(todaysDate + sampleTenors[i]));
+    }
+
+    // Bump-and-reprice for derivatives
+    double bump = 1e-6;
+    std::vector<double> derivs_bump(3);
+
+    // Bump depos[0]
+    auto depos_bump = depos_orig; depos_bump[0] += bump;
+    auto curve_bump = buildCurve(depos_bump, shortOis_orig, datedOIS_orig, longTermOIS_orig);
+    derivs_bump[0] = (value(curve_bump->discount(todaysDate + 5*Years)) - df_orig[2]) / bump;
+
+    // Bump shortOis[0]
+    auto shortOis_bump = shortOis_orig; shortOis_bump[0] += bump;
+    curve_bump = buildCurve(depos_orig, shortOis_bump, datedOIS_orig, longTermOIS_orig);
+    derivs_bump[1] = (value(curve_bump->discount(todaysDate + 5*Years)) - df_orig[2]) / bump;
+
+    // Bump longTermOIS[6] (5Y OIS)
+    auto longTermOIS_bump = longTermOIS_orig; longTermOIS_bump[6] += bump;
+    curve_bump = buildCurve(depos_orig, shortOis_orig, datedOIS_orig, longTermOIS_bump);
+    derivs_bump[2] = (value(curve_bump->discount(todaysDate + 5*Years)) - df_orig[2]) / bump;
+
+    // =========================================================================
+    // TABLE: Discount Factor Comparison
+    // =========================================================================
+    std::cout << "  " << std::string(60, '=') << "\n";
+    std::cout << "  TABLE: DISCOUNT FACTORS\n";
+    std::cout << "  " << std::string(60, '=') << "\n";
+    std::cout << std::endl;
+
+    std::cout << "  " << std::setw(10) << "Tenor" << " | "
+              << std::setw(14) << "Original" << " | "
+              << std::setw(14) << "XAD Tape" << " | "
+              << std::setw(14) << "Difference" << "\n";
+    std::cout << "  " << std::string(10, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "\n";
+
+    bool allMatch = true;
+    for (size_t i = 0; i < sampleTenors.size(); ++i) {
+        double diff = value(df_xad[i]) - df_orig[i];
+        bool match = (std::abs(diff) < 1e-12);
+        if (!match) allMatch = false;
+
+        std::ostringstream tenor_str;
+        tenor_str << sampleTenors[i];
+
+        std::cout << "  " << std::setw(10) << tenor_str.str() << " | "
+                  << std::fixed << std::setprecision(8) << std::setw(14) << df_orig[i] << " | "
+                  << std::setw(14) << value(df_xad[i]) << " | "
+                  << std::scientific << std::setprecision(2) << std::setw(14) << diff << "\n";
+    }
+    std::cout << std::endl;
+
+    // =========================================================================
+    // TABLE: Derivatives Comparison (5Y DF)
+    // =========================================================================
+    std::cout << "  " << std::string(70, '=') << "\n";
+    std::cout << "  TABLE: DERIVATIVES OF DF(5Y) - Bump h=" << std::scientific << std::setprecision(0) << bump << "\n";
+    std::cout << "  " << std::string(70, '=') << "\n";
+    std::cout << std::endl;
+
+    std::vector<std::string> derivLabels = {"dDF/dDepo[0]", "dDF/dShortOIS[0]", "dDF/dLongOIS[6]"};
+
+    std::cout << "  " << std::setw(18) << "Sensitivity" << " | "
+              << std::setw(14) << "Bump&Reprice" << " | "
+              << std::setw(14) << "XAD Tape" << " | "
+              << std::setw(12) << "Rel Diff %" << "\n";
+    std::cout << "  " << std::string(18, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(12, '-') << "\n";
+
+    bool derivsMatch = true;
+    double maxRelDiff = 0.0;
+    for (size_t i = 0; i < 3; ++i) {
+        double diff = derivs_xad[i] - derivs_bump[i];
+        // Relative difference as percentage (use bump as reference since it's ground truth for comparison)
+        double relDiffPct = (std::abs(derivs_bump[i]) > 1e-15) ? (diff / derivs_bump[i] * 100.0) : 0.0;
+        maxRelDiff = std::max(maxRelDiff, std::abs(relDiffPct));
+        bool match = (std::abs(relDiffPct) < 0.01);  // 0.01% tolerance for bump vs AD
+        if (!match) derivsMatch = false;
+
+        std::cout << "  " << std::setw(18) << derivLabels[i] << " | "
+                  << std::scientific << std::setprecision(6) << std::setw(14) << derivs_bump[i] << " | "
+                  << std::setw(14) << derivs_xad[i] << " | "
+                  << std::fixed << std::setprecision(6) << std::setw(11) << relDiffPct << "%\n";
+    }
+    std::cout << std::endl;
+
+    std::cout << "  Values Match: " << (allMatch ? "YES" : "NO") << "\n";
+    std::cout << "  Derivatives: max rel diff " << std::fixed << std::setprecision(4) << maxRelDiff << "%"
+              << (derivsMatch ? " (OK)" : " (CHECK - some > 0.01%)") << "\n";
+    std::cout << std::endl;
+
+    std::cout << "  STATUS: [STAGE 1 COMPLETE]\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    BOOST_CHECK(value(df_xad[2]) > 0.0 && value(df_xad[2]) < 1.0);
+    BOOST_CHECK(allMatch);
+}
+
+// Disable intermediate development tests - Stage 2 Comparison covers everything
+#if 0
+
+//////////////////////////////////////////////////////////////////////////////
+// Stage 2a: Monte Carlo Swaption Pricing - Original (No XAD)
+// Direct adaptation from test-suite/libormarketmodel.cpp testSwaptionPricing
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testStage2a_MonteCarloSwaptionOriginal)
+{
+    BOOST_TEST_MESSAGE("Testing Stage 2a: Monte Carlo Swaption Pricing (Original, no XAD)...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  STAGE 2a: Monte Carlo Swaption Pricing (Original - No XAD)\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Setup: Create yield curve and LMM process
+    // Based on libormarketmodel.cpp testSwaptionPricing
+    // -------------------------------------------------------------------------
+    const Size size = 10;
+    const Size steps = 8 * size;
+
+    std::vector<Date> dates = {{4, September, 2005}, {4, September, 2011}};
+    std::vector<Rate> rates = {0.04, 0.08};
+
+    ext::shared_ptr<IborIndex> index = makeIndex(dates, rates);
+
+    ext::shared_ptr<LiborForwardModelProcess> process(
+        new LiborForwardModelProcess(size, index));
+
+    // Correlation and volatility models
+    ext::shared_ptr<LmCorrelationModel> corrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+
+    ext::shared_ptr<LmVolatilityModel> volaModel(
+        new LmLinearExponentialVolatilityModel(process->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+
+    // Set up covariance
+    process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(volaModel, corrModel)));
+
+    std::cout << "  LMM Process Setup:\n";
+    std::cout << "    - Number of forward rates: " << size << "\n";
+    std::cout << "    - MC time steps: " << steps << "\n";
+    std::cout << "    - Correlation model: Exponential (rho=0.5)\n";
+    std::cout << "    - Volatility model: Linear-Exponential\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Monte Carlo setup
+    // -------------------------------------------------------------------------
+    typedef PseudoRandom::rsg_type rsg_type;
+    typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+
+    std::vector<Time> tmp = process->fixingTimes();
+    TimeGrid grid(tmp.begin(), tmp.end(), steps);
+
+    std::vector<Size> location;
+    for (Size i = 0; i < tmp.size(); ++i) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), tmp[i]) - grid.begin());
+    }
+
+    rsg_type rsg = PseudoRandom::make_sequence_generator(
+        process->factors() * (grid.size() - 1), BigNatural(42));
+
+    const Size nrTrails = 5000;
+    MultiPathGenerator<rsg_type> generator(process, grid, rsg, false);
+
+    ext::shared_ptr<LiborForwardModel> liborModel(
+        new LiborForwardModel(process, volaModel, corrModel));
+
+    std::cout << "  Monte Carlo Configuration:\n";
+    std::cout << "    - Number of paths: " << nrTrails << "\n";
+    std::cout << "    - Random seed: 42\n";
+    std::cout << "    - Antithetic variates: Yes\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Price a single swaption using MC
+    // -------------------------------------------------------------------------
+    Calendar calendar = index->fixingCalendar();
+    DayCounter dayCounter = index->forwardingTermStructure()->dayCounter();
+    BusinessDayConvention convention = index->businessDayConvention();
+    Date settlement = index->forwardingTermStructure()->referenceDate();
+
+    // Price a 2Y into 2Y swaption (i=2, j=2 means 2x6M = 1Y option, 2x6M = 1Y swap)
+    // Let's use i=2, j=2 for a simpler case
+    Size i = 2;
+    Size j = 2;
+
+    Date fwdStart = settlement + Period(6 * i, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j, Months);
+
+    Schedule schedule(fwdStart, fwdMaturity, index->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    // Get fair swap rate
+    Rate swapRate = 0.0404;
+    ext::shared_ptr<VanillaSwap> forwardSwap(
+        new VanillaSwap(Swap::Receiver, 1.0,
+                        schedule, swapRate, dayCounter,
+                        schedule, index, 0.0, index->dayCounter()));
+    forwardSwap->setPricingEngine(ext::shared_ptr<PricingEngine>(
+        new DiscountingSwapEngine(index->forwardingTermStructure())));
+
+    swapRate = forwardSwap->fairRate();
+    forwardSwap = ext::make_shared<VanillaSwap>(
+        Swap::Receiver, 1.0,
+        schedule, swapRate, dayCounter,
+        schedule, index, 0.0, index->dayCounter());
+    forwardSwap->setPricingEngine(ext::shared_ptr<PricingEngine>(
+        new DiscountingSwapEngine(index->forwardingTermStructure())));
+
+    // Analytic price using LfmSwaptionEngine
+    ext::shared_ptr<PricingEngine> engine(
+        new LfmSwaptionEngine(liborModel, index->forwardingTermStructure()));
+    ext::shared_ptr<Exercise> exercise(
+        new EuropeanExercise(process->fixingDates()[i]));
+
+    auto swaption = ext::make_shared<Swaption>(forwardSwap, exercise);
+    swaption->setPricingEngine(engine);
+    Real analyticPrice = swaption->NPV();
+
+    std::cout << "  Swaption Details:\n";
+    std::cout << "    - Option maturity: " << i << " x 6M = " << (i*6) << " months\n";
+    std::cout << "    - Swap tenor: " << j << " x 6M = " << (j*6) << " months\n";
+    std::cout << "    - Fair swap rate: " << std::fixed << std::setprecision(4)
+              << (swapRate * 100) << "%\n";
+    std::cout << "    - Analytic price (LFM): " << std::setprecision(6) << analyticPrice << "\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Monte Carlo pricing loop
+    // -------------------------------------------------------------------------
+    GeneralStatistics stat;
+
+    for (Size n = 0; n < nrTrails; ++n) {
+        sample_type path = (n % 2) != 0U ? generator.antithetic() : generator.next();
+
+        std::vector<Rate> mcRates(size);
+        for (Size k = 0; k < process->size(); ++k) {
+            mcRates[k] = path.value[k][location[i]];
+        }
+        std::vector<DiscountFactor> dis = process->discountBond(mcRates);
+
+        Real npv = 0.0;
+        for (Size m = i; m < i + j; ++m) {
+            npv += (swapRate - mcRates[m])
+                   * (process->accrualEndTimes()[m] - process->accrualStartTimes()[m])
+                   * dis[m];
+        }
+        stat.add(std::max(npv, 0.0));
+    }
+
+    Real mcPrice = stat.mean();
+    Real mcError = stat.errorEstimate();
+
+    std::cout << "  Monte Carlo Results:\n";
+    std::cout << "    - MC price: " << std::setprecision(6) << mcPrice << "\n";
+    std::cout << "    - MC error estimate: " << std::setprecision(6) << mcError << "\n";
+    std::cout << "    - Analytic price: " << std::setprecision(6) << analyticPrice << "\n";
+    std::cout << "    - Difference: " << std::setprecision(6)
+              << std::fabs(mcPrice - analyticPrice) << "\n";
+    std::cout << "    - Within 2.35 std errors: "
+              << (std::fabs(mcPrice - analyticPrice) < 2.35 * mcError ? "YES" : "NO") << "\n";
+    std::cout << std::endl;
+
+    std::cout << "  STATUS: [STAGE 2a COMPLETE - Original MC swaption pricing working]\n";
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    // Verify MC price is close to analytic
+    BOOST_CHECK(std::fabs(mcPrice - analyticPrice) < 2.35 * mcError);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Stage 2b: Monte Carlo Swaption Pricing with XAD Derivatives
+// Same as 2a but computing sensitivities using XAD tape
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testStage2b_MonteCarloSwaptionWithXAD)
+{
+    BOOST_TEST_MESSAGE("Testing Stage 2b: Monte Carlo Swaption Pricing with XAD Derivatives...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  STAGE 2b: Monte Carlo Swaption Pricing (With XAD Derivatives)\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Setup: Same as 2a but with XAD tape
+    // -------------------------------------------------------------------------
+    const Size size = 10;
+    const Size steps = 8 * size;
+
+    std::vector<Date> dates = {{4, September, 2005}, {4, September, 2011}};
+    std::vector<Real> rates = {0.04, 0.08};  // These will be our inputs
+
+    // XAD Tape setup
+    using tape_type = Real::tape_type;
+    tape_type tape;
+
+    // Register curve rates as inputs
+    tape.registerInputs(rates);
+    tape.newRecording();
+
+    std::cout << "  XAD Tape Setup:\n";
+    std::cout << "    - Registered inputs: " << rates.size() << " curve rates\n";
+    std::cout << "    - rates[0] = " << value(rates[0]) << " (short rate)\n";
+    std::cout << "    - rates[1] = " << value(rates[1]) << " (long rate)\n";
+    std::cout << std::endl;
+
+    // Create index with XAD-enabled rates
+    ext::shared_ptr<IborIndex> index = makeIndex(dates, rates);
+
+    ext::shared_ptr<LiborForwardModelProcess> process(
+        new LiborForwardModelProcess(size, index));
+
+    ext::shared_ptr<LmCorrelationModel> corrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+
+    ext::shared_ptr<LmVolatilityModel> volaModel(
+        new LmLinearExponentialVolatilityModel(process->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+
+    process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(volaModel, corrModel)));
+
+    // Monte Carlo setup
+    typedef PseudoRandom::rsg_type rsg_type;
+    typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+
+    std::vector<Time> tmp = process->fixingTimes();
+    TimeGrid grid(tmp.begin(), tmp.end(), steps);
+
+    std::vector<Size> location;
+    for (Size i = 0; i < tmp.size(); ++i) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), tmp[i]) - grid.begin());
+    }
+
+    rsg_type rsg = PseudoRandom::make_sequence_generator(
+        process->factors() * (grid.size() - 1), BigNatural(42));
+
+    const Size nrTrails = 2000;  // Fewer paths for speed with XAD
+    MultiPathGenerator<rsg_type> generator(process, grid, rsg, false);
+
+    ext::shared_ptr<LiborForwardModel> liborModel(
+        new LiborForwardModel(process, volaModel, corrModel));
+
+    std::cout << "  Monte Carlo with XAD:\n";
+    std::cout << "    - Number of paths: " << nrTrails << " (reduced for XAD overhead)\n";
+    std::cout << std::endl;
+
+    // Swaption setup
+    Calendar calendar = index->fixingCalendar();
+    DayCounter dayCounter = index->forwardingTermStructure()->dayCounter();
+    BusinessDayConvention convention = index->businessDayConvention();
+    Date settlement = index->forwardingTermStructure()->referenceDate();
+
+    Size i = 2;
+    Size j = 2;
+
+    Date fwdStart = settlement + Period(6 * i, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j, Months);
+
+    Schedule schedule(fwdStart, fwdMaturity, index->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    Rate swapRate = 0.0404;
+    ext::shared_ptr<VanillaSwap> forwardSwap(
+        new VanillaSwap(Swap::Receiver, 1.0,
+                        schedule, swapRate, dayCounter,
+                        schedule, index, 0.0, index->dayCounter()));
+    forwardSwap->setPricingEngine(ext::shared_ptr<PricingEngine>(
+        new DiscountingSwapEngine(index->forwardingTermStructure())));
+
+    swapRate = forwardSwap->fairRate();
+
+    std::cout << "  Swaption Details:\n";
+    std::cout << "    - Fair swap rate: " << std::fixed << std::setprecision(4)
+              << (value(swapRate) * 100) << "%\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Monte Carlo pricing with tape recording
+    // -------------------------------------------------------------------------
+    Real mcPrice = 0.0;
+
+    for (Size n = 0; n < nrTrails; ++n) {
+        sample_type path = (n % 2) != 0U ? generator.antithetic() : generator.next();
+
+        std::vector<Rate> mcRates(size);
+        for (Size k = 0; k < process->size(); ++k) {
+            mcRates[k] = path.value[k][location[i]];
+        }
+        std::vector<DiscountFactor> dis = process->discountBond(mcRates);
+
+        Real npv = 0.0;
+        for (Size m = i; m < i + j; ++m) {
+            npv += (swapRate - mcRates[m])
+                   * (process->accrualEndTimes()[m] - process->accrualStartTimes()[m])
+                   * dis[m];
+        }
+
+        // Swaption payoff: max(npv, 0)
+        if (value(npv) > 0.0) {
+            mcPrice += npv;
+        }
+    }
+    mcPrice /= static_cast<Real>(nrTrails);
+
+    std::cout << "  Monte Carlo Price: " << std::setprecision(6) << value(mcPrice) << "\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Compute derivatives using XAD
+    // -------------------------------------------------------------------------
+    tape.registerOutput(mcPrice);
+    derivative(mcPrice) = 1.0;
+    tape.computeAdjoints();
+
+    std::cout << "  XAD Derivatives (dPrice/dCurveRates):\n";
+    std::cout << "    dPrice/dRate[0] (short rate) = " << std::scientific
+              << std::setprecision(4) << derivative(rates[0]) << "\n";
+    std::cout << "    dPrice/dRate[1] (long rate)  = " << derivative(rates[1]) << "\n";
+    std::cout << std::endl;
+
+    // Also output derivatives w.r.t. initial forward rates for comparison with Stage 2c
+    Array initFwdRates = process->initialValues();
+    std::cout << "  XAD Derivatives (dPrice/dInitialForwardRates) - for comparison with 2c:\n";
+    for (Size k = 0; k < size; ++k) {
+        std::cout << "    dPrice/dInitRate[" << k << "] = " << std::scientific
+                  << std::setprecision(4) << derivative(initFwdRates[k]) << "\n";
+    }
+    std::cout << std::endl;
+
+    std::cout << "  STATUS: [STAGE 2b COMPLETE - MC swaption with XAD derivatives working]\n";
+    std::cout << "\n";
+    std::cout << "  NOTE: These derivatives are w.r.t. the ZeroCurve input rates.\n";
+    std::cout << "        In Stage 3, we will connect these back to the bootstrapped\n";
+    std::cout << "        curve from Stage 1 to get dPrice/dMarketQuotes.\n";
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    // Verify we got a price and non-zero derivatives
+    BOOST_CHECK(value(mcPrice) > 0.0);
+    // At least one derivative should be non-zero
+    BOOST_CHECK(derivative(rates[0]) != 0.0 || derivative(rates[1]) != 0.0);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Stage 2ci: JIT Path Evolution Verification Test
+// Simple test to verify JIT correctly records and replays process->evolve()
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testStage2ci_JITPathEvolutionVerification)
+{
+    BOOST_TEST_MESSAGE("Testing Stage 2ci: JIT Path Evolution Verification...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  STAGE 2ci: JIT Path Evolution Verification\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    std::cout << "  PURPOSE:\n";
+    std::cout << "    Verify JIT correctly records and replays process->evolve()\n";
+    std::cout << "    by comparing JIT output vs direct call for a few paths.\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Setup: Create yield curve and LMM process (same as 2c but simpler params)
+    // -------------------------------------------------------------------------
+    const Size size = 5;  // Fewer forward rates for clarity
+    const Size steps = 8 * size;
+
+    std::vector<Date> dates = {{4, September, 2005}, {4, September, 2011}};
+    std::vector<Rate> rates_ql = {0.04, 0.08};
+
+    ext::shared_ptr<IborIndex> index = makeIndex(dates, rates_ql);
+
+    ext::shared_ptr<LiborForwardModelProcess> process(
+        new LiborForwardModelProcess(size, index));
+
+    ext::shared_ptr<LmCorrelationModel> corrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+
+    ext::shared_ptr<LmVolatilityModel> volaModel(
+        new LmLinearExponentialVolatilityModel(process->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+
+    process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(volaModel, corrModel)));
+
+    // Get initial forward rates
+    Array initRates = process->initialValues();
+    Size numFactors = process->factors();
+
+    std::cout << "  Setup:\n";
+    std::cout << "    - Forward rates (size): " << size << "\n";
+    std::cout << "    - Factors: " << numFactors << "\n";
+    std::cout << "    - Initial rates:\n";
+    for (Size k = 0; k < size; ++k) {
+        std::cout << "      rate[" << k << "] = " << std::fixed << std::setprecision(6)
+                  << value(initRates[k]) << "\n";
+    }
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Test parameters
+    // -------------------------------------------------------------------------
+    Time t0 = 0.0;
+    Time dt = 0.25;  // 3-month step
+    const Size numTestPaths = 3;
+
+    // Pre-generate random numbers for the test paths
+    std::vector<std::vector<double>> testRandoms(numTestPaths);
+    testRandoms[0] = {0.1, 0.2, 0.3, 0.4, 0.5};   // Path 0: positive randoms
+    testRandoms[1] = {-0.3, -0.2, 0.0, 0.2, 0.3}; // Path 1: mixed randoms
+    testRandoms[2] = {0.5, -0.5, 0.5, -0.5, 0.5}; // Path 2: alternating
+
+    // Ensure we have enough randoms for the number of factors
+    for (Size p = 0; p < numTestPaths; ++p) {
+        testRandoms[p].resize(numFactors, 0.0);
+    }
+
+    // -------------------------------------------------------------------------
+    // Part 1: Direct call to process->evolve() (ground truth)
+    // -------------------------------------------------------------------------
+    std::cout << "  Part 1: Direct evolve() calls (ground truth):\n";
+
+    std::vector<Array> directResults(numTestPaths);
+    for (Size p = 0; p < numTestPaths; ++p) {
+        Array dw(numFactors);
+        for (Size f = 0; f < numFactors; ++f) {
+            dw[f] = testRandoms[p][f];
+        }
+
+        directResults[p] = process->evolve(t0, initRates, dt, dw);
+
+        std::cout << "    Path " << p << " evolved rates:\n";
+        for (Size k = 0; k < size; ++k) {
+            std::cout << "      evolved[" << k << "] = " << std::setprecision(8)
+                      << value(directResults[p][k]) << "\n";
+        }
+    }
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Part 2: JIT recording of evolve()
+    // -------------------------------------------------------------------------
+    std::cout << "  Part 2: JIT recording of evolve():\n";
+
+    auto forgeBackend1 = std::make_unique<xad::forge::ForgeBackend<double>>();
+    xad::JITCompiler<double> jit(std::move(forgeBackend1));
+
+    // JIT inputs: initial rates + random numbers
+    std::vector<xad::AD> jit_initRates(size);
+    std::vector<xad::AD> jit_randoms(numFactors);
+
+    // Register initial rates as JIT inputs
+    for (Size k = 0; k < size; ++k) {
+        jit_initRates[k] = xad::AD(value(initRates[k]));
+        jit.registerInput(jit_initRates[k]);
+    }
+    std::cout << "    Registered " << size << " initial rates as JIT inputs\n";
+
+    // Register random numbers as JIT inputs
+    for (Size f = 0; f < numFactors; ++f) {
+        jit_randoms[f] = xad::AD(0.0);  // Will be set per-path
+        jit.registerInput(jit_randoms[f]);
+    }
+    std::cout << "    Registered " << numFactors << " random numbers as JIT inputs\n";
+
+    // Check initRates BEFORE newRecording
+    std::cout << "    initRate shouldRecord BEFORE newRecording: [";
+    for (Size k = 0; k < size; ++k) {
+        if (k > 0) std::cout << ", ";
+        std::cout << (jit_initRates[k].shouldRecord() ? "Y" : "N");
+    }
+    std::cout << "]\n";
+
+    // Start JIT recording
+    jit.newRecording();
+
+    // Check initRates AFTER newRecording
+    std::cout << "    initRate shouldRecord AFTER newRecording: [";
+    for (Size k = 0; k < size; ++k) {
+        if (k > 0) std::cout << ", ";
+        std::cout << (jit_initRates[k].shouldRecord() ? "Y" : "N");
+    }
+    std::cout << "]\n";
+
+    // Check JIT activation status
+    std::cout << "    JIT active after newRecording: " << (jit.isActive() ? "YES" : "NO") << "\n";
+    std::cout << "    JIT::getActive(): " << (xad::JITCompiler<double>::getActive() ? "set" : "null") << "\n";
+
+    // Check if there's an active tape (which would block JIT recording!)
+    using tape_type = Real::tape_type;
+    std::cout << "    Tape::getActive(): " << (tape_type::getActive() ? "ACTIVE (blocks JIT!)" : "null (good)") << "\n";
+
+    // Build input arrays from JIT variables
+    // WORKAROUND: AReal::operator=(const AReal&) doesn't handle JIT!
+    // Using * 1.0 creates an Expression that DOES record to JIT.
+    // NOTE: +0.0 creates an ADD node but the adjoint might be lost
+    // * 1.0 creates a MUL node with adjoint d/da(a*1) = 1
+    Array jit_asset_arr(size);
+    for (Size k = 0; k < size; ++k) {
+        jit_asset_arr[k] = jit_initRates[k] * xad::AD(1.0);  // Force Expression path with identity
+    }
+
+    // Check if jit_asset_arr elements have JIT slots
+    std::cout << "    After copying to Array (with *1.0 workaround):\n";
+    for (Size k = 0; k < size; ++k) {
+        std::cout << "      jit_asset_arr[" << k << "].shouldRecord() = "
+                  << (jit_asset_arr[k].shouldRecord() ? "true" : "false") << "\n";
+    }
+
+    Array jit_dw(numFactors);
+    for (Size f = 0; f < numFactors; ++f) {
+        jit_dw[f] = jit_randoms[f] * xad::AD(1.0);  // Force Expression path with identity
+    }
+
+    // Call process->evolve() - this should record to JIT graph
+    std::cout << "    Calling process->evolve(t0=" << t0 << ", initRates, dt=" << dt << ", dw)\n";
+    Array jit_evolved = process->evolve(t0, jit_asset_arr, dt, jit_dw);
+
+    // Register outputs directly from evolved array
+    std::cout << "    Checking evolved array before registration:\n";
+    Size numJitOutputs = 0;
+    std::vector<Size> jitOutputIndices;  // Track which indices have JIT outputs
+    for (Size k = 0; k < size; ++k) {
+        bool shouldRec = jit_evolved[k].shouldRecord();
+        std::cout << "      evolved[" << k << "].shouldRecord() = " << (shouldRec ? "true" : "false")
+                  << ", value = " << value(jit_evolved[k]) << "\n";
+        jit.registerOutput(jit_evolved[k]);
+        if (shouldRec) {
+            numJitOutputs++;
+            jitOutputIndices.push_back(k);
+        }
+    }
+
+    // Check how many outputs were actually registered
+    std::cout << "    JIT graph output count: " << jit.getGraph().output_ids.size() << "\n";
+    std::cout << "    JIT graph node count: " << jit.getGraph().nodeCount() << "\n";
+    std::cout << "    Outputs with JIT slots: " << numJitOutputs << " (indices:";
+    for (Size idx : jitOutputIndices) std::cout << " " << idx;
+    std::cout << ")\n";
+
+    // Compile the JIT kernel
+    jit.compile();
+    std::cout << "    JIT kernel compiled.\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Part 3: Execute JIT kernel with test inputs and compare
+    // -------------------------------------------------------------------------
+    std::cout << "  Part 3: JIT execution and comparison:\n";
+
+    // Note: JIT only registered outputs for elements with shouldRecord()=true
+    // We need to pass exactly numJitOutputs to forward()
+    if (numJitOutputs == 0) {
+        std::cout << "    ERROR: No JIT outputs registered! Cannot test.\n";
+        BOOST_CHECK(false);
+        return;
+    }
+
+    bool allMatch = true;
+    double tolerance = 1e-10;
+
+    for (Size p = 0; p < numTestPaths; ++p) {
+        // Set JIT inputs: initial rates (same for all paths)
+        for (Size k = 0; k < size; ++k) {
+            value(jit_initRates[k]) = value(initRates[k]);
+        }
+
+        // Set JIT inputs: random numbers (different per path)
+        for (Size f = 0; f < numFactors; ++f) {
+            value(jit_randoms[f]) = testRandoms[p][f];
+        }
+
+        // Execute JIT kernel - only get outputs for registered elements
+        std::vector<double> jitResults(numJitOutputs);
+        jit.forward(jitResults.data(), numJitOutputs);
+
+        // Compare with direct results (only for indices that have JIT outputs)
+        std::cout << "    Path " << p << ":\n";
+        bool pathMatch = true;
+        for (Size i = 0; i < numJitOutputs; ++i) {
+            Size k = jitOutputIndices[i];  // Map back to original index
+            double directVal = value(directResults[p][k]);
+            double jitVal = jitResults[i];
+            double diff = std::abs(directVal - jitVal);
+            bool match = diff < tolerance;
+
+            std::cout << "      evolved[" << k << "]: direct=" << std::setprecision(8) << directVal
+                      << " JIT=" << jitVal
+                      << " diff=" << std::scientific << diff
+                      << (match ? " OK" : " MISMATCH!") << std::fixed << "\n";
+
+            if (!match) {
+                pathMatch = false;
+                allMatch = false;
+            }
+        }
+        // Also note evolved[0] if it wasn't JIT tracked
+        if (jitOutputIndices.empty() || jitOutputIndices[0] != 0) {
+            std::cout << "      evolved[0]: (not JIT tracked, skipped)\n";
+        }
+        if (!pathMatch) {
+            std::cout << "      PATH " << p << " FAILED!\n";
+        }
+    }
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Part 4: Test derivatives (optional, to debug the derivative issue)
+    // -------------------------------------------------------------------------
+    std::cout << "  Part 4: JIT derivatives (dEvolved/dInitRate):\n";
+
+    // Use path 0 for derivative test
+    for (Size k = 0; k < size; ++k) {
+        value(jit_initRates[k]) = value(initRates[k]);
+    }
+    for (Size f = 0; f < numFactors; ++f) {
+        value(jit_randoms[f]) = testRandoms[0][f];
+    }
+
+    std::vector<double> dummy(numJitOutputs);
+    jit.forward(dummy.data(), numJitOutputs);
+
+    // Seed derivative for first JIT output and compute adjoints
+    // Note: evolved[0] might not have a JIT slot, use first tracked output
+    Size firstOutputIdx = jitOutputIndices[0];
+
+    // Debug: Check slot IDs
+    std::cout << "    Debug - JIT graph info:\n";
+    std::cout << "      graph.output_ids: [";
+    for (Size i = 0; i < jit.getGraph().output_ids.size(); ++i) {
+        if (i > 0) std::cout << ", ";
+        std::cout << jit.getGraph().output_ids[i];
+    }
+    std::cout << "]\n";
+    std::cout << "      graph.input_ids: [";
+    for (Size i = 0; i < jit.getGraph().input_ids.size(); ++i) {
+        if (i > 0) std::cout << ", ";
+        std::cout << jit.getGraph().input_ids[i];
+    }
+    std::cout << "]\n";
+    std::cout << "      evolved shouldRecord: [";
+    for (Size k = 0; k < size; ++k) {
+        if (k > 0) std::cout << ", ";
+        std::cout << (jit_evolved[k].shouldRecord() ? "Y" : "N");
+    }
+    std::cout << "]\n";
+    std::cout << "      initRate shouldRecord: [";
+    for (Size k = 0; k < size; ++k) {
+        if (k > 0) std::cout << ", ";
+        std::cout << (jit_initRates[k].shouldRecord() ? "Y" : "N");
+    }
+    std::cout << "]\n";
+
+    jit.clearDerivatives();
+
+    // Debug: The output_ids are [73, 120, 170, 223] for outputs 1,2,3,4
+    // We need to seed the derivative at the OUTPUT slot, not just any slot
+    // graph.output_ids[0] = 73 is the first registered output
+    // But what is jit_evolved[1].slot_?
+    // If they're different, seeding derivative(jit_evolved[1]) won't work!
+
+    // Try seeding directly via the graph output ID instead
+    std::cout << "      graph.output_ids[0] = " << jit.getGraph().output_ids[0] << "\n";
+    std::cout << "      Setting derivative at graph.output_ids[0] to 1.0\n";
+    jit.setDerivative(jit.getGraph().output_ids[0], 1.0);
+
+    // Verify it was set
+    std::cout << "      Derivative at slot " << jit.getGraph().output_ids[0] << " = "
+              << jit.getDerivative(jit.getGraph().output_ids[0]) << "\n";
+
+    jit.computeAdjoints();
+
+    // Check derivatives at input slots directly
+    std::cout << "    Raw derivatives at input slots (after computeAdjoints):\n";
+    for (Size i = 0; i < jit.getGraph().input_ids.size(); ++i) {
+        uint32_t inputId = jit.getGraph().input_ids[i];
+        std::cout << "      derivatives_[input_ids[" << i << "]=" << inputId << "] = "
+                  << jit.getDerivative(inputId) << "\n";
+    }
+
+    std::cout << "    For evolved[" << firstOutputIdx << "], derivatives w.r.t. initRates:\n";
+    for (Size k = 0; k < size; ++k) {
+        double deriv = derivative(jit_initRates[k]);
+        std::cout << "      dEvolved[" << firstOutputIdx << "]/dInitRate[" << k << "] = " << std::scientific
+                  << std::setprecision(4) << deriv << std::fixed << "\n";
+    }
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Summary
+    // -------------------------------------------------------------------------
+    std::cout << "  RESULT: " << (allMatch ? "ALL PATHS MATCH!" : "SOME PATHS FAILED!") << "\n";
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    BOOST_CHECK(allMatch);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Stage 2c: Monte Carlo Swaption Pricing with JIT Compiler
+// Same as 2b but using JITCompiler for the MC payoff evaluation
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testStage2c_MonteCarloSwaptionWithJIT)
+{
+    BOOST_TEST_MESSAGE("Testing Stage 2c: Monte Carlo Swaption Pricing with JIT Compiler...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  STAGE 2c: Monte Carlo Swaption Pricing (With JIT Compiler)\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    std::cout << "  KEY DIFFERENCE FROM 2b:\n";
+    std::cout << "    - 2b: XAD Tape records ALL operations in MC loop (slow)\n";
+    std::cout << "    - 2c: JIT compiles ENTIRE path evolution + payoff ONCE,\n";
+    std::cout << "          then re-executes with different random numbers (FAST)\n";
+    std::cout << "    - NO TAPE used in 2c - pure JIT only!\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Setup: Create yield curve and LMM process
+    // -------------------------------------------------------------------------
+    const Size size = 10;
+    const Size steps = 8 * size;
+
+    std::vector<Date> dates = {{4, September, 2005}, {4, September, 2011}};
+    std::vector<Rate> rates_ql = {0.04, 0.08};
+
+    ext::shared_ptr<IborIndex> index = makeIndex(dates, rates_ql);
+
+    ext::shared_ptr<LiborForwardModelProcess> process(
+        new LiborForwardModelProcess(size, index));
+
+    ext::shared_ptr<LmCorrelationModel> corrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+
+    ext::shared_ptr<LmVolatilityModel> volaModel(
+        new LmLinearExponentialVolatilityModel(process->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+
+    process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(volaModel, corrModel)));
+
+    // Time grid setup
+    std::vector<Time> fixingTimes = process->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+    // Find location of each fixing time in the grid
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    // Swaption parameters
+    Size i = 2;  // Option expiry index (12M)
+    Size j = 2;  // Swap length index (12M swap)
+
+    // Get fair swap rate
+    Calendar calendar = index->fixingCalendar();
+    DayCounter dayCounter = index->forwardingTermStructure()->dayCounter();
+    BusinessDayConvention convention = index->businessDayConvention();
+    Date settlement = index->forwardingTermStructure()->referenceDate();
+
+    Date fwdStart = settlement + Period(6 * i, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j, Months);
+
+    Schedule schedule(fwdStart, fwdMaturity, index->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    Rate swapRate_ql = 0.0404;
+    ext::shared_ptr<VanillaSwap> forwardSwap(
+        new VanillaSwap(Swap::Receiver, 1.0,
+                        schedule, swapRate_ql, dayCounter,
+                        schedule, index, 0.0, index->dayCounter()));
+    forwardSwap->setPricingEngine(ext::shared_ptr<PricingEngine>(
+        new DiscountingSwapEngine(index->forwardingTermStructure())));
+
+    double swapRate_double = value(forwardSwap->fairRate());
+
+    // -------------------------------------------------------------------------
+    // JIT Setup: Determine dimensions
+    // -------------------------------------------------------------------------
+    Size numFactors = process->factors();
+    Size exerciseStep = location[i];  // Grid step at exercise time
+    Size totalRandoms = numFactors * exerciseStep;  // Randoms needed up to exercise
+
+    const Size nrTrails = 2000;
+
+    std::cout << "  Setup:\n";
+    std::cout << "    - Forward rates: " << size << "\n";
+    std::cout << "    - Exercise at step: " << exerciseStep << " (of " << grid.size()-1 << " total)\n";
+    std::cout << "    - Random numbers per path: " << totalRandoms << "\n";
+    std::cout << "    - MC paths: " << nrTrails << "\n";
+    std::cout << "    - Fair swap rate: " << std::fixed << std::setprecision(4)
+              << (swapRate_double * 100) << "%\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // JIT: Record ENTIRE path evolution + payoff (NO TAPE!)
+    // -------------------------------------------------------------------------
+    std::cout << "  JIT Compilation Phase:\n";
+    std::cout << "    Recording path evolution + payoff into JIT graph...\n";
+
+    // Create JIT compiler with ForgeBackend (NO TAPE!)
+    auto forgeBackend2 = std::make_unique<xad::forge::ForgeBackend<double>>();
+    xad::JITCompiler<double> jit(std::move(forgeBackend2));
+
+    // JIT inputs: initial forward rates + all random numbers up to exercise
+    std::vector<xad::AD> jit_initRates(size);
+    std::vector<xad::AD> jit_randoms(totalRandoms);
+
+    // Get initial forward rates from process
+    Array initRates = process->initialValues();
+
+    // Register initial rates as JIT inputs
+    for (Size k = 0; k < size; ++k) {
+        jit_initRates[k] = xad::AD(value(initRates[k]));
+        jit.registerInput(jit_initRates[k]);
+    }
+
+    // Register random numbers as JIT inputs
+    for (Size m = 0; m < totalRandoms; ++m) {
+        jit_randoms[m] = xad::AD(0.0);
+        jit.registerInput(jit_randoms[m]);
+    }
+
+    jit.newRecording();
+
+    // ----- Record path evolution up to exercise time -----
+    std::vector<xad::AD> asset(size);
+    for (Size k = 0; k < size; ++k) {
+        asset[k] = jit_initRates[k];  // Start from JIT inputs!
+    }
+
+    // Evolve through time steps up to exercise
+    for (Size step = 1; step <= exerciseStep; ++step) {
+        Size offset = (step - 1) * numFactors;
+        Time t = grid[step - 1];
+        Time dt = grid.dt(step - 1);
+
+        // Extract random numbers for this time step
+        Array dw(numFactors);
+        for (Size f = 0; f < numFactors; ++f) {
+            dw[f] = jit_randoms[offset + f];
+        }
+
+        // Convert asset to Array for evolve call
+        Array asset_arr(size);
+        for (Size k = 0; k < size; ++k) {
+            asset_arr[k] = asset[k];
+        }
+
+        // Call process->evolve (JIT records this!)
+        Array evolved = process->evolve(t, asset_arr, dt, dw);
+
+        // Store back
+        for (Size k = 0; k < size; ++k) {
+            asset[k] = evolved[k];
+        }
+    }
+
+    // ----- Compute discount factors from evolved rates -----
+    std::vector<xad::AD> dis(size);
+    xad::AD df = xad::AD(1.0);
+    for (Size k = 0; k < size; ++k) {
+        double accrual = value(process->accrualEndTimes()[k]) - value(process->accrualStartTimes()[k]);
+        df = df / (xad::AD(1.0) + asset[k] * accrual);
+        dis[k] = df;
+    }
+
+    // ----- Compute swaption payoff -----
+    xad::AD jit_swapRate(swapRate_double);
+    xad::AD jit_npv = xad::AD(0.0);
+
+    for (Size m = i; m < i + j; ++m) {
+        double accrual = value(process->accrualEndTimes()[m]) - value(process->accrualStartTimes()[m]);
+        jit_npv = jit_npv + (jit_swapRate - asset[m]) * accrual * dis[m];
+    }
+
+    // Swaption payoff: max(npv, 0) using ABool::If
+    xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+
+    jit.registerOutput(jit_payoff);
+
+    std::cout << "    JIT inputs: " << size << " initial rates + " << totalRandoms << " randoms\n";
+    std::cout << "    JIT graph: initRates -> evolve (x" << exerciseStep << " steps) -> payoff\n";
+
+    // Compile the JIT kernel before MC loop
+    jit.compile();
+    std::cout << "    JIT kernel compiled.\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Monte Carlo loop: re-execute JIT with different random numbers
+    // -------------------------------------------------------------------------
+    std::cout << "  Monte Carlo with JIT:\n";
+
+    typedef PseudoRandom::rsg_type rsg_type;
+    rsg_type rsg = PseudoRandom::make_sequence_generator(totalRandoms, BigNatural(42));
+
+    double mcPrice_jit = 0.0;
+    std::vector<double> dPrice_dInitRates(size, 0.0);
+
+    for (Size n = 0; n < nrTrails; ++n) {
+        // Get random numbers for this path
+        const auto& sequence = (n % 2) != 0U ? rsg.lastSequence() : rsg.nextSequence();
+
+        // Set JIT inputs: initial rates (same every path)
+        for (Size k = 0; k < size; ++k) {
+            value(jit_initRates[k]) = value(initRates[k]);
+        }
+
+        // Set JIT inputs: random numbers (different each path)
+        for (Size m = 0; m < totalRandoms; ++m) {
+            double rnd = (n % 2) != 0U ? -value(sequence.value[m]) : value(sequence.value[m]);
+            value(jit_randoms[m]) = rnd;
+        }
+
+        // Forward pass: execute JIT-compiled kernel
+        double payoff_value;
+        jit.forward(&payoff_value);
+        mcPrice_jit += payoff_value;
+
+        // Backward pass: compute derivatives
+        jit.clearDerivatives();
+        derivative(jit_payoff) = 1.0;
+        jit.computeAdjoints();
+
+        // Accumulate derivatives w.r.t. initial rates
+        for (Size k = 0; k < size; ++k) {
+            dPrice_dInitRates[k] += derivative(jit_initRates[k]);
+        }
+    }
+
+    mcPrice_jit /= static_cast<double>(nrTrails);
+    for (Size k = 0; k < size; ++k) {
+        dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+    }
+
+    std::cout << "    MC swaption price (JIT): " << std::setprecision(6) << mcPrice_jit << "\n";
+    std::cout << std::endl;
+
+    std::cout << "  JIT Derivatives (dPrice/dInitialRate, averaged over paths):\n";
+    for (Size k = 0; k < size; ++k) {
+        std::cout << "    dPrice/dInitRate[" << k << "] = " << std::scientific
+                  << std::setprecision(4) << dPrice_dInitRates[k] << "\n";
+    }
+    std::cout << std::endl;
+
+    std::cout << "  WHY JIT IS FASTER:\n";
+    std::cout << "    - Tape (2b): Records " << nrTrails << " * (operations per path) = millions of ops\n";
+    std::cout << "    - JIT (2c): Records ONCE, compiles to native code, runs " << nrTrails << " times\n";
+    std::cout << "    - JIT kernel includes: " << exerciseStep << " evolve steps + payoff\n";
+    std::cout << std::endl;
+
+    std::cout << "  STATUS: [STAGE 2c COMPLETE - Full path evolution with JIT]\n";
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    // Verify price is positive and reasonable
+    BOOST_CHECK(mcPrice_jit > 0.0);
+    BOOST_CHECK(mcPrice_jit < 0.1);  // Sanity check
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Stage 2b2: Manual MC with Tape (same structure as 2c for comparison)
+// Uses initial forward rates as tape inputs (like 2c uses JIT inputs)
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testStage2b2_ManualMCWithTape)
+{
+    BOOST_TEST_MESSAGE("Testing Stage 2b2: Manual MC with Tape (comparable to 2c)...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  STAGE 2b2: Manual MC with Tape (Same Structure as 2c)\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    std::cout << "  PURPOSE:\n";
+    std::cout << "    Compare tape-based derivatives with JIT-based derivatives (2c)\n";
+    std::cout << "    by using IDENTICAL computation structure.\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Setup: Same as 2c
+    // -------------------------------------------------------------------------
+    const Size size = 10;
+    const Size steps = 8 * size;
+
+    // Build curve WITHOUT tape (just to get the process setup)
+    std::vector<Date> dates = {{4, September, 2005}, {4, September, 2011}};
+    std::vector<Rate> rates_ql = {0.04, 0.08};
+
+    ext::shared_ptr<IborIndex> index = makeIndex(dates, rates_ql);
+
+    ext::shared_ptr<LiborForwardModelProcess> process(
+        new LiborForwardModelProcess(size, index));
+
+    ext::shared_ptr<LmCorrelationModel> corrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+
+    ext::shared_ptr<LmVolatilityModel> volaModel(
+        new LmLinearExponentialVolatilityModel(process->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+
+    process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(volaModel, corrModel)));
+
+    // Time grid setup
+    std::vector<Time> fixingTimes = process->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+    // Find location of each fixing time in the grid
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    // Swaption parameters (same as 2c)
+    Size i = 2;  // Option expiry index
+    Size j = 2;  // Swap length index
+
+    Calendar calendar = index->fixingCalendar();
+    DayCounter dayCounter = index->forwardingTermStructure()->dayCounter();
+    BusinessDayConvention convention = index->businessDayConvention();
+    Date settlement = index->forwardingTermStructure()->referenceDate();
+
+    Date fwdStart = settlement + Period(6 * i, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j, Months);
+
+    Schedule schedule(fwdStart, fwdMaturity, index->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    Rate swapRate_ql = 0.0404;
+    ext::shared_ptr<VanillaSwap> forwardSwap(
+        new VanillaSwap(Swap::Receiver, 1.0,
+                        schedule, swapRate_ql, dayCounter,
+                        schedule, index, 0.0, index->dayCounter()));
+    forwardSwap->setPricingEngine(ext::shared_ptr<PricingEngine>(
+        new DiscountingSwapEngine(index->forwardingTermStructure())));
+
+    double swapRate_double = value(forwardSwap->fairRate());
+
+    // Dimensions
+    Size numFactors = process->factors();
+    Size exerciseStep = location[i];
+    Size totalRandoms = numFactors * exerciseStep;
+    const Size nrTrails = 2000;
+
+    std::cout << "  Setup:\n";
+    std::cout << "    - Forward rates: " << size << "\n";
+    std::cout << "    - Exercise at step: " << exerciseStep << " (of " << grid.size()-1 << " total)\n";
+    std::cout << "    - Random numbers per path: " << totalRandoms << "\n";
+    std::cout << "    - MC paths: " << nrTrails << "\n";
+    std::cout << "    - Fair swap rate: " << std::fixed << std::setprecision(4)
+              << (swapRate_double * 100) << "%\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // XAD Tape Setup: Register initial forward rates as inputs
+    // -------------------------------------------------------------------------
+    using tape_type = Real::tape_type;
+    tape_type tape;
+
+    // Get initial forward rates and register as tape inputs
+    Array initRates_orig = process->initialValues();
+    std::vector<Real> tape_initRates(size);
+    for (Size k = 0; k < size; ++k) {
+        tape_initRates[k] = value(initRates_orig[k]);
+    }
+    tape.registerInputs(tape_initRates);
+    tape.newRecording();
+
+    std::cout << "  Tape Setup:\n";
+    std::cout << "    - Registered " << size << " initial forward rates as tape inputs\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Monte Carlo: Manual evolution (same structure as 2c)
+    // -------------------------------------------------------------------------
+    std::cout << "  Monte Carlo with Tape (manual evolution):\n";
+
+    typedef PseudoRandom::rsg_type rsg_type;
+    rsg_type rsg = PseudoRandom::make_sequence_generator(totalRandoms, BigNatural(42));
+
+    Real mcPrice_tape = 0.0;
+
+    for (Size n = 0; n < nrTrails; ++n) {
+        const auto& sequence = (n % 2) != 0U ? rsg.lastSequence() : rsg.nextSequence();
+
+        // Start from tape-registered initial rates
+        std::vector<Real> asset(size);
+        for (Size k = 0; k < size; ++k) {
+            asset[k] = tape_initRates[k];
+        }
+
+        // Evolve through time steps up to exercise (same as 2c)
+        for (Size step = 1; step <= exerciseStep; ++step) {
+            Size offset = (step - 1) * numFactors;
+            Time t = grid[step - 1];
+            Time dt = grid.dt(step - 1);
+
+            // Extract random numbers for this time step
+            Array dw(numFactors);
+            for (Size f = 0; f < numFactors; ++f) {
+                dw[f] = sequence.value[offset + f];
+            }
+
+            // Convert asset to Array for evolve call
+            Array asset_arr(size);
+            for (Size k = 0; k < size; ++k) {
+                asset_arr[k] = asset[k];
+            }
+
+            // Call process->evolve (tape records this!)
+            Array evolved = process->evolve(t, asset_arr, dt, dw);
+
+            // Store back
+            for (Size k = 0; k < size; ++k) {
+                asset[k] = evolved[k];
+            }
+        }
+
+        // Compute discount factors from evolved rates (same as 2c)
+        std::vector<Real> dis(size);
+        Real df = 1.0;
+        for (Size k = 0; k < size; ++k) {
+            double accrual = value(process->accrualEndTimes()[k]) - value(process->accrualStartTimes()[k]);
+            df = df / (Real(1.0) + asset[k] * accrual);
+            dis[k] = df;
+        }
+
+        // Compute swaption payoff (same as 2c)
+        Real npv = 0.0;
+        for (Size m = i; m < i + j; ++m) {
+            double accrual = value(process->accrualEndTimes()[m]) - value(process->accrualStartTimes()[m]);
+            npv = npv + (swapRate_double - asset[m]) * accrual * dis[m];
+        }
+
+        // Swaption payoff: max(npv, 0)
+        if (value(npv) > 0.0) {
+            mcPrice_tape += npv;
+        }
+    }
+    mcPrice_tape /= static_cast<Real>(nrTrails);
+
+    std::cout << "    MC swaption price (Tape): " << std::setprecision(6) << value(mcPrice_tape) << "\n";
+    std::cout << std::endl;
+
+    // -------------------------------------------------------------------------
+    // Compute derivatives using XAD tape
+    // -------------------------------------------------------------------------
+    tape.registerOutput(mcPrice_tape);
+    derivative(mcPrice_tape) = 1.0;
+    tape.computeAdjoints();
+
+    std::cout << "  Tape Derivatives (dPrice/dInitialRate) - compare with 2c:\n";
+    for (Size k = 0; k < size; ++k) {
+        std::cout << "    dPrice/dInitRate[" << k << "] = " << std::scientific
+                  << std::setprecision(4) << derivative(tape_initRates[k]) << "\n";
+    }
+    std::cout << std::endl;
+
+    std::cout << "  STATUS: [STAGE 2b2 COMPLETE - Manual MC with Tape]\n";
+    std::cout << "\n";
+    std::cout << "  COMPARE WITH 2c: Derivatives should match if JIT is working correctly!\n";
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    // Verify price is reasonable
+    BOOST_CHECK(value(mcPrice_tape) > 0.0);
+    BOOST_CHECK(value(mcPrice_tape) < 0.1);
+}
+
+#endif // Disabled intermediate tests
+
+//////////////////////////////////////////////////////////////////////////////
+// Stage 2 Comparison: Side-by-side comparison of Original, XAD Tape, and JIT
+// Runs all three approaches with SAME random numbers and produces comparison tables
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testStage2_Comparison)
+{
+    BOOST_TEST_MESSAGE("Testing Stage 2 Comparison: Original vs XAD Tape vs JIT...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  STAGE 2 COMPARISON: Original vs XAD Tape vs JIT\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    std::cout << "  Setup: LMM Monte Carlo swaption pricing\n";
+    std::cout << "    - LMM Process: 10 forward rates, exponential correlation (rho=0.5)\n";
+    std::cout << "    - Swaption: 1Y option into 1Y swap (indices i=2, j=2)\n";
+    std::cout << "    - MC: 10 paths\n";
+    std::cout << std::endl;
+    std::cout << "  Approaches:\n";
+    std::cout << "    - Original (QuantLib): Uses MultiPathGenerator (standard QuantLib)\n";
+    std::cout << "    - Original (Re-Route): Custom loop with pre-generated randoms\n";
+    std::cout << "    - XAD (QuantLib):      MultiPathGenerator with XAD tape\n";
+    std::cout << "    - XAD (Re-Route):      Custom loop with XAD tape\n";
+    std::cout << "    - JIT:                 Custom loop with JIT (requires pre-generated randoms)\n";
+    std::cout << std::endl;
+
+    // Common Setup
+    const Size size = 10;
+    const Size steps = 8 * size;
+    const Size numZeroRates = 10;  // Number of zero curve input rates
+
+    // Create zero curve with 10 points (covering 5.5 years for LMM)
+    // Dates: 0, 6M, 1Y, 1.5Y, 2Y, 2.5Y, 3Y, 3.5Y, 4Y, 5.5Y (extended to cover LMM times)
+    Date baseDate(4, September, 2005);
+    std::vector<Date> zeroDates = {
+        baseDate,
+        baseDate + 6 * Months,
+        baseDate + 1 * Years,
+        baseDate + 18 * Months,
+        baseDate + 2 * Years,
+        baseDate + 30 * Months,
+        baseDate + 3 * Years,
+        baseDate + 42 * Months,
+        baseDate + 4 * Years,
+        baseDate + 66 * Months  // 5.5 years to cover LMM times (max ~5.07 years)
+    };
+
+    // Zero rates (upward sloping curve from 4% to 6%)
+    std::vector<double> zeroRates_val = {
+        0.040, 0.042, 0.044, 0.046, 0.048,
+        0.050, 0.052, 0.054, 0.056, 0.060
+    };
+
+    std::vector<Rate> rates_ql(numZeroRates);
+    for (Size k = 0; k < numZeroRates; ++k) rates_ql[k] = zeroRates_val[k];
+
+    ext::shared_ptr<IborIndex> index = makeIndex(zeroDates, rates_ql);
+    ext::shared_ptr<LiborForwardModelProcess> process(
+        new LiborForwardModelProcess(size, index));
+
+    ext::shared_ptr<LmCorrelationModel> corrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> volaModel(
+        new LmLinearExponentialVolatilityModel(process->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(volaModel, corrModel)));
+
+    std::vector<Time> fixingTimes = process->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    Size i = 2, j = 2;
+    Calendar calendar = index->fixingCalendar();
+    DayCounter dayCounter = index->forwardingTermStructure()->dayCounter();
+    BusinessDayConvention convention = index->businessDayConvention();
+    Date settlement = index->forwardingTermStructure()->referenceDate();
+
+    Date fwdStart = settlement + Period(6 * i, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j, Months);
+    Schedule schedule(fwdStart, fwdMaturity, index->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    Rate swapRate_ql = 0.0404;
+    ext::shared_ptr<VanillaSwap> forwardSwap(
+        new VanillaSwap(Swap::Receiver, 1.0, schedule, swapRate_ql, dayCounter,
+                        schedule, index, 0.0, index->dayCounter()));
+    forwardSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+        index->forwardingTermStructure()));
+
+    double swapRate_double = value(forwardSwap->fairRate());
+
+    Size numFactors = process->factors();
+    Size exerciseStep = location[i];
+    Size totalRandoms = numFactors * exerciseStep;
+    const Size nrTrails = 10;
+    Array initRates = process->initialValues();
+
+    // =========================================================================
+    // APPROACH 1: Original (QuantLib) - Uses MultiPathGenerator
+    // =========================================================================
+    typedef PseudoRandom::rsg_type rsg_type;
+    rsg_type rsg_ql = PseudoRandom::make_sequence_generator(
+        numFactors * (grid.size() - 1), BigNatural(42));
+
+    typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+    MultiPathGenerator<rsg_type> generator_ql(process, grid, rsg_ql, false);
+
+    double mcPrice_orig_ql = 0.0;
+    for (Size n = 0; n < nrTrails; ++n) {
+        sample_type path = (n % 2) != 0U ? generator_ql.antithetic() : generator_ql.next();
+
+        std::vector<double> mcRates(size);
+        for (Size k = 0; k < size; ++k) {
+            mcRates[k] = value(path.value[k][location[i]]);
+        }
+
+        std::vector<double> dis(size);
+        double df = 1.0;
+        for (Size k = 0; k < size; ++k) {
+            double accrual = value(process->accrualEndTimes()[k]) - value(process->accrualStartTimes()[k]);
+            df = df / (1.0 + mcRates[k] * accrual);
+            dis[k] = df;
+        }
+
+        double npv = 0.0;
+        for (Size m = i; m < i + j; ++m) {
+            double accrual = value(process->accrualEndTimes()[m]) - value(process->accrualStartTimes()[m]);
+            npv += (swapRate_double - mcRates[m]) * accrual * dis[m];
+        }
+        if (npv > 0.0) mcPrice_orig_ql += npv;
+    }
+    mcPrice_orig_ql /= static_cast<double>(nrTrails);
+
+    // =========================================================================
+    // Pre-generate ALL random numbers for Re-Route approaches
+    // Use same dimension as QuantLib MultiPathGenerator to ensure identical RNG sequence
+    // =========================================================================
+    Size fullGridRandoms = numFactors * (grid.size() - 1);  // Same as QuantLib
+    rsg_type rsg = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+
+    std::vector<std::vector<double>> allRandoms(nrTrails);
+    for (Size n = 0; n < nrTrails; ++n) {
+        const auto& sequence = (n % 2) != 0U ? rsg.lastSequence() : rsg.nextSequence();
+        // Only store up to exerciseStep (we don't need the rest but generate them to keep RNG in sync)
+        allRandoms[n].resize(totalRandoms);
+        for (Size m = 0; m < totalRandoms; ++m) {
+            double rnd = (n % 2) != 0U ? -value(sequence.value[m]) : value(sequence.value[m]);
+            allRandoms[n][m] = rnd;
+        }
+    }
+
+    // =========================================================================
+    // APPROACH 2: Original (Re-Route) - Custom loop with pre-generated randoms
+    // =========================================================================
+    double mcPrice_orig = 0.0;
+    for (Size n = 0; n < nrTrails; ++n) {
+        std::vector<double> asset(size);
+        for (Size k = 0; k < size; ++k) asset[k] = value(initRates[k]);
+
+        for (Size step = 1; step <= exerciseStep; ++step) {
+            Size offset = (step - 1) * numFactors;
+            Array dw(numFactors);
+            for (Size f = 0; f < numFactors; ++f) dw[f] = allRandoms[n][offset + f];
+
+            Array asset_arr(size);
+            for (Size k = 0; k < size; ++k) asset_arr[k] = asset[k];
+            Array evolved = process->evolve(grid[step - 1], asset_arr, grid.dt(step - 1), dw);
+            for (Size k = 0; k < size; ++k) asset[k] = value(evolved[k]);
+        }
+
+        std::vector<double> dis(size);
+        double df = 1.0;
+        for (Size k = 0; k < size; ++k) {
+            double accrual = value(process->accrualEndTimes()[k]) - value(process->accrualStartTimes()[k]);
+            df = df / (1.0 + asset[k] * accrual);
+            dis[k] = df;
+        }
+
+        double npv = 0.0;
+        for (Size m = i; m < i + j; ++m) {
+            double accrual = value(process->accrualEndTimes()[m]) - value(process->accrualStartTimes()[m]);
+            npv += (swapRate_double - asset[m]) * accrual * dis[m];
+        }
+        if (npv > 0.0) mcPrice_orig += npv;
+    }
+    mcPrice_orig /= static_cast<double>(nrTrails);
+
+    // Helper lambda for bump-and-reprice
+    auto computeMCPrice = [&](const std::vector<double>& bumpedInitRates) {
+        double price = 0.0;
+        for (Size n = 0; n < nrTrails; ++n) {
+            std::vector<double> asset_b(size);
+            for (Size k = 0; k < size; ++k) asset_b[k] = bumpedInitRates[k];
+
+            for (Size step = 1; step <= exerciseStep; ++step) {
+                Size offset = (step - 1) * numFactors;
+                Array dw(numFactors);
+                for (Size f = 0; f < numFactors; ++f) dw[f] = allRandoms[n][offset + f];
+
+                Array asset_arr(size);
+                for (Size k = 0; k < size; ++k) asset_arr[k] = asset_b[k];
+                Array evolved = process->evolve(grid[step - 1], asset_arr, grid.dt(step - 1), dw);
+                for (Size k = 0; k < size; ++k) asset_b[k] = value(evolved[k]);
+            }
+
+            std::vector<double> dis_b(size);
+            double df_b = 1.0;
+            for (Size k = 0; k < size; ++k) {
+                double accrual = value(process->accrualEndTimes()[k]) - value(process->accrualStartTimes()[k]);
+                df_b = df_b / (1.0 + asset_b[k] * accrual);
+                dis_b[k] = df_b;
+            }
+
+            double npv_b = 0.0;
+            for (Size m = i; m < i + j; ++m) {
+                double accrual = value(process->accrualEndTimes()[m]) - value(process->accrualStartTimes()[m]);
+                npv_b += (swapRate_double - asset_b[m]) * accrual * dis_b[m];
+            }
+            if (npv_b > 0.0) price += npv_b;
+        }
+        return price / static_cast<double>(nrTrails);
+    };
+
+    // Bump-and-reprice derivatives
+    double bump = 1e-6;
+    std::vector<double> baseInitRates(size);
+    for (Size k = 0; k < size; ++k) baseInitRates[k] = value(initRates[k]);
+
+    std::vector<double> dPrice_bump(size);
+    for (Size k = 0; k < size; ++k) {
+        std::vector<double> bumpedRates = baseInitRates;
+        bumpedRates[k] += bump;
+        double bumpedPrice = computeMCPrice(bumpedRates);
+        dPrice_bump[k] = (bumpedPrice - mcPrice_orig) / bump;
+    }
+
+    // =========================================================================
+    // APPROACH 3: XAD (QuantLib) - Uses MultiPathGenerator with tape
+    // Registers zero curve rates as inputs, derivatives flow through:
+    //   zero rates → forward rates (via term structure) → MC paths → price
+    // =========================================================================
+    using tape_type = Real::tape_type;
+    tape_type tape_ql;
+
+    // Register the 10 zero curve rates as tape inputs
+    std::vector<Real> rates_xad_ql(numZeroRates);
+    for (Size k = 0; k < numZeroRates; ++k) rates_xad_ql[k] = zeroRates_val[k];
+    tape_ql.registerInputs(rates_xad_ql);
+    tape_ql.newRecording();
+
+    // Build curve and process using tape-registered rates
+    ext::shared_ptr<IborIndex> index_xad_ql = makeIndex(zeroDates, rates_xad_ql);
+    ext::shared_ptr<LiborForwardModelProcess> process_xad_ql(
+        new LiborForwardModelProcess(size, index_xad_ql));
+
+    ext::shared_ptr<LmCorrelationModel> corrModel_xad_ql(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> volaModel_xad_ql(
+        new LmLinearExponentialVolatilityModel(process_xad_ql->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    process_xad_ql->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(volaModel_xad_ql, corrModel_xad_ql)));
+
+    // Get location indices for this process
+    std::vector<Time> fixingTimes_xad_ql = process_xad_ql->fixingTimes();
+    TimeGrid grid_xad_ql(fixingTimes_xad_ql.begin(), fixingTimes_xad_ql.end(), steps);
+    std::vector<Size> location_xad_ql;
+    for (Size idx = 0; idx < fixingTimes_xad_ql.size(); ++idx) {
+        location_xad_ql.push_back(
+            std::find(grid_xad_ql.begin(), grid_xad_ql.end(), fixingTimes_xad_ql[idx]) - grid_xad_ql.begin());
+    }
+
+    // Reset RNG to same seed as Original QuantLib
+    rsg_type rsg_xad_ql = PseudoRandom::make_sequence_generator(
+        process_xad_ql->factors() * (grid_xad_ql.size() - 1), BigNatural(42));
+
+    MultiPathGenerator<rsg_type> generator_xad_ql(process_xad_ql, grid_xad_ql, rsg_xad_ql, false);
+
+    // Get swap rate for this process
+    Date fwdStart_xad = index_xad_ql->forwardingTermStructure()->referenceDate() + Period(6 * i, Months);
+    Date fwdMaturity_xad = fwdStart_xad + Period(6 * j, Months);
+    Schedule schedule_xad(fwdStart_xad, fwdMaturity_xad, index_xad_ql->tenor(), calendar,
+                          convention, convention, DateGeneration::Forward, false);
+    ext::shared_ptr<VanillaSwap> forwardSwap_xad(
+        new VanillaSwap(Swap::Receiver, 1.0, schedule_xad, 0.0404, dayCounter,
+                        schedule_xad, index_xad_ql, 0.0, index_xad_ql->dayCounter()));
+    forwardSwap_xad->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+        index_xad_ql->forwardingTermStructure()));
+    Real swapRate_xad_ql = forwardSwap_xad->fairRate();
+
+    Real mcPrice_xad_ql = 0.0;
+    for (Size n = 0; n < nrTrails; ++n) {
+        sample_type path = (n % 2) != 0U ? generator_xad_ql.antithetic() : generator_xad_ql.next();
+
+        std::vector<Real> mcRates(size);
+        for (Size k = 0; k < size; ++k) {
+            mcRates[k] = path.value[k][location_xad_ql[i]];
+        }
+
+        std::vector<Real> dis(size);
+        Real df = 1.0;
+        for (Size k = 0; k < size; ++k) {
+            Real accrual = process_xad_ql->accrualEndTimes()[k] - process_xad_ql->accrualStartTimes()[k];
+            df = df / (Real(1.0) + mcRates[k] * accrual);
+            dis[k] = df;
+        }
+
+        Real npv = 0.0;
+        for (Size m = i; m < i + j; ++m) {
+            Real accrual = process_xad_ql->accrualEndTimes()[m] - process_xad_ql->accrualStartTimes()[m];
+            npv = npv + (swapRate_xad_ql - mcRates[m]) * accrual * dis[m];
+        }
+        if (value(npv) > 0.0) mcPrice_xad_ql += npv;
+    }
+    mcPrice_xad_ql /= static_cast<Real>(nrTrails);
+
+    tape_ql.registerOutput(mcPrice_xad_ql);
+    derivative(mcPrice_xad_ql) = 1.0;
+    tape_ql.computeAdjoints();
+
+    // Get derivatives w.r.t. the 10 zero curve rates
+    std::vector<double> dPrice_xad_ql(numZeroRates);
+    for (Size k = 0; k < numZeroRates; ++k) dPrice_xad_ql[k] = derivative(rates_xad_ql[k]);
+    tape_ql.deactivate();
+
+    // =========================================================================
+    // APPROACH 4: XAD (Re-Route) - Custom loop with XAD tape
+    // Same inputs as XAD QuantLib (zero curve rates) for fair comparison
+    // =========================================================================
+    tape_type tape_rr;
+
+    // Register the same 10 zero curve rates as inputs (like XAD QuantLib)
+    std::vector<Real> rates_xad_rr(numZeroRates);
+    for (Size k = 0; k < numZeroRates; ++k) rates_xad_rr[k] = zeroRates_val[k];
+    tape_rr.registerInputs(rates_xad_rr);
+    tape_rr.newRecording();
+
+    // Build curve and process using tape-registered rates (same as XAD QuantLib)
+    ext::shared_ptr<IborIndex> index_xad_rr = makeIndex(zeroDates, rates_xad_rr);
+    ext::shared_ptr<LiborForwardModelProcess> process_xad_rr(
+        new LiborForwardModelProcess(size, index_xad_rr));
+
+    ext::shared_ptr<LmCorrelationModel> corrModel_xad_rr(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> volaModel_xad_rr(
+        new LmLinearExponentialVolatilityModel(process_xad_rr->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    process_xad_rr->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(volaModel_xad_rr, corrModel_xad_rr)));
+
+    // Get location indices and grid for this process
+    std::vector<Time> fixingTimes_xad_rr = process_xad_rr->fixingTimes();
+    TimeGrid grid_xad_rr(fixingTimes_xad_rr.begin(), fixingTimes_xad_rr.end(), steps);
+    std::vector<Size> location_xad_rr;
+    for (Size idx = 0; idx < fixingTimes_xad_rr.size(); ++idx) {
+        location_xad_rr.push_back(
+            std::find(grid_xad_rr.begin(), grid_xad_rr.end(), fixingTimes_xad_rr[idx]) - grid_xad_rr.begin());
+    }
+    Size exerciseStep_rr = location_xad_rr[i];
+    Size numFactors_rr = process_xad_rr->factors();
+
+    // Get initial forward rates from process (these now depend on tape inputs)
+    Array initRates_rr = process_xad_rr->initialValues();
+
+    // Get swap rate for this process
+    Date fwdStart_rr = index_xad_rr->forwardingTermStructure()->referenceDate() + Period(6 * i, Months);
+    Date fwdMaturity_rr = fwdStart_rr + Period(6 * j, Months);
+    Schedule schedule_rr(fwdStart_rr, fwdMaturity_rr, index_xad_rr->tenor(), calendar,
+                         convention, convention, DateGeneration::Forward, false);
+    ext::shared_ptr<VanillaSwap> forwardSwap_rr(
+        new VanillaSwap(Swap::Receiver, 1.0, schedule_rr, 0.0404, dayCounter,
+                        schedule_rr, index_xad_rr, 0.0, index_xad_rr->dayCounter()));
+    forwardSwap_rr->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+        index_xad_rr->forwardingTermStructure()));
+    Real swapRate_rr = forwardSwap_rr->fairRate();
+
+    // Re-Route MC loop with pre-generated randoms
+    Real mcPrice_tape = 0.0;
+    for (Size n = 0; n < nrTrails; ++n) {
+        // Start from initial forward rates (which depend on zero curve rates via tape)
+        std::vector<Real> asset_rr(size);
+        for (Size k = 0; k < size; ++k) asset_rr[k] = initRates_rr[k];
+
+        for (Size step = 1; step <= exerciseStep_rr; ++step) {
+            Size offset = (step - 1) * numFactors_rr;
+            Array dw(numFactors_rr);
+            for (Size f = 0; f < numFactors_rr; ++f) dw[f] = allRandoms[n][offset + f];
+
+            Array asset_arr(size);
+            for (Size k = 0; k < size; ++k) asset_arr[k] = asset_rr[k];
+            Array evolved = process_xad_rr->evolve(grid_xad_rr[step - 1], asset_arr, grid_xad_rr.dt(step - 1), dw);
+            for (Size k = 0; k < size; ++k) asset_rr[k] = evolved[k];
+        }
+
+        std::vector<Real> dis_rr(size);
+        Real df_rr = 1.0;
+        for (Size k = 0; k < size; ++k) {
+            Real accrual = process_xad_rr->accrualEndTimes()[k] - process_xad_rr->accrualStartTimes()[k];
+            df_rr = df_rr / (Real(1.0) + asset_rr[k] * accrual);
+            dis_rr[k] = df_rr;
+        }
+
+        Real npv_rr = 0.0;
+        for (Size m = i; m < i + j; ++m) {
+            Real accrual = process_xad_rr->accrualEndTimes()[m] - process_xad_rr->accrualStartTimes()[m];
+            npv_rr = npv_rr + (swapRate_rr - asset_rr[m]) * accrual * dis_rr[m];
+        }
+        if (value(npv_rr) > 0.0) mcPrice_tape += npv_rr;
+    }
+    mcPrice_tape /= static_cast<Real>(nrTrails);
+
+    tape_rr.registerOutput(mcPrice_tape);
+    derivative(mcPrice_tape) = 1.0;
+    tape_rr.computeAdjoints();
+
+    // Get derivatives w.r.t. the 10 zero curve rates (same as XAD QuantLib)
+    std::vector<double> dPrice_xad_rr(numZeroRates);
+    for (Size k = 0; k < numZeroRates; ++k) dPrice_xad_rr[k] = derivative(rates_xad_rr[k]);
+    tape_rr.deactivate();
+
+    // =========================================================================
+    // APPROACH 5: JIT - Custom loop with JIT
+    // JIT also uses zero curve rates as inputs for fair comparison
+    // =========================================================================
+    auto forgeBackend3 = std::make_unique<xad::forge::ForgeBackend<double>>();
+    xad::JITCompiler<double> jit(std::move(forgeBackend3));
+
+    // Register 10 zero curve rates as JIT inputs
+    std::vector<xad::AD> jit_zeroRates(numZeroRates);
+    std::vector<xad::AD> jit_randoms(totalRandoms);
+
+    for (Size k = 0; k < numZeroRates; ++k) {
+        jit_zeroRates[k] = xad::AD(zeroRates_val[k]);
+        jit.registerInput(jit_zeroRates[k]);
+    }
+    for (Size m = 0; m < totalRandoms; ++m) {
+        jit_randoms[m] = xad::AD(0.0);
+        jit.registerInput(jit_randoms[m]);
+    }
+    jit.newRecording();
+
+    // Build curve and process using JIT-registered rates
+    // Note: We need to extract forward rates from the curve for the JIT kernel
+    std::vector<xad::AD> jit_zeroRates_vec(numZeroRates);
+    for (Size k = 0; k < numZeroRates; ++k) jit_zeroRates_vec[k] = jit_zeroRates[k];
+
+    // For JIT, we build the curve outside JIT and extract forward rates
+    // The forward rates become functions of the zero rates through interpolation
+    // This is a simplified approach - in practice you'd JIT the curve lookup too
+    ext::shared_ptr<IborIndex> index_jit = makeIndex(zeroDates, jit_zeroRates_vec);
+    ext::shared_ptr<LiborForwardModelProcess> process_jit(
+        new LiborForwardModelProcess(size, index_jit));
+    process_jit->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(
+            ext::make_shared<LmLinearExponentialVolatilityModel>(process_jit->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+            ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+    // Get initial forward rates (these depend on JIT zero rate inputs)
+    Array initRates_jit = process_jit->initialValues();
+    std::vector<xad::AD> jit_initRates(size);
+    for (Size k = 0; k < size; ++k) jit_initRates[k] = initRates_jit[k];
+
+    // Get grid info
+    std::vector<Time> fixingTimes_jit = process_jit->fixingTimes();
+    TimeGrid grid_jit(fixingTimes_jit.begin(), fixingTimes_jit.end(), steps);
+    std::vector<Size> location_jit;
+    for (Size idx = 0; idx < fixingTimes_jit.size(); ++idx) {
+        location_jit.push_back(
+            std::find(grid_jit.begin(), grid_jit.end(), fixingTimes_jit[idx]) - grid_jit.begin());
+    }
+    Size exerciseStep_jit = location_jit[i];
+    Size numFactors_jit = process_jit->factors();
+
+    // Get swap rate
+    Date fwdStart_jit = index_jit->forwardingTermStructure()->referenceDate() + Period(6 * i, Months);
+    Date fwdMaturity_jit = fwdStart_jit + Period(6 * j, Months);
+    Schedule schedule_jit(fwdStart_jit, fwdMaturity_jit, index_jit->tenor(), calendar,
+                          convention, convention, DateGeneration::Forward, false);
+    ext::shared_ptr<VanillaSwap> forwardSwap_jit(
+        new VanillaSwap(Swap::Receiver, 1.0, schedule_jit, 0.0404, dayCounter,
+                        schedule_jit, index_jit, 0.0, index_jit->dayCounter()));
+    forwardSwap_jit->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+        index_jit->forwardingTermStructure()));
+    xad::AD swapRate_jit = forwardSwap_jit->fairRate();
+
+    // Record path evolution + payoff
+    std::vector<xad::AD> asset(size);
+    for (Size k = 0; k < size; ++k) asset[k] = jit_initRates[k];
+
+    for (Size step = 1; step <= exerciseStep_jit; ++step) {
+        Size offset = (step - 1) * numFactors_jit;
+        Array dw(numFactors_jit);
+        for (Size f = 0; f < numFactors_jit; ++f) dw[f] = jit_randoms[offset + f];
+
+        Array asset_arr(size);
+        for (Size k = 0; k < size; ++k) asset_arr[k] = asset[k];
+        Array evolved = process_jit->evolve(grid_jit[step - 1], asset_arr, grid_jit.dt(step - 1), dw);
+        for (Size k = 0; k < size; ++k) asset[k] = evolved[k];
+    }
+
+    // Compute payoff inside JIT: discount factors + NPV + max(npv,0)
+    std::vector<xad::AD> dis(size);
+    xad::AD df_jit_val = xad::AD(1.0);
+    for (Size k = 0; k < size; ++k) {
+        xad::AD accrual = process_jit->accrualEndTimes()[k] - process_jit->accrualStartTimes()[k];
+        df_jit_val = df_jit_val / (xad::AD(1.0) + asset[k] * accrual);
+        dis[k] = df_jit_val;
+    }
+
+    xad::AD jit_npv = xad::AD(0.0);
+    for (Size m = i; m < i + j; ++m) {
+        xad::AD accrual = process_jit->accrualEndTimes()[m] - process_jit->accrualStartTimes()[m];
+        jit_npv = jit_npv + (swapRate_jit - asset[m]) * accrual * dis[m];
+    }
+    xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+    jit.registerOutput(jit_payoff);
+
+    // Compile the JIT graph
+    jit.compile();
+
+    // Execute JIT for all paths
+    double mcPrice_jit = 0.0;
+    for (Size n = 0; n < nrTrails; ++n) {
+        // Set zero rates for this path (they're constant, but we need to set them)
+        for (Size k = 0; k < numZeroRates; ++k) value(jit_zeroRates[k]) = zeroRates_val[k];
+        for (Size m = 0; m < totalRandoms; ++m) value(jit_randoms[m]) = allRandoms[n][m];
+
+        double payoff_value;
+        jit.forward(&payoff_value);
+        mcPrice_jit += payoff_value;
+    }
+    mcPrice_jit /= static_cast<double>(nrTrails);
+
+    // =========================================================================
+    // TABLE: MC PRICES - All 5 approaches
+    // =========================================================================
+    std::cout << "  " << std::string(75, '=') << "\n";
+    std::cout << "  TABLE: MC PRICES\n";
+    std::cout << "  " << std::string(75, '=') << "\n\n";
+
+    std::cout << "  " << std::setw(20) << "Approach" << " | "
+              << std::setw(12) << "MC Price" << " | "
+              << std::setw(14) << "Diff vs Ref" << " | "
+              << "Match\n";
+    std::cout << "  " << std::string(20, '-') << "-+-"
+              << std::string(12, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(5, '-') << "\n";
+
+    // Reference: Original (QuantLib) using MultiPathGenerator
+    std::cout << "  " << std::setw(20) << "Orig (QuantLib)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(12) << mcPrice_orig_ql << " | "
+              << std::setw(14) << "-" << " |   -  \n";
+
+    // Original (Re-Route) - custom loop
+    double diff_orig_rr = mcPrice_orig - mcPrice_orig_ql;
+    bool orig_rr_match = (std::abs(diff_orig_rr) < 1e-6);  // may differ slightly due to different RNG sequences
+    std::cout << "  " << std::setw(20) << "Orig (Re-Route)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(12) << mcPrice_orig << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_orig_rr << " | "
+              << (orig_rr_match ? "  OK " : "DIFF!") << "\n";
+
+    // XAD (QuantLib) - MultiPathGenerator using XAD types (should match Orig QuantLib)
+    double diff_xad_ql = value(mcPrice_xad_ql) - mcPrice_orig_ql;
+    bool xad_ql_match = (std::abs(diff_xad_ql) < 1e-10);
+    std::cout << "  " << std::setw(20) << "XAD (QuantLib)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(12) << value(mcPrice_xad_ql) << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_xad_ql << " | "
+              << (xad_ql_match ? "  OK " : "DIFF!") << "\n";
+
+    // XAD (Re-Route) - custom loop with tape (compare to Re-Route baseline)
+    double diff_tape_price = value(mcPrice_tape) - mcPrice_orig;
+    bool tape_match = (std::abs(diff_tape_price) < 1e-10);
+    std::cout << "  " << std::setw(20) << "XAD (Re-Route)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(12) << value(mcPrice_tape) << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_tape_price << " | "
+              << (tape_match ? "  OK " : "DIFF!") << "\n";
+
+    // JIT (compare to Re-Route baseline since JIT uses same loop structure)
+    double diff_jit_price = mcPrice_jit - mcPrice_orig;
+    bool jit_match = (std::abs(diff_jit_price) < 1e-10);
+    std::cout << "  " << std::setw(20) << "JIT" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(12) << mcPrice_jit << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_jit_price << " | "
+              << (jit_match ? "  OK " : "DIFF!") << "\n";
+
+    std::cout << std::endl;
+    std::cout << "  Note: Re-Route approaches use pre-generated randoms (different sequence than QuantLib)\n";
+    std::cout << "        XAD/JIT Re-Route should match Orig Re-Route exactly\n";
+    std::cout << "        XAD QuantLib should match Orig QuantLib exactly (same RNG, same loop)\n";
+    std::cout << std::endl;
+    bool pricesMatch = tape_match && jit_match && xad_ql_match;
+
+    // =========================================================================
+    // TABLE: DERIVATIVES (w.r.t. 10 zero curve rates) - All AD approaches
+    // =========================================================================
+    std::cout << "  " << std::string(100, '=') << "\n";
+    std::cout << "  TABLE: DERIVATIVES (w.r.t. " << numZeroRates << " zero curve rates)\n";
+    std::cout << "  " << std::string(100, '=') << "\n\n";
+
+    // Compute JIT derivatives w.r.t. zero curve rates
+    std::vector<double> dPrice_jit(numZeroRates, 0.0);
+    const auto& graph = jit.getGraph();
+    uint32_t outputSlot = graph.output_ids[0];
+
+    for (Size n = 0; n < nrTrails; ++n) {
+        for (Size k = 0; k < numZeroRates; ++k) value(jit_zeroRates[k]) = zeroRates_val[k];
+        for (Size m = 0; m < totalRandoms; ++m) value(jit_randoms[m]) = allRandoms[n][m];
+
+        jit.clearDerivatives();
+        jit.setDerivative(outputSlot, 1.0);
+        jit.computeAdjoints();
+
+        for (Size k = 0; k < numZeroRates; ++k) dPrice_jit[k] += jit.derivative(graph.input_ids[k]);
+    }
+
+    for (Size k = 0; k < numZeroRates; ++k) dPrice_jit[k] /= static_cast<double>(nrTrails);
+
+    std::cout << "  " << std::setw(10) << "ZeroRate#" << " | "
+              << std::setw(14) << "XAD QuantLib" << " | "
+              << std::setw(14) << "XAD Re-Route" << " | "
+              << std::setw(14) << "JIT" << " | "
+              << std::setw(12) << "QL/RR diff" << " | "
+              << std::setw(12) << "RR/JIT diff" << "\n";
+    std::cout << "  " << std::string(10, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(12, '-') << "-+-"
+              << std::string(12, '-') << "\n";
+
+    Size matchingDerivs_ql_rr = 0;
+    Size matchingDerivs_rr_jit = 0;
+    for (Size k = 0; k < numZeroRates; ++k) {
+        double diff_ql_rr = dPrice_xad_ql[k] - dPrice_xad_rr[k];
+        double diff_rr_jit = dPrice_xad_rr[k] - dPrice_jit[k];
+
+        bool match_ql_rr = (std::abs(diff_ql_rr) < 1e-10);
+        bool match_rr_jit = (std::abs(diff_rr_jit) < 1e-10);
+        if (match_ql_rr) matchingDerivs_ql_rr++;
+        if (match_rr_jit) matchingDerivs_rr_jit++;
+
+        std::cout << "  " << std::setw(10) << k << " | "
+                  << std::scientific << std::setprecision(4) << std::setw(14) << dPrice_xad_ql[k] << " | "
+                  << std::setw(14) << dPrice_xad_rr[k] << " | "
+                  << std::setw(14) << dPrice_jit[k] << " | "
+                  << std::setw(12) << diff_ql_rr << " | "
+                  << std::setw(12) << diff_rr_jit << "\n";
+    }
+    std::cout << std::endl;
+
+    bool derivsMatch = (matchingDerivs_ql_rr == numZeroRates) && (matchingDerivs_rr_jit == numZeroRates);
+    std::cout << "  XAD QuantLib vs XAD Re-Route: " << matchingDerivs_ql_rr << "/" << numZeroRates << " exact match\n";
+    std::cout << "  XAD Re-Route vs JIT: " << matchingDerivs_rr_jit << "/" << numZeroRates << " exact match\n";
+    std::cout << std::endl;
+
+    // Summary
+    bool allPass = pricesMatch && derivsMatch;
+    std::cout << "  RESULT: " << (allPass ? "[PASS]" : "[CHECK]") << "\n";
+    std::cout << "    - Prices: " << (pricesMatch ? "OK" : "DIFF") << "\n";
+    std::cout << "    - All derivatives match (QL/RR/JIT): " << (derivsMatch ? "OK" : "DIFF") << "\n";
+    std::cout << "\n";
+    std::cout << "  STATUS: [STAGE 2 COMPARISON COMPLETE]\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    BOOST_CHECK(pricesMatch);
+    BOOST_CHECK(derivsMatch);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Stage 3: Combined Pipeline Comparison
+// Compares: Original (QuantLib/Re-Route) vs XAD (QuantLib/Re-Route) vs JIT
+// Full end-to-end: Market Quotes -> Bootstrap -> MC Price -> dPrice/dMarketQuotes
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testStage3_CombinedPipeline)
+{
+    BOOST_TEST_MESSAGE("Testing Stage 3: Combined Bootstrap + MC Pricing Comparison...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  STAGE 3: Combined Pipeline (Bootstrap + MC + Derivatives)\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    std::cout << "  DATA FLOW:\n";
+    std::cout << "    Market Quotes -> Bootstrap -> ZeroRates -> LMM MC -> Price\n";
+    std::cout << "         |                                              |\n";
+    std::cout << "         +<-------- reverse sweep (XAD Tape or JIT) <---+\n";
+    std::cout << std::endl;
+    std::cout << "  Approaches:\n";
+    std::cout << "    - Original (QuantLib):  MultiPathGenerator (standard QuantLib)\n";
+    std::cout << "    - Original (Re-Route):  Custom loop with pre-generated randoms\n";
+    std::cout << "    - XAD (QuantLib):       MultiPathGenerator with XAD tape\n";
+    std::cout << "    - XAD (Re-Route):       Custom loop with XAD tape\n";
+    std::cout << "    - JIT:                  Custom loop with JIT (tape for bootstrap)\n";
+    std::cout << std::endl;
+
+    // =========================================================================
+    // COMMON PARAMETERS
+    // =========================================================================
+    Calendar calendar = TARGET();
+    Date todaysDate = Date(4, September, 2005);
+    Settings::instance().evaluationDate() = todaysDate;
+
+    DayCounter dayCounter = Actual360();
+    Integer fixingDays = 2;
+    Date settlementDate = calendar.advance(todaysDate, fixingDays, Days);
+
+    const Size size = 10;
+    const Size steps = 8 * size;
+    const Size nrTrails = 10;  // Reduced for faster testing
+
+    // Market quote values - more realistic curve
+    // Deposit rates: ON, 1M, 3M, 6M
+    std::vector<Period> depoTenors = {1 * Days, 1 * Months, 3 * Months, 6 * Months};
+    std::vector<double> depoRates_val = {0.0350, 0.0365, 0.0380, 0.0400};
+
+    // Swap rates: 1Y, 2Y, 3Y, 4Y, 5Y
+    std::vector<Period> swapTenors = {1 * Years, 2 * Years, 3 * Years, 4 * Years, 5 * Years};
+    std::vector<double> swapRates_val = {0.0420, 0.0480, 0.0520, 0.0550, 0.0575};
+
+    Size numDeposits = depoTenors.size();
+    Size numSwaps = swapTenors.size();
+    Size numMarketQuotes = numDeposits + numSwaps;  // 4 + 5 = 9 market inputs
+
+    // Swaption parameters
+    Size i_opt = 2;  // Option expiry index
+    Size j_opt = 2;  // Swap length index
+
+    std::cout << "  Setup:\n";
+    std::cout << "    - Market quotes: " << numDeposits << " deposits + " << numSwaps << " swaps = " << numMarketQuotes << " inputs\n";
+    std::cout << "    - Deposit tenors: ON, 1M, 3M, 6M\n";
+    std::cout << "    - Swap tenors: 1Y, 2Y, 3Y, 4Y, 5Y\n";
+    std::cout << "    - Forward rates: " << size << "\n";
+    std::cout << "    - MC paths: " << nrTrails << "\n";
+    std::cout << "    - Swaption: " << (i_opt*6) << "M option into " << (j_opt*6) << "M swap\n";
+    std::cout << std::endl;
+
+    // =========================================================================
+    // Helper: Build curve and LMM process from market quote values
+    // =========================================================================
+    auto buildCurveAndProcess = [&](const std::vector<double>& depoRates,
+                                    const std::vector<double>& swapRates,
+                                    std::vector<Date>& curveDates_out,
+                                    std::vector<Rate>& zeroRates_out) {
+        RelinkableHandle<YieldTermStructure> euriborTS;
+        auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+        euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+        std::vector<ext::shared_ptr<RateHelper>> instruments;
+
+        // Add deposit rate helpers
+        for (Size idx = 0; idx < depoTenors.size(); ++idx) {
+            auto depoQuote = ext::make_shared<SimpleQuote>(depoRates[idx]);
+            instruments.push_back(ext::make_shared<DepositRateHelper>(
+                Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                calendar, ModifiedFollowing, true, dayCounter));
+        }
+
+        // Add swap rate helpers
+        for (Size idx = 0; idx < swapTenors.size(); ++idx) {
+            auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+            instruments.push_back(ext::make_shared<SwapRateHelper>(
+                Handle<Quote>(swapQuote), swapTenors[idx],
+                calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis), euribor6m));
+        }
+
+        auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+            settlementDate, instruments, dayCounter);
+        yieldCurve->enableExtrapolation();
+
+        curveDates_out.clear();
+        zeroRates_out.clear();
+        curveDates_out.push_back(settlementDate);
+        zeroRates_out.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+        Date endDate = settlementDate + 6 * Years;
+        curveDates_out.push_back(endDate);
+        zeroRates_out.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+    };
+
+    // Build base curve to get dimensions
+    std::vector<Date> baseCurveDates;
+    std::vector<Rate> baseZeroRates;
+    buildCurveAndProcess(depoRates_val, swapRates_val, baseCurveDates, baseZeroRates);
+
+    // Build base LMM process
+    RelinkableHandle<YieldTermStructure> baseTermStructure;
+    ext::shared_ptr<IborIndex> baseIndex(new Euribor6M(baseTermStructure));
+    baseIndex->addFixing(Date(2, September, 2005), 0.04);
+    baseTermStructure.linkTo(ext::make_shared<ZeroCurve>(baseCurveDates, baseZeroRates, dayCounter));
+
+    ext::shared_ptr<LiborForwardModelProcess> baseProcess(
+        new LiborForwardModelProcess(size, baseIndex));
+    ext::shared_ptr<LmCorrelationModel> baseCorrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> baseVolaModel(
+        new LmLinearExponentialVolatilityModel(baseProcess->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    baseProcess->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(baseVolaModel, baseCorrModel)));
+
+    std::vector<Time> fixingTimes = baseProcess->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    Size numFactors = baseProcess->factors();
+    Size exerciseStep = location[i_opt];
+    Size totalRandoms = numFactors * exerciseStep;
+
+    // Get fair swap rate
+    BusinessDayConvention convention = baseIndex->businessDayConvention();
+    Date settlement = baseIndex->forwardingTermStructure()->referenceDate();
+    Date fwdStart = settlement + Period(6 * i_opt, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j_opt, Months);
+
+    Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    ext::shared_ptr<VanillaSwap> forwardSwap(
+        new VanillaSwap(Swap::Receiver, 1.0,
+                        schedule, 0.05, dayCounter,
+                        schedule, baseIndex, 0.0, baseIndex->dayCounter()));
+    forwardSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+        baseIndex->forwardingTermStructure()));
+
+    double swapRate_double = value(forwardSwap->fairRate());
+
+    // Pre-generate random numbers for Re-Route approaches
+    // Use same dimension as QuantLib MultiPathGenerator for RNG synchronization
+    typedef PseudoRandom::rsg_type rsg_type;
+    Size fullGridRandoms = numFactors * (grid.size() - 1);  // Full grid dimension (like MultiPathGenerator)
+    rsg_type rsg = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+
+    std::vector<std::vector<double>> allRandoms(nrTrails);
+    for (Size n = 0; n < nrTrails; ++n) {
+        const auto& sequence = (n % 2) != 0U ? rsg.lastSequence() : rsg.nextSequence();
+        // Store only up to exerciseStep (but generate full dimension to keep RNG in sync)
+        allRandoms[n].resize(totalRandoms);
+        for (Size m = 0; m < totalRandoms; ++m) {
+            double rnd = (n % 2) != 0U ? -value(sequence.value[m]) : value(sequence.value[m]);
+            allRandoms[n][m] = rnd;
+        }
+    }
+
+    // =========================================================================
+    // 0. ORIGINAL (QuantLib): Uses MultiPathGenerator
+    // =========================================================================
+    rsg_type rsg_ql = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+    typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+    MultiPathGenerator<rsg_type> generator_ql(baseProcess, grid, rsg_ql, false);
+
+    double mcPrice_orig_ql = 0.0;
+    for (Size n = 0; n < nrTrails; ++n) {
+        sample_type path = (n % 2) != 0U ? generator_ql.antithetic() : generator_ql.next();
+
+        std::vector<double> mcRates(size);
+        for (Size k = 0; k < size; ++k) {
+            mcRates[k] = value(path.value[k][location[i_opt]]);
+        }
+
+        std::vector<double> dis(size);
+        double df = 1.0;
+        for (Size k = 0; k < size; ++k) {
+            double accrual = value(baseProcess->accrualEndTimes()[k]) - value(baseProcess->accrualStartTimes()[k]);
+            df = df / (1.0 + mcRates[k] * accrual);
+            dis[k] = df;
+        }
+
+        double npv = 0.0;
+        for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+            double accrual = value(baseProcess->accrualEndTimes()[m]) - value(baseProcess->accrualStartTimes()[m]);
+            npv += (swapRate_double - mcRates[m]) * accrual * dis[m];
+        }
+        if (npv > 0.0) mcPrice_orig_ql += npv;
+    }
+    mcPrice_orig_ql /= static_cast<double>(nrTrails);
+
+    // Get base initial rates
+    Array baseInitRates = baseProcess->initialValues();
+    std::vector<double> baseInitRates_vec(size);
+    for (Size k = 0; k < size; ++k) {
+        baseInitRates_vec[k] = value(baseInitRates[k]);
+    }
+
+    // Get accrual times
+    std::vector<double> accrualStart(size), accrualEnd(size);
+    for (Size k = 0; k < size; ++k) {
+        accrualStart[k] = value(baseProcess->accrualStartTimes()[k]);
+        accrualEnd[k] = value(baseProcess->accrualEndTimes()[k]);
+    }
+
+    // =========================================================================
+    // Helper lambda: Compute MC price from market quotes (for bump-and-reprice)
+    // =========================================================================
+    auto computeMCPrice = [&](const std::vector<double>& depoRates,
+                              const std::vector<double>& swapRates) {
+        // Build curve
+        std::vector<Date> curveDates;
+        std::vector<Rate> zeroRates;
+        buildCurveAndProcess(depoRates, swapRates, curveDates, zeroRates);
+
+        // Build process
+        RelinkableHandle<YieldTermStructure> termStructure;
+        ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+        index->addFixing(Date(2, September, 2005), 0.04);
+        termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates, dayCounter));
+
+        ext::shared_ptr<LiborForwardModelProcess> process(
+            new LiborForwardModelProcess(size, index));
+        ext::shared_ptr<LmCorrelationModel> corrModel(
+            new LmExponentialCorrelationModel(size, 0.5));
+        ext::shared_ptr<LmVolatilityModel> volaModel(
+            new LmLinearExponentialVolatilityModel(process->fixingTimes(),
+                                                   0.291, 1.483, 0.116, 0.00001));
+        process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+            new LfmCovarianceProxy(volaModel, corrModel)));
+
+        // Get swap rate
+        ext::shared_ptr<VanillaSwap> fwdSwap(
+            new VanillaSwap(Swap::Receiver, 1.0,
+                            schedule, 0.05, dayCounter,
+                            schedule, index, 0.0, index->dayCounter()));
+        fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+            index->forwardingTermStructure()));
+        double swapRate = value(fwdSwap->fairRate());
+
+        Array initRates = process->initialValues();
+
+        // MC loop
+        double price = 0.0;
+        for (Size n = 0; n < nrTrails; ++n) {
+            std::vector<double> asset(size);
+            for (Size k = 0; k < size; ++k) asset[k] = value(initRates[k]);
+
+            for (Size step = 1; step <= exerciseStep; ++step) {
+                Size offset = (step - 1) * numFactors;
+                Time t = grid[step - 1];
+                Time dt = grid.dt(step - 1);
+
+                Array dw(numFactors);
+                for (Size f = 0; f < numFactors; ++f) {
+                    dw[f] = allRandoms[n][offset + f];
+                }
+
+                Array asset_arr(size);
+                for (Size k = 0; k < size; ++k) asset_arr[k] = asset[k];
+
+                Array evolved = process->evolve(t, asset_arr, dt, dw);
+                for (Size k = 0; k < size; ++k) asset[k] = value(evolved[k]);
+            }
+
+            // Discount factors
+            std::vector<double> dis(size);
+            double df = 1.0;
+            for (Size k = 0; k < size; ++k) {
+                double accrual = accrualEnd[k] - accrualStart[k];
+                df = df / (1.0 + asset[k] * accrual);
+                dis[k] = df;
+            }
+
+            // Payoff
+            double npv = 0.0;
+            for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                double accrual = accrualEnd[m] - accrualStart[m];
+                npv += (swapRate - asset[m]) * accrual * dis[m];
+            }
+
+            if (npv > 0.0) price += npv;
+        }
+
+        return price / static_cast<double>(nrTrails);
+    };
+
+    // =========================================================================
+    // 1. ORIGINAL (Re-Route): Compute base price (non-XAD, custom loop)
+    // =========================================================================
+    double mcPrice_orig_rr = computeMCPrice(depoRates_val, swapRates_val);
+
+    // =========================================================================
+    // 2. XAD (QuantLib): Uses MultiPathGenerator with XAD tape
+    // =========================================================================
+    using tape_type = Real::tape_type;
+    tape_type tape_ql;
+
+    // Register market quotes as inputs
+    std::vector<Real> depositRates_ql(numDeposits);
+    std::vector<Real> swapRates_ql(numSwaps);
+    for (Size idx = 0; idx < numDeposits; ++idx) depositRates_ql[idx] = depoRates_val[idx];
+    for (Size idx = 0; idx < numSwaps; ++idx) swapRates_ql[idx] = swapRates_val[idx];
+
+    tape_ql.registerInputs(depositRates_ql);
+    tape_ql.registerInputs(swapRates_ql);
+    tape_ql.newRecording();
+
+    // Bootstrap curve on tape
+    RelinkableHandle<YieldTermStructure> euriborTS_ql;
+    auto euribor6m_ql = ext::make_shared<Euribor6M>(euriborTS_ql);
+    euribor6m_ql->addFixing(Date(2, September, 2005), 0.04);
+
+    std::vector<ext::shared_ptr<RateHelper>> instruments_ql;
+    for (Size idx = 0; idx < numDeposits; ++idx) {
+        auto depoQuote = ext::make_shared<SimpleQuote>(depositRates_ql[idx]);
+        instruments_ql.push_back(ext::make_shared<DepositRateHelper>(
+            Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+            calendar, ModifiedFollowing, true, dayCounter));
+    }
+    for (Size idx = 0; idx < numSwaps; ++idx) {
+        auto swapQuote = ext::make_shared<SimpleQuote>(swapRates_ql[idx]);
+        instruments_ql.push_back(ext::make_shared<SwapRateHelper>(
+            Handle<Quote>(swapQuote), swapTenors[idx],
+            calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis), euribor6m_ql));
+    }
+
+    auto yieldCurve_ql = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+        settlementDate, instruments_ql, dayCounter);
+    yieldCurve_ql->enableExtrapolation();
+
+    std::vector<Date> curveDates_ql;
+    std::vector<Real> zeroRates_ql;
+    curveDates_ql.push_back(settlementDate);
+    zeroRates_ql.push_back(yieldCurve_ql->zeroRate(settlementDate, dayCounter, Continuous).rate());
+    Date endDate_ql = settlementDate + 6 * Years;
+    curveDates_ql.push_back(endDate_ql);
+    zeroRates_ql.push_back(yieldCurve_ql->zeroRate(endDate_ql, dayCounter, Continuous).rate());
+
+    // Build LMM process on tape
+    RelinkableHandle<YieldTermStructure> termStructure_ql;
+    ext::shared_ptr<IborIndex> index_ql(new Euribor6M(termStructure_ql));
+    index_ql->addFixing(Date(2, September, 2005), 0.04);
+    termStructure_ql.linkTo(ext::make_shared<ZeroCurve>(curveDates_ql, zeroRates_ql, dayCounter));
+
+    ext::shared_ptr<LiborForwardModelProcess> process_ql(
+        new LiborForwardModelProcess(size, index_ql));
+    process_ql->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(
+            ext::make_shared<LmLinearExponentialVolatilityModel>(process_ql->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+            ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+    // Get grid and locations for this process
+    std::vector<Time> fixingTimes_ql = process_ql->fixingTimes();
+    TimeGrid grid_ql(fixingTimes_ql.begin(), fixingTimes_ql.end(), steps);
+    std::vector<Size> location_ql;
+    for (Size idx = 0; idx < fixingTimes_ql.size(); ++idx) {
+        location_ql.push_back(
+            std::find(grid_ql.begin(), grid_ql.end(), fixingTimes_ql[idx]) - grid_ql.begin());
+    }
+
+    // Get swap rate
+    ext::shared_ptr<VanillaSwap> fwdSwap_ql(
+        new VanillaSwap(Swap::Receiver, 1.0,
+                        schedule, 0.05, dayCounter,
+                        schedule, index_ql, 0.0, index_ql->dayCounter()));
+    fwdSwap_ql->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+        index_ql->forwardingTermStructure()));
+    Real swapRate_ql = fwdSwap_ql->fairRate();
+
+    // MC with MultiPathGenerator using XAD types
+    rsg_type rsg_xad_ql = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+    MultiPathGenerator<rsg_type> generator_xad_ql(process_ql, grid_ql, rsg_xad_ql, false);
+
+    Real mcPrice_xad_ql = 0.0;
+    for (Size n = 0; n < nrTrails; ++n) {
+        sample_type path = (n % 2) != 0U ? generator_xad_ql.antithetic() : generator_xad_ql.next();
+
+        std::vector<Real> mcRates(size);
+        for (Size k = 0; k < size; ++k) {
+            mcRates[k] = path.value[k][location_ql[i_opt]];
+        }
+
+        std::vector<Real> dis(size);
+        Real df = 1.0;
+        for (Size k = 0; k < size; ++k) {
+            Real accrual = process_ql->accrualEndTimes()[k] - process_ql->accrualStartTimes()[k];
+            df = df / (Real(1.0) + mcRates[k] * accrual);
+            dis[k] = df;
+        }
+
+        Real npv = 0.0;
+        for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+            Real accrual = process_ql->accrualEndTimes()[m] - process_ql->accrualStartTimes()[m];
+            npv = npv + (swapRate_ql - mcRates[m]) * accrual * dis[m];
+        }
+        if (value(npv) > 0.0) mcPrice_xad_ql += npv;
+    }
+    mcPrice_xad_ql /= static_cast<Real>(nrTrails);
+
+    tape_ql.registerOutput(mcPrice_xad_ql);
+    derivative(mcPrice_xad_ql) = 1.0;
+    tape_ql.computeAdjoints();
+
+    std::vector<double> dPrice_xad_ql_depo(numDeposits);
+    std::vector<double> dPrice_xad_ql_swap(numSwaps);
+    for (Size idx = 0; idx < numDeposits; ++idx) dPrice_xad_ql_depo[idx] = derivative(depositRates_ql[idx]);
+    for (Size idx = 0; idx < numSwaps; ++idx) dPrice_xad_ql_swap[idx] = derivative(swapRates_ql[idx]);
+    tape_ql.deactivate();
+
+    // =========================================================================
+    // 3. XAD (Re-Route): Full pipeline with tape recording (custom loop)
+    // =========================================================================
+    tape_type tape_rr;
+
+    // Convert to XAD Real vectors
+    std::vector<Real> depositRates(numDeposits);
+    std::vector<Real> swapRates(numSwaps);
+    for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+    for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+    tape_rr.registerInputs(depositRates);
+    tape_rr.registerInputs(swapRates);
+    tape_rr.newRecording();
+
+    // Bootstrap curve on tape
+    RelinkableHandle<YieldTermStructure> euriborTermStructure;
+    auto euribor6m = ext::make_shared<Euribor6M>(euriborTermStructure);
+    euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+    std::vector<ext::shared_ptr<RateHelper>> instruments;
+
+    // Add deposit rate helpers
+    for (Size idx = 0; idx < numDeposits; ++idx) {
+        auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+        instruments.push_back(ext::make_shared<DepositRateHelper>(
+            Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+            calendar, ModifiedFollowing, true, dayCounter));
+    }
+
+    // Add swap rate helpers
+    for (Size idx = 0; idx < numSwaps; ++idx) {
+        auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+        instruments.push_back(ext::make_shared<SwapRateHelper>(
+            Handle<Quote>(swapQuote), swapTenors[idx],
+            calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+            euribor6m));
+    }
+
+    auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+        settlementDate, instruments, dayCounter);
+    yieldCurve->enableExtrapolation();
+
+    std::vector<Date> curveDates;
+    std::vector<Real> zeroRates;
+    curveDates.push_back(settlementDate);
+    zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+    Date endDate = settlementDate + 6 * Years;
+    curveDates.push_back(endDate);
+    zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+    // Build LMM process on tape
+    RelinkableHandle<YieldTermStructure> termStructure;
+    ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+    index->addFixing(Date(2, September, 2005), 0.04);
+    termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates, dayCounter));
+
+    ext::shared_ptr<LiborForwardModelProcess> process(
+        new LiborForwardModelProcess(size, index));
+    ext::shared_ptr<LmCorrelationModel> corrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> volaModel(
+        new LmLinearExponentialVolatilityModel(process->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(volaModel, corrModel)));
+
+    // Get swap rate (on tape)
+    ext::shared_ptr<VanillaSwap> fwdSwap_tape(
+        new VanillaSwap(Swap::Receiver, 1.0,
+                        schedule, 0.05, dayCounter,
+                        schedule, index, 0.0, index->dayCounter()));
+    fwdSwap_tape->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+        index->forwardingTermStructure()));
+    Real swapRate_tape = fwdSwap_tape->fairRate();
+
+    Array initRates_tape = process->initialValues();
+
+    // MC loop on tape
+    Real mcPrice_tape = 0.0;
+    for (Size n = 0; n < nrTrails; ++n) {
+        std::vector<Real> asset(size);
+        for (Size k = 0; k < size; ++k) asset[k] = initRates_tape[k];
+
+        for (Size step = 1; step <= exerciseStep; ++step) {
+            Size offset = (step - 1) * numFactors;
+            Time t = grid[step - 1];
+            Time dt = grid.dt(step - 1);
+
+            Array dw(numFactors);
+            for (Size f = 0; f < numFactors; ++f) {
+                dw[f] = allRandoms[n][offset + f];
+            }
+
+            Array asset_arr(size);
+            for (Size k = 0; k < size; ++k) asset_arr[k] = asset[k];
+
+            Array evolved = process->evolve(t, asset_arr, dt, dw);
+            for (Size k = 0; k < size; ++k) asset[k] = evolved[k];
+        }
+
+        // Discount factors
+        std::vector<Real> dis(size);
+        Real df = 1.0;
+        for (Size k = 0; k < size; ++k) {
+            double accrual = accrualEnd[k] - accrualStart[k];
+            df = df / (Real(1.0) + asset[k] * accrual);
+            dis[k] = df;
+        }
+
+        // Payoff
+        Real npv = 0.0;
+        for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+            double accrual = accrualEnd[m] - accrualStart[m];
+            npv = npv + (swapRate_tape - asset[m]) * accrual * dis[m];
+        }
+
+        if (value(npv) > 0.0) mcPrice_tape += npv;
+    }
+    mcPrice_tape /= static_cast<Real>(nrTrails);
+
+    // Compute XAD derivatives
+    tape_rr.registerOutput(mcPrice_tape);
+    derivative(mcPrice_tape) = 1.0;
+    tape_rr.computeAdjoints();
+
+    std::vector<double> dPrice_xad_rr_depo(numDeposits);
+    std::vector<double> dPrice_xad_rr_swap(numSwaps);
+    for (Size idx = 0; idx < numDeposits; ++idx) dPrice_xad_rr_depo[idx] = derivative(depositRates[idx]);
+    for (Size idx = 0; idx < numSwaps; ++idx) dPrice_xad_rr_swap[idx] = derivative(swapRates[idx]);
+
+    // Deactivate tape for JIT
+    tape_rr.deactivate();
+
+    // =========================================================================
+    // 4. JIT: Tape for bootstrap, JIT for MC
+    // =========================================================================
+    // Re-create tape for Jacobian computation only
+    tape_type tape2;
+
+    std::vector<Real> depositRates2(numDeposits);
+    std::vector<Real> swapRates2(numSwaps);
+    for (Size idx = 0; idx < numDeposits; ++idx) depositRates2[idx] = depoRates_val[idx];
+    for (Size idx = 0; idx < numSwaps; ++idx) swapRates2[idx] = swapRates_val[idx];
+
+    tape2.registerInputs(depositRates2);
+    tape2.registerInputs(swapRates2);
+    tape2.newRecording();
+
+    // Bootstrap curve
+    RelinkableHandle<YieldTermStructure> euriborTS2;
+    auto euribor6m2 = ext::make_shared<Euribor6M>(euriborTS2);
+    euribor6m2->addFixing(Date(2, September, 2005), 0.04);
+
+    std::vector<ext::shared_ptr<RateHelper>> instruments2;
+
+    // Add deposit rate helpers
+    for (Size idx = 0; idx < numDeposits; ++idx) {
+        auto depoQuote2 = ext::make_shared<SimpleQuote>(depositRates2[idx]);
+        instruments2.push_back(ext::make_shared<DepositRateHelper>(
+            Handle<Quote>(depoQuote2), depoTenors[idx], fixingDays,
+            calendar, ModifiedFollowing, true, dayCounter));
+    }
+
+    // Add swap rate helpers
+    for (Size idx = 0; idx < numSwaps; ++idx) {
+        auto swapQuote = ext::make_shared<SimpleQuote>(swapRates2[idx]);
+        instruments2.push_back(ext::make_shared<SwapRateHelper>(
+            Handle<Quote>(swapQuote), swapTenors[idx],
+            calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+            euribor6m2));
+    }
+
+    auto yieldCurve2 = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+        settlementDate, instruments2, dayCounter);
+    yieldCurve2->enableExtrapolation();
+
+    std::vector<Date> curveDates2;
+    std::vector<Real> zeroRates2;
+    curveDates2.push_back(settlementDate);
+    zeroRates2.push_back(yieldCurve2->zeroRate(settlementDate, dayCounter, Continuous).rate());
+    Date endDate2 = settlementDate + 6 * Years;
+    curveDates2.push_back(endDate2);
+    zeroRates2.push_back(yieldCurve2->zeroRate(endDate2, dayCounter, Continuous).rate());
+
+    // Build process
+    std::vector<Rate> zeroRates2_ql;
+    for (const auto& r : zeroRates2) zeroRates2_ql.push_back(r);
+
+    RelinkableHandle<YieldTermStructure> termStructure2;
+    ext::shared_ptr<IborIndex> index2(new Euribor6M(termStructure2));
+    index2->addFixing(Date(2, September, 2005), 0.04);
+    termStructure2.linkTo(ext::make_shared<ZeroCurve>(curveDates2, zeroRates2_ql, dayCounter));
+
+    ext::shared_ptr<LiborForwardModelProcess> process2(
+        new LiborForwardModelProcess(size, index2));
+    ext::shared_ptr<LmCorrelationModel> corrModel2(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> volaModel2(
+        new LmLinearExponentialVolatilityModel(process2->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    process2->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(volaModel2, corrModel2)));
+
+    // Get swap rate (on tape)
+    ext::shared_ptr<VanillaSwap> fwdSwap2(
+        new VanillaSwap(Swap::Receiver, 1.0,
+                        schedule, 0.05, dayCounter,
+                        schedule, index2, 0.0, index2->dayCounter()));
+    fwdSwap2->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+        index2->forwardingTermStructure()));
+    Real swapRate2_tape = fwdSwap2->fairRate();
+
+    Array initRates2 = process2->initialValues();
+
+    // Compute Jacobian: d(InitRates, SwapRate) / dMarketQuotes
+    // numMarketQuotes already defined above (9 = 4 deposits + 5 swaps)
+    Size numIntermediates = size + 1;  // 10 init rates + 1 swap rate
+
+    // Flat row-major Jacobian: jacobian[i * numMarketQuotes + j] = d(intermediate_i)/d(input_j)
+    std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+
+    for (Size k = 0; k < size; ++k) {
+        if (initRates2[k].shouldRecord()) {
+            tape2.clearDerivatives();
+            tape2.registerOutput(initRates2[k]);
+            derivative(initRates2[k]) = 1.0;
+            tape2.computeAdjoints();
+
+            double* jac_row = jacobian.data() + k * numMarketQuotes;
+            for (Size m = 0; m < numDeposits; ++m)
+                jac_row[m] = derivative(depositRates2[m]);
+            for (Size m = 0; m < numSwaps; ++m)
+                jac_row[numDeposits + m] = derivative(swapRates2[m]);
+        }
+    }
+
+    if (swapRate2_tape.shouldRecord()) {
+        tape2.clearDerivatives();
+        tape2.registerOutput(swapRate2_tape);
+        derivative(swapRate2_tape) = 1.0;
+        tape2.computeAdjoints();
+
+        double* jac_row = jacobian.data() + size * numMarketQuotes;
+        for (Size m = 0; m < numDeposits; ++m)
+            jac_row[m] = derivative(depositRates2[m]);
+        for (Size m = 0; m < numSwaps; ++m)
+            jac_row[numDeposits + m] = derivative(swapRates2[m]);
+    }
+
+    // Deactivate tape for JIT
+    tape2.deactivate();
+
+    // JIT setup with ForgeBackend
+    auto forgeBackend4 = std::make_unique<xad::forge::ForgeBackend<double>>();
+    xad::JITCompiler<double> jit(std::move(forgeBackend4));
+
+    std::vector<xad::AD> jit_initRates(size);
+    xad::AD jit_swapRate;
+    std::vector<xad::AD> jit_randoms(totalRandoms);
+
+    for (Size k = 0; k < size; ++k) {
+        jit_initRates[k] = xad::AD(value(initRates2[k]));
+        jit.registerInput(jit_initRates[k]);
+    }
+
+    jit_swapRate = xad::AD(value(swapRate2_tape));
+    jit.registerInput(jit_swapRate);
+
+    for (Size m = 0; m < totalRandoms; ++m) {
+        jit_randoms[m] = xad::AD(0.0);
+        jit.registerInput(jit_randoms[m]);
+    }
+
+    jit.newRecording();
+
+    // Record path evolution
+    std::vector<xad::AD> asset_jit(size);
+    for (Size k = 0; k < size; ++k) {
+        asset_jit[k] = jit_initRates[k];
+    }
+
+    for (Size step = 1; step <= exerciseStep; ++step) {
+        Size offset = (step - 1) * numFactors;
+        Time t = grid[step - 1];
+        Time dt = grid.dt(step - 1);
+
+        Array dw(numFactors);
+        for (Size f = 0; f < numFactors; ++f) {
+            dw[f] = jit_randoms[offset + f];
+        }
+
+        Array asset_arr(size);
+        for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+        Array evolved = process2->evolve(t, asset_arr, dt, dw);
+        for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+    }
+
+    // Compute discount factors
+    std::vector<xad::AD> dis_jit(size);
+    xad::AD df_jit = xad::AD(1.0);
+    for (Size k = 0; k < size; ++k) {
+        double accrual = accrualEnd[k] - accrualStart[k];
+        df_jit = df_jit / (xad::AD(1.0) + asset_jit[k] * accrual);
+        dis_jit[k] = df_jit;
+    }
+
+    // Compute payoff
+    xad::AD jit_npv = xad::AD(0.0);
+    for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+        double accrual = accrualEnd[m] - accrualStart[m];
+        jit_npv = jit_npv + (jit_swapRate - asset_jit[m]) * accrual * dis_jit[m];
+    }
+
+    xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+    jit.registerOutput(jit_payoff);
+
+    // Compile the JIT kernel before MC loop
+    jit.compile();
+
+    // JIT MC loop
+    double mcPrice_jit = 0.0;
+    std::vector<double> dPrice_dInitRates(size, 0.0);
+    double dPrice_dSwapRate_jit = 0.0;
+
+    const auto& graph = jit.getGraph();
+    uint32_t outputSlot = graph.output_ids[0];
+
+    for (Size n = 0; n < nrTrails; ++n) {
+        for (Size k = 0; k < size; ++k) {
+            value(jit_initRates[k]) = value(initRates2[k]);
+        }
+        value(jit_swapRate) = value(swapRate2_tape);
+
+        for (Size m = 0; m < totalRandoms; ++m) {
+            value(jit_randoms[m]) = allRandoms[n][m];
+        }
+
+        double payoff_value;
+        jit.forward(&payoff_value);
+        mcPrice_jit += payoff_value;
+
+        jit.clearDerivatives();
+        jit.setDerivative(outputSlot, 1.0);
+        jit.computeAdjoints();
+
+        for (Size k = 0; k < size; ++k) {
+            dPrice_dInitRates[k] += jit.derivative(graph.input_ids[k]);
+        }
+        dPrice_dSwapRate_jit += jit.derivative(graph.input_ids[size]);  // swap rate is at index 'size'
+    }
+
+    mcPrice_jit /= static_cast<double>(nrTrails);
+    for (Size k = 0; k < size; ++k) {
+        dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+    }
+    dPrice_dSwapRate_jit /= static_cast<double>(nrTrails);
+
+    // Chain rule: dPrice/dMarketQuotes = jacobian^T * derivatives
+    // Build derivatives vector: [dPrice/dInitRate_0, ..., dPrice/dInitRate_9, dPrice/dSwapRate]
+    std::vector<double> dPrice_dIntermediates(numIntermediates);
+    for (Size k = 0; k < size; ++k)
+        dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+    dPrice_dIntermediates[size] = dPrice_dSwapRate_jit;
+
+    // Apply chain rule using high-performance function
+    std::vector<double> dPrice_jit_market(numMarketQuotes);
+    applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_jit_market.data(),
+                   numIntermediates, numMarketQuotes);
+
+    // Split JIT derivatives into deposits and swaps
+    std::vector<double> dPrice_jit_depo(numDeposits);
+    std::vector<double> dPrice_jit_swap(numSwaps);
+    for (Size idx = 0; idx < numDeposits; ++idx) dPrice_jit_depo[idx] = dPrice_jit_market[idx];
+    for (Size idx = 0; idx < numSwaps; ++idx) dPrice_jit_swap[idx] = dPrice_jit_market[numDeposits + idx];
+
+    // =========================================================================
+    // 5a. BUMP-AND-REPRICE (QuantLib) - MultiPathGenerator
+    // =========================================================================
+    double bump = 1e-6;
+
+    // Helper for QuantLib MC pricing using MultiPathGenerator
+    auto computeMCPriceQL = [&](const std::vector<double>& depoRates,
+                                const std::vector<double>& swapRates) {
+        std::vector<Date> curveDates;
+        std::vector<Rate> zeroRates;
+        buildCurveAndProcess(depoRates, swapRates, curveDates, zeroRates);
+
+        RelinkableHandle<YieldTermStructure> termStructure;
+        ext::shared_ptr<IborIndex> index_tmp(new Euribor6M(termStructure));
+        index_tmp->addFixing(Date(2, September, 2005), 0.04);
+        termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates, dayCounter));
+
+        ext::shared_ptr<LiborForwardModelProcess> process_tmp(
+            new LiborForwardModelProcess(size, index_tmp));
+        process_tmp->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+            new LfmCovarianceProxy(
+                ext::make_shared<LmLinearExponentialVolatilityModel>(process_tmp->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+        ext::shared_ptr<VanillaSwap> fwdSwap_tmp(
+            new VanillaSwap(Swap::Receiver, 1.0,
+                            schedule, 0.05, dayCounter,
+                            schedule, index_tmp, 0.0, index_tmp->dayCounter()));
+        fwdSwap_tmp->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+            index_tmp->forwardingTermStructure()));
+        double swapRate_tmp = value(fwdSwap_tmp->fairRate());
+
+        // Use same grid dimension as base process
+        rsg_type rsg_tmp = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+        MultiPathGenerator<rsg_type> gen_tmp(process_tmp, grid, rsg_tmp, false);
+
+        double price = 0.0;
+        for (Size n = 0; n < nrTrails; ++n) {
+            sample_type path = (n % 2) != 0U ? gen_tmp.antithetic() : gen_tmp.next();
+
+            std::vector<double> mcRates(size);
+            for (Size k = 0; k < size; ++k) {
+                mcRates[k] = value(path.value[k][location[i_opt]]);
+            }
+
+            std::vector<double> dis(size);
+            double df = 1.0;
+            for (Size k = 0; k < size; ++k) {
+                double accrual = accrualEnd[k] - accrualStart[k];
+                df = df / (1.0 + mcRates[k] * accrual);
+                dis[k] = df;
+            }
+
+            double npv = 0.0;
+            for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                double accrual = accrualEnd[m] - accrualStart[m];
+                npv += (swapRate_tmp - mcRates[m]) * accrual * dis[m];
+            }
+            if (npv > 0.0) price += npv;
+        }
+        return price / static_cast<double>(nrTrails);
+    };
+
+    std::vector<double> dPrice_bump_ql_depo(numDeposits);
+    std::vector<double> dPrice_bump_ql_swap(numSwaps);
+
+    // Bump each deposit rate (QuantLib)
+    for (Size idx = 0; idx < numDeposits; ++idx) {
+        std::vector<double> bumpedDepoRates = depoRates_val;
+        bumpedDepoRates[idx] += bump;
+        double price_bumped = computeMCPriceQL(bumpedDepoRates, swapRates_val);
+        dPrice_bump_ql_depo[idx] = (price_bumped - mcPrice_orig_ql) / bump;
+    }
+
+    // Bump each swap rate (QuantLib)
+    for (Size idx = 0; idx < numSwaps; ++idx) {
+        std::vector<double> bumpedSwapRates = swapRates_val;
+        bumpedSwapRates[idx] += bump;
+        double price_bumped = computeMCPriceQL(depoRates_val, bumpedSwapRates);
+        dPrice_bump_ql_swap[idx] = (price_bumped - mcPrice_orig_ql) / bump;
+    }
+
+    // =========================================================================
+    // 5b. BUMP-AND-REPRICE (Re-Route) - Custom loop
+    // =========================================================================
+    std::vector<double> dPrice_bump_rr_depo(numDeposits);
+    std::vector<double> dPrice_bump_rr_swap(numSwaps);
+
+    // Bump each deposit rate (Re-Route)
+    for (Size idx = 0; idx < numDeposits; ++idx) {
+        std::vector<double> bumpedDepoRates = depoRates_val;
+        bumpedDepoRates[idx] += bump;
+        double price_bumped = computeMCPrice(bumpedDepoRates, swapRates_val);
+        dPrice_bump_rr_depo[idx] = (price_bumped - mcPrice_orig_rr) / bump;
+    }
+
+    // Bump each swap rate (Re-Route)
+    for (Size idx = 0; idx < numSwaps; ++idx) {
+        std::vector<double> bumpedSwapRates = swapRates_val;
+        bumpedSwapRates[idx] += bump;
+        double price_bumped = computeMCPrice(depoRates_val, bumpedSwapRates);
+        dPrice_bump_rr_swap[idx] = (price_bumped - mcPrice_orig_rr) / bump;
+    }
+
+    // =========================================================================
+    // COMPARISON TABLES
+    // =========================================================================
+    std::cout << "  " << std::string(85, '=') << "\n";
+    std::cout << "  TABLE 1: MC PRICE COMPARISON\n";
+    std::cout << "  " << std::string(85, '=') << "\n";
+    std::cout << std::endl;
+
+    std::cout << "  " << std::setw(18) << "Approach" << " | "
+              << std::setw(14) << "MC Price" << " | "
+              << std::setw(14) << "Diff vs Ref" << " | "
+              << "Match\n";
+    std::cout << "  " << std::string(18, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(5, '-') << "\n";
+
+    // Reference: Original (QuantLib) using MultiPathGenerator
+    std::cout << "  " << std::setw(18) << "Orig (QuantLib)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << mcPrice_orig_ql << " | "
+              << std::setw(14) << "-" << " |   -  \n";
+
+    // Original (Re-Route) - custom loop
+    double diff_orig_rr = mcPrice_orig_rr - mcPrice_orig_ql;
+    bool orig_rr_match = (std::abs(diff_orig_rr) < 1e-6);
+    std::cout << "  " << std::setw(18) << "Orig (Re-Route)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << mcPrice_orig_rr << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_orig_rr << " | "
+              << (orig_rr_match ? "  OK " : "DIFF!") << "\n";
+
+    // XAD (QuantLib) - MultiPathGenerator with XAD tape
+    double diff_xad_ql = value(mcPrice_xad_ql) - mcPrice_orig_ql;
+    bool xad_ql_match = (std::abs(diff_xad_ql) < 1e-10);
+    std::cout << "  " << std::setw(18) << "XAD (QuantLib)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << value(mcPrice_xad_ql) << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_xad_ql << " | "
+              << (xad_ql_match ? "  OK " : "DIFF!") << "\n";
+
+    // XAD (Re-Route) - custom loop with tape
+    double diff_xad_rr = value(mcPrice_tape) - mcPrice_orig_rr;
+    bool xad_rr_match = (std::abs(diff_xad_rr) < 1e-10);
+    std::cout << "  " << std::setw(18) << "XAD (Re-Route)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << value(mcPrice_tape) << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_xad_rr << " | "
+              << (xad_rr_match ? "  OK " : "DIFF!") << "\n";
+
+    // JIT (compare to Re-Route baseline)
+    double diff_jit = mcPrice_jit - mcPrice_orig_rr;
+    bool jit_match = (std::abs(diff_jit) < 1e-10);
+    std::cout << "  " << std::setw(18) << "JIT" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << mcPrice_jit << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_jit << " | "
+              << (jit_match ? "  OK " : "DIFF!") << "\n";
+
+    std::cout << std::endl;
+    std::cout << "  Note: Re-Route approaches use pre-generated randoms (same RNG sequence as QuantLib)\n";
+    std::cout << "        XAD prices should match their non-XAD counterparts exactly\n";
+    std::cout << std::endl;
+    bool pricesMatch = xad_ql_match && xad_rr_match && jit_match;
+
+    // Derivatives table
+    std::cout << "  " << std::string(150, '=') << "\n";
+    std::cout << "  TABLE 2: DERIVATIVE COMPARISON (dPrice/dMarketQuote)\n";
+    std::cout << "  " << std::string(150, '=') << "\n";
+    std::cout << std::endl;
+
+    std::cout << "  " << std::setw(12) << "Quote" << " | "
+              << std::setw(14) << "Bump QuantLib" << " | "
+              << std::setw(14) << "Bump Re-Route" << " | "
+              << std::setw(14) << "XAD QuantLib" << " | "
+              << std::setw(14) << "XAD Re-Route" << " | "
+              << std::setw(14) << "JIT" << " | "
+              << std::setw(10) << "QL/RR %" << "\n";
+    std::cout << "  " << std::string(12, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(10, '-') << "\n";
+
+    // Helper for relative diff
+    auto relDiff = [](double a, double b) {
+        if (std::abs(b) < 1e-12) return 0.0;
+        return (a - b) / b * 100.0;
+    };
+
+    // Deposit rates
+    std::vector<std::string> depoLabels = {"Depo ON", "Depo 1M", "Depo 3M", "Depo 6M"};
+    for (Size idx = 0; idx < numDeposits; ++idx) {
+        double relDiff_ql_rr = relDiff(dPrice_xad_ql_depo[idx], dPrice_xad_rr_depo[idx]);
+        std::cout << "  " << std::setw(12) << depoLabels[idx] << " | "
+                  << std::scientific << std::setprecision(4) << std::setw(14) << dPrice_bump_ql_depo[idx] << " | "
+                  << std::setw(14) << dPrice_bump_rr_depo[idx] << " | "
+                  << std::setw(14) << dPrice_xad_ql_depo[idx] << " | "
+                  << std::setw(14) << dPrice_xad_rr_depo[idx] << " | "
+                  << std::setw(14) << dPrice_jit_depo[idx] << " | "
+                  << std::fixed << std::setprecision(4) << std::setw(9) << relDiff_ql_rr << "%\n";
+    }
+
+    // Swap rates
+    std::vector<std::string> swapLabels = {"Swap 1Y", "Swap 2Y", "Swap 3Y", "Swap 4Y", "Swap 5Y"};
+    for (Size idx = 0; idx < numSwaps; ++idx) {
+        double relDiff_ql_rr = relDiff(dPrice_xad_ql_swap[idx], dPrice_xad_rr_swap[idx]);
+        std::cout << "  " << std::setw(12) << swapLabels[idx] << " | "
+                  << std::scientific << std::setprecision(4) << std::setw(14) << dPrice_bump_ql_swap[idx] << " | "
+                  << std::setw(14) << dPrice_bump_rr_swap[idx] << " | "
+                  << std::setw(14) << dPrice_xad_ql_swap[idx] << " | "
+                  << std::setw(14) << dPrice_xad_rr_swap[idx] << " | "
+                  << std::setw(14) << dPrice_jit_swap[idx] << " | "
+                  << std::fixed << std::setprecision(4) << std::setw(9) << relDiff_ql_rr << "%\n";
+    }
+
+    std::cout << std::endl;
+
+    std::cout << "  STATUS: [STAGE 3 COMPLETE]\n";
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    // Verify
+    BOOST_CHECK(mcPrice_orig_ql > 0.0);
+    BOOST_CHECK(mcPrice_orig_rr > 0.0);
+    BOOST_CHECK(pricesMatch);
+    BOOST_CHECK(std::abs(value(mcPrice_tape) - mcPrice_orig_rr) < 1e-10);
+    BOOST_CHECK(std::abs(mcPrice_jit - mcPrice_orig_rr) < 1e-6);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Stage 4: Performance Benchmarks
+// Same computation as Stage 3 but with timing measurements
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testStage4_Benchmarks)
+{
+    BOOST_TEST_MESSAGE("Testing Stage 4: Performance Benchmarks...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  STAGE 4: Performance Benchmarks\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    // Benchmark parameters
+    const Size warmupIterations = 5;
+    const Size benchmarkIterations = 10;
+
+    std::cout << "  Setup:\n";
+    std::cout << "    - Warm-up iterations: " << warmupIterations << "\n";
+    std::cout << "    - Benchmark iterations: " << benchmarkIterations << "\n";
+    std::cout << "    - Market quotes: 4 deposits + 5 swaps = 9 inputs\n";
+    std::cout << "    - Forward rates: 10\n";
+    std::cout << "    - MC paths: 10\n";
+    std::cout << std::endl;
+
+    // =========================================================================
+    // COMMON SETUP (same as Stage 3)
+    // =========================================================================
+    Calendar calendar = TARGET();
+    Date todaysDate(4, September, 2005);
+    Settings::instance().evaluationDate() = todaysDate;
+    Integer fixingDays = 2;
+    Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+    DayCounter dayCounter = Actual360();
+
+    // Market quotes
+    std::vector<Period> depoTenors = {1 * Days, 1 * Months, 3 * Months, 6 * Months};
+    std::vector<double> depoRates_val = {0.0350, 0.0365, 0.0380, 0.0400};
+
+    std::vector<Period> swapTenors = {1 * Years, 2 * Years, 3 * Years, 4 * Years, 5 * Years};
+    std::vector<double> swapRates_val = {0.0420, 0.0480, 0.0520, 0.0550, 0.0575};
+
+    Size numDeposits = depoTenors.size();
+    Size numSwaps = swapTenors.size();
+    Size numMarketQuotes = numDeposits + numSwaps;
+
+    // LMM parameters
+    Size size = 10;
+    Size i_opt = 2;
+    Size j_opt = 2;
+    Size nrTrails = 10;
+    Size steps = 8;
+
+    // Build base curve for grid/timing setup
+    std::vector<Rate> baseZeroRates = {0.0350, 0.0575};
+    std::vector<Date> baseDates = {settlementDate, settlementDate + 6 * Years};
+    auto baseIndex = makeIndex(baseDates, baseZeroRates);
+
+    ext::shared_ptr<LiborForwardModelProcess> baseProcess(
+        new LiborForwardModelProcess(size, baseIndex));
+    ext::shared_ptr<LmCorrelationModel> baseCorrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> baseVolaModel(
+        new LmLinearExponentialVolatilityModel(baseProcess->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    baseProcess->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(baseVolaModel, baseCorrModel)));
+
+    std::vector<Time> fixingTimes = baseProcess->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    Size numFactors = baseProcess->factors();
+    Size exerciseStep = location[i_opt];
+    Size totalRandoms = numFactors * exerciseStep;
+    Size fullGridRandoms = numFactors * (grid.size() - 1);  // Full grid for MultiPathGenerator
+
+    // Get fair swap rate
+    BusinessDayConvention convention = baseIndex->businessDayConvention();
+    Date settlement = baseIndex->forwardingTermStructure()->referenceDate();
+    Date fwdStart = settlement + Period(6 * i_opt, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j_opt, Months);
+
+    Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    // Pre-generate random numbers for Re-Route approaches
+    // Use same dimension as QuantLib MultiPathGenerator for RNG synchronization
+    typedef PseudoRandom::rsg_type rsg_type;
+    rsg_type rsg = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+
+    std::vector<std::vector<double>> allRandoms(nrTrails);
+    for (Size n = 0; n < nrTrails; ++n) {
+        const auto& sequence = (n % 2) != 0U ? rsg.lastSequence() : rsg.nextSequence();
+        // Store only up to exerciseStep (but generate full dimension to keep RNG in sync)
+        allRandoms[n].resize(totalRandoms);
+        for (Size m = 0; m < totalRandoms; ++m) {
+            double rnd = (n % 2) != 0U ? -value(sequence.value[m]) : value(sequence.value[m]);
+            allRandoms[n][m] = rnd;
+        }
+    }
+
+    // Get accrual times
+    std::vector<double> accrualStart(size), accrualEnd(size);
+    for (Size k = 0; k < size; ++k) {
+        accrualStart[k] = value(baseProcess->accrualStartTimes()[k]);
+        accrualEnd[k] = value(baseProcess->accrualEndTimes()[k]);
+    }
+
+    // Helper: Build curve and get zero rates
+    auto buildCurveAndProcess = [&](const std::vector<double>& depoRates,
+                                    const std::vector<double>& swapRates,
+                                    std::vector<Date>& curveDates_out,
+                                    std::vector<Rate>& zeroRates_out) {
+        RelinkableHandle<YieldTermStructure> euriborTS;
+        auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+        euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+        std::vector<ext::shared_ptr<RateHelper>> instruments;
+
+        for (Size idx = 0; idx < numDeposits; ++idx) {
+            auto depoQuote = ext::make_shared<SimpleQuote>(depoRates[idx]);
+            instruments.push_back(ext::make_shared<DepositRateHelper>(
+                Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                calendar, ModifiedFollowing, true, dayCounter));
+        }
+
+        for (Size idx = 0; idx < numSwaps; ++idx) {
+            auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+            instruments.push_back(ext::make_shared<SwapRateHelper>(
+                Handle<Quote>(swapQuote), swapTenors[idx],
+                calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                euribor6m));
+        }
+
+        auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+            settlementDate, instruments, dayCounter);
+        yieldCurve->enableExtrapolation();
+
+        curveDates_out.clear();
+        zeroRates_out.clear();
+        curveDates_out.push_back(settlementDate);
+        zeroRates_out.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+        Date endDate = settlementDate + 6 * Years;
+        curveDates_out.push_back(endDate);
+        zeroRates_out.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+    };
+
+    // Pre-generate FULL random numbers for slow version (full grid)
+    Size fullGridSteps = grid.size() - 1;
+    rsg_type rsg_full = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+    std::vector<std::vector<double>> allRandomsFull(nrTrails);
+    for (Size n = 0; n < nrTrails; ++n) {
+        const auto& sequence = (n % 2) != 0U ? rsg_full.lastSequence() : rsg_full.nextSequence();
+        allRandomsFull[n].resize(fullGridRandoms);
+        for (Size m = 0; m < fullGridRandoms; ++m) {
+            double rnd = (n % 2) != 0U ? -value(sequence.value[m]) : value(sequence.value[m]);
+            allRandomsFull[n][m] = rnd;
+        }
+    }
+
+    // Helper: Compute MC price - SLOW version (full grid, like QuantLib)
+    auto computeMCPriceSlow = [&](const std::vector<double>& depoRates,
+                                  const std::vector<double>& swapRates) {
+        std::vector<Date> curveDates;
+        std::vector<Rate> zeroRates;
+        buildCurveAndProcess(depoRates, swapRates, curveDates, zeroRates);
+
+        RelinkableHandle<YieldTermStructure> termStructure;
+        ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+        index->addFixing(Date(2, September, 2005), 0.04);
+        termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates, dayCounter));
+
+        ext::shared_ptr<LiborForwardModelProcess> process(
+            new LiborForwardModelProcess(size, index));
+        ext::shared_ptr<LmCorrelationModel> corrModel(
+            new LmExponentialCorrelationModel(size, 0.5));
+        ext::shared_ptr<LmVolatilityModel> volaModel(
+            new LmLinearExponentialVolatilityModel(process->fixingTimes(),
+                                                   0.291, 1.483, 0.116, 0.00001));
+        process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+            new LfmCovarianceProxy(volaModel, corrModel)));
+
+        ext::shared_ptr<VanillaSwap> fwdSwap(
+            new VanillaSwap(Swap::Receiver, 1.0,
+                            schedule, 0.05, dayCounter,
+                            schedule, index, 0.0, index->dayCounter()));
+        fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+            index->forwardingTermStructure()));
+        double swapRate = value(fwdSwap->fairRate());
+
+        Array initRates = process->initialValues();
+
+        double price = 0.0;
+        for (Size n = 0; n < nrTrails; ++n) {
+            std::vector<double> asset(size);
+            std::vector<double> assetAtExercise(size);  // Store rates at exercise
+            for (Size k = 0; k < size; ++k) asset[k] = value(initRates[k]);
+
+            // SLOW: Evolve through FULL grid (like MultiPathGenerator)
+            for (Size step = 1; step <= fullGridSteps; ++step) {
+                Size offset = (step - 1) * numFactors;
+                Time t = grid[step - 1];
+                Time dt = grid.dt(step - 1);
+
+                Array dw(numFactors);
+                for (Size f = 0; f < numFactors; ++f) {
+                    dw[f] = allRandomsFull[n][offset + f];
+                }
+
+                Array asset_arr(size);
+                for (Size k = 0; k < size; ++k) asset_arr[k] = asset[k];
+
+                Array evolved = process->evolve(t, asset_arr, dt, dw);
+                for (Size k = 0; k < size; ++k) asset[k] = value(evolved[k]);
+
+                // Store rates at exercise step for payoff calculation
+                if (step == exerciseStep) {
+                    for (Size k = 0; k < size; ++k) assetAtExercise[k] = asset[k];
+                }
+            }
+
+            // Use rates at EXERCISE time for payoff (not final rates)
+            std::vector<double> dis(size);
+            double df = 1.0;
+            for (Size k = 0; k < size; ++k) {
+                double accrual = accrualEnd[k] - accrualStart[k];
+                df = df / (1.0 + assetAtExercise[k] * accrual);
+                dis[k] = df;
+            }
+
+            double npv = 0.0;
+            for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                double accrual = accrualEnd[m] - accrualStart[m];
+                npv += (swapRate - assetAtExercise[m]) * accrual * dis[m];
+            }
+
+            if (npv > 0.0) price += npv;
+        }
+
+        return price / static_cast<double>(nrTrails);
+    };
+
+    // =========================================================================
+    // Timing storage
+    // =========================================================================
+    using Clock = std::chrono::high_resolution_clock;
+    using Duration = std::chrono::duration<double, std::milli>;
+
+    // Original (QuantLib) timings - MultiPathGenerator (price only)
+    std::vector<double> orig_ql_total_times;
+
+    // Original (Re-Route) timings - full grid (price only)
+    std::vector<double> orig_rr_slow_total_times;
+
+    // Bump & Reprice (QuantLib) timings - MultiPathGenerator
+    std::vector<double> bump_ql_total_times;
+
+    // Bump & Reprice (Re-Route) timings - full grid
+    std::vector<double> bump_rr_slow_total_times;
+
+    // XAD (QuantLib) timings - MultiPathGenerator with XAD
+    std::vector<double> xad_ql_tape_setup_times;
+    std::vector<double> xad_ql_bootstrap_times;
+    std::vector<double> xad_ql_mc_times;
+    std::vector<double> xad_ql_gradient_times;
+    std::vector<double> xad_ql_total_times;
+
+    // XAD (Re-Route) timings - full grid
+    std::vector<double> xad_rr_slow_tape_setup_times;
+    std::vector<double> xad_rr_slow_bootstrap_times;
+    std::vector<double> xad_rr_slow_mc_times;
+    std::vector<double> xad_rr_slow_gradient_times;
+    std::vector<double> xad_rr_slow_total_times;
+
+    // JIT (Re-Route) timings - full grid
+    std::vector<double> jit_slow_tape_setup_times;
+    std::vector<double> jit_slow_bootstrap_fwd_times;
+    std::vector<double> jit_slow_bootstrap_bwd_times;
+    std::vector<double> jit_slow_kernel_record_times;  // JIT graph recording
+    std::vector<double> jit_slow_kernel_compile_times; // First forward (triggers compile)
+    std::vector<double> jit_slow_set_inputs_times;
+    std::vector<double> jit_slow_kernel_exec_times;    // Subsequent forwards (exec only)
+    std::vector<double> jit_slow_get_outputs_times;
+    std::vector<double> jit_slow_gradient_times;
+    std::vector<double> jit_slow_chain_rule_times;
+    std::vector<double> jit_slow_total_times;
+
+    // JIT Opt (Re-Route with graph optimizations) timings
+    std::vector<double> jit_fast_tape_setup_times;
+    std::vector<double> jit_fast_bootstrap_fwd_times;
+    std::vector<double> jit_fast_bootstrap_bwd_times;
+    std::vector<double> jit_fast_kernel_record_times;
+    std::vector<double> jit_fast_kernel_compile_times;
+    std::vector<double> jit_fast_set_inputs_times;
+    std::vector<double> jit_fast_kernel_exec_times;
+    std::vector<double> jit_fast_get_outputs_times;
+    std::vector<double> jit_fast_gradient_times;
+    std::vector<double> jit_fast_chain_rule_times;
+    std::vector<double> jit_fast_total_times;
+
+    // JIT Interpreter (Re-Route) timings - for comparison
+    std::vector<double> jit_interp_tape_setup_times;
+    std::vector<double> jit_interp_bootstrap_fwd_times;
+    std::vector<double> jit_interp_bootstrap_bwd_times;
+    std::vector<double> jit_interp_kernel_record_times;
+    std::vector<double> jit_interp_kernel_compile_times;
+    std::vector<double> jit_interp_set_inputs_times;
+    std::vector<double> jit_interp_kernel_exec_times;
+    std::vector<double> jit_interp_get_outputs_times;
+    std::vector<double> jit_interp_gradient_times;
+    std::vector<double> jit_interp_chain_rule_times;
+    std::vector<double> jit_interp_total_times;
+
+    // JIT AVX (Re-Route) timings - full grid with AVX2 4-path batching
+    std::vector<double> jit_avx_tape_setup_times;
+    std::vector<double> jit_avx_bootstrap_fwd_times;
+    std::vector<double> jit_avx_bootstrap_bwd_times;
+    std::vector<double> jit_avx_kernel_record_times;
+    std::vector<double> jit_avx_kernel_compile_times;
+    std::vector<double> jit_avx_set_inputs_times;
+    std::vector<double> jit_avx_kernel_exec_times;
+    std::vector<double> jit_avx_get_outputs_times;
+    std::vector<double> jit_avx_gradient_times;
+    std::vector<double> jit_avx_chain_rule_times;
+    std::vector<double> jit_avx_total_times;
+
+    // Results storage (from last iteration for verification)
+    double mcPrice_orig_ql = 0.0;
+    double mcPrice_orig_rr_slow = 0.0;
+    double mcPrice_bump_ql = 0.0;
+    std::vector<double> dPrice_bump_ql_depo(numDeposits);
+    std::vector<double> dPrice_bump_ql_swap(numSwaps);
+    double mcPrice_bump_rr_slow = 0.0;
+    std::vector<double> dPrice_bump_rr_slow_depo(numDeposits);
+    std::vector<double> dPrice_bump_rr_slow_swap(numSwaps);
+
+    double mcPrice_xad_ql = 0.0;
+    std::vector<double> dPrice_xad_ql_depo(numDeposits);
+    std::vector<double> dPrice_xad_ql_swap(numSwaps);
+
+    double mcPrice_xad_rr_slow = 0.0;
+    std::vector<double> dPrice_xad_rr_slow_depo(numDeposits);
+    std::vector<double> dPrice_xad_rr_slow_swap(numSwaps);
+
+    double mcPrice_jit_slow = 0.0;
+    std::vector<double> dPrice_jit_slow_depo(numDeposits);
+    std::vector<double> dPrice_jit_slow_swap(numSwaps);
+
+    double mcPrice_jit_fast = 0.0;
+    std::vector<double> dPrice_jit_fast_depo(numDeposits);
+    std::vector<double> dPrice_jit_fast_swap(numSwaps);
+
+    double mcPrice_jit_interp = 0.0;
+    std::vector<double> dPrice_jit_interp_depo(numDeposits);
+    std::vector<double> dPrice_jit_interp_swap(numSwaps);
+
+    double mcPrice_jit_avx = 0.0;
+    std::vector<double> dPrice_jit_avx_depo(numDeposits);
+    std::vector<double> dPrice_jit_avx_swap(numSwaps);
+
+    Size numIntermediates = size + 1;
+
+    // =========================================================================
+    // BENCHMARK LOOP
+    // =========================================================================
+    for (Size iter = 0; iter < warmupIterations + benchmarkIterations; ++iter) {
+        bool recordTiming = (iter >= warmupIterations);
+        bool isWarmup = (iter < warmupIterations);
+        std::string phase = isWarmup ? "Warmup" : "Benchmark";
+        Size phaseIter = isWarmup ? (iter + 1) : (iter - warmupIterations + 1);
+        Size phaseTotal = isWarmup ? warmupIterations : benchmarkIterations;
+
+        std::cout << "\n  [" << phase << " " << phaseIter << "/" << phaseTotal << "]" << std::flush;
+
+        // =====================================================================
+        // 0. ORIGINAL (QuantLib) - MultiPathGenerator (price only, no derivatives)
+        // =====================================================================
+        std::cout << " Original..." << std::flush;
+        {
+            auto t_total_start = Clock::now();
+
+            // Build curve and process
+            std::vector<Date> curveDates;
+            std::vector<Rate> zeroRates;
+            buildCurveAndProcess(depoRates_val, swapRates_val, curveDates, zeroRates);
+
+            RelinkableHandle<YieldTermStructure> termStructure;
+            ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+            index->addFixing(Date(2, September, 2005), 0.04);
+            termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process(
+                new LiborForwardModelProcess(size, index));
+            process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(
+                    ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                    ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index, 0.0, index->dayCounter()));
+            fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index->forwardingTermStructure()));
+            double swapRate = value(fwdSwap->fairRate());
+
+            // MC with MultiPathGenerator
+            rsg_type rsg_ql = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+            typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+            MultiPathGenerator<rsg_type> generator_ql(process, grid, rsg_ql, false);
+
+            double price = 0.0;
+            for (Size n = 0; n < nrTrails; ++n) {
+                sample_type path = (n % 2) != 0U ? generator_ql.antithetic() : generator_ql.next();
+
+                std::vector<double> mcRates(size);
+                for (Size k = 0; k < size; ++k) {
+                    mcRates[k] = value(path.value[k][location[i_opt]]);
+                }
+
+                std::vector<double> dis(size);
+                double df = 1.0;
+                for (Size k = 0; k < size; ++k) {
+                    double accrual = accrualEnd[k] - accrualStart[k];
+                    df = df / (1.0 + mcRates[k] * accrual);
+                    dis[k] = df;
+                }
+
+                double npv = 0.0;
+                for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                    double accrual = accrualEnd[m] - accrualStart[m];
+                    npv += (swapRate - mcRates[m]) * accrual * dis[m];
+                }
+                if (npv > 0.0) price += npv;
+            }
+            mcPrice_orig_ql = price / static_cast<double>(nrTrails);
+
+            auto t_total_end = Clock::now();
+            if (recordTiming) {
+                orig_ql_total_times.push_back(Duration(t_total_end - t_total_start).count());
+            }
+        }
+
+        // =====================================================================
+        // 0b. ORIGINAL (Re-Route) - Full grid (price only, no derivatives)
+        // =====================================================================
+        {
+            auto t_total_start = Clock::now();
+            mcPrice_orig_rr_slow = computeMCPriceSlow(depoRates_val, swapRates_val);
+            auto t_total_end = Clock::now();
+            if (recordTiming) {
+                orig_rr_slow_total_times.push_back(Duration(t_total_end - t_total_start).count());
+            }
+        }
+
+        // =====================================================================
+        // 1a. BUMP & REPRICE (QuantLib) - MultiPathGenerator
+        // =====================================================================
+        std::cout << " Bump..." << std::flush;
+        {
+            auto t_total_start = Clock::now();
+
+            // Helper lambda for QuantLib MC pricing
+            auto computeMCPriceQL = [&](const std::vector<double>& depoRates,
+                                        const std::vector<double>& swapRates) {
+                std::vector<Date> curveDates;
+                std::vector<Rate> zeroRates;
+                buildCurveAndProcess(depoRates, swapRates, curveDates, zeroRates);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                double swapRate = value(fwdSwap->fairRate());
+
+                rsg_type rsg_tmp = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+                typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+                MultiPathGenerator<rsg_type> gen_tmp(process, grid, rsg_tmp, false);
+
+                double price = 0.0;
+                for (Size n = 0; n < nrTrails; ++n) {
+                    sample_type path = (n % 2) != 0U ? gen_tmp.antithetic() : gen_tmp.next();
+
+                    std::vector<double> mcRates(size);
+                    for (Size k = 0; k < size; ++k) {
+                        mcRates[k] = value(path.value[k][location[i_opt]]);
+                    }
+
+                    std::vector<double> dis(size);
+                    double df = 1.0;
+                    for (Size k = 0; k < size; ++k) {
+                        double accrual = accrualEnd[k] - accrualStart[k];
+                        df = df / (1.0 + mcRates[k] * accrual);
+                        dis[k] = df;
+                    }
+
+                    double npv = 0.0;
+                    for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                        double accrual = accrualEnd[m] - accrualStart[m];
+                        npv += (swapRate - mcRates[m]) * accrual * dis[m];
+                    }
+                    if (npv > 0.0) price += npv;
+                }
+                return price / static_cast<double>(nrTrails);
+            };
+
+            // Base price
+            mcPrice_bump_ql = computeMCPriceQL(depoRates_val, swapRates_val);
+
+            double bump = 1e-6;
+
+            // Bump deposits
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                std::vector<double> bumpedDepoRates = depoRates_val;
+                bumpedDepoRates[idx] += bump;
+                double price_bumped = computeMCPriceQL(bumpedDepoRates, swapRates_val);
+                dPrice_bump_ql_depo[idx] = (price_bumped - mcPrice_bump_ql) / bump;
+            }
+
+            // Bump swaps
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                std::vector<double> bumpedSwapRates = swapRates_val;
+                bumpedSwapRates[idx] += bump;
+                double price_bumped = computeMCPriceQL(depoRates_val, bumpedSwapRates);
+                dPrice_bump_ql_swap[idx] = (price_bumped - mcPrice_bump_ql) / bump;
+            }
+
+            auto t_total_end = Clock::now();
+            if (recordTiming) {
+                bump_ql_total_times.push_back(Duration(t_total_end - t_total_start).count());
+            }
+        }
+
+        // =====================================================================
+        // 1b. BUMP & REPRICE (Re-Route) - Full grid
+        // =====================================================================
+        {
+            auto t_total_start = Clock::now();
+
+            mcPrice_bump_rr_slow = computeMCPriceSlow(depoRates_val, swapRates_val);
+            double bump = 1e-6;
+
+            // Bump deposits
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                std::vector<double> bumpedDepoRates = depoRates_val;
+                bumpedDepoRates[idx] += bump;
+                double price_bumped = computeMCPriceSlow(bumpedDepoRates, swapRates_val);
+                dPrice_bump_rr_slow_depo[idx] = (price_bumped - mcPrice_bump_rr_slow) / bump;
+            }
+
+            // Bump swaps
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                std::vector<double> bumpedSwapRates = swapRates_val;
+                bumpedSwapRates[idx] += bump;
+                double price_bumped = computeMCPriceSlow(depoRates_val, bumpedSwapRates);
+                dPrice_bump_rr_slow_swap[idx] = (price_bumped - mcPrice_bump_rr_slow) / bump;
+            }
+
+            auto t_total_end = Clock::now();
+            if (recordTiming) {
+                bump_rr_slow_total_times.push_back(Duration(t_total_end - t_total_start).count());
+            }
+        }
+
+        // =====================================================================
+        // 2. XAD (QuantLib) - MultiPathGenerator with XAD tape
+        // =====================================================================
+        {
+            auto t_total_start = Clock::now();
+
+            // Tape setup
+            auto t_tape_setup_start = Clock::now();
+
+            using tape_type = Real::tape_type;
+            tape_type tape_ql;
+
+            std::vector<Real> depositRates_ql(numDeposits);
+            std::vector<Real> swapRates_ql(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates_ql[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates_ql[idx] = swapRates_val[idx];
+
+            tape_ql.registerInputs(depositRates_ql);
+            tape_ql.registerInputs(swapRates_ql);
+            tape_ql.newRecording();
+
+            auto t_tape_setup_end = Clock::now();
+
+            // Bootstrap pass
+            auto t_bootstrap_start = Clock::now();
+
+            RelinkableHandle<YieldTermStructure> euriborTS_ql;
+            auto euribor6m_ql = ext::make_shared<Euribor6M>(euriborTS_ql);
+            euribor6m_ql->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments_ql;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote = ext::make_shared<SimpleQuote>(depositRates_ql[idx]);
+                instruments_ql.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates_ql[idx]);
+                instruments_ql.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis), euribor6m_ql));
+            }
+
+            auto yieldCurve_ql = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments_ql, dayCounter);
+            yieldCurve_ql->enableExtrapolation();
+
+            std::vector<Date> curveDates_ql;
+            std::vector<Real> zeroRates_ql;
+            curveDates_ql.push_back(settlementDate);
+            zeroRates_ql.push_back(yieldCurve_ql->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate_ql = settlementDate + 6 * Years;
+            curveDates_ql.push_back(endDate_ql);
+            zeroRates_ql.push_back(yieldCurve_ql->zeroRate(endDate_ql, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates_ql_d;
+            for (const auto& r : zeroRates_ql) zeroRates_ql_d.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure_ql;
+            ext::shared_ptr<IborIndex> index_ql(new Euribor6M(termStructure_ql));
+            index_ql->addFixing(Date(2, September, 2005), 0.04);
+            termStructure_ql.linkTo(ext::make_shared<ZeroCurve>(curveDates_ql, zeroRates_ql_d, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process_ql(
+                new LiborForwardModelProcess(size, index_ql));
+            process_ql->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(
+                    ext::make_shared<LmLinearExponentialVolatilityModel>(process_ql->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                    ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap_ql(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index_ql, 0.0, index_ql->dayCounter()));
+            fwdSwap_ql->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index_ql->forwardingTermStructure()));
+            Real swapRate_ql = fwdSwap_ql->fairRate();
+
+            auto t_bootstrap_end = Clock::now();
+
+            // MC with MultiPathGenerator using XAD types
+            auto t_mc_start = Clock::now();
+
+            rsg_type rsg_xad_ql = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+            typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+            MultiPathGenerator<rsg_type> generator_xad_ql(process_ql, grid, rsg_xad_ql, false);
+
+            Real mcPrice_xad_ql_local = 0.0;
+            for (Size n = 0; n < nrTrails; ++n) {
+                sample_type path = (n % 2) != 0U ? generator_xad_ql.antithetic() : generator_xad_ql.next();
+
+                std::vector<Real> mcRates(size);
+                for (Size k = 0; k < size; ++k) {
+                    mcRates[k] = path.value[k][location[i_opt]];
+                }
+
+                std::vector<Real> dis(size);
+                Real df = 1.0;
+                for (Size k = 0; k < size; ++k) {
+                    Real accrual = process_ql->accrualEndTimes()[k] - process_ql->accrualStartTimes()[k];
+                    df = df / (Real(1.0) + mcRates[k] * accrual);
+                    dis[k] = df;
+                }
+
+                Real npv = 0.0;
+                for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                    Real accrual = process_ql->accrualEndTimes()[m] - process_ql->accrualStartTimes()[m];
+                    npv = npv + (swapRate_ql - mcRates[m]) * accrual * dis[m];
+                }
+                if (value(npv) > 0.0) mcPrice_xad_ql_local += npv;
+            }
+            mcPrice_xad_ql_local /= static_cast<Real>(nrTrails);
+
+            auto t_mc_end = Clock::now();
+
+            // Gradient pass
+            auto t_grad_start = Clock::now();
+            tape_ql.registerOutput(mcPrice_xad_ql_local);
+            derivative(mcPrice_xad_ql_local) = 1.0;
+            tape_ql.computeAdjoints();
+
+            for (Size idx = 0; idx < numDeposits; ++idx) dPrice_xad_ql_depo[idx] = derivative(depositRates_ql[idx]);
+            for (Size idx = 0; idx < numSwaps; ++idx) dPrice_xad_ql_swap[idx] = derivative(swapRates_ql[idx]);
+            auto t_grad_end = Clock::now();
+
+            mcPrice_xad_ql = value(mcPrice_xad_ql_local);
+            tape_ql.deactivate();
+
+            auto t_total_end = Clock::now();
+
+            if (recordTiming) {
+                xad_ql_tape_setup_times.push_back(Duration(t_tape_setup_end - t_tape_setup_start).count());
+                xad_ql_bootstrap_times.push_back(Duration(t_bootstrap_end - t_bootstrap_start).count());
+                xad_ql_mc_times.push_back(Duration(t_mc_end - t_mc_start).count());
+                xad_ql_gradient_times.push_back(Duration(t_grad_end - t_grad_start).count());
+                xad_ql_total_times.push_back(Duration(t_total_end - t_total_start).count());
+            }
+        }
+
+        // =====================================================================
+        // 3a. XAD (Re-Route) - Full grid with XAD tape
+        // =====================================================================
+        std::cout << " XAD..." << std::flush;
+        {
+            auto t_total_start = Clock::now();
+
+            // Tape setup
+            auto t_tape_setup_start = Clock::now();
+
+            using tape_type = Real::tape_type;
+            tape_type tape;
+
+            std::vector<Real> depositRates(numDeposits);
+            std::vector<Real> swapRates(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+            tape.registerInputs(depositRates);
+            tape.registerInputs(swapRates);
+            tape.newRecording();
+
+            auto t_tape_setup_end = Clock::now();
+
+            // Bootstrap pass
+            auto t_bootstrap_start = Clock::now();
+
+            RelinkableHandle<YieldTermStructure> euriborTS;
+            auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+            euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                instruments.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                instruments.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m));
+            }
+
+            auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments, dayCounter);
+            yieldCurve->enableExtrapolation();
+
+            std::vector<Date> curveDates;
+            std::vector<Real> zeroRates;
+            curveDates.push_back(settlementDate);
+            zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate = settlementDate + 6 * Years;
+            curveDates.push_back(endDate);
+            zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates_ql;
+            for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure;
+            ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+            index->addFixing(Date(2, September, 2005), 0.04);
+            termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process(
+                new LiborForwardModelProcess(size, index));
+            ext::shared_ptr<LmCorrelationModel> corrModel(
+                new LmExponentialCorrelationModel(size, 0.5));
+            ext::shared_ptr<LmVolatilityModel> volaModel(
+                new LmLinearExponentialVolatilityModel(process->fixingTimes(),
+                                                       0.291, 1.483, 0.116, 0.00001));
+            process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(volaModel, corrModel)));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap_tape(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index, 0.0, index->dayCounter()));
+            fwdSwap_tape->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index->forwardingTermStructure()));
+            Real swapRate_tape = fwdSwap_tape->fairRate();
+
+            Array initRates_tape = process->initialValues();
+
+            auto t_bootstrap_end = Clock::now();
+
+            // MC pass - SLOW: full grid
+            auto t_mc_start = Clock::now();
+
+            Real mcPrice_tape = 0.0;
+            for (Size n = 0; n < nrTrails; ++n) {
+                std::vector<Real> asset(size);
+                std::vector<Real> assetAtExercise(size);
+                for (Size k = 0; k < size; ++k) asset[k] = initRates_tape[k];
+
+                // SLOW: Evolve through FULL grid
+                for (Size step = 1; step <= fullGridSteps; ++step) {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f) {
+                        dw[f] = allRandomsFull[n][offset + f];
+                    }
+
+                    Array asset_arr(size);
+                    for (Size k = 0; k < size; ++k) asset_arr[k] = asset[k];
+
+                    Array evolved = process->evolve(t, asset_arr, dt, dw);
+                    for (Size k = 0; k < size; ++k) asset[k] = evolved[k];
+
+                    // Store rates at exercise step
+                    if (step == exerciseStep) {
+                        for (Size k = 0; k < size; ++k) assetAtExercise[k] = asset[k];
+                    }
+                }
+
+                // Use rates at EXERCISE time for payoff
+                std::vector<Real> dis(size);
+                Real df = 1.0;
+                for (Size k = 0; k < size; ++k) {
+                    double accrual = accrualEnd[k] - accrualStart[k];
+                    df = df / (Real(1.0) + assetAtExercise[k] * accrual);
+                    dis[k] = df;
+                }
+
+                Real npv = 0.0;
+                for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                    double accrual = accrualEnd[m] - accrualStart[m];
+                    npv = npv + (swapRate_tape - assetAtExercise[m]) * accrual * dis[m];
+                }
+
+                if (value(npv) > 0.0) mcPrice_tape += npv;
+            }
+            mcPrice_tape /= static_cast<Real>(nrTrails);
+
+            auto t_mc_end = Clock::now();
+
+            // Gradient pass
+            auto t_grad_start = Clock::now();
+            tape.registerOutput(mcPrice_tape);
+            derivative(mcPrice_tape) = 1.0;
+            tape.computeAdjoints();
+
+            for (Size idx = 0; idx < numDeposits; ++idx) dPrice_xad_rr_slow_depo[idx] = derivative(depositRates[idx]);
+            for (Size idx = 0; idx < numSwaps; ++idx) dPrice_xad_rr_slow_swap[idx] = derivative(swapRates[idx]);
+            auto t_grad_end = Clock::now();
+
+            mcPrice_xad_rr_slow = value(mcPrice_tape);
+            tape.deactivate();
+
+            auto t_total_end = Clock::now();
+
+            if (recordTiming) {
+                xad_rr_slow_tape_setup_times.push_back(Duration(t_tape_setup_end - t_tape_setup_start).count());
+                xad_rr_slow_bootstrap_times.push_back(Duration(t_bootstrap_end - t_bootstrap_start).count());
+                xad_rr_slow_mc_times.push_back(Duration(t_mc_end - t_mc_start).count());
+                xad_rr_slow_gradient_times.push_back(Duration(t_grad_end - t_grad_start).count());
+                xad_rr_slow_total_times.push_back(Duration(t_total_end - t_total_start).count());
+            }
+        }
+
+        // =====================================================================
+        // 4a. JIT (Re-Route) - Full grid with JIT
+        // =====================================================================
+        std::cout << " JIT..." << std::flush;
+        {
+            auto t_total_start = Clock::now();
+
+            // --- Tape setup ---
+            auto t_tape_setup_start = Clock::now();
+
+            using tape_type = Real::tape_type;
+            tape_type tape2;
+
+            std::vector<Real> depositRates2(numDeposits);
+            std::vector<Real> swapRates2(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates2[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates2[idx] = swapRates_val[idx];
+
+            tape2.registerInputs(depositRates2);
+            tape2.registerInputs(swapRates2);
+            tape2.newRecording();
+
+            auto t_tape_setup_end = Clock::now();
+
+            // --- Bootstrap forward pass ---
+            auto t_boot_fwd_start = Clock::now();
+
+            RelinkableHandle<YieldTermStructure> euriborTS2;
+            auto euribor6m2 = ext::make_shared<Euribor6M>(euriborTS2);
+            euribor6m2->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments2;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote2 = ext::make_shared<SimpleQuote>(depositRates2[idx]);
+                instruments2.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote2), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates2[idx]);
+                instruments2.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m2));
+            }
+
+            auto yieldCurve2 = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments2, dayCounter);
+            yieldCurve2->enableExtrapolation();
+
+            std::vector<Date> curveDates2;
+            std::vector<Real> zeroRates2;
+            curveDates2.push_back(settlementDate);
+            zeroRates2.push_back(yieldCurve2->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate2 = settlementDate + 6 * Years;
+            curveDates2.push_back(endDate2);
+            zeroRates2.push_back(yieldCurve2->zeroRate(endDate2, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates2_ql;
+            for (const auto& r : zeroRates2) zeroRates2_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure2;
+            ext::shared_ptr<IborIndex> index2(new Euribor6M(termStructure2));
+            index2->addFixing(Date(2, September, 2005), 0.04);
+            termStructure2.linkTo(ext::make_shared<ZeroCurve>(curveDates2, zeroRates2_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process2(
+                new LiborForwardModelProcess(size, index2));
+            ext::shared_ptr<LmCorrelationModel> corrModel2(
+                new LmExponentialCorrelationModel(size, 0.5));
+            ext::shared_ptr<LmVolatilityModel> volaModel2(
+                new LmLinearExponentialVolatilityModel(process2->fixingTimes(),
+                                                       0.291, 1.483, 0.116, 0.00001));
+            process2->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(volaModel2, corrModel2)));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap2(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index2, 0.0, index2->dayCounter()));
+            fwdSwap2->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index2->forwardingTermStructure()));
+            Real swapRate2_tape = fwdSwap2->fairRate();
+
+            Array initRates2 = process2->initialValues();
+
+            auto t_boot_fwd_end = Clock::now();
+
+            // --- Bootstrap backward pass (Jacobian) ---
+            auto t_boot_bwd_start = Clock::now();
+
+            std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+
+            for (Size k = 0; k < size; ++k) {
+                if (initRates2[k].shouldRecord()) {
+                    tape2.clearDerivatives();
+                    tape2.registerOutput(initRates2[k]);
+                    derivative(initRates2[k]) = 1.0;
+                    tape2.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + k * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates2[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates2[m]);
+                }
+            }
+
+            if (swapRate2_tape.shouldRecord()) {
+                tape2.clearDerivatives();
+                tape2.registerOutput(swapRate2_tape);
+                derivative(swapRate2_tape) = 1.0;
+                tape2.computeAdjoints();
+
+                double* jac_row = jacobian.data() + size * numMarketQuotes;
+                for (Size m = 0; m < numDeposits; ++m)
+                    jac_row[m] = derivative(depositRates2[m]);
+                for (Size m = 0; m < numSwaps; ++m)
+                    jac_row[numDeposits + m] = derivative(swapRates2[m]);
+            }
+
+            tape2.deactivate();
+
+            auto t_boot_bwd_end = Clock::now();
+
+            // --- JIT kernel recording (build JIT graph) ---
+            auto t_kernel_record_start = Clock::now();
+
+            // Use ForgeBackend without graph optimizations
+            auto forgeBackendSlow = std::make_unique<xad::forge::ForgeBackend<double>>(false);
+            xad::JITCompiler<double> jit(std::move(forgeBackendSlow));
+
+            std::vector<xad::AD> jit_initRates(size);
+            xad::AD jit_swapRate;
+            std::vector<xad::AD> jit_randoms(fullGridRandoms);  // Full grid randoms
+
+            for (Size k = 0; k < size; ++k) {
+                jit_initRates[k] = xad::AD(value(initRates2[k]));
+                jit.registerInput(jit_initRates[k]);
+            }
+
+            jit_swapRate = xad::AD(value(swapRate2_tape));
+            jit.registerInput(jit_swapRate);
+
+            for (Size m = 0; m < fullGridRandoms; ++m) {
+                jit_randoms[m] = xad::AD(0.0);
+                jit.registerInput(jit_randoms[m]);
+            }
+
+            jit.newRecording();
+
+            // Record path evolution - SLOW: full grid
+            std::vector<xad::AD> asset_jit(size);
+            std::vector<xad::AD> assetAtExercise_jit(size);
+            for (Size k = 0; k < size; ++k) {
+                asset_jit[k] = jit_initRates[k];
+            }
+
+            for (Size step = 1; step <= fullGridSteps; ++step) {
+                Size offset = (step - 1) * numFactors;
+                Time t = grid[step - 1];
+                Time dt = grid.dt(step - 1);
+
+                Array dw(numFactors);
+                for (Size f = 0; f < numFactors; ++f) {
+                    dw[f] = jit_randoms[offset + f];
+                }
+
+                Array asset_arr(size);
+                for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                Array evolved = process2->evolve(t, asset_arr, dt, dw);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                // Store rates at exercise step
+                if (step == exerciseStep) {
+                    for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                }
+            }
+
+            // Use rates at EXERCISE time for payoff
+            std::vector<xad::AD> dis_jit(size);
+            xad::AD df_jit = xad::AD(1.0);
+            for (Size k = 0; k < size; ++k) {
+                double accrual = accrualEnd[k] - accrualStart[k];
+                df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                dis_jit[k] = df_jit;
+            }
+
+            xad::AD jit_npv = xad::AD(0.0);
+            for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                double accrual = accrualEnd[m] - accrualStart[m];
+                jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+            }
+
+            xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+            jit.registerOutput(jit_payoff);
+
+            auto t_kernel_record_end = Clock::now();
+
+            // --- JIT kernel compile ---
+            auto t_kernel_compile_start = Clock::now();
+
+            jit.compile();
+
+            auto t_kernel_compile_end = Clock::now();
+
+            // --- JIT kernel execution (MC loop) with granular timing ---
+            const auto& graph = jit.getGraph();
+            uint32_t outputSlot = graph.output_ids[0];
+
+            double mcPrice_jit_local = 0.0;
+            std::vector<double> dPrice_dInitRates(size, 0.0);
+            double dPrice_dSwapRate_jit = 0.0;
+
+            double set_inputs_time = 0.0;
+            double kernel_exec_time = 0.0;
+            double get_outputs_time = 0.0;
+            double get_gradients_time = 0.0;
+
+            for (Size n = 0; n < nrTrails; ++n) {
+                // Set inputs timing
+                auto t_set_start = Clock::now();
+                for (Size k = 0; k < size; ++k) {
+                    value(jit_initRates[k]) = value(initRates2[k]);
+                }
+                value(jit_swapRate) = value(swapRate2_tape);
+                for (Size m = 0; m < fullGridRandoms; ++m) {
+                    value(jit_randoms[m]) = allRandomsFull[n][m];
+                }
+                auto t_set_end = Clock::now();
+                set_inputs_time += Duration(t_set_end - t_set_start).count();
+
+                // Kernel exec timing
+                auto t_exec_start = Clock::now();
+                double payoff_value;
+                jit.forward(&payoff_value);
+                auto t_exec_end = Clock::now();
+                kernel_exec_time += Duration(t_exec_end - t_exec_start).count();
+
+                // Get outputs timing (trivial - just accumulate)
+                auto t_get_out_start = Clock::now();
+                mcPrice_jit_local += payoff_value;
+                auto t_get_out_end = Clock::now();
+                get_outputs_time += Duration(t_get_out_end - t_get_out_start).count();
+
+                // Get gradients timing
+                auto t_grad_mc_start = Clock::now();
+                jit.clearDerivatives();
+                jit.setDerivative(outputSlot, 1.0);
+                jit.computeAdjoints();
+                for (Size k = 0; k < size; ++k) {
+                    dPrice_dInitRates[k] += jit.derivative(graph.input_ids[k]);
+                }
+                dPrice_dSwapRate_jit += jit.derivative(graph.input_ids[size]);
+                auto t_grad_mc_end = Clock::now();
+                get_gradients_time += Duration(t_grad_mc_end - t_grad_mc_start).count();
+            }
+
+            // --- Gradient (chain rule) ---
+            auto t_grad_start = Clock::now();
+
+            mcPrice_jit_local /= static_cast<double>(nrTrails);
+            for (Size k = 0; k < size; ++k) {
+                dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+            }
+            dPrice_dSwapRate_jit /= static_cast<double>(nrTrails);
+
+            std::vector<double> dPrice_dIntermediates(numIntermediates);
+            for (Size k = 0; k < size; ++k)
+                dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+            dPrice_dIntermediates[size] = dPrice_dSwapRate_jit;
+
+            std::vector<double> dPrice_jit_market(numMarketQuotes);
+            applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_jit_market.data(),
+                           numIntermediates, numMarketQuotes);
+
+            for (Size idx = 0; idx < numDeposits; ++idx) dPrice_jit_slow_depo[idx] = dPrice_jit_market[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) dPrice_jit_slow_swap[idx] = dPrice_jit_market[numDeposits + idx];
+
+            mcPrice_jit_slow = mcPrice_jit_local;
+
+            auto t_grad_end = Clock::now();
+            auto t_total_end = Clock::now();
+
+            if (recordTiming) {
+                jit_slow_tape_setup_times.push_back(Duration(t_tape_setup_end - t_tape_setup_start).count());
+                jit_slow_bootstrap_fwd_times.push_back(Duration(t_boot_fwd_end - t_boot_fwd_start).count());
+                jit_slow_bootstrap_bwd_times.push_back(Duration(t_boot_bwd_end - t_boot_bwd_start).count());
+                jit_slow_kernel_record_times.push_back(Duration(t_kernel_record_end - t_kernel_record_start).count());
+                jit_slow_kernel_compile_times.push_back(Duration(t_kernel_compile_end - t_kernel_compile_start).count());
+                jit_slow_set_inputs_times.push_back(set_inputs_time);
+                jit_slow_kernel_exec_times.push_back(kernel_exec_time);
+                jit_slow_get_outputs_times.push_back(get_outputs_time);
+                jit_slow_gradient_times.push_back(get_gradients_time);
+                jit_slow_chain_rule_times.push_back(Duration(t_grad_end - t_grad_start).count());
+                jit_slow_total_times.push_back(Duration(t_total_end - t_total_start).count());
+            }
+        }
+
+        // =====================================================================
+        // 4b. JIT Opt (Re-Route) - Full grid with graph optimizations
+        // =====================================================================
+        std::cout << " JIT-Opt..." << std::flush;
+        {
+            auto t_total_start = Clock::now();
+
+            // --- Tape setup ---
+            auto t_tape_setup_start = Clock::now();
+
+            using tape_type = Real::tape_type;
+            tape_type tape2;
+
+            std::vector<Real> depositRates2(numDeposits);
+            std::vector<Real> swapRates2(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates2[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates2[idx] = swapRates_val[idx];
+
+            tape2.registerInputs(depositRates2);
+            tape2.registerInputs(swapRates2);
+            tape2.newRecording();
+
+            auto t_tape_setup_end = Clock::now();
+
+            // --- Bootstrap forward pass ---
+            auto t_boot_fwd_start = Clock::now();
+
+            RelinkableHandle<YieldTermStructure> euriborTS2;
+            auto euribor6m2 = ext::make_shared<Euribor6M>(euriborTS2);
+            euribor6m2->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments2;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote2 = ext::make_shared<SimpleQuote>(depositRates2[idx]);
+                instruments2.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote2), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates2[idx]);
+                instruments2.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m2));
+            }
+
+            auto yieldCurve2 = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments2, dayCounter);
+            yieldCurve2->enableExtrapolation();
+
+            std::vector<Date> curveDates2;
+            std::vector<Real> zeroRates2;
+            curveDates2.push_back(settlementDate);
+            zeroRates2.push_back(yieldCurve2->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate2 = settlementDate + 6 * Years;
+            curveDates2.push_back(endDate2);
+            zeroRates2.push_back(yieldCurve2->zeroRate(endDate2, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates2_ql;
+            for (const auto& r : zeroRates2) zeroRates2_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure2;
+            ext::shared_ptr<IborIndex> index2(new Euribor6M(termStructure2));
+            index2->addFixing(Date(2, September, 2005), 0.04);
+            termStructure2.linkTo(ext::make_shared<ZeroCurve>(curveDates2, zeroRates2_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process2(
+                new LiborForwardModelProcess(size, index2));
+            ext::shared_ptr<LmCorrelationModel> corrModel2(
+                new LmExponentialCorrelationModel(size, 0.5));
+            ext::shared_ptr<LmVolatilityModel> volaModel2(
+                new LmLinearExponentialVolatilityModel(process2->fixingTimes(),
+                                                       0.291, 1.483, 0.116, 0.00001));
+            process2->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(volaModel2, corrModel2)));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap2(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index2, 0.0, index2->dayCounter()));
+            fwdSwap2->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index2->forwardingTermStructure()));
+            Real swapRate2_tape = fwdSwap2->fairRate();
+
+            Array initRates2 = process2->initialValues();
+
+            auto t_boot_fwd_end = Clock::now();
+
+            // --- Bootstrap backward pass (Jacobian) ---
+            auto t_boot_bwd_start = Clock::now();
+
+            std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+
+            for (Size k = 0; k < size; ++k) {
+                if (initRates2[k].shouldRecord()) {
+                    tape2.clearDerivatives();
+                    tape2.registerOutput(initRates2[k]);
+                    derivative(initRates2[k]) = 1.0;
+                    tape2.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + k * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates2[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates2[m]);
+                }
+            }
+
+            if (swapRate2_tape.shouldRecord()) {
+                tape2.clearDerivatives();
+                tape2.registerOutput(swapRate2_tape);
+                derivative(swapRate2_tape) = 1.0;
+                tape2.computeAdjoints();
+
+                double* jac_row = jacobian.data() + size * numMarketQuotes;
+                for (Size m = 0; m < numDeposits; ++m)
+                    jac_row[m] = derivative(depositRates2[m]);
+                for (Size m = 0; m < numSwaps; ++m)
+                    jac_row[numDeposits + m] = derivative(swapRates2[m]);
+            }
+
+            tape2.deactivate();
+
+            auto t_boot_bwd_end = Clock::now();
+
+            // --- JIT kernel recording (build JIT graph with Forge Fast config) ---
+            auto t_kernel_record_start = Clock::now();
+
+            // Use ForgeBackend with graph optimizations enabled
+            auto forgeBackendFast = std::make_unique<xad::forge::ForgeBackend<double>>(true);
+            xad::JITCompiler<double> jit(std::move(forgeBackendFast));
+
+            std::vector<xad::AD> jit_initRates(size);
+            xad::AD jit_swapRate;
+            std::vector<xad::AD> jit_randoms(fullGridRandoms);  // Full grid randoms
+
+            for (Size k = 0; k < size; ++k) {
+                jit_initRates[k] = xad::AD(value(initRates2[k]));
+                jit.registerInput(jit_initRates[k]);
+            }
+
+            jit_swapRate = xad::AD(value(swapRate2_tape));
+            jit.registerInput(jit_swapRate);
+
+            for (Size m = 0; m < fullGridRandoms; ++m) {
+                jit_randoms[m] = xad::AD(0.0);
+                jit.registerInput(jit_randoms[m]);
+            }
+
+            jit.newRecording();
+
+            // Record path evolution - Full grid (same as JIT Slow)
+            std::vector<xad::AD> asset_jit(size);
+            std::vector<xad::AD> assetAtExercise_jit(size);
+            for (Size k = 0; k < size; ++k) {
+                asset_jit[k] = jit_initRates[k];
+            }
+
+            for (Size step = 1; step <= fullGridSteps; ++step) {
+                Size offset = (step - 1) * numFactors;
+                Time t = grid[step - 1];
+                Time dt = grid.dt(step - 1);
+
+                Array dw(numFactors);
+                for (Size f = 0; f < numFactors; ++f) {
+                    dw[f] = jit_randoms[offset + f];
+                }
+
+                Array asset_arr(size);
+                for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                Array evolved = process2->evolve(t, asset_arr, dt, dw);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                // Store rates at exercise step
+                if (step == exerciseStep) {
+                    for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                }
+            }
+
+            // Use rates at EXERCISE time for payoff
+            std::vector<xad::AD> dis_jit(size);
+            xad::AD df_jit = xad::AD(1.0);
+            for (Size k = 0; k < size; ++k) {
+                double accrual = accrualEnd[k] - accrualStart[k];
+                df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                dis_jit[k] = df_jit;
+            }
+
+            xad::AD jit_npv = xad::AD(0.0);
+            for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                double accrual = accrualEnd[m] - accrualStart[m];
+                jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+            }
+
+            xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+            jit.registerOutput(jit_payoff);
+
+            auto t_kernel_record_end = Clock::now();
+
+            // --- JIT kernel compile ---
+            auto t_kernel_compile_start = Clock::now();
+
+            jit.compile();
+
+            auto t_kernel_compile_end = Clock::now();
+
+            // --- JIT kernel execution (MC loop) with granular timing ---
+            const auto& graph = jit.getGraph();
+            uint32_t outputSlot = graph.output_ids[0];
+
+            double mcPrice_jit_local = 0.0;
+            std::vector<double> dPrice_dInitRates(size, 0.0);
+            double dPrice_dSwapRate_jit = 0.0;
+
+            double set_inputs_time = 0.0;
+            double kernel_exec_time = 0.0;
+            double get_outputs_time = 0.0;
+            double get_gradients_time = 0.0;
+
+            for (Size n = 0; n < nrTrails; ++n) {
+                // Set inputs timing
+                auto t_set_start = Clock::now();
+                for (Size k = 0; k < size; ++k) {
+                    value(jit_initRates[k]) = value(initRates2[k]);
+                }
+                value(jit_swapRate) = value(swapRate2_tape);
+                for (Size m = 0; m < fullGridRandoms; ++m) {
+                    value(jit_randoms[m]) = allRandomsFull[n][m];
+                }
+                auto t_set_end = Clock::now();
+                set_inputs_time += Duration(t_set_end - t_set_start).count();
+
+                // Kernel exec timing
+                auto t_exec_start = Clock::now();
+                double payoff_value;
+                jit.forward(&payoff_value);
+                auto t_exec_end = Clock::now();
+                kernel_exec_time += Duration(t_exec_end - t_exec_start).count();
+
+                // Get outputs timing (trivial - just accumulate)
+                auto t_get_out_start = Clock::now();
+                mcPrice_jit_local += payoff_value;
+                auto t_get_out_end = Clock::now();
+                get_outputs_time += Duration(t_get_out_end - t_get_out_start).count();
+
+                // Get gradients timing
+                auto t_grad_mc_start = Clock::now();
+                jit.clearDerivatives();
+                jit.setDerivative(outputSlot, 1.0);
+                jit.computeAdjoints();
+                for (Size k = 0; k < size; ++k) {
+                    dPrice_dInitRates[k] += jit.derivative(graph.input_ids[k]);
+                }
+                dPrice_dSwapRate_jit += jit.derivative(graph.input_ids[size]);
+                auto t_grad_mc_end = Clock::now();
+                get_gradients_time += Duration(t_grad_mc_end - t_grad_mc_start).count();
+            }
+
+            // --- Gradient (chain rule) ---
+            auto t_grad_start = Clock::now();
+
+            mcPrice_jit_local /= static_cast<double>(nrTrails);
+            for (Size k = 0; k < size; ++k) {
+                dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+            }
+            dPrice_dSwapRate_jit /= static_cast<double>(nrTrails);
+
+            std::vector<double> dPrice_dIntermediates(numIntermediates);
+            for (Size k = 0; k < size; ++k)
+                dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+            dPrice_dIntermediates[size] = dPrice_dSwapRate_jit;
+
+            std::vector<double> dPrice_jit_market(numMarketQuotes);
+            applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_jit_market.data(),
+                           numIntermediates, numMarketQuotes);
+
+            for (Size idx = 0; idx < numDeposits; ++idx) dPrice_jit_fast_depo[idx] = dPrice_jit_market[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) dPrice_jit_fast_swap[idx] = dPrice_jit_market[numDeposits + idx];
+
+            mcPrice_jit_fast = mcPrice_jit_local;
+
+            auto t_grad_end = Clock::now();
+            auto t_total_end = Clock::now();
+
+            if (recordTiming) {
+                jit_fast_tape_setup_times.push_back(Duration(t_tape_setup_end - t_tape_setup_start).count());
+                jit_fast_bootstrap_fwd_times.push_back(Duration(t_boot_fwd_end - t_boot_fwd_start).count());
+                jit_fast_bootstrap_bwd_times.push_back(Duration(t_boot_bwd_end - t_boot_bwd_start).count());
+                jit_fast_kernel_record_times.push_back(Duration(t_kernel_record_end - t_kernel_record_start).count());
+                jit_fast_kernel_compile_times.push_back(Duration(t_kernel_compile_end - t_kernel_compile_start).count());
+                jit_fast_set_inputs_times.push_back(set_inputs_time);
+                jit_fast_kernel_exec_times.push_back(kernel_exec_time);
+                jit_fast_get_outputs_times.push_back(get_outputs_time);
+                jit_fast_gradient_times.push_back(get_gradients_time);
+                jit_fast_chain_rule_times.push_back(Duration(t_grad_end - t_grad_start).count());
+                jit_fast_total_times.push_back(Duration(t_total_end - t_total_start).count());
+            }
+        }
+
+        // =====================================================================
+        // 4c. JIT Interpreter (Re-Route) - Full grid with interpreter backend
+        // =====================================================================
+        std::cout << " JIT-Interp..." << std::flush;
+        {
+            auto t_total_start = Clock::now();
+
+            // --- Tape setup ---
+            auto t_tape_setup_start = Clock::now();
+
+            using tape_type = Real::tape_type;
+            tape_type tape2;
+
+            std::vector<Real> depositRates2(numDeposits);
+            std::vector<Real> swapRates2(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates2[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates2[idx] = swapRates_val[idx];
+
+            tape2.registerInputs(depositRates2);
+            tape2.registerInputs(swapRates2);
+            tape2.newRecording();
+
+            auto t_tape_setup_end = Clock::now();
+
+            // --- Bootstrap forward pass ---
+            auto t_boot_fwd_start = Clock::now();
+
+            RelinkableHandle<YieldTermStructure> euriborTS2;
+            auto euribor6m2 = ext::make_shared<Euribor6M>(euriborTS2);
+            euribor6m2->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments2;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote2 = ext::make_shared<SimpleQuote>(depositRates2[idx]);
+                instruments2.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote2), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates2[idx]);
+                instruments2.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m2));
+            }
+
+            auto yieldCurve2 = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments2, dayCounter);
+            yieldCurve2->enableExtrapolation();
+
+            std::vector<Date> curveDates2;
+            std::vector<Real> zeroRates2;
+            curveDates2.push_back(settlementDate);
+            zeroRates2.push_back(yieldCurve2->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate2 = settlementDate + 6 * Years;
+            curveDates2.push_back(endDate2);
+            zeroRates2.push_back(yieldCurve2->zeroRate(endDate2, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates2_ql;
+            for (const auto& r : zeroRates2) zeroRates2_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure2;
+            ext::shared_ptr<IborIndex> index2(new Euribor6M(termStructure2));
+            index2->addFixing(Date(2, September, 2005), 0.04);
+            termStructure2.linkTo(ext::make_shared<ZeroCurve>(curveDates2, zeroRates2_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process2(
+                new LiborForwardModelProcess(size, index2));
+            ext::shared_ptr<LmCorrelationModel> corrModel2(
+                new LmExponentialCorrelationModel(size, 0.5));
+            ext::shared_ptr<LmVolatilityModel> volaModel2(
+                new LmLinearExponentialVolatilityModel(process2->fixingTimes(),
+                                                       0.291, 1.483, 0.116, 0.00001));
+            process2->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(volaModel2, corrModel2)));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap2(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index2, 0.0, index2->dayCounter()));
+            fwdSwap2->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index2->forwardingTermStructure()));
+            Real swapRate2_tape = fwdSwap2->fairRate();
+
+            Array initRates2 = process2->initialValues();
+
+            auto t_boot_fwd_end = Clock::now();
+
+            // --- Bootstrap backward pass (Jacobian) ---
+            auto t_boot_bwd_start = Clock::now();
+
+            std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+
+            for (Size k = 0; k < size; ++k) {
+                if (initRates2[k].shouldRecord()) {
+                    tape2.clearDerivatives();
+                    tape2.registerOutput(initRates2[k]);
+                    derivative(initRates2[k]) = 1.0;
+                    tape2.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + k * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates2[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates2[m]);
+                }
+            }
+
+            if (swapRate2_tape.shouldRecord()) {
+                tape2.clearDerivatives();
+                tape2.registerOutput(swapRate2_tape);
+                derivative(swapRate2_tape) = 1.0;
+                tape2.computeAdjoints();
+
+                double* jac_row = jacobian.data() + size * numMarketQuotes;
+                for (Size m = 0; m < numDeposits; ++m)
+                    jac_row[m] = derivative(depositRates2[m]);
+                for (Size m = 0; m < numSwaps; ++m)
+                    jac_row[numDeposits + m] = derivative(swapRates2[m]);
+            }
+
+            tape2.deactivate();
+
+            auto t_boot_bwd_end = Clock::now();
+
+            // --- JIT kernel recording (build JIT graph with Interpreter backend) ---
+            auto t_kernel_record_start = Clock::now();
+
+            // Use default JITCompiler with JITGraphInterpreter backend
+            xad::JITCompiler<double> jit;
+
+            std::vector<xad::AD> jit_initRates(size);
+            xad::AD jit_swapRate;
+            std::vector<xad::AD> jit_randoms(fullGridRandoms);  // Full grid randoms
+
+            for (Size k = 0; k < size; ++k) {
+                jit_initRates[k] = xad::AD(value(initRates2[k]));
+                jit.registerInput(jit_initRates[k]);
+            }
+
+            jit_swapRate = xad::AD(value(swapRate2_tape));
+            jit.registerInput(jit_swapRate);
+
+            for (Size m = 0; m < fullGridRandoms; ++m) {
+                jit_randoms[m] = xad::AD(0.0);
+                jit.registerInput(jit_randoms[m]);
+            }
+
+            jit.newRecording();
+
+            // Record path evolution - Full grid (same as JIT Slow)
+            std::vector<xad::AD> asset_jit(size);
+            std::vector<xad::AD> assetAtExercise_jit(size);
+            for (Size k = 0; k < size; ++k) {
+                asset_jit[k] = jit_initRates[k];
+            }
+
+            for (Size step = 1; step <= fullGridSteps; ++step) {
+                Size offset = (step - 1) * numFactors;
+                Time t = grid[step - 1];
+                Time dt = grid.dt(step - 1);
+
+                Array dw(numFactors);
+                for (Size f = 0; f < numFactors; ++f) {
+                    dw[f] = jit_randoms[offset + f];
+                }
+
+                Array asset_arr(size);
+                for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                Array evolved = process2->evolve(t, asset_arr, dt, dw);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                // Store rates at exercise step
+                if (step == exerciseStep) {
+                    for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                }
+            }
+
+            // Use rates at EXERCISE time for payoff
+            std::vector<xad::AD> dis_jit(size);
+            xad::AD df_jit = xad::AD(1.0);
+            for (Size k = 0; k < size; ++k) {
+                double accrual = accrualEnd[k] - accrualStart[k];
+                df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                dis_jit[k] = df_jit;
+            }
+
+            xad::AD jit_npv = xad::AD(0.0);
+            for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                double accrual = accrualEnd[m] - accrualStart[m];
+                jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+            }
+
+            xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+            jit.registerOutput(jit_payoff);
+
+            auto t_kernel_record_end = Clock::now();
+
+            // --- JIT kernel compile ---
+            auto t_kernel_compile_start = Clock::now();
+
+            jit.compile();
+
+            auto t_kernel_compile_end = Clock::now();
+
+            // --- JIT kernel execution (MC loop) with granular timing ---
+            const auto& graph = jit.getGraph();
+            uint32_t outputSlot = graph.output_ids[0];
+
+            double mcPrice_jit_local = 0.0;
+            std::vector<double> dPrice_dInitRates(size, 0.0);
+            double dPrice_dSwapRate_jit = 0.0;
+
+            double set_inputs_time = 0.0;
+            double kernel_exec_time = 0.0;
+            double get_outputs_time = 0.0;
+            double get_gradients_time = 0.0;
+
+            for (Size n = 0; n < nrTrails; ++n) {
+                // Set inputs timing
+                auto t_set_start = Clock::now();
+                for (Size k = 0; k < size; ++k) {
+                    value(jit_initRates[k]) = value(initRates2[k]);
+                }
+                value(jit_swapRate) = value(swapRate2_tape);
+                for (Size m = 0; m < fullGridRandoms; ++m) {
+                    value(jit_randoms[m]) = allRandomsFull[n][m];
+                }
+                auto t_set_end = Clock::now();
+                set_inputs_time += Duration(t_set_end - t_set_start).count();
+
+                // Kernel exec timing
+                auto t_exec_start = Clock::now();
+                double payoff_value;
+                jit.forward(&payoff_value);
+                auto t_exec_end = Clock::now();
+                kernel_exec_time += Duration(t_exec_end - t_exec_start).count();
+
+                // Get outputs timing (trivial - just accumulate)
+                auto t_get_out_start = Clock::now();
+                mcPrice_jit_local += payoff_value;
+                auto t_get_out_end = Clock::now();
+                get_outputs_time += Duration(t_get_out_end - t_get_out_start).count();
+
+                // Get gradients timing
+                auto t_grad_mc_start = Clock::now();
+                jit.clearDerivatives();
+                jit.setDerivative(outputSlot, 1.0);
+                jit.computeAdjoints();
+                for (Size k = 0; k < size; ++k) {
+                    dPrice_dInitRates[k] += jit.derivative(graph.input_ids[k]);
+                }
+                dPrice_dSwapRate_jit += jit.derivative(graph.input_ids[size]);
+                auto t_grad_mc_end = Clock::now();
+                get_gradients_time += Duration(t_grad_mc_end - t_grad_mc_start).count();
+            }
+
+            // --- Gradient (chain rule) ---
+            auto t_grad_start = Clock::now();
+
+            mcPrice_jit_local /= static_cast<double>(nrTrails);
+            for (Size k = 0; k < size; ++k) {
+                dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+            }
+            dPrice_dSwapRate_jit /= static_cast<double>(nrTrails);
+
+            std::vector<double> dPrice_dIntermediates(numIntermediates);
+            for (Size k = 0; k < size; ++k)
+                dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+            dPrice_dIntermediates[size] = dPrice_dSwapRate_jit;
+
+            std::vector<double> dPrice_jit_market(numMarketQuotes);
+            applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_jit_market.data(),
+                           numIntermediates, numMarketQuotes);
+
+            for (Size idx = 0; idx < numDeposits; ++idx) dPrice_jit_interp_depo[idx] = dPrice_jit_market[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) dPrice_jit_interp_swap[idx] = dPrice_jit_market[numDeposits + idx];
+
+            mcPrice_jit_interp = mcPrice_jit_local;
+
+            auto t_grad_end = Clock::now();
+            auto t_total_end = Clock::now();
+
+            if (recordTiming) {
+                jit_interp_tape_setup_times.push_back(Duration(t_tape_setup_end - t_tape_setup_start).count());
+                jit_interp_bootstrap_fwd_times.push_back(Duration(t_boot_fwd_end - t_boot_fwd_start).count());
+                jit_interp_bootstrap_bwd_times.push_back(Duration(t_boot_bwd_end - t_boot_bwd_start).count());
+                jit_interp_kernel_record_times.push_back(Duration(t_kernel_record_end - t_kernel_record_start).count());
+                jit_interp_kernel_compile_times.push_back(Duration(t_kernel_compile_end - t_kernel_compile_start).count());
+                jit_interp_set_inputs_times.push_back(set_inputs_time);
+                jit_interp_kernel_exec_times.push_back(kernel_exec_time);
+                jit_interp_get_outputs_times.push_back(get_outputs_time);
+                jit_interp_gradient_times.push_back(get_gradients_time);
+                jit_interp_chain_rule_times.push_back(Duration(t_grad_end - t_grad_start).count());
+                jit_interp_total_times.push_back(Duration(t_total_end - t_total_start).count());
+            }
+        }
+
+        // =====================================================================
+        // 4d. JIT AVX (Re-Route) - AVX2 4-path batching
+        // =====================================================================
+        std::cout << " JIT-AVX..." << std::flush;
+        try {
+            auto t_total_start = Clock::now();
+
+            // --- Tape setup ---
+            auto t_tape_setup_start = Clock::now();
+
+            using tape_type = Real::tape_type;
+            tape_type tape2;
+
+            std::vector<Real> depositRates2(numDeposits);
+            std::vector<Real> swapRates2(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates2[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates2[idx] = swapRates_val[idx];
+
+            tape2.registerInputs(depositRates2);
+            tape2.registerInputs(swapRates2);
+            tape2.newRecording();
+
+            auto t_tape_setup_end = Clock::now();
+
+            // --- Bootstrap forward pass ---
+            auto t_boot_fwd_start = Clock::now();
+
+            RelinkableHandle<YieldTermStructure> euriborTS2;
+            auto euribor6m2 = ext::make_shared<Euribor6M>(euriborTS2);
+            euribor6m2->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments2;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote2 = ext::make_shared<SimpleQuote>(depositRates2[idx]);
+                instruments2.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote2), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates2[idx]);
+                instruments2.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m2));
+            }
+
+            auto yieldCurve2 = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments2, dayCounter);
+            yieldCurve2->enableExtrapolation();
+
+            std::vector<Date> curveDates2;
+            std::vector<Real> zeroRates2;
+            curveDates2.push_back(settlementDate);
+            zeroRates2.push_back(yieldCurve2->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate2 = settlementDate + 6 * Years;
+            curveDates2.push_back(endDate2);
+            zeroRates2.push_back(yieldCurve2->zeroRate(endDate2, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates2_ql;
+            for (const auto& r : zeroRates2) zeroRates2_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure2;
+            ext::shared_ptr<IborIndex> index2(new Euribor6M(termStructure2));
+            index2->addFixing(Date(2, September, 2005), 0.04);
+            termStructure2.linkTo(ext::make_shared<ZeroCurve>(curveDates2, zeroRates2_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process2(
+                new LiborForwardModelProcess(size, index2));
+            ext::shared_ptr<LmCorrelationModel> corrModel2(
+                new LmExponentialCorrelationModel(size, 0.5));
+            ext::shared_ptr<LmVolatilityModel> volaModel2(
+                new LmLinearExponentialVolatilityModel(process2->fixingTimes(),
+                                                       0.291, 1.483, 0.116, 0.00001));
+            process2->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(volaModel2, corrModel2)));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap2(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index2, 0.0, index2->dayCounter()));
+            fwdSwap2->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index2->forwardingTermStructure()));
+            Real swapRate2_tape = fwdSwap2->fairRate();
+
+            Array initRates2 = process2->initialValues();
+
+            auto t_boot_fwd_end = Clock::now();
+
+            // --- Bootstrap backward pass (Jacobian) ---
+            auto t_boot_bwd_start = Clock::now();
+
+            std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+
+            for (Size k = 0; k < size; ++k) {
+                if (initRates2[k].shouldRecord()) {
+                    tape2.clearDerivatives();
+                    tape2.registerOutput(initRates2[k]);
+                    derivative(initRates2[k]) = 1.0;
+                    tape2.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + k * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates2[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates2[m]);
+                }
+            }
+
+            if (swapRate2_tape.shouldRecord()) {
+                tape2.clearDerivatives();
+                tape2.registerOutput(swapRate2_tape);
+                derivative(swapRate2_tape) = 1.0;
+                tape2.computeAdjoints();
+
+                double* jac_row = jacobian.data() + size * numMarketQuotes;
+                for (Size m = 0; m < numDeposits; ++m)
+                    jac_row[m] = derivative(depositRates2[m]);
+                for (Size m = 0; m < numSwaps; ++m)
+                    jac_row[numDeposits + m] = derivative(swapRates2[m]);
+            }
+
+            tape2.deactivate();
+
+            auto t_boot_bwd_end = Clock::now();
+
+            // --- JIT kernel recording (build JIT graph for AVX compilation) ---
+            auto t_kernel_record_start = Clock::now();
+
+            // Build JIT graph for single path (same as JIT Slow)
+            auto forgeBackendAVX = std::make_unique<xad::forge::ForgeBackend<double>>(false);
+            xad::JITCompiler<double> jit(std::move(forgeBackendAVX));
+
+            std::vector<xad::AD> jit_initRates(size);
+            xad::AD jit_swapRate;
+            std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+            for (Size k = 0; k < size; ++k) {
+                jit_initRates[k] = xad::AD(value(initRates2[k]));
+                jit.registerInput(jit_initRates[k]);
+            }
+
+            jit_swapRate = xad::AD(value(swapRate2_tape));
+            jit.registerInput(jit_swapRate);
+
+            for (Size m = 0; m < fullGridRandoms; ++m) {
+                jit_randoms[m] = xad::AD(0.0);
+                jit.registerInput(jit_randoms[m]);
+            }
+
+            jit.newRecording();
+
+            // Record path evolution - SLOW: full grid
+            std::vector<xad::AD> asset_jit(size);
+            std::vector<xad::AD> assetAtExercise_jit(size);
+            for (Size k = 0; k < size; ++k) {
+                asset_jit[k] = jit_initRates[k];
+            }
+
+            for (Size step = 1; step <= fullGridSteps; ++step) {
+                Size offset = (step - 1) * numFactors;
+                Time t = grid[step - 1];
+                Time dt = grid.dt(step - 1);
+
+                Array dw(numFactors);
+                for (Size f = 0; f < numFactors; ++f) {
+                    dw[f] = jit_randoms[offset + f];
+                }
+
+                Array asset_arr(size);
+                for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                Array evolved = process2->evolve(t, asset_arr, dt, dw);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                if (step == exerciseStep) {
+                    for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                }
+            }
+
+            std::vector<xad::AD> dis_jit(size);
+            xad::AD df_jit = xad::AD(1.0);
+            for (Size k = 0; k < size; ++k) {
+                double accrual = accrualEnd[k] - accrualStart[k];
+                df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                dis_jit[k] = df_jit;
+            }
+
+            xad::AD jit_npv = xad::AD(0.0);
+            for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                double accrual = accrualEnd[m] - accrualStart[m];
+                jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+            }
+
+            xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+            jit.registerOutput(jit_payoff);
+
+            auto t_kernel_record_end = Clock::now();
+
+            // --- JIT AVX kernel compile (compile to AVX2 native code) ---
+            auto t_kernel_compile_start = Clock::now();
+
+            // Get the JIT graph
+            const auto& jitGraph = jit.getGraph();
+
+            // Deactivate jit now that we've got the graph
+            jit.deactivate();
+
+            // Create AVX backend and compile directly from JITGraph
+            xad::forge::ForgeBackendAVX<double> avxBackend(false);
+            avxBackend.compile(jitGraph);
+
+            auto t_kernel_compile_end = Clock::now();
+
+            // --- JIT AVX kernel execution (MC loop with 4-path batching) ---
+            double mcPrice_jit_local = 0.0;
+            std::vector<double> dPrice_dInitRates(size, 0.0);
+            double dPrice_dSwapRate_jit = 0.0;
+
+            // Process paths in batches of 4
+            constexpr int BATCH_SIZE = xad::forge::ForgeBackendAVX<double>::VECTOR_WIDTH;
+            Size numBatches = (nrTrails + BATCH_SIZE - 1) / BATCH_SIZE;
+
+            // Temporary arrays for batch processing
+            double inputLanes[BATCH_SIZE];
+            double outputLanes[BATCH_SIZE];
+
+            // Granular timing accumulators
+            double set_inputs_time = 0.0;
+            double kernel_exec_time = 0.0;
+            double get_outputs_time = 0.0;
+            double get_gradients_time = 0.0;
+
+            for (Size batch = 0; batch < numBatches; ++batch) {
+                Size pathStart = batch * BATCH_SIZE;
+                Size pathsInBatch = std::min(static_cast<Size>(BATCH_SIZE), nrTrails - pathStart);
+
+                // Set inputs timing
+                auto t_set_start = Clock::now();
+
+                // Set initial rates (same for all 4 paths)
+                for (Size k = 0; k < size; ++k) {
+                    for (int lane = 0; lane < BATCH_SIZE; ++lane) {
+                        inputLanes[lane] = value(initRates2[k]);
+                    }
+                    avxBackend.setInput(k, inputLanes);
+                }
+
+                // Set swap rate (same for all 4 paths)
+                for (int lane = 0; lane < BATCH_SIZE; ++lane) {
+                    inputLanes[lane] = value(swapRate2_tape);
+                }
+                avxBackend.setInput(size, inputLanes);
+
+                // Set random numbers (different for each path in batch)
+                for (Size m = 0; m < fullGridRandoms; ++m) {
+                    for (int lane = 0; lane < BATCH_SIZE; ++lane) {
+                        Size pathIdx = pathStart + lane;
+                        if (pathIdx < nrTrails) {
+                            inputLanes[lane] = allRandomsFull[pathIdx][m];
+                        } else {
+                            inputLanes[lane] = 0.0;  // Padding for incomplete batch
+                        }
+                    }
+                    avxBackend.setInput(size + 1 + m, inputLanes);
+                }
+
+                auto t_set_end = Clock::now();
+                set_inputs_time += Duration(t_set_end - t_set_start).count();
+
+                // Kernel exec timing (forward + backward pass together)
+                auto t_exec_start = Clock::now();
+
+                // Prepare containers for results
+                // Need space for: initial rates (size) + swap rate (1) + random numbers (fullGridRandoms)
+                std::size_t numInputs = size + 1 + fullGridRandoms;
+                std::vector<double> inputGradients(numInputs * BATCH_SIZE);
+
+                // Execute forward + backward in one call
+                avxBackend.forwardAndBackward(outputLanes, inputGradients.data());
+
+                auto t_exec_end = Clock::now();
+                kernel_exec_time += Duration(t_exec_end - t_exec_start).count();
+
+                // Get outputs timing
+                auto t_get_out_start = Clock::now();
+                for (Size lane = 0; lane < pathsInBatch; ++lane) {
+                    mcPrice_jit_local += outputLanes[lane];
+                }
+                auto t_get_out_end = Clock::now();
+                get_outputs_time += Duration(t_get_out_end - t_get_out_start).count();
+
+                // Get gradients timing
+                auto t_grad_mc_start = Clock::now();
+                for (Size k = 0; k < size; ++k) {
+                    for (Size lane = 0; lane < pathsInBatch; ++lane) {
+                        dPrice_dInitRates[k] += inputGradients[k * BATCH_SIZE + lane];
+                    }
+                }
+                for (Size lane = 0; lane < pathsInBatch; ++lane) {
+                    dPrice_dSwapRate_jit += inputGradients[size * BATCH_SIZE + lane];
+                }
+                auto t_grad_mc_end = Clock::now();
+                get_gradients_time += Duration(t_grad_mc_end - t_grad_mc_start).count();
+            }
+
+            // --- Gradient (chain rule) ---
+            auto t_grad_start = Clock::now();
+
+            mcPrice_jit_local /= static_cast<double>(nrTrails);
+            for (Size k = 0; k < size; ++k) {
+                dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+            }
+            dPrice_dSwapRate_jit /= static_cast<double>(nrTrails);
+
+            std::vector<double> dPrice_dIntermediates(numIntermediates);
+            for (Size k = 0; k < size; ++k)
+                dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+            dPrice_dIntermediates[size] = dPrice_dSwapRate_jit;
+
+            std::vector<double> dPrice_jit_market(numMarketQuotes);
+            applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_jit_market.data(),
+                           numIntermediates, numMarketQuotes);
+
+            for (Size idx = 0; idx < numDeposits; ++idx) dPrice_jit_avx_depo[idx] = dPrice_jit_market[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) dPrice_jit_avx_swap[idx] = dPrice_jit_market[numDeposits + idx];
+
+            mcPrice_jit_avx = mcPrice_jit_local;
+
+            auto t_grad_end = Clock::now();
+            auto t_total_end = Clock::now();
+
+            if (recordTiming) {
+                jit_avx_tape_setup_times.push_back(Duration(t_tape_setup_end - t_tape_setup_start).count());
+                jit_avx_bootstrap_fwd_times.push_back(Duration(t_boot_fwd_end - t_boot_fwd_start).count());
+                jit_avx_bootstrap_bwd_times.push_back(Duration(t_boot_bwd_end - t_boot_bwd_start).count());
+                jit_avx_kernel_record_times.push_back(Duration(t_kernel_record_end - t_kernel_record_start).count());
+                jit_avx_kernel_compile_times.push_back(Duration(t_kernel_compile_end - t_kernel_compile_start).count());
+                jit_avx_set_inputs_times.push_back(set_inputs_time);
+                jit_avx_kernel_exec_times.push_back(kernel_exec_time);
+                jit_avx_get_outputs_times.push_back(get_outputs_time);
+                jit_avx_gradient_times.push_back(get_gradients_time);
+                jit_avx_chain_rule_times.push_back(Duration(t_grad_end - t_grad_start).count());
+                jit_avx_total_times.push_back(Duration(t_total_end - t_total_start).count());
+            }
+        } catch (const std::exception& e) {
+            std::cout << "\n  WARNING: JIT-AVX failed: " << e.what() << std::endl;
+            std::cout << "  Skipping JIT-AVX benchmarks for this run." << std::endl;
+        }
+
+        std::cout << " Done." << std::flush;
+    }
+
+    std::cout << "\n\n";
+
+    // =========================================================================
+    // RESULTS VERIFICATION (same table as Stage 3)
+    // =========================================================================
+    std::cout << "  " << std::string(85, '=') << "\n";
+    std::cout << "  TABLE 1: MC PRICE COMPARISON (Verification)\n";
+    std::cout << "  " << std::string(85, '=') << "\n";
+    std::cout << std::endl;
+
+    std::cout << "  " << std::setw(18) << "Approach" << " | "
+              << std::setw(14) << "MC Price" << " | "
+              << std::setw(14) << "Diff vs Ref" << " | "
+              << "Match\n";
+    std::cout << "  " << std::string(18, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(5, '-') << "\n";
+
+    // Reference: Original (QuantLib)
+    std::cout << "  " << std::setw(18) << "Orig (QuantLib)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << mcPrice_orig_ql << " | "
+              << std::setw(14) << "-" << " |   -  \n";
+
+    // Original (Re-Route)
+    double diff_orig_rr_slow = mcPrice_orig_rr_slow - mcPrice_orig_ql;
+    bool orig_rr_slow_match = (std::abs(diff_orig_rr_slow) < 1e-6);
+    std::cout << "  " << std::setw(18) << "Orig (RR)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << mcPrice_orig_rr_slow << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_orig_rr_slow << " | "
+              << (orig_rr_slow_match ? "  OK " : "DIFF!") << "\n";
+
+    // Bump & Reprice (QuantLib)
+    double diff_bump_ql = mcPrice_bump_ql - mcPrice_orig_ql;
+    bool bump_ql_match = (std::abs(diff_bump_ql) < 1e-10);
+    std::cout << "  " << std::setw(18) << "Bump (QuantLib)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << mcPrice_bump_ql << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_bump_ql << " | "
+              << (bump_ql_match ? "  OK " : "DIFF!") << "\n";
+
+    // Bump & Reprice (Re-Route)
+    double diff_bump_rr_slow = mcPrice_bump_rr_slow - mcPrice_orig_rr_slow;
+    bool bump_rr_slow_match = (std::abs(diff_bump_rr_slow) < 1e-10);
+    std::cout << "  " << std::setw(18) << "Bump (RR)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << mcPrice_bump_rr_slow << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_bump_rr_slow << " | "
+              << (bump_rr_slow_match ? "  OK " : "DIFF!") << "\n";
+
+    // XAD (QuantLib)
+    double diff_xad_ql = mcPrice_xad_ql - mcPrice_orig_ql;
+    bool xad_ql_match = (std::abs(diff_xad_ql) < 1e-10);
+    std::cout << "  " << std::setw(18) << "XAD (QuantLib)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << mcPrice_xad_ql << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_xad_ql << " | "
+              << (xad_ql_match ? "  OK " : "DIFF!") << "\n";
+
+    // XAD (Re-Route)
+    double diff_xad_rr_slow = mcPrice_xad_rr_slow - mcPrice_orig_rr_slow;
+    bool xad_rr_slow_match = (std::abs(diff_xad_rr_slow) < 1e-10);
+    std::cout << "  " << std::setw(18) << "XAD (RR)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << mcPrice_xad_rr_slow << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_xad_rr_slow << " | "
+              << (xad_rr_slow_match ? "  OK " : "DIFF!") << "\n";
+
+    // JIT (Re-Route)
+    double diff_jit_slow = mcPrice_jit_slow - mcPrice_orig_rr_slow;
+    bool jit_slow_match = (std::abs(diff_jit_slow) < 1e-10);
+    std::cout << "  " << std::setw(18) << "JIT (RR)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << mcPrice_jit_slow << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_jit_slow << " | "
+              << (jit_slow_match ? "  OK " : "DIFF!") << "\n";
+
+    // JIT AVX (Re-Route)
+    double diff_jit_avx = mcPrice_jit_avx - mcPrice_orig_rr_slow;
+    bool jit_avx_match = (std::abs(diff_jit_avx) < 1e-10);
+    std::cout << "  " << std::setw(18) << "JIT AVX (RR)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << mcPrice_jit_avx << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_jit_avx << " | "
+              << (jit_avx_match ? "  OK " : "DIFF!") << "\n";
+
+    // JIT Opt (Re-Route)
+    double diff_jit_fast = mcPrice_jit_fast - mcPrice_orig_rr_slow;
+    bool jit_fast_match = (std::abs(diff_jit_fast) < 1e-10);
+    std::cout << "  " << std::setw(18) << "JIT Opt (RR)" << " | "
+              << std::fixed << std::setprecision(6) << std::setw(14) << mcPrice_jit_fast << " | "
+              << std::scientific << std::setprecision(2) << std::setw(14) << diff_jit_fast << " | "
+              << (jit_fast_match ? "  OK " : "DIFF!") << "\n";
+
+    std::cout << std::endl;
+
+    // Derivatives table
+    std::cout << "  " << std::string(170, '=') << "\n";
+    std::cout << "  TABLE 2: DERIVATIVE COMPARISON (dPrice/dMarketQuote)\n";
+    std::cout << "  " << std::string(170, '=') << "\n";
+    std::cout << std::endl;
+
+    std::cout << "  " << std::setw(12) << "Quote" << " | "
+              << std::setw(14) << "Bump QuantLib" << " | "
+              << std::setw(14) << "XAD QuantLib" << " | "
+              << std::setw(14) << "XAD RR" << " | "
+              << std::setw(14) << "JIT RR" << " | "
+              << std::setw(14) << "JIT AVX" << " | "
+              << std::setw(14) << "JIT Opt" << "\n";
+    std::cout << "  " << std::string(12, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "-+-"
+              << std::string(14, '-') << "\n";
+
+    std::vector<std::string> depoLabels = {"Depo ON", "Depo 1M", "Depo 3M", "Depo 6M"};
+    for (Size idx = 0; idx < numDeposits; ++idx) {
+        std::cout << "  " << std::setw(12) << depoLabels[idx] << " | "
+                  << std::scientific << std::setprecision(4) << std::setw(14) << dPrice_bump_ql_depo[idx] << " | "
+                  << std::setw(14) << dPrice_xad_ql_depo[idx] << " | "
+                  << std::setw(14) << dPrice_xad_rr_slow_depo[idx] << " | "
+                  << std::setw(14) << dPrice_jit_slow_depo[idx] << " | "
+                  << std::setw(14) << dPrice_jit_avx_depo[idx] << " | "
+                  << std::setw(14) << dPrice_jit_fast_depo[idx] << "\n";
+    }
+
+    std::vector<std::string> swapLabels = {"Swap 1Y", "Swap 2Y", "Swap 3Y", "Swap 4Y", "Swap 5Y"};
+    for (Size idx = 0; idx < numSwaps; ++idx) {
+        std::cout << "  " << std::setw(12) << swapLabels[idx] << " | "
+                  << std::scientific << std::setprecision(4) << std::setw(14) << dPrice_bump_ql_swap[idx] << " | "
+                  << std::setw(14) << dPrice_xad_ql_swap[idx] << " | "
+                  << std::setw(14) << dPrice_xad_rr_slow_swap[idx] << " | "
+                  << std::setw(14) << dPrice_jit_slow_swap[idx] << " | "
+                  << std::setw(14) << dPrice_jit_avx_swap[idx] << " | "
+                  << std::setw(14) << dPrice_jit_fast_swap[idx] << "\n";
+    }
+
+    std::cout << std::endl;
+
+    // =========================================================================
+    // PERFORMANCE TABLE
+    // =========================================================================
+    auto avg = [](const std::vector<double>& v) {
+        double sum = 0.0;
+        for (double x : v) sum += x;
+        return v.empty() ? 0.0 : sum / v.size();
+    };
+
+    auto stddev = [&avg](const std::vector<double>& v) {
+        if (v.size() <= 1) return 0.0;
+        double mean = avg(v);
+        double sq_sum = 0.0;
+        for (double x : v) {
+            double diff = x - mean;
+            sq_sum += diff * diff;
+        }
+        return std::sqrt(sq_sum / (v.size() - 1));
+    };
+
+    std::cout << "  " << std::string(85, '=') << "\n";
+    std::cout << "  TABLE 3: PERFORMANCE ANALYSIS (averaged over " << benchmarkIterations << " iterations)\n";
+    std::cout << "  " << std::string(85, '=') << "\n";
+    std::cout << std::endl;
+
+    // Original (QuantLib) - price only
+    std::cout << "  ORIGINAL (QuantLib) - price only, no derivatives:\n";
+    std::cout << "    - TOTAL (avg):            " << std::fixed << std::setprecision(3) << avg(orig_ql_total_times) << " ms\n";
+    std::cout << std::endl;
+
+    // Original (Re-Route) - price only, full grid
+    std::cout << "  ORIGINAL (Re-Route) - full grid, price only:\n";
+    std::cout << "    - TOTAL (avg):            " << std::fixed << std::setprecision(3) << avg(orig_rr_slow_total_times) << " ms\n";
+    std::cout << std::endl;
+
+    // Bump & Reprice (QuantLib)
+    std::cout << "  BUMP & REPRICE (QuantLib) - MultiPathGenerator:\n";
+    std::cout << "    - Evaluations:           " << (1 + numMarketQuotes) << " (1 base + " << numMarketQuotes << " bumps)\n";
+    std::cout << "    - TOTAL (avg):           " << std::fixed << std::setprecision(3) << avg(bump_ql_total_times) << " ms\n";
+    std::cout << std::endl;
+
+    // Bump & Reprice (Re-Route)
+    std::cout << "  BUMP & REPRICE (Re-Route) - full grid:\n";
+    std::cout << "    - Evaluations:           " << (1 + numMarketQuotes) << " (1 base + " << numMarketQuotes << " bumps)\n";
+    std::cout << "    - TOTAL (avg):           " << std::fixed << std::setprecision(3) << avg(bump_rr_slow_total_times) << " ms\n";
+    std::cout << std::endl;
+
+    // XAD (QuantLib)
+    std::cout << "  XAD (QuantLib) - MultiPathGenerator:\n";
+    std::cout << "    - Tape setup:             " << std::fixed << std::setprecision(3) << avg(xad_ql_tape_setup_times) << " ms\n";
+    std::cout << "    - Bootstrap (forward):    " << std::fixed << std::setprecision(3) << avg(xad_ql_bootstrap_times) << " ms\n";
+    std::cout << "    - MC Pricing (forward):   " << std::fixed << std::setprecision(3) << avg(xad_ql_mc_times) << " ms\n";
+    std::cout << "    - Gradient (adjoints):    " << std::fixed << std::setprecision(3) << avg(xad_ql_gradient_times) << " ms\n";
+    std::cout << "    - TOTAL (avg):            " << std::fixed << std::setprecision(3) << avg(xad_ql_total_times) << " ms\n";
+    std::cout << std::endl;
+
+    // XAD (Re-Route)
+    std::cout << "  XAD (Re-Route) - Full grid:\n";
+    std::cout << "    - Tape setup:             " << std::fixed << std::setprecision(3) << avg(xad_rr_slow_tape_setup_times) << " ms\n";
+    std::cout << "    - Bootstrap (forward):    " << std::fixed << std::setprecision(3) << avg(xad_rr_slow_bootstrap_times) << " ms\n";
+    std::cout << "    - MC Pricing (forward):   " << std::fixed << std::setprecision(3) << avg(xad_rr_slow_mc_times) << " ms\n";
+    std::cout << "    - Gradient (adjoints):    " << std::fixed << std::setprecision(3) << avg(xad_rr_slow_gradient_times) << " ms\n";
+    std::cout << "    - TOTAL (avg):            " << std::fixed << std::setprecision(3) << avg(xad_rr_slow_total_times) << " ms\n";
+    std::cout << std::endl;
+
+    // JIT (Re-Route)
+    std::cout << "  JIT (Re-Route) - Full grid:\n";
+    std::cout << "    - Tape setup:             " << std::fixed << std::setprecision(3) << avg(jit_slow_tape_setup_times) << " ms\n";
+    std::cout << "    - Bootstrap forward:      " << std::fixed << std::setprecision(3) << avg(jit_slow_bootstrap_fwd_times) << " ms\n";
+    std::cout << "    - Bootstrap backward:     " << std::fixed << std::setprecision(3) << avg(jit_slow_bootstrap_bwd_times) << " ms\n";
+    std::cout << "    - Kernel record:          " << std::fixed << std::setprecision(3) << avg(jit_slow_kernel_record_times) << " ms\n";
+    std::cout << "    - Kernel compile:         " << std::fixed << std::setprecision(3) << avg(jit_slow_kernel_compile_times) << " ms\n";
+    std::cout << "    - Set inputs:             " << std::fixed << std::setprecision(3) << avg(jit_slow_set_inputs_times) << " ms\n";
+    std::cout << "    - Kernel exec:            " << std::fixed << std::setprecision(3) << avg(jit_slow_kernel_exec_times) << " ms\n";
+    std::cout << "    - Get outputs:            " << std::fixed << std::setprecision(3) << avg(jit_slow_get_outputs_times) << " ms\n";
+    std::cout << "    - Get gradients:          " << std::fixed << std::setprecision(3) << avg(jit_slow_gradient_times) << " ms\n";
+    std::cout << "    - Chain rule:             " << std::fixed << std::setprecision(3) << avg(jit_slow_chain_rule_times) << " ms\n";
+    std::cout << "    - TOTAL (avg):            " << std::fixed << std::setprecision(3) << avg(jit_slow_total_times) << " ms\n";
+    std::cout << std::endl;
+
+    // JIT Opt (Re-Route) - Full grid with graph optimizations
+    std::cout << "  JIT Opt (RR) - Full grid + graph optimizations:\n";
+    std::cout << "    - Tape setup:             " << std::fixed << std::setprecision(3) << avg(jit_fast_tape_setup_times) << " ms\n";
+    std::cout << "    - Bootstrap forward:      " << std::fixed << std::setprecision(3) << avg(jit_fast_bootstrap_fwd_times) << " ms\n";
+    std::cout << "    - Bootstrap backward:     " << std::fixed << std::setprecision(3) << avg(jit_fast_bootstrap_bwd_times) << " ms\n";
+    std::cout << "    - Kernel record:          " << std::fixed << std::setprecision(3) << avg(jit_fast_kernel_record_times) << " ms\n";
+    std::cout << "    - Kernel compile:         " << std::fixed << std::setprecision(3) << avg(jit_fast_kernel_compile_times) << " ms\n";
+    std::cout << "    - Set inputs:             " << std::fixed << std::setprecision(3) << avg(jit_fast_set_inputs_times) << " ms\n";
+    std::cout << "    - Kernel exec:            " << std::fixed << std::setprecision(3) << avg(jit_fast_kernel_exec_times) << " ms\n";
+    std::cout << "    - Get outputs:            " << std::fixed << std::setprecision(3) << avg(jit_fast_get_outputs_times) << " ms\n";
+    std::cout << "    - Get gradients:          " << std::fixed << std::setprecision(3) << avg(jit_fast_gradient_times) << " ms\n";
+    std::cout << "    - Chain rule:             " << std::fixed << std::setprecision(3) << avg(jit_fast_chain_rule_times) << " ms\n";
+    std::cout << "    - TOTAL (avg):            " << std::fixed << std::setprecision(3) << avg(jit_fast_total_times) << " ms\n";
+    std::cout << std::endl;
+
+    // JIT Interpreter (Re-Route) - Full grid with interpreter backend
+    std::cout << "  JIT Interpreter (RR) - Full grid + interpreter:\n";
+    std::cout << "    - Tape setup:             " << std::fixed << std::setprecision(3) << avg(jit_interp_tape_setup_times) << " ms\n";
+    std::cout << "    - Bootstrap forward:      " << std::fixed << std::setprecision(3) << avg(jit_interp_bootstrap_fwd_times) << " ms\n";
+    std::cout << "    - Bootstrap backward:     " << std::fixed << std::setprecision(3) << avg(jit_interp_bootstrap_bwd_times) << " ms\n";
+    std::cout << "    - Kernel record:          " << std::fixed << std::setprecision(3) << avg(jit_interp_kernel_record_times) << " ms\n";
+    std::cout << "    - Kernel compile:         " << std::fixed << std::setprecision(3) << avg(jit_interp_kernel_compile_times) << " ms\n";
+    std::cout << "    - Set inputs:             " << std::fixed << std::setprecision(3) << avg(jit_interp_set_inputs_times) << " ms\n";
+    std::cout << "    - Kernel exec:            " << std::fixed << std::setprecision(3) << avg(jit_interp_kernel_exec_times) << " ms\n";
+    std::cout << "    - Get outputs:            " << std::fixed << std::setprecision(3) << avg(jit_interp_get_outputs_times) << " ms\n";
+    std::cout << "    - Get gradients:          " << std::fixed << std::setprecision(3) << avg(jit_interp_gradient_times) << " ms\n";
+    std::cout << "    - Chain rule:             " << std::fixed << std::setprecision(3) << avg(jit_interp_chain_rule_times) << " ms\n";
+    std::cout << "    - TOTAL (avg):            " << std::fixed << std::setprecision(3) << avg(jit_interp_total_times) << " ms\n";
+    std::cout << std::endl;
+
+    // JIT AVX (Re-Route) - Full grid with AVX2 4-path batching
+    std::cout << "  JIT AVX (RR) - Full grid + AVX2 4-path batching:\n";
+    std::cout << "    - Tape setup:             " << std::fixed << std::setprecision(3) << avg(jit_avx_tape_setup_times) << " ms\n";
+    std::cout << "    - Bootstrap forward:      " << std::fixed << std::setprecision(3) << avg(jit_avx_bootstrap_fwd_times) << " ms\n";
+    std::cout << "    - Bootstrap backward:     " << std::fixed << std::setprecision(3) << avg(jit_avx_bootstrap_bwd_times) << " ms\n";
+    std::cout << "    - Kernel record:          " << std::fixed << std::setprecision(3) << avg(jit_avx_kernel_record_times) << " ms\n";
+    std::cout << "    - Kernel compile:         " << std::fixed << std::setprecision(3) << avg(jit_avx_kernel_compile_times) << " ms\n";
+    std::cout << "    - Set inputs:             " << std::fixed << std::setprecision(3) << avg(jit_avx_set_inputs_times) << " ms\n";
+    std::cout << "    - Kernel exec:            " << std::fixed << std::setprecision(3) << avg(jit_avx_kernel_exec_times) << " ms\n";
+    std::cout << "    - Get outputs:            " << std::fixed << std::setprecision(3) << avg(jit_avx_get_outputs_times) << " ms\n";
+    std::cout << "    - Get gradients:          " << std::fixed << std::setprecision(3) << avg(jit_avx_gradient_times) << " ms\n";
+    std::cout << "    - Chain rule:             " << std::fixed << std::setprecision(3) << avg(jit_avx_chain_rule_times) << " ms\n";
+    std::cout << "    - TOTAL (avg):            " << std::fixed << std::setprecision(3) << avg(jit_avx_total_times) << " ms\n";
+    std::cout << std::endl;
+
+    // Summary
+    double orig_ql_avg = avg(orig_ql_total_times);
+    double orig_rr_slow_avg = avg(orig_rr_slow_total_times);
+    double bump_ql_avg = avg(bump_ql_total_times);
+    double bump_rr_slow_avg = avg(bump_rr_slow_total_times);
+    double xad_ql_avg = avg(xad_ql_total_times);
+    double xad_rr_slow_avg = avg(xad_rr_slow_total_times);
+    double jit_slow_avg = avg(jit_slow_total_times);
+    double jit_fast_avg = avg(jit_fast_total_times);
+    double jit_interp_avg = avg(jit_interp_total_times);
+    double jit_avx_avg = avg(jit_avx_total_times);
+
+    double orig_ql_std = stddev(orig_ql_total_times);
+    double orig_rr_slow_std = stddev(orig_rr_slow_total_times);
+    double bump_ql_std = stddev(bump_ql_total_times);
+    double bump_rr_slow_std = stddev(bump_rr_slow_total_times);
+    double xad_ql_std = stddev(xad_ql_total_times);
+    double xad_rr_slow_std = stddev(xad_rr_slow_total_times);
+    double jit_slow_std = stddev(jit_slow_total_times);
+    double jit_fast_std = stddev(jit_fast_total_times);
+    double jit_interp_std = stddev(jit_interp_total_times);
+    double jit_avx_std = stddev(jit_avx_total_times);
+
+    std::cout << "  " << std::string(80, '-') << "\n";
+    std::cout << "  SUMMARY (price + all " << numMarketQuotes << " derivatives):\n";
+    std::cout << "    Orig (QuantLib):      " << std::fixed << std::setprecision(3) << orig_ql_avg << " ms (" << orig_ql_std << " ms std) (price only)\n";
+    std::cout << "    Orig (RR):       " << std::fixed << std::setprecision(3) << orig_rr_slow_avg << " ms (" << orig_rr_slow_std << " ms std) (price only)\n";
+    std::cout << "    Bump (QuantLib):      " << std::fixed << std::setprecision(3) << bump_ql_avg << " ms (" << bump_ql_std << " ms std)\n";
+    std::cout << "    Bump (RR):       " << std::fixed << std::setprecision(3) << bump_rr_slow_avg << " ms (" << bump_rr_slow_std << " ms std)\n";
+    std::cout << "    XAD (QuantLib):       " << std::fixed << std::setprecision(3) << xad_ql_avg << " ms (" << xad_ql_std << " ms std)";
+    if (bump_rr_slow_avg > 0) std::cout << " -> " << std::fixed << std::setprecision(1) << (bump_rr_slow_avg / xad_ql_avg) << "x speedup vs BumpSlow";
+    std::cout << "\n";
+    std::cout << "    XAD (RR):        " << std::fixed << std::setprecision(3) << xad_rr_slow_avg << " ms (" << xad_rr_slow_std << " ms std)";
+    if (bump_rr_slow_avg > 0) std::cout << " -> " << std::fixed << std::setprecision(1) << (bump_rr_slow_avg / xad_rr_slow_avg) << "x speedup vs BumpSlow";
+    std::cout << "\n";
+    std::cout << "    JIT (RR):        " << std::fixed << std::setprecision(3) << jit_slow_avg << " ms (" << jit_slow_std << " ms std)";
+    if (bump_rr_slow_avg > 0) std::cout << " -> " << std::fixed << std::setprecision(1) << (bump_rr_slow_avg / jit_slow_avg) << "x speedup vs BumpSlow";
+    std::cout << "\n";
+    std::cout << "    JIT Opt (RR):    " << std::fixed << std::setprecision(3) << jit_fast_avg << " ms (" << jit_fast_std << " ms std)";
+    if (bump_rr_slow_avg > 0) std::cout << " -> " << std::fixed << std::setprecision(1) << (bump_rr_slow_avg / jit_fast_avg) << "x speedup vs BumpSlow";
+    std::cout << "\n";
+    std::cout << "    JIT Interp (RR): " << std::fixed << std::setprecision(3) << jit_interp_avg << " ms (" << jit_interp_std << " ms std)";
+    if (bump_rr_slow_avg > 0) std::cout << " -> " << std::fixed << std::setprecision(1) << (bump_rr_slow_avg / jit_interp_avg) << "x speedup vs BumpSlow";
+    std::cout << "\n";
+    std::cout << "    JIT AVX (RR):    " << std::fixed << std::setprecision(3) << jit_avx_avg << " ms (" << jit_avx_std << " ms std)";
+    if (bump_rr_slow_avg > 0) std::cout << " -> " << std::fixed << std::setprecision(1) << (bump_rr_slow_avg / jit_avx_avg) << "x speedup vs BumpSlow";
+    std::cout << "\n";
+    std::cout << "  " << std::string(80, '-') << "\n";
+
+    std::cout << std::endl;
+    std::cout << "  STATUS: [STAGE 4 BENCHMARKS COMPLETE]\n";
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    // Basic verification
+    BOOST_CHECK(mcPrice_orig_ql > 0.0);
+    BOOST_CHECK(mcPrice_orig_rr_slow > 0.0);
+    BOOST_CHECK(mcPrice_bump_ql > 0.0);
+    BOOST_CHECK(mcPrice_bump_rr_slow > 0.0);
+    BOOST_CHECK(orig_rr_slow_match);
+    BOOST_CHECK(bump_ql_match);
+    BOOST_CHECK(bump_rr_slow_match);
+    BOOST_CHECK(xad_ql_match);
+    BOOST_CHECK(xad_rr_slow_match);
+    BOOST_CHECK(jit_slow_match);
+    BOOST_CHECK(jit_fast_match);
+    BOOST_CHECK(jit_avx_match);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// STAGE 5: Scaling Benchmarks (XAD vs JIT on RR)
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testStage5_ScalingBenchmarks)
+{
+    BOOST_TEST_MESSAGE("Testing Stage 5: Scaling Benchmarks (XAD vs JIT)...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  STAGE 5: SCALING BENCHMARKS (XAD vs JIT on RR)\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    using Clock = std::chrono::high_resolution_clock;
+    using Duration = std::chrono::duration<double, std::milli>;
+
+    // Market data setup (same as Stage 4)
+    Calendar calendar = TARGET();
+    Date todaysDate(4, September, 2005);
+    Settings::instance().evaluationDate() = todaysDate;
+    Integer fixingDays = 2;
+    Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+    DayCounter dayCounter = Actual360();
+
+    Size numDeposits = 4;
+    Size numSwaps = 5;
+    std::vector<Period> depoTenors = {1 * Days, 1 * Months, 3 * Months, 6 * Months};
+    std::vector<Period> swapTenors = {1 * Years, 2 * Years, 3 * Years, 4 * Years, 5 * Years};
+
+    std::vector<double> depoRates_val = {0.0350, 0.0365, 0.0380, 0.0400};
+    std::vector<double> swapRates_val = {0.0420, 0.0480, 0.0520, 0.0550, 0.0575};
+
+    Size numMarketQuotes = numDeposits + numSwaps;
+
+    // LMM parameters
+    Size size = 10;
+    Size i_opt = 2;
+    Size j_opt = 2;
+    Size steps = 8;
+
+    // Build base curve and process setup
+    std::vector<Rate> baseZeroRates = {0.0350, 0.0575};
+    std::vector<Date> baseDates = {settlementDate, settlementDate + 6 * Years};
+    auto baseIndex = makeIndex(baseDates, baseZeroRates);
+
+    ext::shared_ptr<LiborForwardModelProcess> baseProcess(
+        new LiborForwardModelProcess(size, baseIndex));
+    ext::shared_ptr<LmCorrelationModel> baseCorrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> baseVolaModel(
+        new LmLinearExponentialVolatilityModel(baseProcess->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    baseProcess->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(baseVolaModel, baseCorrModel)));
+
+    // Grid and timing setup
+    std::vector<Time> fixingTimes = baseProcess->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    Size numFactors = baseProcess->factors();
+    Size exerciseStep = location[i_opt];
+    Size fullGridSteps = grid.size() - 1;
+    Size fullGridRandoms = fullGridSteps * numFactors;
+
+    // Types for MC generators
+    typedef PseudoRandom::rsg_type rsg_type;
+    typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+
+    // Get fair swap rate (same approach as Stage 4)
+    BusinessDayConvention convention = baseIndex->businessDayConvention();
+    Date settlement = baseIndex->forwardingTermStructure()->referenceDate();
+    Date fwdStart = settlement + Period(6 * i_opt, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j_opt, Months);
+
+    Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    // Accrual periods
+    std::vector<double> accrualStart(size), accrualEnd(size);
+    for (Size k = 0; k < size; ++k) {
+        accrualStart[k] = value(baseProcess->accrualStartTimes()[k]);
+        accrualEnd[k] = value(baseProcess->accrualEndTimes()[k]);
+    }
+
+    Size numIntermediates = size + 1;
+
+    // Helper lambda for curve building
+    auto buildCurveAndProcess = [&](const std::vector<double>& depoRates,
+                                    const std::vector<double>& swapRates,
+                                    std::vector<Date>& curveDates,
+                                    std::vector<Rate>& zeroRates) {
+        RelinkableHandle<YieldTermStructure> euriborTS;
+        auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+        euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+        std::vector<ext::shared_ptr<RateHelper>> instruments;
+        for (Size idx = 0; idx < numDeposits; ++idx) {
+            auto depoQuote = ext::make_shared<SimpleQuote>(depoRates[idx]);
+            instruments.push_back(ext::make_shared<DepositRateHelper>(
+                Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                calendar, ModifiedFollowing, true, dayCounter));
+        }
+        for (Size idx = 0; idx < numSwaps; ++idx) {
+            auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+            instruments.push_back(ext::make_shared<SwapRateHelper>(
+                Handle<Quote>(swapQuote), swapTenors[idx],
+                calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                euribor6m));
+        }
+
+        auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+            settlementDate, instruments, dayCounter);
+        yieldCurve->enableExtrapolation();
+
+        curveDates.clear();
+        zeroRates.clear();
+        curveDates.push_back(settlementDate);
+        zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+        Date endDate = settlementDate + 6 * Years;
+        curveDates.push_back(endDate);
+        zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+    };
+
+    // Test cases: different path counts
+    std::vector<Size> pathCounts = {10, 100, 1000, 10000};
+    std::vector<std::string> testCaseNames = {"10", "100", "1K", "10K"};
+
+    // Results storage
+    struct ScalingResult {
+        double xad_ql_total;
+        double xad_rrs_total;
+        double jit_rrs_total;
+        double jit_interp_total;
+        double jit_avx_total;
+        double xad_ql_std;
+        double xad_rrs_std;
+        double jit_rrs_std;
+        double jit_interp_std;
+        double jit_avx_std;
+    };
+    std::vector<ScalingResult> results(pathCounts.size());
+
+    Size warmupIterations = 5;
+    Size benchmarkIterations = 10;
+
+    std::cout << "  Configuration:\n";
+    std::cout << "    - Market inputs: " << numMarketQuotes << " (4 deposits + 5 swaps)\n";
+    std::cout << "    - Forward rates: " << size << "\n";
+    std::cout << "    - Grid steps: " << fullGridSteps << " (full grid)\n";
+    std::cout << "    - Warmup iterations: " << warmupIterations << "\n";
+    std::cout << "    - Benchmark iterations: " << benchmarkIterations << "\n";
+    std::cout << std::endl;
+
+    for (Size tc = 0; tc < pathCounts.size(); ++tc) {
+        Size nrTrails = pathCounts[tc];
+        std::cout << "  Running test case: " << testCaseNames[tc] << " (" << nrTrails << " paths)..." << std::flush;
+
+        // Pre-generate random numbers for this path count
+        rsg_type rsg_base = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+        std::vector<std::vector<double>> allRandoms(nrTrails);
+        for (Size n = 0; n < nrTrails; ++n) {
+            allRandoms[n].resize(fullGridRandoms);
+            const auto& seq = rsg_base.nextSequence();
+            for (Size m = 0; m < fullGridRandoms; ++m) {
+                allRandoms[n][m] = value(seq.value[m]);
+            }
+        }
+
+        // Timing accumulators
+        std::vector<double> xad_ql_times, xad_rrs_times, jit_rrs_times, jit_interp_times, jit_avx_times;
+
+        for (Size iter = 0; iter < warmupIterations + benchmarkIterations; ++iter) {
+            bool recordTiming = (iter >= warmupIterations);
+
+            // =================================================================
+            // XAD (QuantLib) - MultiPathGenerator with XAD tape
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(numDeposits);
+                std::vector<Real> swapRates(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRates);
+                tape.newRecording();
+
+                std::vector<Date> curveDates;
+                std::vector<Rate> zeroRates;
+                std::vector<double> depoRates_dbl(numDeposits), swapRates_dbl(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depoRates_dbl[idx] = value(depositRates[idx]);
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates_dbl[idx] = value(swapRates[idx]);
+                buildCurveAndProcess(depoRates_dbl, swapRates_dbl, curveDates, zeroRates);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<Real> zeroRates_real(zeroRates.begin(), zeroRates.end());
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_real, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate = fwdSwap->fairRate();
+
+                rsg_type rsg_ql = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+                MultiPathGenerator<rsg_type> generator_ql(process, grid, rsg_ql, false);
+
+                Real price = Real(0.0);
+                for (Size n = 0; n < nrTrails; ++n) {
+                    sample_type path = (n % 2) != 0U ? generator_ql.antithetic() : generator_ql.next();
+
+                    Array mcRates(size);
+                    for (Size k = 0; k < size; ++k) {
+                        mcRates[k] = path.value[k][exerciseStep];
+                    }
+
+                    Array dis(size);
+                    Real df = Real(1.0);
+                    for (Size k = 0; k < size; ++k) {
+                        Real accrual = accrualEnd[k] - accrualStart[k];
+                        df = df / (Real(1.0) + mcRates[k] * accrual);
+                        dis[k] = df;
+                    }
+
+                    Real npv = Real(0.0);
+                    for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                        Real accrual = accrualEnd[m] - accrualStart[m];
+                        npv += (swapRate - mcRates[m]) * accrual * dis[m];
+                    }
+                    price += max(npv, Real(0.0));
+                }
+                price /= Real(static_cast<double>(nrTrails));
+
+                tape.registerOutput(price);
+                derivative(price) = 1.0;
+                tape.computeAdjoints();
+
+                auto t_end = Clock::now();
+                if (recordTiming) {
+                    xad_ql_times.push_back(Duration(t_end - t_start).count());
+                }
+                tape.deactivate();
+            }
+
+            // =================================================================
+            // XAD (RR) - Full grid with XAD tape
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(numDeposits);
+                std::vector<Real> swapRates(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRates);
+                tape.newRecording();
+
+                RelinkableHandle<YieldTermStructure> euriborTS;
+                auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<ext::shared_ptr<RateHelper>> instruments;
+                for (Size idx = 0; idx < numDeposits; ++idx) {
+                    auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                    instruments.push_back(ext::make_shared<DepositRateHelper>(
+                        Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                        calendar, ModifiedFollowing, true, dayCounter));
+                }
+                for (Size idx = 0; idx < numSwaps; ++idx) {
+                    auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                    instruments.push_back(ext::make_shared<SwapRateHelper>(
+                        Handle<Quote>(swapQuote), swapTenors[idx],
+                        calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                        euribor6m));
+                }
+
+                auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                    settlementDate, instruments, dayCounter);
+                yieldCurve->enableExtrapolation();
+
+                std::vector<Date> curveDates;
+                std::vector<Real> zeroRates;
+                curveDates.push_back(settlementDate);
+                zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                Date endDate = settlementDate + 6 * Years;
+                curveDates.push_back(endDate);
+                zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                std::vector<Rate> zeroRates_ql;
+                for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate = fwdSwap->fairRate();
+
+                Array initRates = process->initialValues();
+
+                Real price = Real(0.0);
+                for (Size n = 0; n < nrTrails; ++n) {
+                    Array asset(size);
+                    for (Size k = 0; k < size; ++k) asset[k] = initRates[k];
+
+                    Array assetAtExercise(size);
+                    for (Size step = 1; step <= fullGridSteps; ++step) {
+                        Size offset = (step - 1) * numFactors;
+                        Time t = grid[step - 1];
+                        Time dt = grid.dt(step - 1);
+
+                        Array dw(numFactors);
+                        for (Size f = 0; f < numFactors; ++f) {
+                            dw[f] = allRandoms[n][offset + f];
+                        }
+
+                        asset = process->evolve(t, asset, dt, dw);
+
+                        if (step == exerciseStep) {
+                            for (Size k = 0; k < size; ++k) assetAtExercise[k] = asset[k];
+                        }
+                    }
+
+                    Array dis(size);
+                    Real df = Real(1.0);
+                    for (Size k = 0; k < size; ++k) {
+                        Real accrual = accrualEnd[k] - accrualStart[k];
+                        df = df / (Real(1.0) + assetAtExercise[k] * accrual);
+                        dis[k] = df;
+                    }
+
+                    Real npv = Real(0.0);
+                    for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                        Real accrual = accrualEnd[m] - accrualStart[m];
+                        npv += (swapRate - assetAtExercise[m]) * accrual * dis[m];
+                    }
+                    price += max(npv, Real(0.0));
+                }
+                price /= Real(static_cast<double>(nrTrails));
+
+                tape.registerOutput(price);
+                derivative(price) = 1.0;
+                tape.computeAdjoints();
+
+                auto t_end = Clock::now();
+                if (recordTiming) {
+                    xad_rrs_times.push_back(Duration(t_end - t_start).count());
+                }
+                tape.deactivate();
+            }
+
+            // =================================================================
+            // JIT (RR) - ForgeBackend with full grid
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(numDeposits);
+                std::vector<Real> swapRates(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRates);
+                tape.newRecording();
+
+                RelinkableHandle<YieldTermStructure> euriborTS;
+                auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<ext::shared_ptr<RateHelper>> instruments;
+                for (Size idx = 0; idx < numDeposits; ++idx) {
+                    auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                    instruments.push_back(ext::make_shared<DepositRateHelper>(
+                        Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                        calendar, ModifiedFollowing, true, dayCounter));
+                }
+                for (Size idx = 0; idx < numSwaps; ++idx) {
+                    auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                    instruments.push_back(ext::make_shared<SwapRateHelper>(
+                        Handle<Quote>(swapQuote), swapTenors[idx],
+                        calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                        euribor6m));
+                }
+
+                auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                    settlementDate, instruments, dayCounter);
+                yieldCurve->enableExtrapolation();
+
+                std::vector<Date> curveDates;
+                std::vector<Real> zeroRates;
+                curveDates.push_back(settlementDate);
+                zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                Date endDate = settlementDate + 6 * Years;
+                curveDates.push_back(endDate);
+                zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                std::vector<Rate> zeroRates_ql;
+                for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate_tape = fwdSwap->fairRate();
+
+                Array initRates = process->initialValues();
+
+                // Jacobian computation
+                std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+                for (Size k = 0; k < size; ++k) {
+                    if (initRates[k].shouldRecord()) {
+                        tape.clearDerivatives();
+                        tape.registerOutput(initRates[k]);
+                        derivative(initRates[k]) = 1.0;
+                        tape.computeAdjoints();
+
+                        double* jac_row = jacobian.data() + k * numMarketQuotes;
+                        for (Size m = 0; m < numDeposits; ++m)
+                            jac_row[m] = derivative(depositRates[m]);
+                        for (Size m = 0; m < numSwaps; ++m)
+                            jac_row[numDeposits + m] = derivative(swapRates[m]);
+                    }
+                }
+                if (swapRate_tape.shouldRecord()) {
+                    tape.clearDerivatives();
+                    tape.registerOutput(swapRate_tape);
+                    derivative(swapRate_tape) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + size * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates[m]);
+                }
+                tape.deactivate();
+
+                // JIT kernel creation
+                auto forgeBackend = std::make_unique<xad::forge::ForgeBackend<double>>(false);
+                xad::JITCompiler<double> jit(std::move(forgeBackend));
+
+                std::vector<xad::AD> jit_initRates(size);
+                xad::AD jit_swapRate;
+                std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+                for (Size k = 0; k < size; ++k) {
+                    jit_initRates[k] = xad::AD(value(initRates[k]));
+                    jit.registerInput(jit_initRates[k]);
+                }
+                jit_swapRate = xad::AD(value(swapRate_tape));
+                jit.registerInput(jit_swapRate);
+                for (Size m = 0; m < fullGridRandoms; ++m) {
+                    jit_randoms[m] = xad::AD(0.0);
+                    jit.registerInput(jit_randoms[m]);
+                }
+
+                jit.newRecording();
+
+                std::vector<xad::AD> asset_jit(size);
+                std::vector<xad::AD> assetAtExercise_jit(size);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = jit_initRates[k];
+
+                for (Size step = 1; step <= fullGridSteps; ++step) {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f) dw[f] = jit_randoms[offset + f];
+
+                    Array asset_arr(size);
+                    for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                    Array evolved = process->evolve(t, asset_arr, dt, dw);
+                    for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                    if (step == exerciseStep) {
+                        for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                    }
+                }
+
+                std::vector<xad::AD> dis_jit(size);
+                xad::AD df_jit = xad::AD(1.0);
+                for (Size k = 0; k < size; ++k) {
+                    double accrual = accrualEnd[k] - accrualStart[k];
+                    df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                    dis_jit[k] = df_jit;
+                }
+
+                xad::AD jit_npv = xad::AD(0.0);
+                for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                    double accrual = accrualEnd[m] - accrualStart[m];
+                    jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+                }
+
+                xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+                jit.registerOutput(jit_payoff);
+
+                // Compile the JIT kernel before MC loop
+                jit.compile();
+
+                // MC execution
+                double mcPrice = 0.0;
+                std::vector<double> dPrice_dInitRates(size, 0.0);
+                double dPrice_dSwapRate = 0.0;
+
+                const auto& graph = jit.getGraph();
+                uint32_t outputSlot = graph.output_ids[0];
+
+                for (Size n = 0; n < nrTrails; ++n) {
+                    for (Size k = 0; k < size; ++k) value(jit_initRates[k]) = value(initRates[k]);
+                    value(jit_swapRate) = value(swapRate_tape);
+                    for (Size m = 0; m < fullGridRandoms; ++m) value(jit_randoms[m]) = allRandoms[n][m];
+
+                    double payoff_value;
+                    jit.forward(&payoff_value);
+                    mcPrice += payoff_value;
+
+                    jit.clearDerivatives();
+                    jit.setDerivative(outputSlot, 1.0);
+                    jit.computeAdjoints();
+
+                    for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] += jit.derivative(graph.input_ids[k]);
+                    dPrice_dSwapRate += jit.derivative(graph.input_ids[size]);
+                }
+
+                mcPrice /= static_cast<double>(nrTrails);
+                for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+                dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+                // Chain rule
+                std::vector<double> dPrice_dIntermediates(numIntermediates);
+                for (Size k = 0; k < size; ++k) dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+                dPrice_dIntermediates[size] = dPrice_dSwapRate;
+
+                std::vector<double> dPrice_market(numMarketQuotes);
+                applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                               numIntermediates, numMarketQuotes);
+
+                auto t_end = Clock::now();
+                if (recordTiming) {
+                    jit_rrs_times.push_back(Duration(t_end - t_start).count());
+                }
+            }
+
+            // =================================================================
+            // JIT Interpreter (RR) - JITGraphInterpreter with full grid
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(numDeposits);
+                std::vector<Real> swapRates(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRates);
+                tape.newRecording();
+
+                RelinkableHandle<YieldTermStructure> euriborTS;
+                auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<ext::shared_ptr<RateHelper>> instruments;
+                for (Size idx = 0; idx < numDeposits; ++idx) {
+                    auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                    instruments.push_back(ext::make_shared<DepositRateHelper>(
+                        Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                        calendar, ModifiedFollowing, true, dayCounter));
+                }
+                for (Size idx = 0; idx < numSwaps; ++idx) {
+                    auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                    instruments.push_back(ext::make_shared<SwapRateHelper>(
+                        Handle<Quote>(swapQuote), swapTenors[idx],
+                        calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                        euribor6m));
+                }
+
+                auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                    settlementDate, instruments, dayCounter);
+                yieldCurve->enableExtrapolation();
+
+                std::vector<Date> curveDates;
+                std::vector<Real> zeroRates;
+                curveDates.push_back(settlementDate);
+                zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                Date endDate = settlementDate + 6 * Years;
+                curveDates.push_back(endDate);
+                zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                std::vector<Rate> zeroRates_ql;
+                for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate_tape = fwdSwap->fairRate();
+
+                Array initRates = process->initialValues();
+
+                // Jacobian computation
+                std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+                for (Size k = 0; k < size; ++k) {
+                    if (initRates[k].shouldRecord()) {
+                        tape.clearDerivatives();
+                        tape.registerOutput(initRates[k]);
+                        derivative(initRates[k]) = 1.0;
+                        tape.computeAdjoints();
+
+                        double* jac_row = jacobian.data() + k * numMarketQuotes;
+                        for (Size m = 0; m < numDeposits; ++m)
+                            jac_row[m] = derivative(depositRates[m]);
+                        for (Size m = 0; m < numSwaps; ++m)
+                            jac_row[numDeposits + m] = derivative(swapRates[m]);
+                    }
+                }
+                if (swapRate_tape.shouldRecord()) {
+                    tape.clearDerivatives();
+                    tape.registerOutput(swapRate_tape);
+                    derivative(swapRate_tape) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + size * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates[m]);
+                }
+                tape.deactivate();
+
+                // JIT kernel creation with interpreter
+                xad::JITCompiler<double> jit;  // Default: JITGraphInterpreter
+
+                std::vector<xad::AD> jit_initRates(size);
+                xad::AD jit_swapRate;
+                std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+                for (Size k = 0; k < size; ++k) {
+                    jit_initRates[k] = xad::AD(value(initRates[k]));
+                    jit.registerInput(jit_initRates[k]);
+                }
+                jit_swapRate = xad::AD(value(swapRate_tape));
+                jit.registerInput(jit_swapRate);
+                for (Size m = 0; m < fullGridRandoms; ++m) {
+                    jit_randoms[m] = xad::AD(0.0);
+                    jit.registerInput(jit_randoms[m]);
+                }
+
+                jit.newRecording();
+
+                std::vector<xad::AD> asset_jit(size);
+                std::vector<xad::AD> assetAtExercise_jit(size);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = jit_initRates[k];
+
+                for (Size step = 1; step <= fullGridSteps; ++step) {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f) dw[f] = jit_randoms[offset + f];
+
+                    Array asset_arr(size);
+                    for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                    Array evolved = process->evolve(t, asset_arr, dt, dw);
+                    for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                    if (step == exerciseStep) {
+                        for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                    }
+                }
+
+                std::vector<xad::AD> dis_jit(size);
+                xad::AD df_jit = xad::AD(1.0);
+                for (Size k = 0; k < size; ++k) {
+                    double accrual = accrualEnd[k] - accrualStart[k];
+                    df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                    dis_jit[k] = df_jit;
+                }
+
+                xad::AD jit_npv = xad::AD(0.0);
+                for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                    double accrual = accrualEnd[m] - accrualStart[m];
+                    jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+                }
+
+                xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+                jit.registerOutput(jit_payoff);
+
+                // Compile the JIT kernel before MC loop
+                jit.compile();
+
+                // MC execution
+                double mcPrice = 0.0;
+                std::vector<double> dPrice_dInitRates(size, 0.0);
+                double dPrice_dSwapRate = 0.0;
+
+                const auto& graph = jit.getGraph();
+                uint32_t outputSlot = graph.output_ids[0];
+
+                for (Size n = 0; n < nrTrails; ++n) {
+                    for (Size k = 0; k < size; ++k) value(jit_initRates[k]) = value(initRates[k]);
+                    value(jit_swapRate) = value(swapRate_tape);
+                    for (Size m = 0; m < fullGridRandoms; ++m) value(jit_randoms[m]) = allRandoms[n][m];
+
+                    double payoff_value;
+                    jit.forward(&payoff_value);
+                    mcPrice += payoff_value;
+
+                    jit.clearDerivatives();
+                    jit.setDerivative(outputSlot, 1.0);
+                    jit.computeAdjoints();
+
+                    for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] += jit.derivative(graph.input_ids[k]);
+                    dPrice_dSwapRate += jit.derivative(graph.input_ids[size]);
+                }
+
+                mcPrice /= static_cast<double>(nrTrails);
+                for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+                dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+                // Chain rule
+                std::vector<double> dPrice_dIntermediates(numIntermediates);
+                for (Size k = 0; k < size; ++k) dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+                dPrice_dIntermediates[size] = dPrice_dSwapRate;
+
+                std::vector<double> dPrice_market(numMarketQuotes);
+                applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                               numIntermediates, numMarketQuotes);
+
+                auto t_end = Clock::now();
+                if (recordTiming) {
+                    jit_interp_times.push_back(Duration(t_end - t_start).count());
+                }
+            }
+
+            // =================================================================
+            // JIT AVX (RR) - ForgeBackendAVX with 4-path batching
+            // =================================================================
+            {
+                auto t_start = Clock::now();
+
+                using tape_type = Real::tape_type;
+                tape_type tape;
+
+                std::vector<Real> depositRates(numDeposits);
+                std::vector<Real> swapRates(numSwaps);
+                for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+                for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+                tape.registerInputs(depositRates);
+                tape.registerInputs(swapRates);
+                tape.newRecording();
+
+                RelinkableHandle<YieldTermStructure> euriborTS;
+                auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+                euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+                std::vector<ext::shared_ptr<RateHelper>> instruments;
+                for (Size idx = 0; idx < numDeposits; ++idx) {
+                    auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                    instruments.push_back(ext::make_shared<DepositRateHelper>(
+                        Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                        calendar, ModifiedFollowing, true, dayCounter));
+                }
+                for (Size idx = 0; idx < numSwaps; ++idx) {
+                    auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                    instruments.push_back(ext::make_shared<SwapRateHelper>(
+                        Handle<Quote>(swapQuote), swapTenors[idx],
+                        calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                        euribor6m));
+                }
+
+                auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                    settlementDate, instruments, dayCounter);
+                yieldCurve->enableExtrapolation();
+
+                std::vector<Date> curveDates;
+                std::vector<Real> zeroRates;
+                curveDates.push_back(settlementDate);
+                zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+                Date endDate = settlementDate + 6 * Years;
+                curveDates.push_back(endDate);
+                zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+                std::vector<Rate> zeroRates_ql;
+                for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+                RelinkableHandle<YieldTermStructure> termStructure;
+                ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+                index->addFixing(Date(2, September, 2005), 0.04);
+                termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+                ext::shared_ptr<LiborForwardModelProcess> process(
+                    new LiborForwardModelProcess(size, index));
+                process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                    new LfmCovarianceProxy(
+                        ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                        ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+                ext::shared_ptr<VanillaSwap> fwdSwap(
+                    new VanillaSwap(Swap::Receiver, 1.0,
+                                    schedule, 0.05, dayCounter,
+                                    schedule, index, 0.0, index->dayCounter()));
+                fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                    index->forwardingTermStructure()));
+                Real swapRate_tape = fwdSwap->fairRate();
+
+                Array initRates = process->initialValues();
+
+                // Jacobian computation
+                std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+                for (Size k = 0; k < size; ++k) {
+                    if (initRates[k].shouldRecord()) {
+                        tape.clearDerivatives();
+                        tape.registerOutput(initRates[k]);
+                        derivative(initRates[k]) = 1.0;
+                        tape.computeAdjoints();
+
+                        double* jac_row = jacobian.data() + k * numMarketQuotes;
+                        for (Size m = 0; m < numDeposits; ++m)
+                            jac_row[m] = derivative(depositRates[m]);
+                        for (Size m = 0; m < numSwaps; ++m)
+                            jac_row[numDeposits + m] = derivative(swapRates[m]);
+                    }
+                }
+                if (swapRate_tape.shouldRecord()) {
+                    tape.clearDerivatives();
+                    tape.registerOutput(swapRate_tape);
+                    derivative(swapRate_tape) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + size * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates[m]);
+                }
+                tape.deactivate();
+
+                // JIT kernel creation for AVX
+                xad::JITCompiler<double> jit;
+
+                std::vector<xad::AD> jit_initRates(size);
+                xad::AD jit_swapRate;
+                std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+                for (Size k = 0; k < size; ++k) {
+                    jit_initRates[k] = xad::AD(value(initRates[k]));
+                    jit.registerInput(jit_initRates[k]);
+                }
+                jit_swapRate = xad::AD(value(swapRate_tape));
+                jit.registerInput(jit_swapRate);
+                for (Size m = 0; m < fullGridRandoms; ++m) {
+                    jit_randoms[m] = xad::AD(0.0);
+                    jit.registerInput(jit_randoms[m]);
+                }
+
+                jit.newRecording();
+
+                std::vector<xad::AD> asset_jit(size);
+                std::vector<xad::AD> assetAtExercise_jit(size);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = jit_initRates[k];
+
+                for (Size step = 1; step <= fullGridSteps; ++step) {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f) dw[f] = jit_randoms[offset + f];
+
+                    Array asset_arr(size);
+                    for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                    Array evolved = process->evolve(t, asset_arr, dt, dw);
+                    for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                    if (step == exerciseStep) {
+                        for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                    }
+                }
+
+                std::vector<xad::AD> dis_jit(size);
+                xad::AD df_jit = xad::AD(1.0);
+                for (Size k = 0; k < size; ++k) {
+                    double accrual = accrualEnd[k] - accrualStart[k];
+                    df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                    dis_jit[k] = df_jit;
+                }
+
+                xad::AD jit_npv = xad::AD(0.0);
+                for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                    double accrual = accrualEnd[m] - accrualStart[m];
+                    jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+                }
+
+                xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+                jit.registerOutput(jit_payoff);
+
+                // Get the JIT graph
+                const auto& jitGraph = jit.getGraph();
+
+                // Deactivate jit - we still use it for adjoints but don't need it active
+                jit.deactivate();
+
+                // AVX backend with 4-path batching - compiles directly from JITGraph
+                xad::forge::ForgeBackendAVX<double> avxBackend(false);
+                avxBackend.compile(jitGraph);
+
+                // MC execution with 4-path batching
+                double mcPrice = 0.0;
+                std::vector<double> dPrice_dInitRates(size, 0.0);
+                double dPrice_dSwapRate = 0.0;
+
+                constexpr int BATCH_SIZE = xad::forge::ForgeBackendAVX<double>::VECTOR_WIDTH;
+                Size numBatches = (nrTrails + BATCH_SIZE - 1) / BATCH_SIZE;
+
+                std::vector<double> inputBatch(BATCH_SIZE);
+                std::vector<double> outputBatch(BATCH_SIZE);
+
+                // Pre-compute input buffer indices for gradient retrieval
+                std::vector<size_t> inputBufferIndices;
+                inputBufferIndices.reserve(avxBackend.numInputs());
+                for (auto inputId : avxBackend.inputIds()) {
+                    inputBufferIndices.push_back(avxBackend.buffer()->getBufferIndex(inputId));
+                }
+
+                for (Size batch = 0; batch < numBatches; ++batch) {
+                    Size batchStart = batch * BATCH_SIZE;
+                    Size actualBatchSize = std::min(static_cast<Size>(BATCH_SIZE), nrTrails - batchStart);
+
+                    // Set initRates (same for all paths in batch)
+                    for (Size k = 0; k < size; ++k) {
+                        for (int lane = 0; lane < BATCH_SIZE; ++lane)
+                            inputBatch[lane] = value(initRates[k]);
+                        avxBackend.setInput(k, inputBatch.data());
+                    }
+
+                    // Set swapRate (same for all paths in batch)
+                    for (int lane = 0; lane < BATCH_SIZE; ++lane)
+                        inputBatch[lane] = value(swapRate_tape);
+                    avxBackend.setInput(size, inputBatch.data());
+
+                    // Set random numbers (different for each path in batch)
+                    for (Size m = 0; m < fullGridRandoms; ++m) {
+                        for (int lane = 0; lane < BATCH_SIZE; ++lane) {
+                            Size pathIdx = batchStart + lane;
+                            inputBatch[lane] = (pathIdx < nrTrails) ? allRandoms[pathIdx][m] : 0.0;
+                        }
+                        avxBackend.setInput(size + 1 + m, inputBatch.data());
+                    }
+
+                    // Execute forward + backward in one call
+                    // Need space for: initial rates (size) + swap rate (1) + random numbers (fullGridRandoms)
+                    std::size_t numInputs = size + 1 + fullGridRandoms;
+                    std::vector<double> inputGradients(numInputs * BATCH_SIZE);
+                    avxBackend.forwardAndBackward(outputBatch.data(), inputGradients.data());
+
+                    // Accumulate MC price
+                    for (Size lane = 0; lane < actualBatchSize; ++lane) {
+                        mcPrice += outputBatch[lane];
+                    }
+
+                    // Accumulate gradients
+                    for (Size k = 0; k < size; ++k) {
+                        for (Size lane = 0; lane < actualBatchSize; ++lane) {
+                            dPrice_dInitRates[k] += inputGradients[k * BATCH_SIZE + lane];
+                        }
+                    }
+
+                    // Accumulate gradient for swap rate
+                    for (Size lane = 0; lane < actualBatchSize; ++lane) {
+                        dPrice_dSwapRate += inputGradients[size * BATCH_SIZE + lane];
+                    }
+                }
+
+                mcPrice /= static_cast<double>(nrTrails);
+                for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+                dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+                // Chain rule
+                std::vector<double> dPrice_dIntermediates(numIntermediates);
+                for (Size k = 0; k < size; ++k) dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+                dPrice_dIntermediates[size] = dPrice_dSwapRate;
+
+                std::vector<double> dPrice_market(numMarketQuotes);
+                applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                               numIntermediates, numMarketQuotes);
+
+                auto t_end = Clock::now();
+                if (recordTiming) {
+                    jit_avx_times.push_back(Duration(t_end - t_start).count());
+                }
+            }
+        }
+
+        // Compute averages
+        auto avg = [](const std::vector<double>& v) {
+            if (v.empty()) return 0.0;
+            double sum = 0.0;
+            for (double x : v) sum += x;
+            return sum / static_cast<double>(v.size());
+        };
+
+        auto stddev = [&avg](const std::vector<double>& v) {
+            if (v.size() <= 1) return 0.0;
+            double mean = avg(v);
+            double sq_sum = 0.0;
+            for (double x : v) {
+                double diff = x - mean;
+                sq_sum += diff * diff;
+            }
+            return std::sqrt(sq_sum / (v.size() - 1));
+        };
+
+        results[tc].xad_ql_total = avg(xad_ql_times);
+        results[tc].xad_rrs_total = avg(xad_rrs_times);
+        results[tc].jit_rrs_total = avg(jit_rrs_times);
+        results[tc].jit_interp_total = avg(jit_interp_times);
+        results[tc].jit_avx_total = avg(jit_avx_times);
+        results[tc].xad_ql_std = stddev(xad_ql_times);
+        results[tc].xad_rrs_std = stddev(xad_rrs_times);
+        results[tc].jit_rrs_std = stddev(jit_rrs_times);
+        results[tc].jit_interp_std = stddev(jit_interp_times);
+        results[tc].jit_avx_std = stddev(jit_avx_times);
+
+        std::cout << " Done." << std::endl;
+    }
+
+    // Print results table (compact format)
+    std::cout << std::endl;
+    std::cout << "  " << std::string(79, '=') << "\n";
+    std::cout << "  SCALING RESULTS (ms)\n";
+    std::cout << "  " << std::string(79, '=') << "\n";
+    std::cout << std::endl;
+
+    std::cout << "   Paths |   XAD(QL) |  XAD(RR) |  JIT(RR) | JIT-Intrp |   JIT-AVX | Speedup\n";
+    std::cout << "  -------+-----------+-----------+-----------+-----------+-----------+--------\n";
+
+    for (Size tc = 0; tc < pathCounts.size(); ++tc) {
+        double speedup = results[tc].xad_rrs_total / results[tc].jit_rrs_total;
+        std::cout << "  " << std::setw(6) << pathCounts[tc] << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(10) << results[tc].xad_ql_total << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(10) << results[tc].xad_rrs_total << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(10) << results[tc].jit_rrs_total << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(10) << results[tc].jit_interp_total << " |"
+                  << std::fixed << std::setprecision(1) << std::setw(10) << results[tc].jit_avx_total << " |"
+                  << std::fixed << std::setprecision(2) << std::setw(7) << speedup << "x\n";
+    }
+
+    std::cout << std::endl;
+    std::cout << "  Speedup = XAD(RR) / JIT(RR)\n";
+    std::cout << std::endl;
+    std::cout << "  STATUS: [STAGE 5 SCALING BENCHMARKS COMPLETE]\n";
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    // Basic verification
+    BOOST_CHECK(results[0].xad_ql_total > 0.0);
+    BOOST_CHECK(results[0].jit_rrs_total > 0.0);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// STAGE 6: Production-Like Configuration Benchmarks
+//////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(testStage6_ProductionLikeBenchmarks)
+{
+    BOOST_TEST_MESSAGE("Testing Stage 6: Production-Like Configuration Benchmarks...");
+
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << "  STAGE 6: PRODUCTION-LIKE CONFIGURATION BENCHMARKS\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    using Clock = std::chrono::high_resolution_clock;
+    using Duration = std::chrono::duration<double, std::milli>;
+
+    // Market data setup - PRODUCTION-LIKE CONFIGURATION
+    Calendar calendar = TARGET();
+    Date todaysDate(4, September, 2005);
+    Settings::instance().evaluationDate() = todaysDate;
+    Integer fixingDays = 2;
+    Date settlementDate = calendar.adjust(calendar.advance(todaysDate, fixingDays, Days));
+    DayCounter dayCounter = Actual360();
+
+    // Production-like: 4 deposits + 10 swaps = 14 market inputs (up to 10Y)
+    Size numDeposits = 4;
+    Size numSwaps = 10;
+    std::vector<Period> depoTenors = {1 * Days, 1 * Months, 3 * Months, 6 * Months};
+    std::vector<Period> swapTenors = {1 * Years, 2 * Years, 3 * Years, 4 * Years, 5 * Years,
+                                      6 * Years, 7 * Years, 8 * Years, 9 * Years, 10 * Years};
+
+    // Realistic deposit rates (upward sloping short end)
+    std::vector<double> depoRates_val = {0.0320, 0.0335, 0.0355, 0.0375};
+    // Realistic swap rates (upward sloping curve to 10Y)
+    std::vector<double> swapRates_val = {0.0400, 0.0435, 0.0460, 0.0480, 0.0495,
+                                         0.0505, 0.0515, 0.0522, 0.0528, 0.0532};
+
+    Size numMarketQuotes = numDeposits + numSwaps;
+
+    // LMM parameters: 20 forward rates (semi-annual to 10Y)
+    // Swaption: 5Y option into 5Y swap (exercises at 5Y, underlying matures at 10Y)
+    Size size = 20;      // Semi-annual rates to 10Y
+    Size i_opt = 10;     // Option starts at 5Y (10 × 6 months)
+    Size j_opt = 10;     // 5Y swap (10 × 6 months)
+    Size steps = 20;     // Time steps for 5Y simulation
+
+    // Build base curve and process setup - to 12Y (extra buffer for accrual periods)
+    std::vector<Rate> baseZeroRates = {0.0320, 0.0535};
+    std::vector<Date> baseDates = {settlementDate, settlementDate + 12 * Years};
+    auto baseIndex = makeIndex(baseDates, baseZeroRates);
+
+    ext::shared_ptr<LiborForwardModelProcess> baseProcess(
+        new LiborForwardModelProcess(size, baseIndex));
+    ext::shared_ptr<LmCorrelationModel> baseCorrModel(
+        new LmExponentialCorrelationModel(size, 0.5));
+    ext::shared_ptr<LmVolatilityModel> baseVolaModel(
+        new LmLinearExponentialVolatilityModel(baseProcess->fixingTimes(),
+                                               0.291, 1.483, 0.116, 0.00001));
+    baseProcess->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+        new LfmCovarianceProxy(baseVolaModel, baseCorrModel)));
+
+    // Grid and timing setup
+    std::vector<Time> fixingTimes = baseProcess->fixingTimes();
+    TimeGrid grid(fixingTimes.begin(), fixingTimes.end(), steps);
+
+    std::vector<Size> location;
+    for (Size idx = 0; idx < fixingTimes.size(); ++idx) {
+        location.push_back(
+            std::find(grid.begin(), grid.end(), fixingTimes[idx]) - grid.begin());
+    }
+
+    Size numFactors = baseProcess->factors();
+    Size exerciseStep = location[i_opt];
+    Size fullGridSteps = grid.size() - 1;
+    Size fullGridRandoms = fullGridSteps * numFactors;
+
+    // Types for MC generators
+    typedef PseudoRandom::rsg_type rsg_type;
+    typedef MultiPathGenerator<rsg_type>::sample_type sample_type;
+
+    // Get fair swap rate
+    BusinessDayConvention convention = baseIndex->businessDayConvention();
+    Date settlement = baseIndex->forwardingTermStructure()->referenceDate();
+    Date fwdStart = settlement + Period(6 * i_opt, Months);
+    Date fwdMaturity = fwdStart + Period(6 * j_opt, Months);
+
+    Schedule schedule(fwdStart, fwdMaturity, baseIndex->tenor(), calendar,
+                      convention, convention, DateGeneration::Forward, false);
+
+    // Accrual periods
+    std::vector<double> accrualStart(size), accrualEnd(size);
+    for (Size k = 0; k < size; ++k) {
+        accrualStart[k] = value(baseProcess->accrualStartTimes()[k]);
+        accrualEnd[k] = value(baseProcess->accrualEndTimes()[k]);
+    }
+
+    Size numIntermediates = size + 1;
+
+    // Helper lambda for curve building
+    auto buildCurveAndProcess = [&](const std::vector<double>& depoRates,
+                                    const std::vector<double>& swapRates,
+                                    std::vector<Date>& curveDates,
+                                    std::vector<Rate>& zeroRates) {
+        RelinkableHandle<YieldTermStructure> euriborTS;
+        auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+        euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+        std::vector<ext::shared_ptr<RateHelper>> instruments;
+        for (Size idx = 0; idx < numDeposits; ++idx) {
+            auto depoQuote = ext::make_shared<SimpleQuote>(depoRates[idx]);
+            instruments.push_back(ext::make_shared<DepositRateHelper>(
+                Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                calendar, ModifiedFollowing, true, dayCounter));
+        }
+        for (Size idx = 0; idx < numSwaps; ++idx) {
+            auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+            instruments.push_back(ext::make_shared<SwapRateHelper>(
+                Handle<Quote>(swapQuote), swapTenors[idx],
+                calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                euribor6m));
+        }
+
+        auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+            settlementDate, instruments, dayCounter);
+        yieldCurve->enableExtrapolation();
+
+        curveDates.clear();
+        zeroRates.clear();
+        curveDates.push_back(settlementDate);
+        zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+        Date endDate = settlementDate + 12 * Years;  // Extended for 10Y instrument + buffer
+        curveDates.push_back(endDate);
+        zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+    };
+
+    // Test configuration - scaling over different path counts
+    std::vector<Size> pathCounts = {10, 100, 1000, 10000};
+    Size maxPaths = pathCounts.back();
+    Size warmupIterations = 2;
+    Size benchmarkIterations = 3;
+
+    std::cout << "  Configuration (Production-Like):\n";
+    std::cout << "    - Market inputs: " << numMarketQuotes << " (" << numDeposits << " deposits + " << numSwaps << " swaps)\n";
+    std::cout << "    - Forward rates: " << size << " (semi-annual to 10Y)\n";
+    std::cout << "    - Grid steps: " << fullGridSteps << "\n";
+    std::cout << "    - MC paths: 10, 100, 1K, 10K\n";
+    std::cout << "    - Swaption: " << (i_opt/2) << "Y into " << (j_opt/2) << "Y swap (matures at " << ((i_opt+j_opt)/2) << "Y)\n";
+    std::cout << "    - Warmup iterations: " << warmupIterations << "\n";
+    std::cout << "    - Benchmark iterations: " << benchmarkIterations << "\n";
+    std::cout << std::endl;
+
+    // Pre-generate random numbers for max paths
+    std::cout << "  Generating " << maxPaths << " x " << fullGridRandoms << " random numbers..." << std::flush;
+    rsg_type rsg_base = PseudoRandom::make_sequence_generator(fullGridRandoms, BigNatural(42));
+    std::vector<std::vector<double>> allRandoms(maxPaths);
+    for (Size n = 0; n < maxPaths; ++n) {
+        allRandoms[n].resize(fullGridRandoms);
+        const auto& seq = rsg_base.nextSequence();
+        for (Size m = 0; m < fullGridRandoms; ++m) {
+            allRandoms[n][m] = value(seq.value[m]);
+        }
+    }
+    std::cout << " Done." << std::endl;
+
+    // Results storage for scaling table
+    struct ScalingResult {
+        double xad_time;
+        double jit_time;
+        double jit_avx_time;
+    };
+    std::vector<ScalingResult> scalingResults(pathCounts.size());
+
+    // Store final prices/derivs from largest path count
+    double xad_price = 0.0, jit_price = 0.0, jit_avx_price = 0.0;
+    std::vector<double> xad_derivs, jit_derivs, jit_avx_derivs;
+
+    // Run benchmarks for each path count
+    for (Size pathIdx = 0; pathIdx < pathCounts.size(); ++pathIdx) {
+        Size nrTrails = pathCounts[pathIdx];
+        std::cout << "\n  --- Running with " << nrTrails << " paths ---\n";
+
+        // Timing accumulators for this path count
+        std::vector<double> xad_rrs_times, jit_rrs_times, jit_avx_times;
+
+        for (Size iter = 0; iter < warmupIterations + benchmarkIterations; ++iter) {
+            bool recordTiming = (iter >= warmupIterations);
+            bool isLast = (iter == warmupIterations + benchmarkIterations - 1) &&
+                          (pathIdx == pathCounts.size() - 1);  // Only save details for largest path count
+
+            std::cout << "  [" << (iter < warmupIterations ? "Warmup" : "Bench") << " "
+                      << (iter < warmupIterations ? iter + 1 : iter - warmupIterations + 1) << "/"
+                      << (iter < warmupIterations ? warmupIterations : benchmarkIterations) << "] ";
+
+        // =================================================================
+        // XAD (RR) - Full grid with XAD tape (with granular timing)
+        // =================================================================
+        std::cout << "XAD..." << std::flush;
+        {
+            auto t_start = Clock::now();
+            auto t_phase = Clock::now();
+
+            // Phase timing accumulators (only for last iteration)
+            double t_bootstrap_fwd = 0, t_mc_fwd = 0, t_backward = 0;
+
+            using tape_type = Real::tape_type;
+            tape_type tape;
+
+            std::vector<Real> depositRates(numDeposits);
+            std::vector<Real> swapRates(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+            tape.registerInputs(depositRates);
+            tape.registerInputs(swapRates);
+            tape.newRecording();
+
+            RelinkableHandle<YieldTermStructure> euriborTS;
+            auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+            euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                instruments.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                instruments.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m));
+            }
+
+            auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments, dayCounter);
+            yieldCurve->enableExtrapolation();
+
+            std::vector<Date> curveDates;
+            std::vector<Real> zeroRates;
+            curveDates.push_back(settlementDate);
+            zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate = settlementDate + 12 * Years;  // Extended for 10Y instrument + buffer
+            curveDates.push_back(endDate);
+            zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates_ql;
+            for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure;
+            ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+            index->addFixing(Date(2, September, 2005), 0.04);
+            termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process(
+                new LiborForwardModelProcess(size, index));
+            process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(
+                    ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                    ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index, 0.0, index->dayCounter()));
+            fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index->forwardingTermStructure()));
+            Real swapRate = fwdSwap->fairRate();
+
+            Array initRates = process->initialValues();
+
+            if (isLast) {
+                t_bootstrap_fwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // MC pricing with full grid
+            Real price = Real(0.0);
+            for (Size n = 0; n < nrTrails; ++n) {
+                Array asset(size);
+                for (Size k = 0; k < size; ++k) asset[k] = initRates[k];
+
+                Array assetAtExercise(size);
+                for (Size step = 1; step <= fullGridSteps; ++step) {
+                    Size offset = (step - 1) * numFactors;
+                    Time t = grid[step - 1];
+                    Time dt = grid.dt(step - 1);
+
+                    Array dw(numFactors);
+                    for (Size f = 0; f < numFactors; ++f)
+                        dw[f] = Real(allRandoms[n][offset + f]);
+
+                    asset = process->evolve(t, asset, dt, dw);
+
+                    if (step == exerciseStep) {
+                        for (Size k = 0; k < size; ++k) assetAtExercise[k] = asset[k];
+                    }
+                }
+
+                Array dis(size);
+                Real df = Real(1.0);
+                for (Size k = 0; k < size; ++k) {
+                    Real accrual = accrualEnd[k] - accrualStart[k];
+                    df = df / (Real(1.0) + assetAtExercise[k] * accrual);
+                    dis[k] = df;
+                }
+
+                Real npv = Real(0.0);
+                for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                    Real accrual = accrualEnd[m] - accrualStart[m];
+                    npv += (swapRate - assetAtExercise[m]) * accrual * dis[m];
+                }
+                price += max(npv, Real(0.0));
+            }
+            price /= Real(static_cast<double>(nrTrails));
+
+            if (isLast) {
+                t_mc_fwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            tape.registerOutput(price);
+            derivative(price) = 1.0;
+            tape.computeAdjoints();
+
+            if (isLast) {
+                t_backward = Duration(Clock::now() - t_phase).count();
+
+                // Report XAD timing breakdown
+                std::cout << "\n    [XAD Details: " << tape.getNumStatements() << " tape statements]\n";
+                std::cout << "      Bootstrap fwd:   " << std::fixed << std::setprecision(1) << t_bootstrap_fwd << " ms\n";
+                std::cout << "      MC fwd (" << nrTrails << " paths): " << std::fixed << std::setprecision(1) << t_mc_fwd << " ms\n";
+                std::cout << "      Backward:        " << std::fixed << std::setprecision(1) << t_backward << " ms\n";
+
+                xad_price = value(price);
+                xad_derivs.resize(numMarketQuotes);
+                for (Size m = 0; m < numDeposits; ++m)
+                    xad_derivs[m] = derivative(depositRates[m]);
+                for (Size m = 0; m < numSwaps; ++m)
+                    xad_derivs[numDeposits + m] = derivative(swapRates[m]);
+            }
+
+            auto t_end = Clock::now();
+            if (recordTiming) {
+                xad_rrs_times.push_back(Duration(t_end - t_start).count());
+            }
+            tape.deactivate();
+        }
+
+        // =================================================================
+        // JIT (RR) - Full grid with JIT compilation (with granular timing)
+        // =================================================================
+        std::cout << " JIT..." << std::flush;
+        {
+            auto t_start = Clock::now();
+            auto t_phase = Clock::now();
+
+            // Phase timing accumulators (only for last iteration to avoid overhead)
+            double t_bootstrap_fwd = 0, t_bootstrap_bwd = 0, t_kernel_record = 0;
+            double t_kernel_compile = 0, t_mc_exec = 0, t_chain_rule = 0;
+
+            using tape_type = Real::tape_type;
+            tape_type tape;
+
+            std::vector<Real> depositRates(numDeposits);
+            std::vector<Real> swapRates(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+            tape.registerInputs(depositRates);
+            tape.registerInputs(swapRates);
+            tape.newRecording();
+
+            RelinkableHandle<YieldTermStructure> euriborTS;
+            auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+            euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                instruments.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                instruments.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m));
+            }
+
+            auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments, dayCounter);
+            yieldCurve->enableExtrapolation();
+
+            std::vector<Date> curveDates;
+            std::vector<Real> zeroRates;
+            curveDates.push_back(settlementDate);
+            zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate = settlementDate + 12 * Years;  // Extended for 10Y instrument + buffer
+            curveDates.push_back(endDate);
+            zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates_ql;
+            for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure;
+            ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+            index->addFixing(Date(2, September, 2005), 0.04);
+            termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process(
+                new LiborForwardModelProcess(size, index));
+            process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(
+                    ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                    ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index, 0.0, index->dayCounter()));
+            fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index->forwardingTermStructure()));
+            Real swapRate_tape = fwdSwap->fairRate();
+
+            Array initRates = process->initialValues();
+
+            if (isLast) {
+                t_bootstrap_fwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // Jacobian computation (bootstrap backward)
+            std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+            for (Size k = 0; k < size; ++k) {
+                if (initRates[k].shouldRecord()) {
+                    tape.clearDerivatives();
+                    tape.registerOutput(initRates[k]);
+                    derivative(initRates[k]) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + k * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates[m]);
+                }
+            }
+            if (swapRate_tape.shouldRecord()) {
+                tape.clearDerivatives();
+                tape.registerOutput(swapRate_tape);
+                derivative(swapRate_tape) = 1.0;
+                tape.computeAdjoints();
+
+                double* jac_row = jacobian.data() + size * numMarketQuotes;
+                for (Size m = 0; m < numDeposits; ++m)
+                    jac_row[m] = derivative(depositRates[m]);
+                for (Size m = 0; m < numSwaps; ++m)
+                    jac_row[numDeposits + m] = derivative(swapRates[m]);
+            }
+            tape.deactivate();
+
+            if (isLast) {
+                t_bootstrap_bwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // JIT kernel creation (recording)
+            auto forgeBackend = std::make_unique<xad::forge::ForgeBackend<double>>(false);
+            xad::JITCompiler<double> jit(std::move(forgeBackend));
+
+            std::vector<xad::AD> jit_initRates(size);
+            xad::AD jit_swapRate;
+            std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+            for (Size k = 0; k < size; ++k) {
+                jit_initRates[k] = xad::AD(value(initRates[k]));
+                jit.registerInput(jit_initRates[k]);
+            }
+            jit_swapRate = xad::AD(value(swapRate_tape));
+            jit.registerInput(jit_swapRate);
+            for (Size m = 0; m < fullGridRandoms; ++m) {
+                jit_randoms[m] = xad::AD(0.0);
+                jit.registerInput(jit_randoms[m]);
+            }
+
+            jit.newRecording();
+
+            std::vector<xad::AD> asset_jit(size);
+            std::vector<xad::AD> assetAtExercise_jit(size);
+            for (Size k = 0; k < size; ++k) asset_jit[k] = jit_initRates[k];
+
+            for (Size step = 1; step <= fullGridSteps; ++step) {
+                Size offset = (step - 1) * numFactors;
+                Time t = grid[step - 1];
+                Time dt = grid.dt(step - 1);
+
+                Array dw(numFactors);
+                for (Size f = 0; f < numFactors; ++f) dw[f] = jit_randoms[offset + f];
+
+                Array asset_arr(size);
+                for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                Array evolved = process->evolve(t, asset_arr, dt, dw);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                if (step == exerciseStep) {
+                    for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                }
+            }
+
+            std::vector<xad::AD> dis_jit(size);
+            xad::AD df_jit = xad::AD(1.0);
+            for (Size k = 0; k < size; ++k) {
+                double accrual = accrualEnd[k] - accrualStart[k];
+                df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                dis_jit[k] = df_jit;
+            }
+
+            xad::AD jit_npv = xad::AD(0.0);
+            for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                double accrual = accrualEnd[m] - accrualStart[m];
+                jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+            }
+
+            xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+            jit.registerOutput(jit_payoff);
+
+            if (isLast) {
+                t_kernel_record = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // Compile the JIT kernel
+            jit.compile();
+
+            if (isLast) {
+                t_kernel_compile = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // MC execution
+            double mcPrice = 0.0;
+            std::vector<double> dPrice_dInitRates(size, 0.0);
+            double dPrice_dSwapRate = 0.0;
+
+            const auto& graph = jit.getGraph();
+            uint32_t outputSlot = graph.output_ids[0];
+
+            for (Size n = 0; n < nrTrails; ++n) {
+                for (Size k = 0; k < size; ++k) value(jit_initRates[k]) = value(initRates[k]);
+                value(jit_swapRate) = value(swapRate_tape);
+                for (Size m = 0; m < fullGridRandoms; ++m) value(jit_randoms[m]) = allRandoms[n][m];
+
+                double payoff_value;
+                jit.forward(&payoff_value);
+                mcPrice += payoff_value;
+
+                jit.clearDerivatives();
+                jit.setDerivative(outputSlot, 1.0);
+                jit.computeAdjoints();
+
+                for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] += jit.derivative(graph.input_ids[k]);
+                dPrice_dSwapRate += jit.derivative(graph.input_ids[size]);
+            }
+
+            mcPrice /= static_cast<double>(nrTrails);
+            for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+            dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+            if (isLast) {
+                t_mc_exec = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // Chain rule
+            std::vector<double> dPrice_dIntermediates(numIntermediates);
+            for (Size k = 0; k < size; ++k) dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+            dPrice_dIntermediates[size] = dPrice_dSwapRate;
+
+            std::vector<double> dPrice_market(numMarketQuotes);
+            applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                           numIntermediates, numMarketQuotes);
+
+            if (isLast) {
+                t_chain_rule = Duration(Clock::now() - t_phase).count();
+
+                // Report graph size and timing breakdown
+                std::cout << "\n    [JIT Details: " << graph.nodeCount() << " nodes, "
+                          << graph.input_ids.size() << " inputs]\n";
+                std::cout << "      Bootstrap fwd:   " << std::fixed << std::setprecision(1) << t_bootstrap_fwd << " ms\n";
+                std::cout << "      Bootstrap bwd:   " << std::fixed << std::setprecision(1) << t_bootstrap_bwd << " ms\n";
+                std::cout << "      Kernel record:   " << std::fixed << std::setprecision(1) << t_kernel_record << " ms\n";
+                std::cout << "      Kernel compile:  " << std::fixed << std::setprecision(1) << t_kernel_compile << " ms\n";
+                std::cout << "      MC exec (" << nrTrails << " paths): " << std::fixed << std::setprecision(1) << t_mc_exec << " ms\n";
+                std::cout << "      Chain rule:      " << std::fixed << std::setprecision(1) << t_chain_rule << " ms\n";
+
+                jit_price = mcPrice;
+                jit_derivs = dPrice_market;
+            }
+
+            auto t_end = Clock::now();
+            if (recordTiming) {
+                jit_rrs_times.push_back(Duration(t_end - t_start).count());
+            }
+        }
+
+        // =================================================================
+        // JIT AVX (RR) - ForgeBackendAVX with 4-path batching (with granular timing)
+        // =================================================================
+        std::cout << " JIT-AVX..." << std::flush;
+        {
+            auto t_start = Clock::now();
+            auto t_phase = Clock::now();
+
+            // Phase timing accumulators (only for last iteration)
+            double t_bootstrap_fwd = 0, t_bootstrap_bwd = 0, t_kernel_record = 0;
+            double t_kernel_compile = 0, t_mc_exec = 0, t_chain_rule = 0;
+
+            using tape_type = Real::tape_type;
+            tape_type tape;
+
+            std::vector<Real> depositRates(numDeposits);
+            std::vector<Real> swapRates(numSwaps);
+            for (Size idx = 0; idx < numDeposits; ++idx) depositRates[idx] = depoRates_val[idx];
+            for (Size idx = 0; idx < numSwaps; ++idx) swapRates[idx] = swapRates_val[idx];
+
+            tape.registerInputs(depositRates);
+            tape.registerInputs(swapRates);
+            tape.newRecording();
+
+            RelinkableHandle<YieldTermStructure> euriborTS;
+            auto euribor6m = ext::make_shared<Euribor6M>(euriborTS);
+            euribor6m->addFixing(Date(2, September, 2005), 0.04);
+
+            std::vector<ext::shared_ptr<RateHelper>> instruments;
+            for (Size idx = 0; idx < numDeposits; ++idx) {
+                auto depoQuote = ext::make_shared<SimpleQuote>(depositRates[idx]);
+                instruments.push_back(ext::make_shared<DepositRateHelper>(
+                    Handle<Quote>(depoQuote), depoTenors[idx], fixingDays,
+                    calendar, ModifiedFollowing, true, dayCounter));
+            }
+            for (Size idx = 0; idx < numSwaps; ++idx) {
+                auto swapQuote = ext::make_shared<SimpleQuote>(swapRates[idx]);
+                instruments.push_back(ext::make_shared<SwapRateHelper>(
+                    Handle<Quote>(swapQuote), swapTenors[idx],
+                    calendar, Annual, Unadjusted, Thirty360(Thirty360::BondBasis),
+                    euribor6m));
+            }
+
+            auto yieldCurve = ext::make_shared<PiecewiseYieldCurve<ZeroYield, Linear>>(
+                settlementDate, instruments, dayCounter);
+            yieldCurve->enableExtrapolation();
+
+            std::vector<Date> curveDates;
+            std::vector<Real> zeroRates;
+            curveDates.push_back(settlementDate);
+            zeroRates.push_back(yieldCurve->zeroRate(settlementDate, dayCounter, Continuous).rate());
+            Date endDate = settlementDate + 12 * Years;  // Extended for 10Y instrument + buffer
+            curveDates.push_back(endDate);
+            zeroRates.push_back(yieldCurve->zeroRate(endDate, dayCounter, Continuous).rate());
+
+            std::vector<Rate> zeroRates_ql;
+            for (const auto& r : zeroRates) zeroRates_ql.push_back(r);
+
+            RelinkableHandle<YieldTermStructure> termStructure;
+            ext::shared_ptr<IborIndex> index(new Euribor6M(termStructure));
+            index->addFixing(Date(2, September, 2005), 0.04);
+            termStructure.linkTo(ext::make_shared<ZeroCurve>(curveDates, zeroRates_ql, dayCounter));
+
+            ext::shared_ptr<LiborForwardModelProcess> process(
+                new LiborForwardModelProcess(size, index));
+            process->setCovarParam(ext::shared_ptr<LfmCovarianceParameterization>(
+                new LfmCovarianceProxy(
+                    ext::make_shared<LmLinearExponentialVolatilityModel>(process->fixingTimes(), 0.291, 1.483, 0.116, 0.00001),
+                    ext::make_shared<LmExponentialCorrelationModel>(size, 0.5))));
+
+            ext::shared_ptr<VanillaSwap> fwdSwap(
+                new VanillaSwap(Swap::Receiver, 1.0,
+                                schedule, 0.05, dayCounter,
+                                schedule, index, 0.0, index->dayCounter()));
+            fwdSwap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(
+                index->forwardingTermStructure()));
+            Real swapRate_tape = fwdSwap->fairRate();
+
+            Array initRates = process->initialValues();
+
+            if (isLast) {
+                t_bootstrap_fwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // Jacobian computation
+            std::vector<double> jacobian(numIntermediates * numMarketQuotes, 0.0);
+            for (Size k = 0; k < size; ++k) {
+                if (initRates[k].shouldRecord()) {
+                    tape.clearDerivatives();
+                    tape.registerOutput(initRates[k]);
+                    derivative(initRates[k]) = 1.0;
+                    tape.computeAdjoints();
+
+                    double* jac_row = jacobian.data() + k * numMarketQuotes;
+                    for (Size m = 0; m < numDeposits; ++m)
+                        jac_row[m] = derivative(depositRates[m]);
+                    for (Size m = 0; m < numSwaps; ++m)
+                        jac_row[numDeposits + m] = derivative(swapRates[m]);
+                }
+            }
+            if (swapRate_tape.shouldRecord()) {
+                tape.clearDerivatives();
+                tape.registerOutput(swapRate_tape);
+                derivative(swapRate_tape) = 1.0;
+                tape.computeAdjoints();
+
+                double* jac_row = jacobian.data() + size * numMarketQuotes;
+                for (Size m = 0; m < numDeposits; ++m)
+                    jac_row[m] = derivative(depositRates[m]);
+                for (Size m = 0; m < numSwaps; ++m)
+                    jac_row[numDeposits + m] = derivative(swapRates[m]);
+            }
+            tape.deactivate();
+
+            if (isLast) {
+                t_bootstrap_bwd = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // JIT kernel creation for AVX
+            xad::JITCompiler<double> jit;
+
+            std::vector<xad::AD> jit_initRates(size);
+            xad::AD jit_swapRate;
+            std::vector<xad::AD> jit_randoms(fullGridRandoms);
+
+            for (Size k = 0; k < size; ++k) {
+                jit_initRates[k] = xad::AD(value(initRates[k]));
+                jit.registerInput(jit_initRates[k]);
+            }
+            jit_swapRate = xad::AD(value(swapRate_tape));
+            jit.registerInput(jit_swapRate);
+            for (Size m = 0; m < fullGridRandoms; ++m) {
+                jit_randoms[m] = xad::AD(0.0);
+                jit.registerInput(jit_randoms[m]);
+            }
+
+            jit.newRecording();
+
+            std::vector<xad::AD> asset_jit(size);
+            std::vector<xad::AD> assetAtExercise_jit(size);
+            for (Size k = 0; k < size; ++k) asset_jit[k] = jit_initRates[k];
+
+            for (Size step = 1; step <= fullGridSteps; ++step) {
+                Size offset = (step - 1) * numFactors;
+                Time t = grid[step - 1];
+                Time dt = grid.dt(step - 1);
+
+                Array dw(numFactors);
+                for (Size f = 0; f < numFactors; ++f) dw[f] = jit_randoms[offset + f];
+
+                Array asset_arr(size);
+                for (Size k = 0; k < size; ++k) asset_arr[k] = asset_jit[k];
+
+                Array evolved = process->evolve(t, asset_arr, dt, dw);
+                for (Size k = 0; k < size; ++k) asset_jit[k] = evolved[k];
+
+                if (step == exerciseStep) {
+                    for (Size k = 0; k < size; ++k) assetAtExercise_jit[k] = asset_jit[k];
+                }
+            }
+
+            std::vector<xad::AD> dis_jit(size);
+            xad::AD df_jit = xad::AD(1.0);
+            for (Size k = 0; k < size; ++k) {
+                double accrual = accrualEnd[k] - accrualStart[k];
+                df_jit = df_jit / (xad::AD(1.0) + assetAtExercise_jit[k] * accrual);
+                dis_jit[k] = df_jit;
+            }
+
+            xad::AD jit_npv = xad::AD(0.0);
+            for (Size m = i_opt; m < i_opt + j_opt; ++m) {
+                double accrual = accrualEnd[m] - accrualStart[m];
+                jit_npv = jit_npv + (jit_swapRate - assetAtExercise_jit[m]) * accrual * dis_jit[m];
+            }
+
+            xad::AD jit_payoff = xad::less(jit_npv, xad::AD(0.0)).If(xad::AD(0.0), jit_npv);
+            jit.registerOutput(jit_payoff);
+
+            if (isLast) {
+                t_kernel_record = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // Get the JIT graph
+            const auto& jitGraph = jit.getGraph();
+            jit.deactivate();
+
+            // AVX backend with 4-path batching
+            xad::forge::ForgeBackendAVX<double> avxBackend(false);
+            avxBackend.compile(jitGraph);
+
+            if (isLast) {
+                t_kernel_compile = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // MC execution with 4-path batching
+            double mcPrice = 0.0;
+            std::vector<double> dPrice_dInitRates(size, 0.0);
+            double dPrice_dSwapRate = 0.0;
+
+            constexpr int BATCH_SIZE = xad::forge::ForgeBackendAVX<double>::VECTOR_WIDTH;
+            Size numBatches = (nrTrails + BATCH_SIZE - 1) / BATCH_SIZE;
+
+            std::vector<double> inputBatch(BATCH_SIZE);
+            std::vector<double> outputBatch(BATCH_SIZE);
+
+            // Pre-compute input buffer indices
+            std::vector<size_t> inputBufferIndices;
+            inputBufferIndices.reserve(avxBackend.numInputs());
+            for (auto inputId : avxBackend.inputIds()) {
+                inputBufferIndices.push_back(avxBackend.buffer()->getBufferIndex(inputId));
+            }
+
+            for (Size batch = 0; batch < numBatches; ++batch) {
+                Size batchStart = batch * BATCH_SIZE;
+                Size actualBatchSize = std::min(static_cast<Size>(BATCH_SIZE), nrTrails - batchStart);
+
+                // Set initRates
+                for (Size k = 0; k < size; ++k) {
+                    for (int lane = 0; lane < BATCH_SIZE; ++lane)
+                        inputBatch[lane] = value(initRates[k]);
+                    avxBackend.setInput(k, inputBatch.data());
+                }
+
+                // Set swapRate
+                for (int lane = 0; lane < BATCH_SIZE; ++lane)
+                    inputBatch[lane] = value(swapRate_tape);
+                avxBackend.setInput(size, inputBatch.data());
+
+                // Set random numbers
+                for (Size m = 0; m < fullGridRandoms; ++m) {
+                    for (int lane = 0; lane < BATCH_SIZE; ++lane) {
+                        Size pathIdx = batchStart + lane;
+                        inputBatch[lane] = (pathIdx < nrTrails) ? allRandoms[pathIdx][m] : 0.0;
+                    }
+                    avxBackend.setInput(size + 1 + m, inputBatch.data());
+                }
+
+                // Execute forward + backward
+                std::size_t numInputs = size + 1 + fullGridRandoms;
+                std::vector<double> inputGradients(numInputs * BATCH_SIZE);
+                avxBackend.forwardAndBackward(outputBatch.data(), inputGradients.data());
+
+                // Accumulate MC price
+                for (Size lane = 0; lane < actualBatchSize; ++lane) {
+                    mcPrice += outputBatch[lane];
+                }
+
+                // Accumulate gradients
+                for (Size k = 0; k < size; ++k) {
+                    for (Size lane = 0; lane < actualBatchSize; ++lane) {
+                        dPrice_dInitRates[k] += inputGradients[k * BATCH_SIZE + lane];
+                    }
+                }
+
+                for (Size lane = 0; lane < actualBatchSize; ++lane) {
+                    dPrice_dSwapRate += inputGradients[size * BATCH_SIZE + lane];
+                }
+            }
+
+            mcPrice /= static_cast<double>(nrTrails);
+            for (Size k = 0; k < size; ++k) dPrice_dInitRates[k] /= static_cast<double>(nrTrails);
+            dPrice_dSwapRate /= static_cast<double>(nrTrails);
+
+            if (isLast) {
+                t_mc_exec = Duration(Clock::now() - t_phase).count();
+                t_phase = Clock::now();
+            }
+
+            // Chain rule
+            std::vector<double> dPrice_dIntermediates(numIntermediates);
+            for (Size k = 0; k < size; ++k) dPrice_dIntermediates[k] = dPrice_dInitRates[k];
+            dPrice_dIntermediates[size] = dPrice_dSwapRate;
+
+            std::vector<double> dPrice_market(numMarketQuotes);
+            applyChainRule(jacobian.data(), dPrice_dIntermediates.data(), dPrice_market.data(),
+                           numIntermediates, numMarketQuotes);
+
+            if (isLast) {
+                t_chain_rule = Duration(Clock::now() - t_phase).count();
+
+                // Report timing breakdown for JIT-AVX
+                std::cout << "\n    [JIT-AVX Details: " << jitGraph.nodeCount() << " nodes]\n";
+                std::cout << "      Bootstrap fwd:   " << std::fixed << std::setprecision(1) << t_bootstrap_fwd << " ms\n";
+                std::cout << "      Bootstrap bwd:   " << std::fixed << std::setprecision(1) << t_bootstrap_bwd << " ms\n";
+                std::cout << "      Kernel record:   " << std::fixed << std::setprecision(1) << t_kernel_record << " ms\n";
+                std::cout << "      Kernel compile:  " << std::fixed << std::setprecision(1) << t_kernel_compile << " ms\n";
+                std::cout << "      MC exec (" << nrTrails << " paths): " << std::fixed << std::setprecision(1) << t_mc_exec << " ms\n";
+                std::cout << "      Chain rule:      " << std::fixed << std::setprecision(1) << t_chain_rule << " ms\n";
+
+                jit_avx_price = mcPrice;
+                jit_avx_derivs = dPrice_market;
+            }
+
+            auto t_end = Clock::now();
+            if (recordTiming) {
+                jit_avx_times.push_back(Duration(t_end - t_start).count());
+            }
+        }
+
+        std::cout << " Done." << std::endl;
+        }  // end iteration loop
+
+        // Compute averages for this path count
+        auto avg = [](const std::vector<double>& v) {
+            if (v.empty()) return 0.0;
+            double sum = 0.0;
+            for (double x : v) sum += x;
+            return sum / static_cast<double>(v.size());
+        };
+
+        scalingResults[pathIdx].xad_time = avg(xad_rrs_times);
+        scalingResults[pathIdx].jit_time = avg(jit_rrs_times);
+        scalingResults[pathIdx].jit_avx_time = avg(jit_avx_times);
+
+        std::cout << "    Avg times: XAD=" << std::fixed << std::setprecision(1) << scalingResults[pathIdx].xad_time
+                  << "ms, JIT=" << scalingResults[pathIdx].jit_time
+                  << "ms, JIT-AVX=" << scalingResults[pathIdx].jit_avx_time << "ms\n";
+    }  // end path count loop
+
+    // Print scaling table
+    std::cout << std::endl;
+    std::cout << "  " << std::string(79, '=') << "\n";
+    std::cout << "  PRODUCTION-LIKE BENCHMARK RESULTS (5Y into 5Y Swaption, 10Y total)\n";
+    std::cout << "  " << std::string(79, '=') << "\n";
+    std::cout << std::endl;
+
+    std::cout << "  SCALING TABLE (times in ms):\n";
+    std::cout << "    " << std::setw(8) << "Paths" << " | " << std::setw(10) << "XAD"
+              << " | " << std::setw(10) << "JIT" << " | " << std::setw(10) << "JIT-AVX"
+              << " | " << std::setw(10) << "Speedup" << "\n";
+    std::cout << "    " << std::string(58, '-') << "\n";
+    for (Size i = 0; i < pathCounts.size(); ++i) {
+        std::string pathStr;
+        if (pathCounts[i] >= 1000) pathStr = std::to_string(pathCounts[i]/1000) + "K";
+        else pathStr = std::to_string(pathCounts[i]);
+
+        double speedup = scalingResults[i].xad_time / scalingResults[i].jit_avx_time;
+        std::cout << "    " << std::setw(8) << pathStr << " | "
+                  << std::fixed << std::setprecision(1) << std::setw(10) << scalingResults[i].xad_time << " | "
+                  << std::fixed << std::setprecision(1) << std::setw(10) << scalingResults[i].jit_time << " | "
+                  << std::fixed << std::setprecision(1) << std::setw(10) << scalingResults[i].jit_avx_time << " | "
+                  << std::fixed << std::setprecision(2) << std::setw(9) << speedup << "x\n";
+    }
+    std::cout << std::endl;
+
+    std::cout << "  MC PRICE COMPARISON (10K paths):\n";
+    std::cout << "    XAD:     " << std::fixed << std::setprecision(8) << xad_price << "\n";
+    std::cout << "    JIT:     " << std::fixed << std::setprecision(8) << jit_price << "\n";
+    std::cout << "    JIT-AVX: " << std::fixed << std::setprecision(8) << jit_avx_price << "\n";
+    std::cout << std::endl;
+
+    std::cout << "  DERIVATIVE COMPARISON (first 5 market quotes, 10K paths):\n";
+    std::cout << "    " << std::setw(12) << "Quote" << " | " << std::setw(14) << "XAD" << " | "
+              << std::setw(14) << "JIT" << " | " << std::setw(14) << "JIT-AVX" << "\n";
+    std::cout << "    " << std::string(60, '-') << "\n";
+    for (Size i = 0; i < std::min(Size(5), numMarketQuotes); ++i) {
+        std::string label = (i < numDeposits) ? "Depo " + std::to_string(i) : "Swap " + std::to_string(i - numDeposits);
+        std::cout << "    " << std::setw(12) << label << " | "
+                  << std::scientific << std::setprecision(4) << std::setw(14) << xad_derivs[i] << " | "
+                  << std::scientific << std::setprecision(4) << std::setw(14) << jit_derivs[i] << " | "
+                  << std::scientific << std::setprecision(4) << std::setw(14) << jit_avx_derivs[i] << "\n";
+    }
+    std::cout << std::endl;
+
+    // Final speedup summary
+    double final_speedup_jit = scalingResults.back().xad_time / scalingResults.back().jit_time;
+    double final_speedup_avx = scalingResults.back().xad_time / scalingResults.back().jit_avx_time;
+    std::cout << "  SPEEDUP vs XAD (10K paths):\n";
+    std::cout << "    JIT:     " << std::fixed << std::setprecision(2) << final_speedup_jit << "x\n";
+    std::cout << "    JIT-AVX: " << std::fixed << std::setprecision(2) << final_speedup_avx << "x\n";
+    std::cout << std::endl;
+
+    std::cout << "  STATUS: [STAGE 6 PRODUCTION-LIKE BENCHMARKS COMPLETE]\n";
+    std::cout << "\n";
+    std::cout << "=============================================================================\n";
+    std::cout << std::endl;
+
+    // Verification
+    double price_diff = std::abs(xad_price - jit_price);
+    BOOST_CHECK_SMALL(price_diff, 1e-10);
+    BOOST_CHECK(scalingResults.back().xad_time > 0.0);
+    BOOST_CHECK(scalingResults.back().jit_time > 0.0);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
+