Merge pull request #5902 from wxpppp/develop

LoongArch64: avoid SGEMM LA464 ncopy fallthrough from N2 to N1
Merge pull request #5898 from moluopro/develop
2026-07-12 01:11:37 +02:00 · 2026-07-11 10:52:51 +02:00 · 2026-07-09 20:53:05 +08:00 · 2026-07-09 11:12:58 +02:00 · 2026-07-09 09:50:42 +02:00 · 2026-07-09 13:44:29 +08:00
1814 changed files with 91238 additions and 49611 deletions
@@ -1,6 +1,6 @@
-macos_instance:
-  image: ghcr.io/cirruslabs/macos-monterey-xcode:latest
-
+#macos_instance:
+#  image: ghcr.io/cirruslabs/macos-monterey-xcode:latest
+#
 #task:
 #  name: AppleM1/LLVM
 #  compile_script:
@@ -9,7 +9,7 @@ macos_instance:
 #  - export LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
 #  - export CPPFLAGS="-I/opt/homebrew/opt/llvm/include"
 #  - make TARGET=VORTEX USE_OPENMP=1 CC=clang
-
+#
 #task:
 #  name: AppleM1/LLVM/ILP64
 #  compile_script:
@@ -18,7 +18,7 @@ macos_instance:
 #  - export LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
 #  - export CPPFLAGS="-I/opt/homebrew/opt/llvm/include"
 #  - make TARGET=VORTEX USE_OPENMP=1 CC=clang INTERFACE64=1
-
+#
 #task:
 #  name: AppleM1/LLVM/CMAKE
 #  compile_script:
@@ -30,7 +30,7 @@ macos_instance:
 #  - cd build
 #  - cmake -DTARGET=VORTEX -DCMAKE_C_COMPILER=clang -DBUILD_SHARED_LIBS=ON ..
 #  - make -j 4
-
+#
 #task:
 #  name: AppleM1/GCC/MAKE/OPENMP
 #  compile_script:
@@ -39,122 +39,125 @@ macos_instance:
 #  - export LDFLAGS="-L/opt/homebrew/lib"
 #  - export CPPFLAGS="-I/opt/homebrew/include"
 #  - make CC=gcc-11 FC=gfortran-11 USE_OPENMP=1
-  
-macos_instance:
-  image: ghcr.io/cirruslabs/macos-sonoma-xcode:latest
-task:
-  name: AppleM1/LLVM x86_64 xbuild
-  compile_script:
-  - #brew install llvm
-  - export #PATH=/opt/homebrew/opt/llvm/bin:$PATH
-  - export #LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
-  - export #CPPFLAGS="-I/opt/homebrew/opt/llvm/include" 
-  - export ARCHS="i386 x86_64"
-  - export ARCHS_STANDARD="i386 x86_64"
-  - export ARCHS_STANDARD_32_64_BIT="i386 x86_64"
-  - export ARCHS_STANDARD_64_BIT=x86_64
-  - export ARCHS_STANDARD_INCLUDING_64_BIT="i386 x86_64"
-  - export ARCHS_UNIVERSAL_IPHONE_OS="i386 x86_64"
-  - export VALID_ARCHS="i386 x86_64"
-  - xcrun --sdk macosx --show-sdk-path
-  - xcodebuild -version
-  - export CC=/Applications/Xcode_16.3.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-  - export CFLAGS="-O2 -unwindlib=none -Wno-macro-redefined -isysroot /Applications/Xcode_16.3.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX15.4.sdk -arch x86_64"
-  - make TARGET=CORE2 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1 RANLIB="ls -l"
-  always:
-    config_artifacts:
-      path: "*conf*"
-      type: text/plain
+#  
+#macos_instance:
+#  image: ghcr.io/cirruslabs/macos-sonoma-xcode:latest
+#task:
+#  name: AppleM1/LLVM x86_64 xbuild
+#  compile_script:
+#  - #brew install llvm
+#  - export #PATH=/opt/homebrew/opt/llvm/bin:$PATH
+#  - export #LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
+#  - export #CPPFLAGS="-I/opt/homebrew/opt/llvm/include" 
+#  - export ARCHS="i386 x86_64"
+#  - export ARCHS_STANDARD="i386 x86_64"
+#  - export ARCHS_STANDARD_32_64_BIT="i386 x86_64"
+#  - export ARCHS_STANDARD_64_BIT=x86_64
+#  - export ARCHS_STANDARD_INCLUDING_64_BIT="i386 x86_64"
+#  - export ARCHS_UNIVERSAL_IPHONE_OS="i386 x86_64"
+#  - export VALID_ARCHS="i386 x86_64"
+#  - xcrun --sdk macosx --show-sdk-path
+#  - xcodebuild -version
+#  - export CC=/Applications/Xcode_26.0.1.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
+#  - export CFLAGS="-O2 -unwindlib=none -Wno-macro-redefined -isysroot /Applications/Xcode_26.0.1.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX26.0.sdk -arch x86_64"
+#  - make TARGET=CORE2 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1 RANLIB="ls -l"
+#  always:
+#    config_artifacts:
+#      path: "*conf*"
+#      type: text/plain
 #  lib_artifacts:
 #    path: "libopenblas*"
 #    type: application/octet-streamm
-
-macos_instance:
-  image: ghcr.io/cirruslabs/macos-sonoma-xcode:latest
-task:
-  name: AppleM1/LLVM armv8-ios xbuild
-  compile_script:
-  - #brew install llvm
-  - export #PATH=/opt/homebrew/opt/llvm/bin:$PATH
-  - export #LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
-  - export #CPPFLAGS="-I/opt/homebrew/opt/llvm/include" 
-  - export CC=/Applications/Xcode_16.3.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-  - export CFLAGS="-O2 -unwindlib=none -Wno-macro-redefined -isysroot /Applications/Xcode_16.3.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS18.4.sdk -arch arm64 -miphoneos-version-min=10.0"
-  - xcrun --sdk iphoneos --show-sdk-path
-  - ls -l /Applications
-  - make TARGET=ARMV8 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1 CROSS=1
-  always:
-    config_artifacts:
-      path: "*conf*"
-      type: text/plain
-
-macos_instance:
-  image: ghcr.io/cirruslabs/macos-sonoma-xcode:latest
-task:
-  name: AppleM1/LLVM armv7-androidndk xbuild
-  compile_script:
-  - brew install --cask android-ndk
-  - export ANDROID_NDK_HOME="/opt/homebrew/share/android-ndk"
-  - export CC=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/armv7a-linux-androideabi23-clang
-  - make TARGET=ARMV7 ARM_SOFTFP_ABI=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1 RANLIB="ls -l"
-  always:
-    config_artifacts:
-      path: "*conf*"
-      type: text/plain
-
-task:
-  name: NeoverseN1
-  arm_container:
-    image: node:latest
-  compile_script:
-  - make
-
-  task:
-  name: NeoverseN1-ILP64
-  arm_container:
-    image: node:latest
-  compile_script:
-  - make INTERFACE64=1
-
-task:
-  name: NeoverseN1-OMP
-  arm_container:
-    image: node:latest
-    cpu: 8
-  compile_script:
-  - make USE_OPENMP=1
-
-FreeBSD_task:
-  name: FreeBSD-gcc
-  freebsd_instance:
-    image_family: freebsd-14-2
-  install_script:
-  - pkg update -f && pkg upgrade -y && pkg install -y gmake gcc
-  compile_script:
-  - ls -l /usr/local/lib
-  - gmake CC=gcc 
-
-
-FreeBSD_task:
-  name: freebsd-gcc-ilp64
-  freebsd_instance:
-    image_family: freebsd-14-2
-  install_script:
-  - pkg update -f && pkg upgrade -y && pkg install -y gmake gcc
-  compile_script:
-  - ls -l /usr/local/lib
-  - gmake CC=gcc INTERFACE64=1
-
-FreeBSD_task:
-  name: FreeBSD-clang-openmp
-  freebsd_instance:
-    image_family: freebsd-14-2
-  install_script:
-  - pkg update -f && pkg upgrade -y && pkg install -y gmake gcc 
-  - ln -s /usr/local/lib/gcc13/libgfortran.so.5.0.0 /usr/lib/libgfortran.so
-  compile_script:
-  - gmake CC=clang FC=gfortran USE_OPENMP=1 CPP_THREAD_SAFETY_TEST=1
-
+#
+#macos_instance:
+#  image: ghcr.io/cirruslabs/macos-sonoma-xcode:latest
+#task:
+#  name: AppleM1/LLVM armv8-ios xbuild
+#  compile_script:
+#  - #brew install llvm
+#  - export #PATH=/opt/homebrew/opt/llvm/bin:$PATH
+#  - export #LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
+#  - export #CPPFLAGS="-I/opt/homebrew/opt/llvm/include" 
+#  - export CC=/Applications/Xcode_26.0.1.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
+#  - export CFLAGS="-O2 -unwindlib=none -Wno-macro-redefined -isysroot /Applications/Xcode_26.0.1.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS26.0.sdk -arch arm64 -miphoneos-version-min=10.0"
+#  - xcrun --sdk iphoneos --show-sdk-path
+#  - ls -l /Applications
+#  - make TARGET=ARMV8 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1 CROSS=1
+#  always:
+#    config_artifacts:
+#      path: "*conf*"
+#      type: text/plain
+#
+#macos_instance:
+#  image: ghcr.io/cirruslabs/macos-tahoe-xcode:latest
+#task:
+#  name: AppleM1/LLVM armv7-androidndk xbuild
+#  compile_script:
+#  - brew install --cask android-ndk
+#  - export ANDROID_NDK_HOME="/opt/homebrew/share/android-ndk"
+#  - export CC=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/armv7a-linux-androideabi23-clang
+#  - export AR=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-ar
+#  - export RANLIB=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-ranlib
+#  - make TARGET=ARMV7 ARM_SOFTFP_ABI=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1
+#  always:
+#    config_artifacts:
+#      path: "*conf*"
+#      type: text/plain
+#
+#task:
+#  name: NeoverseN1
+#  arm_container:
+#    image: node:latest
+#  compile_script:
+#  - make
+#
+#  task:
+#  name: NeoverseN1-ILP64
+#  arm_container:
+#    image: node:latest
+#  compile_script:
+#  - make INTERFACE64=1
+#
+#task:
+#  name: NeoverseN1-OMP
+#  arm_container:
+#    image: node:latest
+#    cpu: 8
+#  compile_script:
+#  - make USE_OPENMP=1
+#
+#
+#FreeBSD_task:
+#  name: FreeBSD-gcc
+#  freebsd_instance:
+#    image_family: freebsd-14-3
+#  install_script:
+#  - pkg update -f && pkg upgrade -y && pkg install -y gmake gcc
+#  compile_script:
+#  - ls -l /usr/local/lib
+#  - gmake CC=gcc 
+#
+#
+#FreeBSD_task:
+#  name: freebsd-gcc-ilp64
+#  freebsd_instance:
+#    image_family: freebsd-14-3
+#  install_script:
+#  - pkg update -f && pkg upgrade -y && pkg install -y gmake gcc
+#  compile_script:
+#  - ls -l /usr/local/lib
+#  - gmake CC=gcc INTERFACE64=1
+#
+#FreeBSD_task:
+#  name: FreeBSD-clang-openmp
+#  freebsd_instance:
+#    image_family: freebsd-14-3
+#  install_script:
+#  - pkg update -f && pkg upgrade -y && pkg install -y gmake gcc 
+#  - ln -s /usr/local/lib/gcc14/libgfortran.so.5.0.0 /usr/lib/libgfortran.so
+#  compile_script:
+#  - gmake CC=clang FC=gfortran USE_OPENMP=1 CPP_THREAD_SAFETY_TEST=1
+#
 #task:
 #  name: Windows/LLVM16     --- too slow ---
 #  windows_container:
@@ -1,6 +1,14 @@
 name: apple m

-on: [push, pull_request]
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'

 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -10,7 +18,7 @@ permissions:
  contents: read # to fetch code (actions/checkout)

 jobs:
-  build:
+  build-windows:
    if: "github.repository == 'OpenMathLib/OpenBLAS'"
    runs-on: macos-14

@@ -24,7 +32,7 @@ jobs:
        
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: Print system information
        run: |
@@ -52,7 +60,7 @@ jobs:
          fi

      - name: Compilation cache
-        uses: actions/cache@v3
+        uses: actions/cache@v5
        with:
          path: ~/.ccache
          # We include the commit sha in the cache key, as new cache entries are
@@ -99,6 +107,7 @@ jobs:
        run: |
          export CPPFLAGS="-I/opt/homebrew/opt/llvm/include"
          export CC="/opt/homebrew/opt/llvm/bin/clang"
+          export RANLIB=llvm-ranlib
          case "${{ matrix.build }}" in
            "make")
              make -j$(nproc) DYNAMIC_ARCH=1 USE_OPENMP=${{matrix.openmp}} INTERFACE64=${{matrix.ilp64}} FC="ccache ${{ matrix.fortran }}"
@@ -154,3 +163,141 @@ jobs:
              exit 1
              ;;
          esac
+
+  xbuild-x86_64:
+    if: "github.repository == 'OpenMathLib/OpenBLAS'"
+    runs-on: macos-26
+
+    strategy:
+      fail-fast: false
+        
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Print system information
+        run: |
+          if [ "$RUNNER_OS" == "macOS" ]; then
+            sysctl -a | grep machdep.cpu
+          else
+            echo "::error::$RUNNER_OS not supported"
+            exit 1
+          fi
+
+      - name: Install Dependencies
+        run: |
+          if [ "$RUNNER_OS" == "Linux" ]; then
+            sudo apt-get install -y gfortran cmake ccache libtinfo5
+          elif [ "$RUNNER_OS" == "macOS" ]; then
+            # It looks like "gfortran" isn't working correctly unless "gcc" is re-installed.
+            brew reinstall gcc
+            brew install coreutils ccache
+            brew install llvm
+          else
+            echo "::error::$RUNNER_OS not supported"
+            exit 1
+          fi
+          
+      - name: Crossbuild OpenBLAS to x86_64
+        run: |
+          #export PATH=/opt/homebrew/opt/llvm/bin:$PATH
+          #export LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
+          #export CPPFLAGS="-I/opt/homebrew/opt/llvm/include" 
+          export ARCHS="i386 x86_64"
+          export ARCHS_STANDARD="i386 x86_64"
+          export ARCHS_STANDARD_32_64_BIT="i386 x86_64"
+          export ARCHS_STANDARD_64_BIT=x86_64
+          export ARCHS_STANDARD_INCLUDING_64_BIT="i386 x86_64"
+          export ARCHS_UNIVERSAL_IPHONE_OS="i386 x86_64"
+          export VALID_ARCHS="i386 x86_64"
+          xcrun --sdk macosx --show-sdk-path
+          xcodebuild -version
+          export CC=/Applications/Xcode_26.0.1.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
+          export CFLAGS="-O2 -unwindlib=none -Wno-macro-redefined -isysroot /Applications/Xcode_26.0.1.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX26.0.sdk -arch x86_64"
+          make TARGET=CORE2 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1 RANLIB="ls -l"
+
+  xbuild-ios:
+    if: "github.repository == 'OpenMathLib/OpenBLAS'"
+    runs-on: macos-26
+
+    strategy:
+      fail-fast: false
+        
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Print system information
+        run: |
+          if [ "$RUNNER_OS" == "macOS" ]; then
+            sysctl -a | grep machdep.cpu
+          else
+            echo "::error::$RUNNER_OS not supported"
+            exit 1
+          fi
+
+      - name: Install Dependencies
+        run: |
+          if [ "$RUNNER_OS" == "Linux" ]; then
+            sudo apt-get install -y gfortran cmake ccache libtinfo5
+          elif [ "$RUNNER_OS" == "macOS" ]; then
+            # It looks like "gfortran" isn't working correctly unless "gcc" is re-installed.
+            brew reinstall gcc
+            brew install coreutils ccache
+            brew install llvm
+          else
+            echo "::error::$RUNNER_OS not supported"
+            exit 1
+          fi
+
+      - name: Crossbuild to iOS
+        run: |
+          CC="$(xcrun --sdk iphoneos --find clang)"
+          SDKROOT="$(xcrun --sdk iphoneos --show-sdk-path)"
+          echo "CC=${CC}"
+          echo "SDKROOT=${SDKROOT}"
+          make TARGET=ARMV8 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1 \
+            CC="${CC}" CFLAGS="-O2 -Wno-macro-redefined -isysroot ${SDKROOT} -arch arm64 -miphoneos-version-min=10.0"
+
+  xbuild-ios32:
+    if: "github.repository == 'OpenMathLib/OpenBLAS'"
+    runs-on: macos-26
+
+    strategy:
+      fail-fast: false
+        
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Print system information
+        run: |
+          if [ "$RUNNER_OS" == "macOS" ]; then
+            sysctl -a | grep machdep.cpu
+          else
+            echo "::error::$RUNNER_OS not supported"
+            exit 1
+          fi
+
+      - name: Install Dependencies
+        run: |
+          if [ "$RUNNER_OS" == "Linux" ]; then
+            sudo apt-get install -y gfortran cmake ccache libtinfo5
+          elif [ "$RUNNER_OS" == "macOS" ]; then
+            # It looks like "gfortran" isn't working correctly unless "gcc" is re-installed.
+            brew reinstall gcc
+            brew install coreutils ccache
+            brew install llvm
+            brew install --cask android-ndk
+          else
+            echo "::error::$RUNNER_OS not supported"
+            exit 1
+          fi
+
+      - name: AppleM1/LLVM armv7-androidndk xbuild
+        run: |
+          export ANDROID_NDK_HOME="/opt/homebrew/share/android-ndk"
+          export CC=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/armv7a-linux-androideabi23-clang
+          export AR=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-ar
+          export RANLIB=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-ranlib
+          make TARGET=ARMV7 ARM_SOFTFP_ABI=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1
@@ -5,10 +5,16 @@ on:
    branches:
      - develop
      - release-**
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
  pull_request:
    branches:
      - develop
      - release-**
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'

 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -30,7 +36,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: Print system information
        run: |
@@ -52,7 +58,7 @@ jobs:
          fi

      - name: Compilation cache
-        uses: actions/cache@v3
+        uses: actions/cache@v5
        with:
          path: ~/.ccache
          # We include the commit sha in the cache key, as new cache entries are
@@ -1,6 +1,14 @@
 name: c910v qemu test

-on: [push, pull_request]
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'

 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -31,7 +39,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6

      - name: install build deps
        run: |
@@ -40,7 +48,7 @@ jobs:
          gcc-${{ matrix.apt_triple }} gfortran-${{ matrix.apt_triple }} libgomp1-riscv64-cross libglib2.0-dev

      - name: checkout qemu
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
        with:
          repository: XUANTIE-RV/qemu
          path: qemu
@@ -58,7 +66,7 @@ jobs:
          make install

      - name: Compilation cache
-        uses: actions/cache@v3
+        uses: actions/cache@v5
        with:
          path: ~/.ccache
          key: ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}-${{ github.sha }}
@@ -1,6 +1,14 @@
 name: Run codspeed benchmarks

-on: [push, pull_request]
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'

 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -21,8 +29,8 @@ jobs:
        pyver: ["3.12"]
    runs-on: ${{ matrix.os }}
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
        with:
            python-version: ${{ matrix.pyver }}

@@ -43,7 +51,7 @@ jobs:
          fi

      - name: Compilation cache
-        uses: actions/cache@v3
+        uses: actions/cache@v5
        with:
          path: ~/.ccache
          # We include the commit sha in the cache key, as new cache entries are
@@ -147,8 +155,9 @@ jobs:
          OPENBLAS_NUM_THREADS=1 pytest benchmarks/bench_blas.py -k 'gesdd'

      - name: Run benchmarks
-        uses: CodSpeedHQ/action@v3
+        uses: CodSpeedHQ/action@v4
        with:
+          mode: simulation
          token: ${{ secrets.CODSPEED_TOKEN }}
          run: |
            cd benchmark/pybench
@@ -4,9 +4,17 @@ on:
  push:
    branches:
      - develop
+    paths:
+      - 'docs/**'
+      - 'mkdocs.yml'
+      - '.github/workflows/docs.yml'
  pull_request:
    branches:
      - develop
+    paths:
+      - 'docs/**'
+      - 'mkdocs.yml'
+      - '.github/workflows/docs.yml'

 jobs:
  build:
@@ -14,11 +22,11 @@ jobs:
    if: "github.repository == 'OpenMathLib/OpenBLAS'"
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
        with:
          fetch-depth: 0

-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
        with:
          python-version: "3.10"

@@ -1,6 +1,15 @@
 name: continuous build

-on: [push, pull_request]
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  workflow_dispatch:

 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -11,22 +20,29 @@ permissions:

 jobs:
  build:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
+    if: "github.repository == 'OpenMathLib/OpenBLAS' || github.event_name == 'workflow_dispatch'"
    runs-on: ${{ matrix.os }}

    strategy:
      fail-fast: false
      matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, ubuntu-24.04-arm]
+        cc: [gcc, clang, clang-21]
        fortran: [gfortran, flang]
        build: [cmake, make]
        exclude:
          - os: macos-latest
+            cc: gcc
+          - os: macos-latest
+            cc: clang-21
+          - os: macos-latest
+            fortran: flang
+          - os: ubuntu-24.04-arm
            fortran: flang

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: Print system information
        run: |
@@ -42,10 +58,23 @@ jobs:
      - name: Install Dependencies
        run: |
          if [ "$RUNNER_OS" == "Linux" ]; then
+            cat << EOF | sudo tee -a /etc/apt/apt.conf.d/01norecommend
+          APT::Install-Recommends "0";
+          APT::Install-Suggests "0";
+          EOF
            sudo apt-get update
-            sudo apt-get install -y gfortran cmake ccache
-            wget http://security.ubuntu.com/ubuntu/pool/universe/n/ncurses/libtinfo5_6.3-2ubuntu0.1_amd64.deb
-            sudo apt install ./libtinfo5_6.3-2ubuntu0.1_amd64.deb
+            sudo apt-get install -y ccache
+            if [ "${{ matrix.cc }}" == "clang-21" ]; then
+                wget https://apt.llvm.org/llvm.sh
+                chmod +x llvm.sh
+                sudo ./llvm.sh 21
+            fi
+            if [ "${{ matrix.fortran }}" == "flang" ]; then
+              wget http://security.ubuntu.com/ubuntu/pool/universe/n/ncurses/libtinfo5_6.3-2ubuntu0.2_amd64.deb
+              sudo apt install ./libtinfo5_6.3-2ubuntu0.2_amd64.deb
+            else
+              sudo apt-get install -y ${{ matrix.fortran }}
+            fi
          elif [ "$RUNNER_OS" == "macOS" ]; then
            # It looks like "gfortran" isn't working correctly unless "gcc" is re-installed.
            brew reinstall gcc
@@ -56,7 +85,7 @@ jobs:
          fi

      - name: Compilation cache
-        uses: actions/cache@v3
+        uses: actions/cache@v5
        with:
          path: ~/.ccache
          # We include the commit sha in the cache key, as new cache entries are
@@ -64,12 +93,12 @@ jobs:
          # GNU make and cmake call the compilers differently. It looks like
          # that causes the cache to mismatch. Keep the ccache for both build
          # tools separate to avoid polluting each other.
-          key: ccache-${{ runner.os }}-${{ matrix.build }}-${{ matrix.fortran }}-${{ github.ref }}-${{ github.sha }}
+          key: ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.build }}-${{ matrix.cc }}-${{ matrix.fortran }}-${{ github.ref }}-${{ github.sha }}
          # Restore a matching ccache cache entry. Prefer same branch and same Fortran compiler.
          restore-keys: |
-            ccache-${{ runner.os }}-${{ matrix.build }}-${{ matrix.fortran }}-${{ github.ref }}
-            ccache-${{ runner.os }}-${{ matrix.build }}-${{ matrix.fortran }}
-            ccache-${{ runner.os }}-${{ matrix.build }}
+            ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.build }}-${{ matrix.cc }}-${{ matrix.fortran }}-${{ github.ref }}
+            ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.build }}-${{ matrix.cc }}-${{ matrix.fortran }}
+            ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.build }}-${{ matrix.cc }}

      - name: Configure ccache
        run: |
@@ -89,7 +118,7 @@ jobs:
          echo "max_size = 300M" > ~/.ccache/ccache.conf
          echo "compression = true" >> ~/.ccache/ccache.conf
          ccache -s
-          
+
      - name: Add gfortran runtime to link path
        if: matrix.build == 'make' && runner.os == 'macOS'
        run: |
@@ -110,7 +139,7 @@ jobs:
          fi
          case "${{ matrix.build }}" in
            "make")
-              make -j$(nproc) DYNAMIC_ARCH=1 USE_OPENMP=0 FC="ccache ${{ matrix.fortran }}"
+              make -j$(nproc) DYNAMIC_ARCH=1 USE_OPENMP=0 CC="ccache ${{ matrix.cc }}" FC="ccache ${{ matrix.fortran }}"
              ;;
            "cmake")
              mkdir build && cd build
@@ -119,6 +148,7 @@ jobs:
                    -DBUILD_WITHOUT_LAPACK=0 \
                    -DCMAKE_VERBOSE_MAKEFILE=ON \
                    -DCMAKE_BUILD_TYPE=Release \
+                    -DCMAKE_C_COMPILER=${{ matrix.cc }} \
                    -DCMAKE_Fortran_COMPILER=${{ matrix.fortran }} \
                    -DCMAKE_C_COMPILER_LAUNCHER=ccache \
                    -DCMAKE_Fortran_COMPILER_LAUNCHER=ccache \
@@ -142,13 +172,13 @@ jobs:
            "make")
              MAKE_FLAGS='DYNAMIC_ARCH=1 USE_OPENMP=0'
              echo "::group::Tests in 'test' directory"
-              make -C test $MAKE_FLAGS FC="ccache ${{ matrix.fortran }}"
+              make -C test $MAKE_FLAGS CC="ccache ${{ matrix.cc }}" FC="ccache ${{ matrix.fortran }}"
              echo "::endgroup::"
              echo "::group::Tests in 'ctest' directory"
-              make -C ctest $MAKE_FLAGS FC="ccache ${{ matrix.fortran }}"
+              make -C ctest $MAKE_FLAGS CC="ccache ${{ matrix.cc }}" FC="ccache ${{ matrix.fortran }}"
              echo "::endgroup::"
              echo "::group::Tests in 'utest' directory"
-              make -C utest $MAKE_FLAGS FC="ccache ${{ matrix.fortran }}"
+              make -C utest $MAKE_FLAGS CC="ccache ${{ matrix.cc }}" FC="ccache ${{ matrix.fortran }}"
              echo "::endgroup::"
              ;;
            "cmake")
@@ -175,29 +205,29 @@ jobs:
          - msystem: UCRT64
            idx: int32
            target-prefix: mingw-w64-ucrt-x86_64
-            fc-pkg: fc
+            fc-pkg: mingw-w64-ucrt-x86_64-fc
          - msystem: MINGW32
            idx: int32
            target-prefix: mingw-w64-i686
-            fc-pkg: fc
+            fc-pkg:
          - msystem: CLANG64
            idx: int32
            target-prefix: mingw-w64-clang-x86_64
-            fc-pkg: fc
+            fc-pkg: mingw-w64-clang-x86_64-fc
          - msystem: UCRT64
            idx: int64
            idx64-flags: -DBINARY=64 -DINTERFACE64=1
            target-prefix: mingw-w64-ucrt-x86_64
-            fc-pkg: fc
+            fc-pkg: mingw-w64-ucrt-x86_64-fc
          - msystem: CLANG64
            idx: int64
            idx64-flags: -DBINARY=64 -DINTERFACE64=1
            target-prefix: mingw-w64-clang-x86_64
-            fc-pkg: fc
+            fc-pkg: mingw-w64-clang-x86_64-fc
          - msystem: UCRT64
            idx: int32
            target-prefix: mingw-w64-ucrt-x86_64
-            fc-pkg: fc
+            fc-pkg: mingw-w64-ucrt-x86_64-fc
            build-type: None
        exclude:
          - msystem: MINGW32
@@ -226,13 +256,13 @@ jobs:
          install: >-
            base-devel
            ${{ matrix.target-prefix }}-cc
-            ${{ matrix.target-prefix }}-${{ matrix.fc-pkg }}
+            ${{ matrix.fc-pkg }}
            ${{ matrix.target-prefix }}-cmake
            ${{ matrix.target-prefix }}-ninja
            ${{ matrix.target-prefix }}-ccache

      - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: Prepare ccache
        # Get cache location of ccache
@@ -245,7 +275,7 @@ jobs:
          echo "key=ccache-msys2-${{ matrix.msystem }}-${{ matrix.idx }}-${{ matrix.build-type }}-${{ github.ref }}-${{ github.sha }}" >> $GITHUB_OUTPUT

      - name: Restore ccache
-        uses: actions/cache/restore@v3
+        uses: actions/cache/restore@v5
        with:
          path: ${{ steps.ccache-prepare.outputs.ccachedir }}
          key: ${{ steps.ccache-prepare.outputs.key }}
@@ -290,7 +320,7 @@ jobs:

      - name: Save ccache
        # Save the cache after we are done (successfully) building
-        uses: actions/cache/save@v3
+        uses: actions/cache/save@v5
        with:
          path: ${{ steps.ccache-prepare.outputs.ccachedir }}
          key: ${{ steps.ccache-prepare.outputs.key }}
@@ -313,6 +343,277 @@ jobs:
          echo "::endgroup::"


+  linux_thread_stress:
+    if: "github.repository == 'OpenMathLib/OpenBLAS'"
+    name: ${{ matrix.check-name }}
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - backend: pthread
+            check-name: "linux_thread_stress (pthread)"
+          - backend: openmp
+            check-name: "linux_thread_stress (openmp)"
+          - backend: tsan
+            check-name: linux_thread_sanitizer
+          - backend: tsan-openmp
+            check-name: linux_thread_sanitizer_openmp
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Install Dependencies
+        run: |
+          cat << EOF | sudo tee -a /etc/apt/apt.conf.d/01norecommend
+          APT::Install-Recommends "0";
+          APT::Install-Suggests "0";
+          EOF
+          sudo apt-get update
+          sudo apt-get install -y ccache cmake ninja-build
+          case "${{ matrix.backend }}" in
+            tsan|tsan-openmp) sudo apt-get install -y clang llvm ;;
+          esac
+          if [ "${{ matrix.backend }}" = "tsan-openmp" ]; then
+            sudo apt-get install -y libomp-dev
+          fi
+
+      - name: Compilation cache
+        uses: actions/cache@v5
+        with:
+          path: ~/.ccache
+          key: ccache-${{ runner.os }}-thread-${{ matrix.backend }}-${{ github.ref }}-${{ github.sha }}
+          restore-keys: |
+            ccache-${{ runner.os }}-thread-${{ matrix.backend }}-${{ github.ref }}
+            ccache-${{ runner.os }}-thread-${{ matrix.backend }}
+
+      - name: Configure ccache
+        # Limit the maximum size and switch on compression to avoid exceeding the total disk or cache quota.
+        run: |
+          test -d ~/.ccache || mkdir -p ~/.ccache
+          echo "max_size = 250M" > ~/.ccache/ccache.conf
+          echo "compression = true" >> ~/.ccache/ccache.conf
+          ccache -s
+
+      - name: Configure OpenBLAS
+        run: |
+          mkdir build && cd build
+          build_type=Release
+          c_compiler=gcc
+          cxx_compiler=g++
+          dynamic_arch=ON
+          use_openmp=OFF
+          cpp_thread_safety_use_openmp=ON
+          dgemm_args="512;12;4"
+          dgemm_mixed_args="524288;16;20"
+          dgemv_args="512;12;4"
+          sanitizer_flags=
+          if [ "${{ matrix.backend }}" = "openmp" ]; then
+            use_openmp=ON
+          elif [ "${{ matrix.backend }}" = "tsan" ] || [ "${{ matrix.backend }}" = "tsan-openmp" ]; then
+            build_type=RelWithDebInfo
+            c_compiler=clang
+            cxx_compiler=clang++
+            dynamic_arch=OFF
+            cpp_thread_safety_use_openmp=OFF
+            dgemm_args="64;4;1"
+            dgemm_mixed_args="131072;8;10"
+            dgemv_args="64;4;1"
+            sanitizer_flags="-fsanitize=thread -g -O1 -fno-omit-frame-pointer"
+            if [ "${{ matrix.backend }}" = "tsan-openmp" ]; then
+              use_openmp=ON
+              cpp_thread_safety_use_openmp=ON
+            fi
+          fi
+          cmake_args=(
+            -G Ninja
+            "-DCMAKE_BUILD_TYPE=$build_type"
+            "-DCMAKE_C_COMPILER=$c_compiler"
+            "-DCMAKE_CXX_COMPILER=$cxx_compiler"
+            -DBUILD_SHARED_LIBS=ON
+            -DBUILD_STATIC_LIBS=OFF
+            -DBUILD_WITHOUT_LAPACK=ON
+            -DBUILD_SINGLE=OFF
+            -DBUILD_DOUBLE=ON
+            -DBUILD_COMPLEX=OFF
+            -DBUILD_COMPLEX16=OFF
+            "-DDYNAMIC_ARCH=$dynamic_arch"
+            -DNOFORTRAN=ON
+            -DUSE_THREAD=ON
+            "-DUSE_OPENMP=$use_openmp"
+            -DNUM_THREADS=32
+            -DNUM_PARALLEL=2
+            -DTARGET=CORE2
+            -DCPP_THREAD_SAFETY_TEST=ON
+            "-DCPP_THREAD_SAFETY_USE_OPENMP=$cpp_thread_safety_use_openmp"
+            "-DCPP_THREAD_SAFETY_DGEMM_ARGS=$dgemm_args"
+            "-DCPP_THREAD_SAFETY_DGEMM_MIXED_ARGS=$dgemm_mixed_args"
+            "-DCPP_THREAD_SAFETY_DGEMV_ARGS=$dgemv_args"
+            -DCMAKE_C_COMPILER_LAUNCHER=ccache
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+          )
+          if [ "${{ matrix.backend }}" = "tsan" ] || [ "${{ matrix.backend }}" = "tsan-openmp" ]; then
+            cmake_args+=(
+              "-DCMAKE_C_FLAGS=$sanitizer_flags"
+              "-DCMAKE_CXX_FLAGS=$sanitizer_flags"
+              -DCMAKE_SHARED_LINKER_FLAGS=-fsanitize=thread
+              -DCMAKE_EXE_LINKER_FLAGS=-fsanitize=thread
+            )
+          fi
+          cmake "${cmake_args[@]}" ..
+
+      - name: Build OpenBLAS
+        run: |
+          cd build
+          cmake --build . --target dgemm_thread_safety dgemm_thread_safety_mixed dgemv_thread_safety
+
+      - name: Show ccache status
+        continue-on-error: true
+        run: ccache -s
+
+      - name: Run thread stress tests
+        timeout-minutes: 30
+        run: |
+          cd build
+          if [ "${{ matrix.backend }}" = "tsan" ] || [ "${{ matrix.backend }}" = "tsan-openmp" ]; then
+            export LLVM_SYMBOLIZER_PATH=/usr/bin/llvm-symbolizer
+            export TSAN_OPTIONS=halt_on_error=1:exitcode=66:second_deadlock_stack=1
+          fi
+          if [ "${{ matrix.backend }}" = "tsan-openmp" ]; then
+            # Load Archer (the OMPT tool from Ubuntu's libomp-dev) so TSan
+            # understands libomp's barriers instead of flagging them as false positives. The OpenMP runtime will load this tool automatically if OMP_TOOL_LIBRARIES is set.
+            archer=$(clang -print-file-name=libarcher.so)
+            [ -f "$archer" ] || archer=$(find /usr/lib/llvm-* -name libarcher.so 2>/dev/null | head -1)
+            if [ ! -f "$archer" ]; then
+              echo "::error::libarcher.so not found (expected from libomp-dev)"
+              exit 1
+            fi
+            echo "Using distro Archer: $archer"
+            export OMP_TOOL_LIBRARIES="$archer"
+            export TSAN_OPTIONS="$TSAN_OPTIONS:ignore_noninstrumented_modules=1"
+          fi
+          if [ "${{ matrix.backend }}" != "tsan" ]; then
+            export OMP_NUM_THREADS=16
+          fi
+          export OPENBLAS_NUM_THREADS=8
+          ctest -R 'dgemm_thread_safety|dgemm_thread_safety_mixed|dgemv_thread_safety' --output-on-failure
+
+
+  msys2_thread_stress:
+    if: "github.repository == 'OpenMathLib/OpenBLAS'"
+    runs-on: windows-latest
+
+    defaults:
+      run:
+        shell: msys2 {0}
+
+    env:
+      CHERE_INVOKING: 1
+
+    steps:
+      - name: Get CPU name
+        shell: pwsh
+        run : |
+          Get-CIMInstance -Class Win32_Processor | Select-Object -Property Name
+
+      - name: Install build dependencies
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: UCRT64
+          update: true
+          release: false  # Use pre-installed version
+          install: >-
+            base-devel
+            mingw-w64-ucrt-x86_64-cc
+            mingw-w64-ucrt-x86_64-cmake
+            mingw-w64-ucrt-x86_64-ninja
+            mingw-w64-ucrt-x86_64-ccache
+
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Prepare ccache
+        # Get cache location of ccache
+        # Create key that is used in action/cache/restore and action/cache/save steps
+        id: ccache-prepare
+        run: |
+          echo "ccachedir=$(cygpath -m $(ccache -k cache_dir))" >> $GITHUB_OUTPUT
+          # We include the commit sha in the cache key, as new cache entries are
+          # only created if there is no existing entry for the key yet.
+          echo "key=ccache-msys2-thread-stress-${{ github.ref }}-${{ github.sha }}" >> $GITHUB_OUTPUT
+
+      - name: Restore ccache
+        uses: actions/cache/restore@v5
+        with:
+          path: ${{ steps.ccache-prepare.outputs.ccachedir }}
+          key: ${{ steps.ccache-prepare.outputs.key }}
+          # Restore a matching ccache cache entry. Prefer same branch.
+          restore-keys: |
+            ccache-msys2-thread-stress-${{ github.ref }}
+            ccache-msys2-thread-stress
+
+      - name: Configure ccache
+        # Limit the maximum size and switch on compression to avoid exceeding the total disk or cache quota.
+        run: |
+          which ccache
+          test -d ${{ steps.ccache-prepare.outputs.ccachedir }} || mkdir -p ${{ steps.ccache-prepare.outputs.ccachedir }}
+          echo "max_size = 250M" > ${{ steps.ccache-prepare.outputs.ccachedir }}/ccache.conf
+          echo "compression = true" >> ${{ steps.ccache-prepare.outputs.ccachedir }}/ccache.conf
+          ccache -p
+          ccache -s
+
+      - name: Configure OpenBLAS
+        run: |
+          mkdir build && cd build
+          cmake -G Ninja \
+                -DCMAKE_BUILD_TYPE=Release \
+                -DBUILD_SHARED_LIBS=ON \
+                -DBUILD_STATIC_LIBS=OFF \
+                -DBUILD_WITHOUT_LAPACK=ON \
+                -DBUILD_SINGLE=OFF \
+                -DBUILD_DOUBLE=ON \
+                -DBUILD_COMPLEX=OFF \
+                -DBUILD_COMPLEX16=OFF \
+                -DDYNAMIC_ARCH=OFF \
+                -DNOFORTRAN=ON \
+                -DUSE_THREAD=ON \
+                -DUSE_OPENMP=OFF \
+                -DNUM_THREADS=32 \
+                -DTARGET=CORE2 \
+                -DCPP_THREAD_SAFETY_TEST=ON \
+                -DCPP_THREAD_SAFETY_DGEMM_ARGS="384;8;4" \
+                -DCPP_THREAD_SAFETY_DGEMM_MIXED_ARGS="524288;16;20" \
+                -DCPP_THREAD_SAFETY_DGEMV_ARGS="384;8;4" \
+                -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+                -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+                ..
+
+      - name: Build OpenBLAS
+        run: |
+          cd build
+          cmake --build . --target dgemm_thread_safety dgemm_thread_safety_mixed dgemv_thread_safety
+
+      - name: Show ccache status
+        continue-on-error: true
+        run: ccache -s
+
+      - name: Save ccache
+        # Save the cache after we are done (successfully) building
+        uses: actions/cache/save@v5
+        with:
+          path: ${{ steps.ccache-prepare.outputs.ccachedir }}
+          key: ${{ steps.ccache-prepare.outputs.key }}
+
+      - name: Run thread stress tests
+        timeout-minutes: 30
+        run: |
+          cd build
+          export PATH="$PWD/lib:$PATH"
+          OPENBLAS_NUM_THREADS=8 OMP_NUM_THREADS=16 ctest -R 'dgemm_thread_safety|dgemm_thread_safety_mixed|dgemv_thread_safety' --output-on-failure
+
+
  cross_build:
    if: "github.repository == 'OpenMathLib/OpenBLAS'"
    runs-on: ubuntu-22.04
@@ -336,7 +637,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: Install Dependencies
        run: |
@@ -344,7 +645,7 @@ jobs:
          sudo apt-get install -y ccache gcc-${{ matrix.triple }} gfortran-${{ matrix.triple }} libgomp1-${{ matrix.target }}-cross

      - name: Compilation cache
-        uses: actions/cache@v3
+        uses: actions/cache@v5
        with:
          path: ~/.ccache
          key: ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}-${{ github.sha }}
@@ -371,16 +672,67 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v3
-        
+        uses: actions/checkout@v6
+
      - name: Install Dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y gcc gfortran make
-          
+
      - name: Build OpenBLAS
        run: |
-          make -j${nproc} 
+          make -j${nproc}
          make -j${nproc} lapack-test
-    
-          
+
+  neoverse_n1_build:
+    if: "github.repository == 'OpenMathLib/OpenBLAS'"
+    runs-on: ubuntu-24.04-arm
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Install Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc gfortran make
+
+      - name: Build OpenBLAS
+        run: |
+          make -j${nproc} TARGET=NEOVERSEN1
+          make -j${nproc} TARGET=NEOVERSEN1 lapack-test
+
+  neoverse_n1_omp_build:
+    if: "github.repository == 'OpenMathLib/OpenBLAS'"
+    runs-on: ubuntu-24.04-arm
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Install Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc gfortran make
+
+      - name: Build OpenBLAS
+        run: |
+          make -j${nproc} TARGET=NEOVERSEN1 USE_OPENMP=1
+
+  neoverse_n1_ilp64_build:
+    if: "github.repository == 'OpenMathLib/OpenBLAS'"
+    runs-on: ubuntu-24.04-arm
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Install Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc gfortran make
+
+      - name: Build OpenBLAS
+        run: |
+          make -j${nproc} TARGET=NEOVERSEN1 INTERFACE64=1
+          make -j${nproc} TARGET=NEOVERSEN1 INTERFACE64=1 lapack-test
@@ -0,0 +1,63 @@
+name: freebsd
+
+on:
+  push:
+    branches:
+      - develop
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  pull_request:
+    branches:
+      - develop
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read # to fetch code (actions/checkout)
+
+jobs:
+  bsd-x86:
+    if: "github.repository == 'OpenMathLib/OpenBLAS'"
+    runs-on: ubuntu-latest
+    steps:
+     - name: checkout
+       uses: actions/checkout@v6
+     
+     - name: build
+       id: freebsd_x86_64
+       uses: vmactions/freebsd-vm@v1
+       with:
+        usesh: true
+        prepare: |
+
+        run: |
+          freebsd-version
+          sysctl hw.ncpu
+          pkg install -y gmake gcc15
+          gmake CC=gcc15 FC=gfortran15
+          
+  bsd-aarch64:
+    if: "github.repository == 'OpenMathLib/OpenBLAS'"
+    runs-on: ubuntu-latest
+    steps:
+     - name: checkout
+       uses: actions/checkout@v6
+     
+     - name: build
+       id: freebsd_arm64
+       uses: vmactions/freebsd-vm@v1
+       with:
+        arch: aarch64
+        usesh: true
+        run: |
+          freebsd-version
+          sysctl hw.ncpu
+          pkg install -y gmake gcc15
+          gmake CC=gcc15 FC=gfortran15
+          
@@ -1,6 +1,14 @@
 name: harmonyos

-on: [push, pull_request]
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'

 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -20,7 +28,7 @@ jobs:
        -DCMAKE_INSTALL_PREFIX=install \
        -DCMAKE_BUILD_TYPE=Release \
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
    - name: ndk-install
      run: |
        wget https://repo.huaweicloud.com/harmonyos/os/4.1.1-Release/ohos-sdk-windows_linux-public.tar.gz
@@ -1,6 +1,14 @@
 name: loongarch64 qemu test

-on: [push, pull_request]
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'

 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -38,7 +46,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: Install APT deps
        run: |
@@ -47,7 +55,7 @@ jobs:
                               gcc-14-loongarch64-linux-gnu g++-14-loongarch64-linux-gnu gfortran-14-loongarch64-linux-gnu

      - name: Compilation cache
-        uses: actions/cache@v3
+        uses: actions/cache@v5
        with:
          path: ~/.ccache
          key: ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}-${{ github.sha }}
@@ -1,6 +1,14 @@
 name: loongarch64 clang qemu test

-on: [push, pull_request]
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'

 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -31,7 +39,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: Install libffi6
        run: |
@@ -51,7 +59,7 @@ jobs:
          tar -xf loongson-gnu-toolchain-8.3-x86_64-loongarch64-linux-gnu-rc1.3.tar.xz -C /opt

      - name: Checkout qemu
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6
        with:
          repository: qemu/qemu
          path: qemu
@@ -69,7 +77,7 @@ jobs:
          echo "PATH=$GITHUB_WORKSPACE:/opt/clang+llvm_8.0.1-6_amd64-linux-gnu_debian-10/bin:/opt/loongson-gnu-toolchain-8.3-x86_64-loongarch64-linux-gnu-rc1.3/bin:$PATH" >> $GITHUB_ENV

      - name: Compilation cache
-        uses: actions/cache@v3
+        uses: actions/cache@v5
        with:
          path: ~/.ccache
          key: ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}-${{ github.sha }}
@@ -1,6 +1,14 @@
 name: mips64 qemu test

-on: [push, pull_request]
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'

 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -35,7 +43,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: install build deps
        run: |
@@ -44,7 +52,7 @@ jobs:
          gcc-${{ matrix.triple }} gfortran-${{ matrix.triple }} libgomp1-mips64el-cross libglib2.0-dev

      - name: checkout qemu
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6
        with:
          repository: qemu/qemu
          path: qemu
@@ -58,7 +66,7 @@ jobs:
          make install

      - name: Compilation cache
-        uses: actions/cache@v3
+        uses: actions/cache@v5
        with:
          path: ~/.ccache
          key: ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}-${{ github.sha }}
@@ -48,7 +48,7 @@ jobs:
          sleep ${delay}
        if: github.event_name == 'schedule'

-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v6
        # This isn't even needed, technically. Homebrew will get `develop` via git

      - name: Update Homebrew
@@ -69,7 +69,7 @@ jobs:
          mv *.bottle.tar.gz bottles

      - name: Upload bottle
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
        with:
          name: openblas--HEAD.catalina.bottle.tar.gz
          path: bottles
@@ -1,6 +1,14 @@
 name: riscv64 zvl256b qemu test

-on: [push, pull_request]
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'

 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -16,7 +24,7 @@ jobs:
    env:
      triple: riscv64-unknown-linux-gnu
      riscv_gnu_toolchain: https://github.com/riscv-collab/riscv-gnu-toolchain
-      riscv_gnu_toolchain_version: 13.2.0
+      riscv_gnu_toolchain_version: 15.1.0
      riscv_gnu_toolchain_nightly_download_path: /releases/download/2025.08.29/riscv64-glibc-ubuntu-22.04-llvm-nightly-2025.08.29-nightly.tar.xz
    strategy:
      fail-fast: false
@@ -26,26 +34,29 @@ jobs:
            opts: TARGET=RISCV64_ZVL128B BINARY=64 ARCH=riscv64
            qemu_cpu: rv64,g=true,c=true,v=true,vext_spec=v1.0,vlen=128,elen=64
          - target: RISCV64_ZVL256B
-            opts: TARGET=RISCV64_ZVL256B BINARY=64 ARCH=riscv64
-            qemu_cpu: rv64,g=true,c=true,v=true,vext_spec=v1.0,vlen=256,elen=64
+            opts: TARGET=RISCV64_ZVL256B BINARY=64 ARCH=riscv64 BUILD_BFLOAT16=1 BUILD_HFLOAT16=1
+            qemu_cpu: rv64,g=true,c=true,v=true,vext_spec=v1.0,vlen=256,elen=64,zfh=true,zvfh=true,zvfbfwma=true
          - target: DYNAMIC_ARCH=1
            opts: TARGET=RISCV64_GENERIC BINARY=64 ARCH=riscv64 DYNAMIC_ARCH=1
            qemu_cpu: rv64,g=true,c=true,v=true,vext_spec=v1.0,vlen=256,elen=64

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: install build deps
        run: |
          sudo apt-get update
          sudo apt-get install autoconf automake autotools-dev ninja-build make \
-          libgomp1-riscv64-cross ccache
+          libgomp1-riscv64-cross ccache qemu-kvm qemu-user libc6-riscv64-cross
          wget ${riscv_gnu_toolchain}/${riscv_gnu_toolchain_nightly_download_path}
          tar -xvf $(basename ${riscv_gnu_toolchain_nightly_download_path}) -C /opt
-
+          wget https://gist.github.com/martin-frbg/bb630e0de34978e578eeb496b1538d4e/raw/7fd8d971f327f7a517b8f5f7989479ff2b36f71f/qemu-riscv64-10.1-ubuntu24 -P /opt/riscv/bin -o riscv64-qemu
+          mv /opt/riscv/bin/qemu-riscv64-10.1-ubuntu24 /opt/riscv/bin/qemu-riscv64
+          chmod +x /opt/riscv/bin/qemu-riscv64
+          
      - name: Compilation cache
-        uses: actions/cache@v3
+        uses: actions/cache@v5
        with:
          path: ~/.ccache
          key: ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}-${{ github.sha }}
@@ -74,7 +85,7 @@ jobs:
        run: |
            export PATH="/opt/riscv/bin:$PATH"
            make TARGET=${{ matrix.target }} CFLAGS="-DTARGET=${{ matrix.target }}" \
-            CC='${triple}-gcc' \
+            CC='ccache clang --rtlib=compiler-rt -target ${triple} --sysroot /opt/riscv/sysroot --gcc-toolchain=/opt/riscv/lib/gcc/riscv64-unknown-linux-gnu/${riscv_gnu_toolchain_version}/' \
            AR='ccache ${triple}-ar' AS='ccache ${triple}-gcc' LD='ccache ${triple}-gcc' \
            RANLIB='ccache ${triple}-ranlib' \
            FC='ccache ${triple}-gfortran' ${{ matrix.opts }} \
@@ -98,6 +109,8 @@ jobs:
        shell: bash
        run: |
          export PATH="/opt/riscv/bin:$PATH"
+          export LD_LIBRARY_PATH=/opt/riscv/sysroot/lib
+          sudo ln -s /opt/riscv/sysroot/lib/ld-linux-riscv64-lp64d.so.1 /lib
          export QEMU_CPU=${{ matrix.qemu_cpu }}
          rm -rf ./test_out
          mkdir -p ./test_out
@@ -134,6 +147,14 @@ jobs:
          wait
          while IFS= read -r -d $'\0' LOG; do cat $LOG ; FAILURES=1 ; done < <(grep -lZ FAIL ./test_out/*)
          if [[ ! -z $FAILURES ]]; then echo "==========" ; echo "== FAIL ==" ; echo "==========" ; echo ; exit 1 ; fi
+          if [ "${{matrix.target}}" == "RISCV64_ZVL256B" ]; then
+          qemu-riscv64 test/test_sbgemm &
+          qemu-riscv64 test/test_sbgemv &
+          qemu-riscv64 test/test_shgemm &
+          qemu-riscv64 test/test_shgemv &
+          qemu-riscv64 test/test_bgemm
+          fi
+

      - name: netlib tests
        shell: bash
@@ -4,9 +4,15 @@ on:
  push:
    branches:
      - develop
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
  pull_request:
    branches:
      - develop
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'

 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -21,7 +27,7 @@ jobs:
    runs-on: windows-11-arm
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6

      - name: Install LLVM for Win-ARM64
        shell: pwsh
@@ -4,6 +4,7 @@
 *.dylib
 *.def
 *.o
+*.exe
 *.out
 *.tmp
 lapack-3.1.1
@@ -80,6 +81,7 @@ test/SBLAT3_3M.SUMM
 test/ZBLAT2.SUMM
 test/ZBLAT3.SUMM
 test/ZBLAT3_3M.SUMM
+test/SHBLAT2.SUMM
 test/SHBLAT3.SUMM
 test/SBBLAT2.SUMM
 test/SBBLAT3.SUMM
@@ -98,6 +100,7 @@ test/sblat2
 test/sblat3
 test/sblat3_3m
 test/test_shgemm
+test/test_shgemv
 test/test_sbgemm
 test/test_sbgemv
 test/test_bgemm
@@ -9,7 +9,7 @@ project(OpenBLAS C ASM)

 set(OpenBLAS_MAJOR_VERSION 0)
 set(OpenBLAS_MINOR_VERSION 3)
-set(OpenBLAS_PATCH_VERSION 30.dev)
+set(OpenBLAS_PATCH_VERSION 33.dev)

 set(OpenBLAS_VERSION "${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}.${OpenBLAS_PATCH_VERSION}")

@@ -58,9 +58,10 @@ else()
  set(NO_AFFINITY 1)
 endif()

-option(CPP_THREAD_SAFETY_TEST "Run a massively parallel DGEMM test to confirm thread safety of the library (requires OpenMP and about 1.3GB of RAM)" OFF)
+option(CPP_THREAD_SAFETY_TEST "Run massively parallel DGEMM tests to confirm thread safety of the library (requires about 1.3GB of RAM)" OFF)
+option(CPP_THREAD_SAFETY_USE_OPENMP "Use OpenMP to launch the C++ thread safety tests" ON)

-option(CPP_THREAD_SAFETY_GEMV "Run a massively parallel DGEMV test to confirm thread safety of the library (requires OpenMP)" OFF)
+option(CPP_THREAD_SAFETY_GEMV "Run a massively parallel DGEMV test to confirm thread safety of the library" OFF)
 option(BUILD_STATIC_LIBS "Build static library" OFF)
 option(BUILD_SHARED_LIBS "Build shared library" OFF)
 if(NOT BUILD_STATIC_LIBS AND NOT BUILD_SHARED_LIBS)
@@ -243,6 +244,38 @@ if (${DYNAMIC_ARCH})
  endforeach()
 endif ()

+# Work around Apple issue with "argument list too long" when linking.
+# Seen for DYNAMIC_ARCH when there are a _LOT_ of variants build, previously
+# mostly with older versions on POWERPC or Intel CPUs, but with newer ARM
+# CPUs and newer compilers this will also occur on ARM.
+#
+# This must happen before the add_library() calls, otherwise this will have
+# no effect.
+#
+# Unfortunately, while this workaround will work for shared libraries (with
+# either Ninja oder Unix Makefiles), but not for static libraries, as ar
+# does not accept response files. So for the case where we (also) build
+# static libraries we need an additional workaround, see below. (The
+# generation of the response files by CMake must still be enabled, so this
+# is required regardless.)
+if(APPLE)
+  set(CMAKE_C_USE_RESPONSE_FILE_FOR_OBJECTS ON)
+  set(CMAKE_C_USE_RESPONSE_FILE_FOR_LIBRARIES ON)
+  if(NOT NOFORTRAN)
+    set(CMAKE_Fortran_USE_RESPONSE_FILE_FOR_OBJECTS ON)
+    set(CMAKE_Fortran_USE_RESPONSE_FILE_FOR_LIBRARIES ON)
+    # NAG Fortran does not support the GCC-specific -x f95-cpp-input flag
+    # used in the shared library link rule below.  Override
+    # CMAKE_Fortran_CREATE_SHARED_LIBRARY early (before targets are defined)
+    # to use the C compiler link rule instead; the shared library contains
+    # only C and assembler objects so this is safe.
+    if(CMAKE_Fortran_COMPILER_ID MATCHES "NAG")
+      set(CMAKE_Fortran_CREATE_SHARED_LIBRARY ${CMAKE_C_CREATE_SHARED_LIBRARY})
+    endif()
+  endif()
+  set(CMAKE_NINJA_FORCE_RESPONSE_FILE ON)
+endif()
+
 # add objects to the openblas lib
 if(NOT NO_LAPACK)
  add_library(LAPACK_OVERRIDES OBJECT ${LA_SOURCES})
@@ -308,20 +341,22 @@ if (USE_OPENMP)
  endif()
 endif()

-# Fix "Argument list too long" for macOS with POWERPC or Intel CPUs 
-if(APPLE AND (NOT CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "arm64"))
-  # Use response files
-  set(CMAKE_C_USE_RESPONSE_FILE_FOR_OBJECTS 1)
+# Second part of "Argument list too long" fix when static libraries are
+# built. See above for details.
+if(APPLE AND BUILD_STATIC_LIBS)
  # Always build static library first
-  if(BUILD_STATIC_LIBS)
-    set(STATIC_PATH "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/lib${OpenBLAS_LIBNAME}.a")
+  set(STATIC_PATH "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/lib${OpenBLAS_LIBNAME}.a")
+  # Handle differences in how many response files are generated and/or where
+  # they are stored for Ninja / Unix Makefiles.
+  if("${CMAKE_GENERATOR}" MATCHES "Ninja")
+    set(CREATE_STATIC_LIBRARY_COMMAND
+      "sh -c 'cat ${CMAKE_BINARY_DIR}/CMakeFiles/openblas_static.rsp | xargs -n 1024 ${CMAKE_AR} -ru ${STATIC_PATH} && exit 0' "
+      "sh -c '${CMAKE_AR} -rs ${STATIC_PATH} ${CMAKE_BINARY_DIR}/driver/others/CMakeFiles/driver_others.dir/xerbla.c.o && exit 0' ")
  else()
-    add_library(${OpenBLAS_LIBNAME}_static STATIC ${TARGET_OBJS} ${OpenBLAS_DEF_FILE})
-    set(STATIC_PATH "lib${OpenBLAS_LIBNAME}.a")
+    set(CREATE_STATIC_LIBRARY_COMMAND
+      "sh -c 'cat ${CMAKE_BINARY_DIR}/CMakeFiles/${OpenBLAS_LIBNAME}_static.dir/objects*.rsp | xargs -n 1024 ${CMAKE_AR} -ru ${STATIC_PATH} && exit 0' "
+      "sh -c '${CMAKE_AR} -rs ${STATIC_PATH} ${CMAKE_BINARY_DIR}/driver/others/CMakeFiles/driver_others.dir/xerbla.c.o && exit 0' ")
  endif()
-  set(CREATE_STATIC_LIBRARY_COMMAND
-    "sh -c 'cat ${CMAKE_BINARY_DIR}/CMakeFiles/${OpenBLAS_LIBNAME}_static.dir/objects*.rsp | xargs -n 1024 ${CMAKE_AR} -ru ${STATIC_PATH} && exit 0' "
-    "sh -c '${CMAKE_AR} -rs ${STATIC_PATH} ${CMAKE_BINARY_DIR}/driver/others/CMakeFiles/driver_others.dir/xerbla.c.o && exit 0' ")
  if(BUILD_SHARED_LIBS)
    add_dependencies(${OpenBLAS_LIBNAME}_shared ${OpenBLAS_LIBNAME}_static)
    set(SHARED_PATH "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libopenblas.${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}.dylib")
@@ -332,12 +367,34 @@ if(APPLE AND (NOT CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "arm64"))
    set(OMP_LIB "")
  endif()
  if(NOT NOFORTRAN)
-    set(CMAKE_Fortran_USE_RESPONSE_FILE_FOR_OBJECTS 1)
    set(CMAKE_Fortran_CREATE_STATIC_LIBRARY ${CREATE_STATIC_LIBRARY_COMMAND})
    if(BUILD_SHARED_LIBS)
-      set(CMAKE_Fortran_CREATE_SHARED_LIBRARY
-	"sh -c 'echo \"\" | ${CMAKE_Fortran_COMPILER} -o dummy.o -c -x f95-cpp-input - '"
-	"sh -c '${CMAKE_Fortran_COMPILER} -fpic -shared -Wl,-all_load -Wl,-force_load,${STATIC_PATH} dummy.o -o ${SHARED_PATH} ${OMP_LIB}'")
+      if(CMAKE_Fortran_COMPILER_ID MATCHES "GNU")
+        set(CMAKE_Fortran_CREATE_SHARED_LIBRARY
+          "sh -c 'echo \"\" | ${CMAKE_Fortran_COMPILER} -o dummy.o -c -x f95-cpp-input - '"
+          "sh -c '${CMAKE_Fortran_COMPILER} -fpic -shared -Wl,-all_load -Wl,-force_load,${STATIC_PATH} dummy.o -o ${SHARED_PATH} ${OMP_LIB}'")
+      elseif(CMAKE_Fortran_COMPILER_ID MATCHES "NAG")
+        # NAG does not support -x f95-cpp-input, and macOS needs -dynamiclib
+        # rather than -Wl,-shared.  Use the C compiler as the linker driver
+        # and add the NAG Fortran runtime so NAGf90_* symbols resolve.
+        # Locate the NAG Fortran runtime (libf<XY>rts) without hardcoding the
+        # version digits: NAG 7.1 ships libf71rts, 7.2 ships libf72rts, etc.
+        get_filename_component(_NAG_FC_DIR "${CMAKE_Fortran_COMPILER}" DIRECTORY)
+        set(_NAG_RTS_DIR "${_NAG_FC_DIR}/../lib/NAG_Fortran")
+        file(GLOB _NAG_RTS_CANDIDATES
+             "${_NAG_RTS_DIR}/libf*rts.dylib"
+             "${_NAG_RTS_DIR}/libf*rts.a")
+        if(_NAG_RTS_CANDIDATES)
+          list(GET _NAG_RTS_CANDIDATES 0 _NAG_RTS_LIB)
+          get_filename_component(_NAG_RTS_NAME "${_NAG_RTS_LIB}" NAME_WE)
+          string(REGEX REPLACE "^lib" "" _NAG_RTS_LIBNAME "${_NAG_RTS_NAME}")
+          set(_NAG_RTS_FLAGS "-L${_NAG_RTS_DIR} -l${_NAG_RTS_LIBNAME}")
+        else()
+          set(_NAG_RTS_FLAGS "")
+        endif()
+        set(CMAKE_Fortran_CREATE_SHARED_LIBRARY
+          "sh -c '${CMAKE_C_COMPILER} -dynamiclib -Wl,-all_load -Wl,-force_load,${STATIC_PATH} -o ${SHARED_PATH} ${OMP_LIB} ${_NAG_RTS_FLAGS}'")
+      endif()
    endif()
  else()
    set(CMAKE_C_CREATE_STATIC_LIBRARY ${CREATE_STATIC_LIBRARY_COMMAND})
@@ -498,6 +555,11 @@ if (BUILD_SHARED_LIBS OR DELETE_STATIC_LIBS AND NOT ${SYMBOLPREFIX}${SYMBOLSUFFI
  else ()
 	  set (BBF16 0)
  endif()
+  if (${BUILD_HFLOAT16})
+	  set (BHF16 1)
+  else ()
+	  set (BHF16 0)
+  endif()
  if (${BUILD_SINGLE})
 	  set (BS 1)
  else ()
@@ -533,7 +595,7 @@ endif()
 #if (USE_PERL)
 message(STATUS "adding postbuild instruction to rename syms")
  add_custom_command(TARGET ${OpenBLAS_LIBNAME}_static POST_BUILD
-	COMMAND perl ${PROJECT_SOURCE_DIR}/exports/gensymbol.pl "win2k" "${ARCH}" "${BU}" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" "${SYMBOLPREFIX}" "${SYMBOLSUFFIX}" "${BLD}" "${BBF16}" "${BS}" "${BD}" "${BC}" "${BZ}" > ${PROJECT_BINARY_DIR}/renamesyms.def
+	COMMAND perl ${PROJECT_SOURCE_DIR}/exports/gensymbol.pl "win2k" "${ARCH}" "${BU}" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" "${SYMBOLPREFIX}" "${SYMBOLSUFFIX}" "${BLD}" "${BBF16}" "${BHF16}" "${BS}" "${BD}" "${BC}" "${BZ}" > ${PROJECT_BINARY_DIR}/renamesyms.def
 	COMMAND ${CMAKE_C_COMPILER} ${CMAKE_C_FLAGS} -I${PROJECT_SOURCE_DIR} -I${PROJECT_BINARY_DIR} -c -o ${PROJECT_BINARY_DIR}/dllinit.o ${PROJECT_SOURCE_DIR}/exports/dllinit.c
 	COMMAND lld-link -nodefaultlib:libcmt -defaultlib:${CRTLIB} ${CMAKE_LINKER_FLAGS} -errorlimit:0 -def:${PROJECT_BINARY_DIR}/renamesyms.def ${PROJECT_BINARY_DIR}/dllinit.o $<TARGET_FILE:${OpenBLAS_LIBNAME}_static> -wholearchive:$<TARGET_FILE:${OpenBLAS_LIBNAME}_static> -dll -out:$<TARGET_FILE_DIR:${OpenBLAS_LIBNAME}_static>/${OpenBLAS_LIBNAME}.dll -implib:$<TARGET_FILE_DIR:${OpenBLAS_LIBNAME}_static>/${OpenBLAS_LIBNAME}.dll.a ${PDBOPT} 
 	#COMMAND lld-link -nodefaultlib:libcmt -defaultlib:msvcrt ${CMAKE_LINKER_FLAGS} -errorlimit:0 -def:${PROJECT_BINARY_DIR}/renamesyms.def ${PROJECT_BINARY_DIR}/dllinit.o $<TARGET_FILE:${OpenBLAS_LIBNAME}_static> -wholearchive:$<TARGET_FILE:${OpenBLAS_LIBNAME}_static> -dll -out:$<TARGET_FILE_DIR:${OpenBLAS_LIBNAME}_static>/${OpenBLAS_LIBNAME}.dll -implib:$<TARGET_FILE_DIR:${OpenBLAS_LIBNAME}_static>/${OpenBLAS_LIBNAME}.dll.a
@@ -543,13 +605,13 @@ message(STATUS "adding postbuild instruction to rename syms")
  else ()
  if (NOT USE_PERL)
  add_custom_command(TARGET ${OpenBLAS_LIBNAME}_shared POST_BUILD
-	  COMMAND sh ${PROJECT_SOURCE_DIR}/exports/gensymbol "objcopy" "${ARCH}" "${BU}" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" \"${SYMBOLPREFIX}\" \"${SYMBOLSUFFIX}\" "${BLD}" "${BBF16}" "${BS}" "${BD}" "${BC}" "${BZ}" > ${PROJECT_BINARY_DIR}/objcopy.def
+	  COMMAND sh ${PROJECT_SOURCE_DIR}/exports/gensymbol "objcopy" "${ARCH}" "${BU}" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" \"${SYMBOLPREFIX}\" \"${SYMBOLSUFFIX}\" "${BLD}" "${BBF16}" "${BHF16}" "${BS}" "${BD}" "${BC}" "${BZ}" > ${PROJECT_BINARY_DIR}/objcopy.def
    COMMAND objcopy --redefine-syms ${PROJECT_BINARY_DIR}/objcopy.def  ${PROJECT_BINARY_DIR}/lib/${OpenBLAS_LIBNAME}.so
    COMMENT "renaming symbols"
    )
  else()
  add_custom_command(TARGET ${OpenBLAS_LIBNAME}_shared POST_BUILD
-    COMMAND perl ${PROJECT_SOURCE_DIR}/exports/gensymbol.pl "objcopy" "${ARCH}" "${BU}" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" \"${SYMBOLPREFIX}\" \"${SYMBOLSUFFIX}\" "${BLD}" "${BBF16}" "${BS}" "${BD}" "${BC}" "${BZ}" > ${PROJECT_BINARY_DIR}/objcopy.def
+    COMMAND perl ${PROJECT_SOURCE_DIR}/exports/gensymbol.pl "objcopy" "${ARCH}" "${BU}" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" \"${SYMBOLPREFIX}\" \"${SYMBOLSUFFIX}\" "${BLD}" "${BBF16}" "${BHF16}" "${BS}" "${BD}" "${BC}" "${BZ}" > ${PROJECT_BINARY_DIR}/objcopy.def
    COMMAND objcopy --redefine-syms ${PROJECT_BINARY_DIR}/objcopy.def  ${PROJECT_BINARY_DIR}/lib/lib${OpenBLAS_LIBNAME}.so
    COMMENT "renaming symbols"
    )
@@ -703,6 +765,39 @@ if(NOT NO_LAPACKE)
  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/lapack-netlib/LAPACKE/include/lapacke_mangling_with_flags.h.in "${CMAKE_BINARY_DIR}/lapacke_mangling.h"
  )
  install (FILES ${CMAKE_BINARY_DIR}/lapacke_mangling.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+  if (NOT (x${SYMBOLPREFIX}${SYMBOLSUFFIX} STREQUAL "x"))
+  message (STATUS "Generating lapacke.h in ${CMAKE_INSTALL_INCLUDEDIR}")
+  set(LAPACKE_H ${CMAKE_BINARY_DIR}/generated/lapacke.h)
+  file(READ ${CMAKE_CURRENT_SOURCE_DIR}/lapack-netlib/LAPACKE/include/lapacke.h LAPACKE_H_CONTENTS)
+  if (NOT ${SYMBOLPREFIX} STREQUAL "")
+	  string(REGEX REPLACE "(LAPACKE_*)" " ${SYMBOLPREFIX}\\1" LAPACKE_H_CONTENTS_NEW	"${LAPACKE_H_CONTENTS}")
+	  string(REPLACE "_ ${SYMBOLPREFIX}LAPACKE_H_"  "_LAPACKE_H_" LAPACKE_H_CONTENTS ${LAPACKE_H_CONTENTS_NEW})
+	  string(REPLACE "${SYMBOLPREFIX}LAPACKE_malloc"  "LAPACKE_malloc" LAPACKE_H_CONTENTS_NEW ${LAPACKE_H_CONTENTS})
+	  string(REPLACE "${SYMBOLPREFIX}LAPACKE_free"  "LAPACKE_free" LAPACKE_H_CONTENTS ${LAPACKE_H_CONTENTS_NEW})
+	  set(LAPACKE_H_CONTENTS_NEW ${LAPACKE_H_CONTENTS})
+  endif()
+  if (NOT ${SYMBOLSUFFIX} STREQUAL "")
+	  string(REGEX REPLACE "(${SYMBOLPREFIX}LAPACKE_[a-z1-9]*[^ (]*)" "\\1${SYMBOLSUFFIX}" LAPACKE_H_CONTENTS_NEW	"${LAPACKE_H_CONTENTS}")
+	  string(REPLACE "#define${SYMBOLSUFFIX}"  "#define" LAPACKE_H_CONTENTS ${LAPACKE_H_CONTENTS_NEW})
+	  string(REPLACE "LAPACKE_malloc${SYMBOLSUFFIX}"  "LAPACKE_malloc" LAPACKE_H_CONTENTS_NEW ${LAPACKE_H_CONTENTS})
+	  string(REPLACE "LAPACKE_free${SYMBOLSUFFIX}"  "LAPACKE_free" LAPACKE_H_CONTENTS ${LAPACKE_H_CONTENTS_NEW})
+	  set(LAPACKE_H_CONTENTS_NEW ${LAPACKE_H_CONTENTS})
+  endif()
+  file(WRITE ${LAPACKE_H} "${LAPACKE_H_CONTENTS_NEW}")
+  install (FILES ${LAPACKE_H} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+  message (STATUS "Generating lapack.h in ${CMAKE_INSTALL_INCLUDEDIR}")
+  set(LAPACK_H ${CMAKE_BINARY_DIR}/generated/lapack.h)
+  file(READ ${CMAKE_CURRENT_SOURCE_DIR}/lapack-netlib/LAPACKE/include/lapack.h LAPACK_H_CONTENTS)
+  if (NOT ${SYMBOLPREFIX} STREQUAL "")
+	  string(REGEX REPLACE "(LAPACK_[a-z1-9]*[ \(][.\)]*)" "${SYMBOLPREFIX}\\1" LAPACK_H_CONTENTS_NEW	"${LAPACK_H_CONTENTS}")
+	  set(LAPACK_H_CONTENTS ${LAPACK_H_CONTENTS_NEW})
+  endif()
+  if (NOT ${SYMBOLSUFFIX} STREQUAL "")
+	  string(REGEX REPLACE "(${SYMBOLPREFIX}LAPACK_[a-z1-9]*)([ \(].\)" "\\1${SYMBOLSUFFIX}\\2" LAPACK_H_CONTENTS_NEW	"${LAPACK_H_CONTENTS}")
+  endif()
+  file(WRITE ${LAPACK_H} "${LAPACK_H_CONTENTS_NEW}")
+  install (FILES ${LAPACK_H} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+endif()
 endif()

 # Install pkg-config files
@@ -726,4 +821,3 @@ install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PN}ConfigVersion.cmake
 install(EXPORT "${PN}${SUFFIX64}Targets"
        NAMESPACE "${PN}${SUFFIX64}::"
        DESTINATION ${CMAKECONFIG_INSTALL_DIR})
-
@@ -29,6 +29,9 @@
 * Annop Wongwathanarat <annop.wongwathanarat@arm.com>
  * Optimizations and other improvements targeting AArch64

+* Anna Mayne <anna.mayne@arm.com>
+  * Optimizations and other improvements targeting AArch64
+
 ## Previous Developers

 * Zaheer Chothia <zaheer.chothia@gmail.com>
@@ -267,3 +270,12 @@ In chronological order:
  * [2025-05-29] Optimise axpby kernel for RISCV64_ZVL256B
  * [2025-06-05] Optimise hbmv kernel for RISCV64_ZVL256B

+* Anna Mayne <anna.mayne@arm.com>
+  * [2025-11-19] Update thread throttling profile for SGEMV on NEOVERSEV1 and NEOVERSEV2
+
+* Fadi Arafeh <fadi.arafeh@arm.com>
+  * [2026-03-05] Accelerate SVE128 SBGEMM/BGEMM
+
+* Nathan Sircombe <nathan.sircombe@arm.com>
+  * [2026-04-16] Add CPU ID for Neoverse V3
+hheei <hheei@users.noreply.github.com>
@@ -1,4 +1,253 @@
 OpenBLAS ChangeLog
+====================================================================
+Version 0.3.33
+23-Apr-2026
+
+general:
+ - fixed an incorrect cast in the SBGEMM test case that could lead to spurious test failures
+ - fixed an invalid memory access in the converted C version of the CBLAS tests
+ - made the BIGNUMA setting automatic when the number of cores exceeds 256
+ - Imported recent updates from Reference-LAPACK to realign with its upcoming 3.13.0 release:
+   - Implement ?LARF1F and ?ORM2R (Reference-LAPACK PRs 1019,1020,1196,1257)
+   - Change loop order in ?GETC2 to improve performance (Reference-LAPACK PR 1023)
+   - Change WORK array dimension in ?GELQS/?GEQRS (Reference-LAPACK PR 1094)
+   - Add NaN checks for input matrix A in ?GEEV (Reference-LAPACK PR 1136)
+   - Fix support for jobu/v in LAPACKE_?GESVDQ_WORK (Reference-LAPACK PRs 1146,1221)
+   - Fix display of version number in LAPACK testsuite (Reference-LAPACK PR 1149)
+   - Fix DGGES test seed to avoid bad matrix cases (Reference-LAPACK PR 1187)
+   - Fix truncation of large WORK array sizes in ZHE (Reference-LAPACK PR 1195)
+   - Fix overwriting of LDSWORK parameter in ?TRSYL3 (Reference-LAPACK PR 1206)
+   - Fix overwriting of error states in some EIG tests (Reference-LAPACK PR 1207) 
+   - Remove unused parameter in DORBDB3/ZUNBDB3 (Reference-LAPACK PR 1209)
+   - Re-enable testing of ?BB and ?GG driver functions (Reference-LAPACK PR 1211)
+   - Fix workspace size calculation in ?TGSEN (Reference-LAPACK PR 774)
+   - Fix typos in the EIG DMD tests and initialized the cutoff variable (PR 1212,1228)
+   - Optimized looping in ?LACPY/?LASCL/?LANTR with fat matrix and UPLO=L (PR 1251)
+
+arm64:
+ - worked around a serious miscompilation of the DDOT kernel by GCC15, affecting
+   most non-SVE targets, and SVE targets in the case of non-unit array stride)
+ - fixed an accuracy issue in the GEMV kernel for Neoverse V1 and other SVE targets
+ - fixed broken STRMM and SSYMM in DYNAMIC_ARCH builds when running on non-SME hardware
+ - added an optimized SHGEMM kernel for Neoverse N2
+ - fixed DYNAMIC_ARCH builds under Windows on Arm
+ - Added autodetection of Cortex A75/A76 in DYNAMIC_ARCH builds
+ - Added autodetection of Neoverse V3, currently supported through V2 kernels
+ - Re-added support for the "VORTEX" target in DYNAMIC_ARCH builds with DYNAMIC_LIST
+ - Fixed CMake-based builds that use the "Ninja" generator
+
+loongarch64:
+ - fixed a build failure due to missing support for the new half-precision float type
+ - fixed a long-standing bug in asserting 64bit capability in the c_check helper script
+
+x86_64:
+ - added a workaround for miscompilation of the AVX512 GEMM kernels by LLVM on Windows
+ - fixed a build failure in the LAED3 code when compiling with MinGW on Windows
+ - fixed CMake-based compilation with the NVIDIA HPC compiler
+ - Fixed CMake-based builds that use the "Ninja" generator
+
+wasm:
+ - added optimized kernels for STRSM and DTRSM
+
+====================================================================
+Version 0.3.32
+23-Mar-2026
+
+general:
+ - Moved the preliminary support for a Web Assembly target to its own WASM
+   architecture and WASM128_GENERIC target
+ - Fixed a potential performance difference between dedicated compilation for
+   a target and its representation in DYNAMIC_ARCH builds by making additional
+   cpu-specific parameters available to the DYNAMIC_ARCH configuration
+ - Fixed the reimplementation of LAPACK ?GESV to conform to the reference (i.e.
+   compute the LU factorization even when NRHS is zero)
+ - Improved the error message that is displayed when the compile-time allocation
+   of memory buffers is exceeded
+ - Fixed a problem with non-serialized accesses to parallelized SYRK by concurrent
+   callers
+ - Fixed an ABI mismatch in the internal version of CDOT/ZDOT used by the C fallback
+   versions of the LAPACK source
+ - Improved the f_check script for detecting the Fortran compiler to handle embedded
+   dashes in path names
+ - Fixed several memory access issues in the utests that were detected by Address
+   Sanitizer
+ - Fixed Makefile errors in cases where only a subset of precision types was selected
+ - Fixed missing function errors in Makefile builds without LAPACK or without threads
+ - Fixed a syntax error in the benchmarks Makefile
+ - Fixed compiler warnings in the CBLAS testsuite
+ - Fixed the OpenMP compiler option used with the Intel Ifx compiler
+ - Updated the README sections on supported cpus and operating systems, and added
+   notes pertaining to JAVA
+ - Updated the documentation page for supported BLAS-like extensions
+ - included fixes from the Reference-LAPACK project:
+   - Improved step length selection in the fallback path of ?LAED4 
+     (Reference-LAPACK PR 1191)
+   - Rounding up of LWORK and removal of redundant type conversions in the GVD
+     functions (Reference-LAPACK PR 1202)
+   - internal errors were getting ignored in calculation of selected eigenvalues
+     (Reference-LAPACK PR 1204)
+
+arm64:
+ - Fixed a potential miscompilation of the SDOT/DDOT/DSDOT kernels
+ - Fixed DYNAMIC_ARCH compilation with CMake and compilers lacking SVE support
+ - Improved the performance of BGEMM and SBGEMM kernels for Neoverse V2
+ - Added optimized SSUM and DSUM kernels for Neoverse N1
+ - Added preliminary support for Neoverse V3 cpus as NEOVERSEV2
+ - Added cpu autodetection of Cortex A725 and X925 cpus
+ - Fixed a CMake build problem with flang on Mac OS
+ - Fixed build problems with gcc versions 12 and earlier that do not support fp16
+ - Fixed compilation of GEMM kernels for VORTEXM4/ARMV9SME without multithreading
+ - Fixed the optimized CDOT/ZDOT kernel to compile with LLVM under Windows on Arm
+ - Renamed the copy of the DllMain function used in static linking on MS Windows to
+   OpenBLASDllMain to avoid symbol name conflicts with other libraries
+
+ioongarch64:
+ - fixed POTRF returning wrong results on LA464 due to a wrong parameter setting
+
+power:
+ - Fixed compilation problems caused by missing support for half-precision floats (FP16)
+ - Fixed a potential miscompilation of the POWER10 DGEMV kernel by limiting its optimization
+   level
+ - Fixed a SCAL issue on PPCG4/PPC970 running Linux
+ - Worked around a SCAL issue on PPC970 running FreeBSD by switching to the generic C kernels
+
+riscv64:
+ - Optimized the CROT/ZROT kernel for vector length 128 in the non-unit stride path
+ - Improved SBGEMM/SHGEMM and related helper functions for type conversion
+ - Fixed probing for BFLOAT16 support in DYNAMIC_ARCH cpu detection at runtime
+
+x86_64:
+ - Fixed a potential miscompilation (by gcc 15.x) of the AVX512 SGEMM kernel for "small"
+   matrix sizes
+ - Fixed the SROT and DROT kernels for Haswell to have consistent (FMA) rounding
+   in the main loop and tail call
+ - Added automatic detection of Intel Arrow Lake H/U, Panther Lake and Jasper Lake
+ - Added automatic detection of Intel Emerald Rapids and upcoming cpu models
+ - Updated the cache size translation table in the cpu model autodetection code
+ - Improved cpu detection fallback to also include Nehalem as a non-AVX option  
+ - Fixed a Makefile build issue with clang and the SkylakeX SGEMM kernel 
+ - Renamed the copy of the DllMain function used in static linking on MS Windows to
+   OpenBLASDllMain to avoid symbol name conflicts with other libraries
+
+wasm:
+ - Added optimized intrinsics kernels for SGEMM and DGEMM as well as DOT, ROT and SUM
+
+====================================================================
+Version 0.3.31
+15-Jan-2026
+
+general:
+ - reverted a matrix partitioning optimization from 0.3.30 that could lead to 
+   race conditions and subsequent invalid results in GEMM
+ - added the bfloat16 extensions BGEMM and BGEMV
+ - added a BLAS interface for the ?GEMM_BATCH extensions
+ - added the BLAS extensions ?GEMM_BATCH_STRIDED and their CBLAS interface
+ - added the basic infrastructure for half-precision float (FP16) format 
+   using SH prefix
+ - reimplemented the LAPACK SLAED3/DLAED3 function using multithreading, thereby
+   improving the performance of the SSYEVD/DSYEVD eigensolver for symmetric matrices 
+   on all platforms
+ - limited the number of retries for initial memory allocation to avoid infinite
+   hanging on low-memory systems
+ - fixed a thread lockup situation encountered with python 3.9 or older and numpy
+ - introduced a problem size threshold for multithreading in STRMV/DTRMV
+ - introduced a problem size threshold for multithreading in CHER/CHER2/CHPR/CHPR2
+   and ZHER/ZHER2/ZHPR/ZHPR2
+ - improved the problem size thresholds for multithreading in SGER/DGER
+ - improved autodetection of the Fortran compiler
+ - fixed passing of the INTERFACE64=1 option to the flang-new compiler
+ - fixed a potential deadlock in multithreaded code after calling fork()
+ - fixed builds using CMake on FreeBSD
+ - fixed builds using CMake from within Cygwin on Windows
+ - fixed builds using CMake and the NVHPC compiler on ARM64
+ - fixed CMake build error from misdetecting compiler or OpenMP versions
+ - improved contents of the CMake-generated OpenBLASConfig.cmake file
+ - added support for cross-compilation to RISCV targets via CMake
+ - fixed cross-compilation to x86 targets from non-x86 architectures
+ - fixed failure to install cblas.h if NO_CBLAS=0 was specified
+ - fixed missing user-defined pre- and postfixes on functions in lapack.h,lapacke.h 
+ - included fixes from the Reference-LAPACK project:
+   - fix ordering bug in ?LAED/?LASD (Reference-LAPACK PR 1140)
+   - revert changes in ?GEEV from PR 1129 (Reference-LAPACK PR 1142)
+   - fix workspace allocation in LAPACKE_?TRSEN (Reference-LAPACK PR 1144)
+
+riscv:
+ - added optimized SBGEMM kernels for ZVL128B and ZVL256B targets
+ - added optimized SHGEMM kernels for ZVL128B and ZVL256B targets
+ - added optimized SBGEMV and SHGEMV kernels for ZVL128B/ZVL256B
+ - improved performance of the GEMV kernel for ZVL256B
+ - improved the performance of the CROT and ZROT kernels for ZVL128B and x280
+ - improved the detection of RVV1.0 capability 
+ - improved performance of the matrix packing helper functions for ZVL128B and ZVL256B
+ - improved performance of OMATCOPY for ZVL128B and ZVL256B
+
+arm:
+ - fixed spurious executable stack in the getarch utility
+
+arm64:
+ - fixed spurious executable stack in the getarch utility
+ - fixed compiler warnings arising from the timer macro RPCC
+ - fixed cache size detection for Qualcomm Oryon under Windows on Arm
+ - fixed argument handling in the default SVE kernel for SDOT/DDOT
+ - building the BFLOAT16 kernels is now enabled by default
+ - improved the overall performance of GEMM,SYMM and HEMM on A64FX
+ - improved the performance of SDOT/DDOT on A64FX
+ - improved the multithreading performance of SDOT/DDOT on A64FX by
+   introduction of a throttling table matching thread count to problem size
+ - improved the performance of SGER/DGER on A64FX and NEOVERSEV1
+ - improved the multithreading performance of GEMM on A64FX and NEOVERSEV1
+ - improved the performance of the GEMV kernel for SVE-capable targets
+ - improved the multithreading performance of SGEMM on NEOVERSEV1 and V2
+ - added optimized SAXPY/DAXPY SVE kernels for A64FX and NEOVERSEV1
+ - added optimized BGEMM and BGEMV kernels for NEOVERSEV1
+ - added an optimized BGEMM kernel for NEOVERSEN2
+ - added support for the NEOVERSEV2 cpu
+ - added dedicated support for the Apple M4 cpu as VORTEXM4
+ - added optimized SGEMM/SSYMM/STRMM/SSYRK/SSYR2K for SME-capable targets
+   (ARMV9SME and VORTEXM4)
+ - improved the precision of the SNRM2 kernel
+ - added cpu autodetection and compiler settings for Ampere One processors
+ - fixed cpu autodetection for Apple M systems running Linux
+ - fixed building on MacOS with AppleClang,gfortran and xcode v16 or newer
+ - fixed several errors in the C code replacements for the complex and double
+   precision complex LAPACK functions that get used (only) when compiling with
+   Microsoft C and NOFORTRAN=1 under MS Windows
+
+power:
+ - added initial support for the POWER11 architecture
+ - improved performance of DGEMM and DGEMV on POWER10
+ - fixed the default compiler flags to use "-O3" instead of the possibly unsafe 
+   "-Ofast"
+ - fixed building under MacOS (for old G4 Macs) with CMake
+ - fixed potential miscompilation of DGEMV and other assembly kernels by gcc15.1
+ - fixed compilation with recent versions of flang
+
+loongarch64:
+ - fixed warnings and potential inaccuracies arising from incorrect saving of registers
+ - fixed enumeration of logical cores on big NUMA servers
+ - fixed building with LLVM and the INTERFACE64=1 option
+
+x86:
+ - fixed building the GEMM3M kernels for the GENERIC target
+ - fixed several errors in the C code replacements for the complex and double
+   precision complex LAPACK functions that get used (only) when compiling with
+   Microsoft C and NOFORTRAN=1 under MS Windows
+
+x86_64:
+ - added cpu autodetection for Intel Lunar Lake (Core Ultra 200V)
+ - changed all ?MIN and ?MAX assembly kernels to use unaligned operations 
+ - fixed several errors in the C code replacements for the complex and double
+   precision complex LAPACK functions that get used (only) when compiling with
+   Microsoft C and NOFORTRAN=1 under MS Windows
+ - fixed potential crashes in builds for Cooper Lake, Sapphire Rapids or Zen5 cpus
+   under MS Windows
+
+zarch:
+ - added support for building with CMake
+
+sparc:
+ - fixed a potential crash in the DNRM2 kernel
+
 ====================================================================
 Version 0.3.30
 19-Jun-2025
@@ -1,16 +1,31 @@
 pipeline {
-    agent { 
-        docker {
-            image 'osuosl/ubuntu-ppc64le:18.04'
-        }
-    }
+    agent none
    stages {
-        stage('Build') {
+        stage('GCC build') {
+            agent {
+                docker {
+                    image 'osuosl/ubuntu-ppc64le:18.04' // gcc 7, gfortran 7
+                }
+            }
            steps {
+                checkout scm
                sh 'sudo apt update'
                sh 'sudo apt install gfortran -y'
                sh 'make clean && make'
            }
        }
+        stage('Clang build') {
+            agent {
+                docker {
+                    image 'osuosl/ubuntu-ppc64le:20.04' // clang 10, gfortran 9
+                }
+            }
+            steps {
+                checkout scm
+                sh 'sudo apt update'
+                sh 'sudo apt install -y clang gfortran'
+                sh 'make clean && make CC=clang'
+            }
+        }
    }
 }
@@ -1,6 +1,7 @@
 TOPDIR	= .
 include ./Makefile.system
 LNCMD = ln -fs
+OSNAME_DISPLAY ?= $(OSNAME)
 ifeq ($(FIXED_LIBNAME), 1)
 LNCMD = true
 endif
@@ -58,7 +59,7 @@ all :: tests
 	@echo
 	@echo " OpenBLAS build complete. ($(LIB_COMPONENTS))"
 	@echo
-	@echo "  OS               ... $(OSNAME)             "
+	@echo "  OS               ... $(OSNAME_DISPLAY)             "
 	@echo "  Architecture     ... $(ARCH)               "
 ifndef BINARY64
 	@echo "  BINARY           ... 32bit                 "
@@ -34,7 +34,7 @@ endif
 ifeq ($(C_COMPILER), FUJITSU)
 ISCLANG=1
 endif
-ifneq (1, $(filter 1,$(GCCVERSIONGT4) $(ISCLANG)))
+ifeq "$(or $(GCCVERSIONGT4),$(ISCLANG))" ""
 CCOMMON_OPT += -march=armv8-a
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8-a
@@ -61,6 +61,11 @@ endif
 ifeq ($(CORE), ARMV9SME)
 CCOMMON_OPT += -march=armv9-a+sve2+sme
 FCOMMON_OPT += -march=armv9-a+sve2
+ifdef OS_WINDOWS
+ifeq ($(C_COMPILER), CLANG)
+CCOMMON_OPT += --aarch64-stack-hazard-size=0
+endif
+endif
 endif

 ifeq ($(CORE), CORTEXA53)
@@ -303,6 +308,18 @@ FCOMMON_OPT += -march=armv8.3-a
 endif
 endif

+ifeq ($(CORE), VORTEXM4)
+ifneq ($(C_COMPILER), GCC)
+CCOMMON_OPT += -march=armv8.4-a+sme
+#ifneq ($(APPLECLANG),1)
+#override LDFLAGS += -lclang_rt_builtins-aarch64
+#endif
+else
+CCOMMON_OPT += -march=armv8.4-a
+endif
+FCOMMON_OPT += -march=armv8.4-a
+endif
+
 ifeq (1, $(filter 1,$(GCCVERSIONGTEQ9) $(ISCLANG)))
 ifeq ($(CORE), TSV110)
 CCOMMON_OPT += -march=armv8.2-a -mtune=tsv110
@@ -32,7 +32,7 @@ PKG_EXTRALIB := $(EXTRALIB)
 ifeq ($(INTERFACE64),1)
 	SUFFIX64=64
 endif
-PKGFILE="$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE)$(SUFFIX64).pc"
+PKGFILE := $(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE)$(SUFFIX64).pc

 ifeq ($(USE_OPENMP), 1)
  ifeq ($(C_COMPILER), PGI)
@@ -93,9 +93,27 @@ endif

 ifneq ($(OSNAME), AIX)
 ifneq ($(NO_LAPACKE), 1)
+	@cp $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke.h lapacke_h.tmp
+ifdef SYMBOLPREFIX
+	@sed 's/LAPACKE_[a-z1-9].[^() ]*/$(SYMBOLPREFIX)&/g' lapacke_h.tmp > lapacke.tmp2
+	@mv lapacke.tmp2 lapacke_h.tmp
+endif
+ifdef SYMBOLSUFFIX
+	@sed 's/LAPACKE_[a-z1-9].[^() ]*/&$(SYMBOLSUFFIX)/g' lapacke_h.tmp > lapacke.tmp2
+	@mv lapacke.tmp2 lapacke_h.tmp
+endif
+	@-install -m644 lapacke_h.tmp "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke.h"
 	@echo Copying LAPACKE header files to $(DESTDIR)$(OPENBLAS_INCLUDE_DIR)
-	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapack.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapack.h"
-	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke.h"
+	@cp $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapack.h lapack_h.tmp
+ifdef SYMBOLPREFIX
+	@sed 's/LAPACK_[a-z1-9]*(\.\.\.)/$(SYMBOLPREFIX)&/g' lapack_h.tmp > lapack.tmp2
+	@mv lapack.tmp2 lapack_h.tmp
+endif
+ifdef SYMBOLSUFFIX
+	@sed 's/\(#define $(SYMBOLPREFIX)LAPACK_[a-z1-9].*\)\((...)\)/\1$(SYMBOLSUFFIX)\2/g' lapack_h.tmp > lapack.tmp2
+	@mv lapack.tmp2 lapack_h.tmp
+endif
+	@-install -m644 lapack_h.tmp "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapack.h"
 	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_config.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_config.h"
 	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_mangling_with_flags.h.in "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_mangling.h"
 	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_utils.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_utils.h"
@@ -173,8 +191,6 @@ endif
 ifeq ($(INTERFACE64),1)
 	SUFFIX64=64
 endif
-	PKGFILE="$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE)$(SUFFIX64).pc"
-
 	@echo Generating $(LIBSONAMEBASE)$(SUFFIX64).pc in "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)"
 	@echo 'libdir='$(OPENBLAS_LIBRARY_DIR) > "$(PKGFILE)"
 	@echo 'libprefix='$(LIBNAMEPREFIX) >> "$(PKGFILE)"
@@ -253,46 +269,46 @@ endif

 install_tests : lib.grd
 ifneq ($(ONLY_CBLAS), 1)
-	@install -m 666 utest/openblas_utest $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 utest/openblas_utest_ext $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 utest/openblas_utest$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 utest/openblas_utest_ext$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
 ifndef NO_FBLAS
 ifeq ($(BUILD_BFLOAT16),1)
-	@install -m 666 test/test_sbgemm $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/test_sbgemm$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 endif
 ifeq ($(BUILD_SINGLE),1)
-	@install -m 666 test/sblat1 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/sblat2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/sblat3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/sblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/sblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/sblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 test/sblat2.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 test/sblat3.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 endif
 ifeq ($(BUILD_DOUBLE),1)
-	@install -m 666 test/dblat1 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/dblat2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/dblat3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/dblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/dblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/dblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 test/dblat2.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 test/dblat3.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 endif
 ifeq ($(BUILD_COMPLEX),1)
-	@install -m 666 test/cblat1 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/cblat2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/cblat3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/cblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/cblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/cblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 test/cblat2.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 test/cblat3.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 ifeq ($(ARCH), filter($(ARCH), x86 x86_64 ia64 MIPS))
-	@install -m 666 test/cblat3_3m $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/cblat3_3m$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 test/cblat3_3m.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 endif
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-	@install -m 666 test/zblat1 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/zblat2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/zblat3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/zblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/zblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/zblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 test/zblat2.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 test/zblat3.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 ifeq ($(ARCH), filter($(ARCH), x86 x86_64 ia64 MIPS))
-	@install -m 666 test/zblat3_3m $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 test/zblat3_3m$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 test/zblat3_3m.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 endif
 endif
@@ -300,46 +316,46 @@ endif
 endif
 ifneq ($(ONLY_CBLAS), 1)
 ifeq ($(BUILD_SINGLE),1)
-	@install -m 666 ctest/xscblat1 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xscblat2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xscblat3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xscblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xscblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xscblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 ctest/sin2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 ctest/sin3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 endif
 ifeq ($(BUILD_DOUBLE),1)
-	@install -m 666 ctest/xdcblat1 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xdcblat2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xdcblat3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xdcblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xdcblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xdcblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 ctest/din2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 ctest/din3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 endif
 ifeq ($(BUILD_COMPLEX),1)
-	@install -m 666 ctest/xccblat1 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xccblat2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xccblat3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xccblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xccblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xccblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 ctest/cin2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 ctest/cin3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 ifeq ($(ARCH), filter($(ARCH), x86 x86_64 ia64 MIPS))
-	@install -m 666 ctest/xccblat3_3m $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xccblat3_3m$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 ctest/cin3_3m $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 endif
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-	@install -m 666 ctest/xzcblat1 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xzcblat2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xzcblat3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xzcblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xzcblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xzcblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 ctest/zin2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 ctest/zin3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 ifeq ($(ARCH), filter($(ARCH), x86 x86_64 ia64 MIPS))
-	@install -m 666 ctest/xzcblat3_3m $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 ctest/xzcblat3_3m$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 	@install -m 666 ctest/zin3_3m $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 endif
 endif

 endif
 ifeq ($(CPP_THREAD_SAFETY_TEST), 1)
-	@install -m 666 cpp_thread_test/dgemm_tester $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 cpp_thread_test/dgemv_tester $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 cpp_thread_test/dgemm_tester$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 cpp_thread_test/dgemm_mixed_tester$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
+	@install -m 666 cpp_thread_test/dgemv_tester$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
 endif
 endif
-
@@ -111,13 +111,17 @@ endif
 endif

 ifeq ($(C_COMPILER), CLANG)
-CCOMMON_OPT += -fno-integrated-as
+CCOMMON_OPT += -fno-integrated-as -Wa,-mpwr10
 endif
 # workaround for C->FORTRAN ABI violation in LAPACKE
 ifeq ($(F_COMPILER), GFORTRAN)
 FCOMMON_OPT += -fno-optimize-sibling-calls
 endif

+ifeq ($(F_COMPILER), FLANGNEW)
+override FCOMMON_OPT := $(filter-out -frecursive,$(FCOMMON_OPT))
+endif
+
 FLAMEPATH	= $(HOME)/flame/lib

 #ifeq ($(CORE), CELL)
@@ -147,12 +151,15 @@ endif
 ifdef BINARY64


+#Skip C/Fortran compiler combination checks in AIX if NO_FORTRAN or ONLY_CBLAS is set
+ifeq ($(filter 1,$(NO_FORTRAN) $(ONLY_CBLAS)),)
 ifeq ($(C_COMPILER)$(F_COMPILER)$(OSNAME), GCCIBMAIX)
 $(error Using GCC and XLF on AIX is not a supported combination.)
 endif
 ifeq ($(C_COMPILER)$(F_COMPILER)$(OSNAME), CLANGGFORTRANAIX)
 $(error Using Clang and gFortran on AIX is not a supported combination.)
 endif
+endif

 ifeq ($(OSNAME), AIX)
 ifeq ($(C_COMPILER), GCC)
@@ -6,23 +6,20 @@ ifeq ($(CORE), x280)
 CCOMMON_OPT += -march=rv64imafdcv_zba_zbb_zfh_zvl512b -mabi=lp64d 
 FCOMMON_OPT += -march=rv64imafdcv_zba_zbb_zfh -mabi=lp64d -static
 endif
-ifeq ($(CORE), RISCV64_ZVL256B)
+RISCV64_OPT  = rv64imafdcv
 ifeq ($(BUILD_HFLOAT16), 1)
-CCOMMON_OPT += -march=rv64imafdcv_zvl256b_zvfh_zfh -mabi=lp64d
-FCOMMON_OPT += -march=rv64imafdcv_zvfh_zfh -mabi=lp64d
-else
-CCOMMON_OPT += -march=rv64imafdcv_zvl256b -mabi=lp64d
-FCOMMON_OPT += -march=rv64imafdcv -mabi=lp64d
+RISCV64_OPT := $(RISCV64_OPT)_zvfh_zfh
 endif
+ifeq ($(BUILD_BFLOAT16), 1)
+RISCV64_OPT := $(RISCV64_OPT)_zvfbfwma
+endif
+ifeq ($(CORE), RISCV64_ZVL256B)
+CCOMMON_OPT += -march=$(RISCV64_OPT)_zvl256b -mabi=lp64d
+FCOMMON_OPT += -march=$(RISCV64_OPT) -mabi=lp64d
 endif
 ifeq ($(CORE), RISCV64_ZVL128B)
-ifeq ($(BUILD_HFLOAT16), 1)
-CCOMMON_OPT += -march=rv64imafdcv_zvfh_zfh -mabi=lp64d
-FCOMMON_OPT += -march=rv64imafdcv_zvfh_zfh -mabi=lp64d
-else
-CCOMMON_OPT += -march=rv64imafdcv -mabi=lp64d
-FCOMMON_OPT += -march=rv64imafdcv -mabi=lp64d
-endif
+CCOMMON_OPT += -march=$(RISCV64_OPT) -mabi=lp64d
+FCOMMON_OPT += -march=$(RISCV64_OPT) -mabi=lp64d
 endif
 ifeq ($(CORE), RISCV64_GENERIC)
 CCOMMON_OPT += -march=rv64imafdc -mabi=lp64d
@@ -3,7 +3,7 @@
 #

 # This library's version
-VERSION = 0.3.30.dev
+VERSION = 0.3.33.dev

 # If you set this prefix, the library name will be lib$(LIBNAMESUFFIX)openblas.a
 # and lib$(LIBNAMESUFFIX)openblas.so, with a matching soname in the shared library
@@ -290,10 +290,10 @@ COMMON_PROF = -pg
 # This is mostly intended as a developer feature to spot regressions, but users and
 # package maintainers can enable this if they have doubts about the thread safety of
 # the library, given the configuration in this file.
-# By default, the thread safety tester launches 52 concurrent calculations at the same
-# time.
+# By default, the thread safety testers launch many concurrent calculations at
+# the same time.
 #
-# Please note that the test uses ~1300 MiB of RAM for the DGEMM test.
+# Please note that the tests use ~1300 MiB of RAM for the DGEMM test.
 #
 # The test requires CBLAS to be built, a C++11 capable compiler and the presence of
 # an OpenMP implementation. If you are cross-compiling this test will probably not
@@ -194,7 +194,7 @@ ifeq ($(TARGET_CORE), EXCAVATOR)
 GETARCH_FLAGS := -DFORCE_BARCELONA
 endif
 ifeq ($(TARGET_CORE), ZEN)
-GETARCH_FLAGS := -DFORCE_BARCELONA
+GETARCH_FLAGS := -DFORCE_NEHALEM
 endif
 endif

@@ -247,6 +247,11 @@ NO_PARALLEL_MAKE=0
 endif
 GETARCH_FLAGS	+= -DNO_PARALLEL_MAKE=$(NO_PARALLEL_MAKE)

+ifndef MAKE_NB_JOBS
+ifneq (,$(patsubst -j%,%,$(filter -j%,$(MAKEFLAGS))))
+MAKE_NB_JOBS=-1
+endif
+endif
 ifdef MAKE_NB_JOBS
 GETARCH_FLAGS += -DMAKE_NB_JOBS=$(MAKE_NB_JOBS)
 endif
@@ -331,6 +336,7 @@ HAVE_SSE5=
 HAVE_AVX=
 HAVE_AVX2=
 HAVE_FMA3=
+HAVE_SME=
 include $(TOPDIR)/Makefile_kernel.conf
 endif

@@ -416,6 +422,9 @@ endif
 ifeq ($(C_COMPILER), CLANG)
 CLANGVERSIONGTEQ9 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 9)
 CLANGVERSIONGTEQ12 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 12)
+ifeq ($(F_COMPILER), GFORTRAN)
+GCCVERSIONGT4 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \> 4)
+endif
 endif

 #
@@ -427,7 +436,7 @@ ifndef MACOSX_DEPLOYMENT_TARGET
 ifeq ($(ARCH), arm64)
 export MACOSX_DEPLOYMENT_TARGET=11.0
 export NO_SVE = 1
-export NO_SME = 1
+# export NO_SME = 1
 else
 export MACOSX_DEPLOYMENT_TARGET=10.8
 endif
@@ -441,7 +450,7 @@ ifeq (x$(XCVER), x 15)
 CCOMMON_OPT += -Wl,-ld_classic
 FCOMMON_OPT += -Wl,-ld_classic
 endif
-ifeq (x$(XCVER), x 16)
+ifeq ($(shell [ $(XCVER) -ge 16 ] && echo yes),yes)
 override CEXTRALIB := $(filter-out(-lto_library, $(CEXTRALIB))) 
 endif
 endif
@@ -468,7 +477,7 @@ EXTRALIB	+= -lm
 endif

 ifeq ($(OSNAME), $(filter $(OSNAME),FreeBSD OpenBSD NetBSD DragonFly))
-ifeq ($(ARCH), $(filter $(ARCH),arm arm64))
+ifeq ($(ARCH), $(filter $(ARCH),arm arm64 power))
 EXTRALIB	+= -lm
 endif
 endif
@@ -721,12 +730,31 @@ DYNAMIC_CORE += A64FX
 endif
 ifneq ($(NO_SME), 1)
 DYNAMIC_CORE += ARMV9SME
+ifeq ($(OSNAME), Darwin)
+ifneq ($(C_COMPILER), GCC)
+DYNAMIC_CORE += VORTEXM4
+endif
+endif
 endif
 DYNAMIC_CORE += THUNDERX
 DYNAMIC_CORE += THUNDERX2T99
 DYNAMIC_CORE += TSV110
 DYNAMIC_CORE += EMAG8180
 DYNAMIC_CORE += THUNDERX3T110
+
+ifeq ($(OSNAME), Darwin)
+DYNAMIC_CORE =  ARMV8
+DYNAMIC_CORE += NEOVERSEN1
+ifneq ($(NO_SME), 1)
+DYNAMIC_CORE += ARMV9SME
+ifeq ($(OSNAME), Darwin)
+ifneq ($(C_COMPILER), GCC)
+DYNAMIC_CORE += VORTEXM4
+endif
+endif
+endif
+endif
+
 ifdef DYNAMIC_LIST
 override DYNAMIC_CORE = ARMV8 $(DYNAMIC_LIST)
 XCCOMMON_OPT = -DDYNAMIC_LIST -DDYN_ARMV8
@@ -887,7 +915,7 @@ NO_BINARY_MODE  = 1
 BINARY_DEFINED  = 1
 ifdef INTERFACE64
 ifneq ($(INTERFACE64), 0)
-ifeq ($(F_COMPILER), GFORTRAN)
+ifeq ($(F_COMPILER), $(filter $(F_COMPILER),GFORTRAN FLANGNEW))
 FCOMMON_OPT +=  -fdefault-integer-8
 endif
 ifeq ($(F_COMPILER), FLANG)
@@ -902,7 +930,7 @@ NO_BINARY_MODE  = 1
 BINARY_DEFINED  = 1
 ifdef INTERFACE64
 ifneq ($(INTERFACE64), 0)
-ifeq ($(F_COMPILER), GFORTRAN)
+ifeq ($(F_COMPILER), $(filter $(F_COMPILER),GFORTRAN FLANGNEW))
 FCOMMON_OPT +=  -fdefault-integer-8
 endif
 ifeq ($(F_COMPILER), FLANG)
@@ -917,7 +945,7 @@ NO_BINARY_MODE  = 1
 BINARY_DEFINED  = 1
 ifdef INTERFACE64
 ifneq ($(INTERFACE64), 0)
-ifeq ($(F_COMPILER), GFORTRAN)
+ifeq ($(F_COMPILER), $(filter $(F_COMPILER),GFORTRAN FLANGNEW))
 FCOMMON_OPT +=  -fdefault-integer-8
 endif
 ifeq ($(F_COMPILER), FLANG)
@@ -1620,7 +1648,11 @@ ifneq ($(C_COMPILER), SUN)
 CCOMMON_OPT     += -UASMNAME -UASMFNAME -UNAME -UCNAME -UCHAR_NAME -UCHAR_CNAME
 endif
 endif
+ifeq ( ,$(findstring pizfix,$(CEXTRALIB)))
 CCOMMON_OPT	+= -DASMNAME=$(FU)$(*F) -DASMFNAME=$(FU)$(*F)$(BU) -DNAME=$(*F)$(BU) -DCNAME=$(*F) -DCHAR_NAME=\"$(*F)$(BU)\" -DCHAR_CNAME=\"$(*F)\"
+else
+CCOMMON_OPT	+= -DASMNAME=$(FU)pizlonated_$(*F) -DASMFNAME=$(FU)pizlonated_$(*F)$(BU) -DNAME=$(*F)$(BU) -DCNAME=$(*F) -DCHAR_NAME=\"$(*F)$(BU)\" -DCHAR_CNAME=\"$(*F)\"
+endif

 ifeq ($(CORE), PPC440)
 CCOMMON_OPT	+= -DALLOC_QALLOC
@@ -1790,6 +1822,14 @@ ifndef LIBSUFFIX
 LIBSUFFIX = a
 endif

+ifndef EXE
+ifeq ($(OSNAME), $(filter $(OSNAME),WINNT CYGWIN_NT))
+EXE = .exe
+else
+EXE =
+endif
+endif
+
 ifneq ($(DYNAMIC_ARCH), 1)
 ifndef SMP
 LIBNAME		= $(LIBPREFIX)_$(LIBCORE)$(REVISION).$(LIBSUFFIX)
@@ -1896,6 +1936,7 @@ ifndef NO_MSA
  export HAVE_MSA
  export MSA_FLAGS
 endif
+export HAVE_SME
 export KERNELDIR
 export FUNCTION_PROFILE
 export TARGET_CORE
@@ -0,0 +1 @@
+CCOMMON_OPT += -msimd128
@@ -61,6 +61,9 @@ endif
 ifeq ($(CORE), SKYLAKEX)
 ifndef NO_AVX512
 CCOMMON_OPT += -march=skylake-avx512
+ifeq ($(C_COMPILER), CLANG)
+CCOMMON_OPT += -mllvm -exhaustive-register-search
+endif
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=skylake-avx512
 endif
@@ -93,6 +96,7 @@ ifeq ($(C_COMPILER), GCC)
  endif
 endif
 else ifeq ($(C_COMPILER), CLANG)
+ CCOMMON_OPT += -mllvm -exhaustive-register-search
 # cooperlake support was added in clang 9
 ifeq ($(CLANGVERSIONGTEQ9), 1)
  CCOMMON_OPT += -march=cooperlake
@@ -135,6 +139,7 @@ ifeq ($(C_COMPILER), GCC)
  endif
 endif
 else ifeq ($(C_COMPILER), CLANG)
+  CCOMMON_OPT += -mllvm -exhaustive-register-search
 # sapphire rapids support was added in clang 12
 ifeq ($(CLANGVERSIONGTEQ12), 1)
  CCOMMON_OPT += -march=sapphirerapids
@@ -2,15 +2,10 @@

 [![Join the chat at https://gitter.im/xianyi/OpenBLAS](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/xianyi/OpenBLAS?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

-Cirrus CI: [![Build Status](https://api.cirrus-ci.com/github/xianyi/OpenBLAS.svg?branch=develop)](https://cirrus-ci.com/github/xianyi/OpenBLAS)
+GitHub Actions: [![Build Status](https://github.com/OpenMathLib/OpenBLAS/actions/workflows/dynamic_arch.yml/badge.svg?branch=develop)](https://github.com/OpenMathLib/OpenBLAS/actions/workflows/dynamic_arch.yml?query=branch%3Adevelop)

+Azure Pipelines: [![Build Status](https://dev.azure.com/xianyi/OpenBLAS/_apis/build/status/xianyi.OpenBLAS?branchName=develop)](https://dev.azure.com/xianyi/OpenBLAS/_build/latest?definitionId=1&branchName=develop)

-
-[![Build Status](https://dev.azure.com/xianyi/OpenBLAS/_apis/build/status/xianyi.OpenBLAS?branchName=develop)](https://dev.azure.com/xianyi/OpenBLAS/_build/latest?definitionId=1&branchName=develop)
-
-OSUOSL POWERCI [![Build Status](https://powerci.osuosl.org/buildStatus/icon?job=OpenBLAS_gh%2Fdevelop)](http://powerci.osuosl.org/job/OpenBLAS_gh/job/develop/)
-
-OSUOSL IBMZ-CI [![Build Status](http://ibmz-ci.osuosl.org/buildStatus/icon?job=OpenBLAS-Z%2Fdevelop)](http://ibmz-ci.osuosl.org/job/OpenBLAS-Z/job/develop/)
 ## Introduction

 OpenBLAS is an optimized BLAS (Basic Linear Algebra Subprograms) library based on GotoBLAS2 1.13 BSD version.
@@ -148,11 +143,12 @@ Please read `GotoBLAS_01Readme.txt` for older CPU models already supported by th
 - **Intel Haswell**: Optimized Level-3 and Level-2 BLAS with AVX2 and FMA on x86-64.
 - **Intel Skylake-X**: Optimized Level-3 and Level-2 BLAS with AVX512 and FMA on x86-64.
 - **Intel Cooper Lake**: as Skylake-X with improved BFLOAT16 support.
+- **Intel Sapphire Rapids**: as Cooper Lake with improved BFLOAT16 SBGEMM kernel.
 - **AMD Bobcat**: Used GotoBLAS2 Barcelona codes.
 - **AMD Bulldozer**: x86-64 ?GEMM FMA4 kernels. (Thanks to Werner Saar)
 - **AMD PILEDRIVER**: Uses Bulldozer codes with some optimizations.
 - **AMD STEAMROLLER**: Uses Bulldozer codes with some optimizations.
- **AMD ZEN**: Uses Haswell codes with some optimizations for Zen 2/3 (use SkylakeX for Zen4)
+- **AMD ZEN**: Uses Haswell codes with some optimizations for Zen 2/3, SkylakeX for Zen4, Cooperlake for Zen5

 #### MIPS32

@@ -175,7 +171,7 @@ Please read `GotoBLAS_01Readme.txt` for older CPU models already supported by th
 - **Cortex-A53**: same as ARMV8 (different cpu specifications)
 - **Cortex-A55**: same as ARMV8 (different cpu specifications)
 - **Cortex A57**: Optimized Level-3 and Level-2 functions
- **Cortex A72**: same as A57 ( different cpu specifications)
+- **Cortex A72**: same as A57 (different cpu specifications)
 - **Cortex A73**: same as A57 (different cpu specifications)
 - **Cortex A76**: same as A57 (different cpu specifications)
 - **Falkor**: same as A57 (different cpu specifications)
@@ -186,9 +182,15 @@ Please read `GotoBLAS_01Readme.txt` for older CPU models already supported by th
 - **EMAG 8180**: preliminary support based on A57
 - **Neoverse N1**: (AWS Graviton2) preliminary support
 - **Neoverse V1**: (AWS Graviton3) optimized Level-3 BLAS
+- **Neoverse N2**: preliminary support
+- **Neoverse V2**: preliminary support
+- **Neoverse V3**: preliminary support
+- **Neoverse V3AE**: preliminary support
 - **Apple Vortex**: preliminary support based on ThunderX2/3
+- **Apple VortexM4**: preliminary support based on ThunderX2/3, SME kernels for SGEMM,SSYMM,STRMM,SSYRK,SSYR2K
 - **A64FX**:  preliminary support, optimized Level-3 BLAS
 - **ARMV8SVE**: any ARMV8 cpu with SVE extensions 
+- **ARMV9SME**: any ARMV9 cpu with SVE and SME extensions 

 #### PPC/PPC64

@@ -219,6 +221,8 @@ Please read `GotoBLAS_01Readme.txt` for older CPU models already supported by th
  make HOSTCC=gcc TARGET=x280 NUM_THREADS=8 CC=riscv64-unknown-linux-gnu-clang FC=riscv64-unknown-linux-gnu-gfortran
  ```

+(For RVV 1.0 target selection and compiler requirements, see the [RISC-V section in docs/install.md](docs/install.md#risc-v).)
+
 - **ZVL???B**: Level-3 BLAS and Level-1,2 including vectorised kernels targeting generic RISCV cores with vector support with registers of at least the corresponding width; ZVL128B and ZVL256B are available.
 e.g.:
  ```sh
@@ -249,9 +253,15 @@ e.g.:
  ```
  The old-style TARGET=LOONGSON3R5 is still supported

+#### WASM
+  Not a cpu target in the strict sense, but portable WebAssembly for browser-based applications and the like. See emscripten.org for the compiler and related information
+
+- **WASM128_GENERIC**: Optimized SGEMM,DGEMM, DAXPY, SSUM/DSUM, SDOT/DDOT and SROT/DROT
+
+
 ### Support for multiple targets in a single library

-OpenBLAS can be built for multiple targets with runtime detection of the target cpu by specifiying `DYNAMIC_ARCH=1` in Makefile.rule, on the gmake command line or as `-DDYNAMIC_ARCH=TRUE` in cmake.
+OpenBLAS can be built for multiple targets with runtime detection of the target cpu by specifying `DYNAMIC_ARCH=1` in Makefile.rule, on the gmake command line or as `-DDYNAMIC_ARCH=TRUE` in cmake.

 For **x86_64**, the list of targets this activates contains Prescott, Core2, Nehalem, Barcelona, Sandybridge, Bulldozer, Piledriver, Steamroller, Excavator, Haswell, Zen, SkylakeX, Cooper Lake, Sapphire Rapids. For cpu generations not included in this list, the corresponding older model is used. If you also specify `DYNAMIC_OLDER=1`, specific support for Penryn, Dunnington, Opteron, Opteron/SSE3, Bobcat, Atom and Nano is added. Finally there is an option `DYNAMIC_LIST` that allows to specify an individual list of targets to include instead of the default.

@@ -277,23 +287,29 @@ Please note that it is not possible to combine support for different architectur
 ### Supported OS

 - **GNU/Linux**
- **MinGW or Visual Studio (CMake)/Windows**: Please read <https://github.com/xianyi/OpenBLAS/wiki/How-to-use-OpenBLAS-in-Microsoft-Visual-Studio>.
- **Darwin/macOS/OSX/iOS**: Experimental. Although GotoBLAS2 already supports Darwin, we are not OSX/iOS experts.
- **FreeBSD**: Supported by the community. We don't actively test the library on this OS.
+- **MinGW or Visual Studio (CMake)/Windows**: Please read <https://github.com/OpenMathLib/OpenBLAS/blob/develop/docs/install.md#visual-studio--native-windows-abi>.
+- **Darwin/macOS/OSX/iOS**: Already supported on PPC and x86 by the original GotoBLAS, now also on ARM64 but we are not OSX/iOS experts.
+- **FreeBSD**: Supported by the community. Basic test coverage is provided by GitHub Actions.
 - **OpenBSD**: Supported by the community. We don't actively test the library on this OS.
 - **NetBSD**: Supported by the community. We don't actively test the library on this OS.
 - **DragonFly BSD**: Supported by the community. We don't actively test the library on this OS.
- **Android**: Supported by the community. Please read <https://github.com/xianyi/OpenBLAS/wiki/How-to-build-OpenBLAS-for-Android>.
- **AIX**: Supported on PPC up to POWER10
+- **Android**: Supported by the community. Please read <https://github.com/OpenMathLib/OpenBLAS/blob/develop/docs/install.md#android>.
+- **AIX**: Supported on PPC up to POWER10 but testing is increasingly problematic due to lack of publicly available systems
 - **Haiku**: Supported by the community. We don't actively test the library on this OS.
 - **SunOS**: Supported by the community. We don't actively test the library on this OS.
- **Cortex-M**: Supported by the community. Please read <https://github.com/xianyi/OpenBLAS/wiki/How-to-use-OpenBLAS-on-Cortex-M>.
+- **Cortex-M**: Supported by the community. Please read <https://github.com/OpenMathLib/OpenBLAS/blob/develop/docs/install.md#cortex-m>.

 ## Usage

 Statically link with `libopenblas.a` or dynamically link with `-lopenblas` if OpenBLAS was
 compiled as a shared library.

+### Considerations for using the library from Java
+
+The default stack size of only 1MB may be too small, especially if you built OpenBLAS to support larger matrix sizes than provided for by the default settings. Use the -Xss option to request a larger stack size if you encounter problems.
+
+When a Windows build of OpenBLAS was created using the MINGW gfortran (for the LAPACK parts), the java application may hang on startup due to a deadlock between the gfortran runtime library initialization and any pipes created by a Win11/SBT/Play Framework environment. Use -Djdk.console=jdk.internal.le to work around this. 
+
 ### Setting the number of threads using environment variables

 Environment variables are used to specify a maximum number of threads.
@@ -111,6 +111,7 @@ THUNDERX2T99
 TSV110
 THUNDERX3T110
 VORTEX
+VORTEXM4
 A64FX
 ARMV8SVE
 ARMV9SME
@@ -152,3 +153,7 @@ EV6
 14.CSKY
 CSKY
 CK860FV
+
+15. WebAssembly/Emscripten:
+WASM128_GENERIC
+
@@ -4,6 +4,15 @@ trigger:
  branches:
    include:
      - develop
+  paths:
+    exclude:
+      - 'docs/**'
+      - '**/*.md'
+pr:
+  paths:
+    exclude:
+      - 'docs/**'
+      - '**/*.md'
 resources:
  containers:
      - container: oneapi-hpckit
@@ -91,11 +100,12 @@ jobs:
      openblas_utest.exe

 - job: Windows_mingw_gmake
+  timeoutInMinutes: 100
  pool:
     vmImage: 'windows-latest'
  steps:   
  - script: |
-      mingw32-make CC=gcc FC=gfortran DYNAMIC_ARCH=1 DYNAMIC_LIST="SANDYBRIDGE"
+      mingw32-make CC=gcc NOLAPACK=1 DYNAMIC_ARCH=1 DYNAMIC_LIST="SANDYBRIDGE"

 - job: Windows_clang_cmake
  pool:
@@ -155,7 +165,7 @@ jobs:

 - job: OSX_OpenMP
  pool:
-     vmImage: 'macOS-13'
+     vmImage: 'macOS-14'
  steps:   
  - script: |
      brew update
@@ -165,19 +175,19 @@ jobs:
     
 - job: OSX_GCC_Nothreads
  pool:
-     vmImage: 'macOS-13'
+     vmImage: 'macOS-14'
  steps:   
  - script: |
      brew update
      make USE_THREADS=0 CC=gcc-13 FC=gfortran-13
     
- job: OSX_GCC12
+- job: OSX_GCC15
  pool:
     vmImage: 'macOS-latest'
  steps:   
  - script: |
      brew update
-      make CC=gcc-12 FC=gfortran-12
+      make CC=gcc-15 FC=gfortran-15

 - job: OSX_LLVM_flangnew
  pool:
@@ -185,6 +195,7 @@ jobs:
  variables:
     LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
     LIBRARY_PATH: /usr/local/opt/llvm/lib
+     RANLIB: touch
  steps:   
  - script: |
      brew update
@@ -197,11 +208,12 @@ jobs:
  variables:
     LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
     LIBRARY_PATH: /usr/local/opt/llvm/lib
+     RANLIB: touch
  steps:   
  - script: |
      brew update
      brew install llvm libomp
-      make TARGET=CORE2 USE_OPENMP=1 DYNAMIC_ARCH=1 CC=/usr/local/opt/llvm/bin/clang NOFORTRAN=1
+      make TARGET=CORE2 USE_OPENMP=1 DYNAMIC_ARCH=1 DYNAMIC_LIST='NEHALEM HASWELL SKYLAKEX' CC=/usr/local/opt/llvm/bin/clang NOFORTRAN=1

 - job: OSX_OpenMP_Clang_cmake
  pool:
@@ -215,13 +227,13 @@ jobs:
      brew install llvm libomp
      mkdir build
      cd build
-      cmake -DTARGET=CORE2 -DUSE_OPENMP=1 -DINTERFACE64=1 -DDYNAMIC_ARCH=1 -DCMAKE_C_COMPILER=/usr/local/opt/llvm/bin/clang -DNOFORTRAN=1 -DNO_AVX512=1 ..
+      cmake -DTARGET=CORE2 -DUSE_OPENMP=1 -DINTERFACE64=1 -DDYNAMIC_ARCH=1 -DDYNAMIC_LIST='NEHALEM HASWELL SKYLAKEX' -DCMAKE_C_COMPILER=/usr/local/opt/llvm/bin/clang -DNOFORTRAN=1 -DNO_AVX512=1 ..
      make
      ctest
      
 - job: OSX_dynarch_cmake
  pool:
-     vmImage: 'macOS-13'
+     vmImage: 'macOS-14'
  variables:
     LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
     LIBRARY_PATH: /usr/local/opt/llvm/lib
@@ -240,6 +252,7 @@ jobs:
     LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
     MACOS_HPCKIT_URL: https://registrationcenter-download.intel.com/akdlm/IRC_NAS/edb4dc2f-266f-47f2-8d56-21bc7764e119/m_HPCKit_p_2023.2.0.49443.dmg
     LIBRARY_PATH: /usr/local/opt/llvm/lib
+     RANLIB: touch
     MACOS_FORTRAN_COMPONENTS: intel.oneapi.mac.ifort-compiler
  steps:   
  - script: |
@@ -268,7 +281,7 @@ jobs:
 
 - job: OSX_NDK_ARMV7
  pool:
-     vmImage: 'macOS-13'
+     vmImage: 'macOS-14'
  steps:   
  - script: | 
      brew update
@@ -278,35 +291,37 @@ jobs:

 - job: OSX_IOS_ARMV8
  pool:
-     vmImage: 'macOS-13'
+     vmImage: 'macOS-14'
  variables:
-     CC: /Applications/Xcode_14.2.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-     CFLAGS: -O2 -Wno-macro-redefined -isysroot /Applications/Xcode_14.2.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS16.2.sdk -arch arm64 -miphoneos-version-min=10.0
+     CC: /Applications/Xcode_16.2.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
+     CFLAGS: -O2 -Wno-macro-redefined -isysroot /Applications/Xcode_16.2.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS18.2.sdk -arch arm64 -miphoneos-version-min=10.0
  steps:
  - script: |
+     ls /Applications/Xcode_16.2.app/Contents/Developer/Platforms/
+     ls /Applications/Xcode_16.2.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs
     make TARGET=ARMV8 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1

 - job: OSX_IOS_ARMV7
  pool:
-     vmImage: 'macOS-13'
+     vmImage: 'macOS-14'
  variables:
-     CC: /Applications/Xcode_14.2.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-     CFLAGS: -O2 -mno-thumb -Wno-macro-redefined -isysroot /Applications/Xcode_14.2.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS16.2.sdk -arch armv7 -miphoneos-version-min=5.1
+     CC: /Applications/Xcode_16.2.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
+     CFLAGS: -O2 -mno-thumb -Wno-macro-redefined -isysroot /Applications/Xcode_16.2.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS18.2.sdk -arch armv7 -miphoneos-version-min=5.1
  steps:
  - script: |
     make TARGET=ARMV7 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1

 - job: OSX_xbuild_DYNAMIC_ARM64
  pool:
-     vmImage: 'macOS-13'
+     vmImage: 'macOS-14'
  variables:
-     CC: /Applications/Xcode_14.2.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-     CFLAGS: -O2 -Wno-macro-redefined -isysroot /Applications/Xcode_14.2.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX13.1.sdk -arch arm64
+     CC: /Applications/Xcode_16.2.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
+     CFLAGS: -O2 -Wno-macro-redefined -isysroot /Applications/Xcode_16.2.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX15.2.sdk -arch arm64
  steps:
  - script: |
-     ls /Applications/Xcode_14.2.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs
+     ls /Applications/Xcode_16.2.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs
     /Applications/Xcode_12.2.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang -arch arm64 --print-supported-cpus
-     /Applications/Xcode_14.2.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang --version
+     /Applications/Xcode_16.2.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang --version
     make TARGET=ARMV8 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1

 - job: ALPINE_MUSL
@@ -3155,7 +3155,7 @@ bgemv.$(SUFFIX) : gemv.c
 	$(CC) $(CFLAGS) -c -DBFLOAT16 -DBGEMM -UCOMPLEX -UDOUBLE -o $(@F) $^
 sbgemv.$(SUFFIX) : gemv.c
 	$(CC) $(CFLAGS) -c -DBFLOAT16 -UCOMPLEX -UDOUBLE -o $(@F) $^
-endif ()
+endif

 zgemv.$(SUFFIX) : gemv.c
 	$(CC) $(CFLAGS) -c -DCOMPLEX -DDOUBLE -o $(@F) $^
@@ -95,7 +95,6 @@ static void *aligned_alloc_cacheline(size_t n)
 #if defined(__WIN32__) || defined(__WIN64__) || !defined(_POSIX_TIMERS)
  struct timeval start, stop;
 #elif defined(__APPLE__)
- mach_timebase_info_data_t info;
 uint64_t start = 0, stop = 0;
 #else
  struct timespec start = { 0, 0 }, stop = { 0, 0 };
@@ -106,8 +105,7 @@ double getsec()
 #if defined(__WIN32__) || defined(__WIN64__) || !defined(_POSIX_TIMERS)
    return (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 #elif defined(__APPLE__)
-    mach_timebase_info(&info);
-    return (double)(((stop - start) * info.numer)/info.denom) * 1.e-9;
+    return (double)(stop - start) * 1.e-9;
 #else
    return (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_nsec - start.tv_nsec)) * 1.e-9;
 #endif
@@ -236,7 +236,7 @@ def test_gesdd(benchmark, mn, variant):

    assert info == 0

-    atol = {'s': 1e-5, 'd': 1e-13}
+    atol = {'s': 5e-5, 'd': 1e-13}
    np.testing.assert_allclose(u @ np.diag(s) @ vt, a, atol=atol[variant])


@@ -23,6 +23,7 @@ config="$2"
 compiler_name="$3"
 shift 3
 flags="$*"
+darwin_os=""

 # First, we need to know the target OS and compiler name
 {
@@ -69,7 +70,7 @@ case "$data" in *OS_FREEBSD*) os=FreeBSD ;; esac
 case "$data" in *OS_NETBSD*) os=NetBSD ;; esac
 case "$data" in *OS_OPENBSD*) os=OpenBSD ;; esac
 case "$data" in *OS_DRAGONFLY*) os=DragonFly ;; esac
-case "$data" in *OS_DARWIN*) os=Darwin ;; esac
+case "$data" in *OS_DARWIN*) os=Darwin; darwin_os=macOS ;; esac
 case "$data" in *OS_SUNOS*) os=SunOS ;; esac
 case "$data" in *OS_AIX*) os=AIX ;; esac
 case "$data" in *OS_OSF*) os=osf ;; esac
@@ -78,6 +79,7 @@ case "$data" in *OS_CYGWIN_NT*) os=CYGWIN_NT ;; esac
 case "$data" in *OS_INTERIX*) os=Interix ;; esac
 case "$data" in *OS_ANDROID*) os=Android ;; esac
 case "$data" in *OS_HAIKU*) os=Haiku ;; esac
+case "$data" in *OS_IOS*) darwin_os=iOS ;; esac

 case "$data" in
    *ARCH_X86_64*) architecture=x86_64 ;;
@@ -95,6 +97,7 @@ case "$data" in
    *ARCH_RISCV64*) architecture=riscv64 ;;
    *ARCH_LOONGARCH64*) architecture=loongarch64 ;;
    *ARCH_CSKY*) architecture=csky ;;
+    *ARCH_WASM*) architecture=wasm ;;
 esac

 defined=0
@@ -128,7 +131,7 @@ case "$architecture" in
    	defined=1
    	;;
    arm|arm64) defined=1 ;;
-    zarch|e2k|alpha|ia64|riscv64|loonarch64)
+    zarch|e2k|alpha|ia64|riscv64|loongarch64|wasm)
    	defined=1
    	BINARY=64
    	;;
@@ -252,6 +255,7 @@ case "$data" in
    *ARCH_ZARCH*) architecture=zarch ;;
    *ARCH_LOONGARCH64*) architecture=loongarch64 ;;
    *ARCH_CSKY*) architecture=csky ;;
+    *ARCH_WASM*) architecture=wasm ;;
 esac

 binformat='bin32'
@@ -335,7 +339,14 @@ if [ "$architecture" = "arm64" ]; then
 fi

 no_sme=0
+is_appleclang=0
 if [ "$architecture" = "arm64" ]; then
+    if [ "$compiler" = "CLANG" ]; then
+        vdata=`$compiler_name --version`
+	case "$vdata" in Apple*)
+	is_appleclang=1
+	esac
+    fi
    tmpd=$(mktemp -d 2>/dev/null || mktemp -d -t 'OBC')
    tmpf="$tmpd/a.S"
    printf ".text \n.global sme_test\n\nsme_test:\nsmstart\nsmstop\nret\n">> "$tmpf"
@@ -393,7 +404,7 @@ fi
 data=`$compiler_name $flags -S ctest1.c && grep globl ctest1.s | head -n 1 && rm -f ctest1.s`

 need_fu=''
-if echo "$data" | grep 'globl[[:space:]][_\.]'; then
+if echo "$data" | grep -q 'globl[[:space:]][_\.]'; then
    need_fu="${data##*globl[[:space:]]}"
    need_fu="${need_fu%%[!_\.]*}"
 fi
@@ -410,6 +421,8 @@ fi
 [ "$os" = "Android" ] && [ "$hostos" = "Linux" ] && [ -n "$TERMUX_APP_PID" ] \
    && cross=0

+[ "$darwin_os" = iOS ] && cross=1
+
 [ "$USE_OPENMP" != 1 ] && openmp=''

 linker_L=""
@@ -469,17 +482,18 @@ done
    [ "$no_avx512bf" -eq 1 ] && printf "NO_AVX512BF16=1\n"
    [ "$no_avx2" -eq 1 ] && printf "NO_AVX2=1\n"
    [ "$oldgcc" -eq 1 ] && printf "OLDGCC=1\n"
+    [ "$is_appleclang" -eq 1 ] && printf "APPLECLANG=1\n"
    exit 0
 }

 :> "$makefile" || exit 1
 :> "$config" || exit 1

-
 # print $data, "\n";

 {
    printf "OSNAME=%s\n" "$os"
+    [ -n "$darwin_os" ] && printf "OSNAME_DISPLAY=%s\n" "$darwin_os"
    printf "ARCH=%s\n" "$architecture"
    printf "C_COMPILER=%s\n" "$compiler"
    [ $binformat != 'bin32' ] && printf "BINARY32=\n"
@@ -499,6 +513,7 @@ done
    [ "$no_avx512bf" -eq 1 ] && printf "NO_AVX512BF16=1\n"
    [ "$no_avx2" -eq 1 ] && printf "NO_AVX2=1\n"
    [ "$oldgcc" -eq 1 ] && printf "OLDGCC=1\n"
+    [ "$is_appleclang" -eq 1 ] && printf "APPLECLANG=1\n"
    [ "$no_lsx" -eq 1 ] && printf "NO_LSX=1\n"
    [ "$no_lasx" -eq 1 ] && printf "NO_LASX=1\n"
 } >> "$makefile"
@@ -56,6 +56,7 @@ if ($@){
 }

 $compiler = "";
+$darwin_os = "";
 $compiler = LSB       if ($data =~ /COMPILER_LSB/);
 $compiler = CLANG     if ($data =~ /COMPILER_CLANG/);
 $compiler = PGI       if ($data =~ /COMPILER_PGI/);
@@ -73,7 +74,13 @@ $os = FreeBSD         if ($data =~ /OS_FREEBSD/);
 $os = NetBSD          if ($data =~ /OS_NETBSD/);
 $os = OpenBSD         if ($data =~ /OS_OPENBSD/);
 $os = DragonFly       if ($data =~ /OS_DRAGONFLY/);
-$os = Darwin          if ($data =~ /OS_DARWIN/);
+if ($data =~ /OS_DARWIN/) {
+    $os = Darwin;
+    $darwin_os = "macOS";
+}
+if ($data =~ /OS_IOS/) {
+    $darwin_os = "iOS";
+}
 $os = SunOS           if ($data =~ /OS_SUNOS/);
 $os = AIX             if ($data =~ /OS_AIX/);
 $os = osf             if ($data =~ /OS_OSF/);
@@ -391,6 +398,7 @@ if ($architecture ne $hostarch) {

 $cross = 1 if ($os ne $hostos);
 $cross = 0 if (($os eq "Android") && ($hostos eq "Linux") && ($ENV{TERMUX_APP_PID} != ""));
+$cross = 1 if $darwin_os eq "iOS";

 $openmp = "" if $ENV{USE_OPENMP} != 1;

@@ -454,6 +462,7 @@ open(CONFFILE, "> $config"  ) || die "Can't create $config";
 # print $data, "\n";

 print MAKEFILE "OSNAME=$os\n";
+print MAKEFILE "OSNAME_DISPLAY=$darwin_os\n" if $darwin_os ne "";
 print MAKEFILE "ARCH=$architecture\n";
 print MAKEFILE "C_COMPILER=$compiler\n";
 print MAKEFILE "BINARY32=\n" if $binformat ne bin32;
@@ -456,6 +456,14 @@ void cblas_cgemm_batch(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enu
 void cblas_zgemm_batch(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransA_array, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransB_array, OPENBLAS_CONST blasint * M_array, OPENBLAS_CONST blasint * N_array, OPENBLAS_CONST blasint * K_array,
 		       OPENBLAS_CONST void * alpha_array, OPENBLAS_CONST void ** A_array, OPENBLAS_CONST blasint * lda_array, OPENBLAS_CONST void ** B_array, OPENBLAS_CONST blasint * ldb_array, OPENBLAS_CONST void * beta_array, void ** C_array, OPENBLAS_CONST blasint * ldc_array, OPENBLAS_CONST blasint group_count, OPENBLAS_CONST blasint * group_size);

+void cblas_sgemm_batch_strided(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float * A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST blasint stridea, OPENBLAS_CONST float * B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST blasint strideb, OPENBLAS_CONST float beta, float * C, OPENBLAS_CONST blasint ldc, OPENBLAS_CONST blasint stridec, OPENBLAS_CONST blasint group_size);
+
+void cblas_dgemm_batch_strided(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double alpha, OPENBLAS_CONST double * A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST blasint stridea, OPENBLAS_CONST double * B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST blasint strideb, OPENBLAS_CONST double beta, double * C, OPENBLAS_CONST blasint ldc, OPENBLAS_CONST blasint stridec, OPENBLAS_CONST blasint group_size);
+
+void cblas_cgemm_batch_strided(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void * alpha, OPENBLAS_CONST void * A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST blasint stridea, OPENBLAS_CONST void * B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST blasint strideb, OPENBLAS_CONST void * beta, void * C, OPENBLAS_CONST blasint ldc, OPENBLAS_CONST blasint stridec, OPENBLAS_CONST blasint group_size);
+
+void cblas_zgemm_batch_strided(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void * alpha, OPENBLAS_CONST void * A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST blasint stridea, OPENBLAS_CONST void * B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST blasint strideb, OPENBLAS_CONST void * beta, void * C, OPENBLAS_CONST blasint ldc, OPENBLAS_CONST blasint stridec, OPENBLAS_CONST blasint group_size);
+
 /*** BFLOAT16 and INT8 extensions ***/
 /* convert float array to BFLOAT16 array by rounding */
 void   cblas_sbstobf16(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *in, OPENBLAS_CONST blasint incin, bfloat16 *out, OPENBLAS_CONST blasint incout);
@@ -477,6 +485,7 @@ void   cblas_sbgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum C
 void cblas_sbgemm_batch(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransA_array, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransB_array, OPENBLAS_CONST blasint * M_array, OPENBLAS_CONST blasint * N_array, OPENBLAS_CONST blasint * K_array,
 		       OPENBLAS_CONST float * alpha_array, OPENBLAS_CONST bfloat16 ** A_array, OPENBLAS_CONST blasint * lda_array, OPENBLAS_CONST bfloat16 ** B_array, OPENBLAS_CONST blasint * ldb_array, OPENBLAS_CONST float * beta_array, float ** C_array, OPENBLAS_CONST blasint * ldc_array, OPENBLAS_CONST blasint group_count, OPENBLAS_CONST blasint * group_size);

+void cblas_sbgemm_batch_strided(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST bfloat16 * A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST blasint stridea, OPENBLAS_CONST bfloat16 * B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST blasint strideb, OPENBLAS_CONST float beta, float * C, OPENBLAS_CONST blasint ldc, OPENBLAS_CONST blasint stridec, OPENBLAS_CONST blasint group_size);
 /*** FLOAT16 extensions ***/
 void cblas_shgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
 		    OPENBLAS_CONST float alpha, OPENBLAS_CONST hfloat16 *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST hfloat16 *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
@@ -50,30 +50,30 @@ set(PN OpenBLAS)

 # need to check that the @USE_*@ evaluate to something cmake can perform boolean logic upon
 if(@USE_OPENMP@)
-    set(${PN}_openmp_FOUND 1)
+    set(${PN}@SUFFIX64@_openmp_FOUND 1)
 elseif(@USE_THREAD@)
-    set(${PN}_pthread_FOUND 1)
+    set(${PN}@SUFFIX64@_pthread_FOUND 1)
 else()
-    set(${PN}_serial_FOUND 1)
+    set(${PN}@SUFFIX64@_serial_FOUND 1)
 endif()

-check_required_components(${PN})
+check_required_components(${PN}@SUFFIX64@)

 #-----------------------------------------------------------------------------
 # Don't include targets if this file is being picked up by another
 # project which has already built this as a subproject
 #-----------------------------------------------------------------------------
-if(NOT TARGET ${PN}::OpenBLAS)
-    include("${CMAKE_CURRENT_LIST_DIR}/${PN}Targets.cmake")
+if(NOT TARGET ${PN}@SUFFIX64@::OpenBLAS)
+    include("${CMAKE_CURRENT_LIST_DIR}/${PN}@SUFFIX64@Targets.cmake")

-    get_property(_loc TARGET ${PN}::OpenBLAS PROPERTY LOCATION)
-    set(${PN}_LIBRARY ${_loc})
-    get_property(_ill TARGET ${PN}::OpenBLAS PROPERTY INTERFACE_LINK_LIBRARIES)
-    set(${PN}_LIBRARIES ${_ill})
+    get_property(_loc TARGET ${PN}@SUFFIX64@::OpenBLAS PROPERTY LOCATION)
+    set(${PN}@SUFFIX64@_LIBRARY ${_loc})
+    get_property(_ill TARGET ${PN}@SUFFIX64@::OpenBLAS PROPERTY INTERFACE_LINK_LIBRARIES)
+    set(${PN}@SUFFIX64@_LIBRARIES ${_ill})

-    get_property(_id TARGET ${PN}::OpenBLAS PROPERTY INCLUDE_DIRECTORIES)
-    set(${PN}_INCLUDE_DIR ${_id})
-    get_property(_iid TARGET ${PN}::OpenBLAS PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
-    set(${PN}_INCLUDE_DIRS ${_iid})
+    get_property(_id TARGET ${PN}@SUFFIX64@::OpenBLAS PROPERTY INCLUDE_DIRECTORIES)
+    set(${PN}@SUFFIX64@_INCLUDE_DIR ${_id})
+    get_property(_iid TARGET ${PN}@SUFFIX64@::OpenBLAS PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
+    set(${PN}@SUFFIX64@_INCLUDE_DIRS ${_iid})
 endif()

@@ -40,15 +40,35 @@ if (DYNAMIC_ARCH)
      endif ()
      if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 14) # SME ACLE supported in GCC >= 14
        set(DYNAMIC_CORE ${DYNAMIC_CORE} ARMV9SME)
+      endif()
+	  if (${CMAKE_C_COMPILER_ID} MATCHES "Clang" AND ${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
+	    set(DYNAMIC_CORE ${DYNAMIC_CORE} VORTEXM4)
      endif()
    elseif (${CMAKE_C_COMPILER_ID} MATCHES "Clang")
      if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 11) # SVE ACLE supported in LLVM >= 11
        set(DYNAMIC_CORE ${DYNAMIC_CORE} NEOVERSEV1 NEOVERSEN2 ARMV8SVE A64FX)
      endif ()
-      if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 19) # SME ACLE supported in LLVM >= 19
+	  if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 17) # SME ACLE supported in LLVM >= 17
        set(DYNAMIC_CORE ${DYNAMIC_CORE} ARMV9SME)
      endif()
+
+	  if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+      if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 19 OR (${CMAKE_C_COMPILER_ID} MATCHES AppleClang AND ${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 17) ) # SME w/out SVE supported in LLVM >= 19 and AppleClang >= 17
+        set(DYNAMIC_CORE ${DYNAMIC_CORE} VORTEXM4)
+      endif()
+	  endif()
    endif ()
+
+    if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin" OR ${CMAKE_SYSTEM_NAME} STREQUAL "iOS")
+      set(DYNAMIC_CORE ARMV8 NEOVERSEN1)
+      if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 19 OR (${CMAKE_C_COMPILER_ID} MATCHES AppleClang AND ${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 17) ) # SME ACLE supported in LLVM >= 19 and AppleClang >= 17
+        set(DYNAMIC_CORE ${DYNAMIC_CORE} VORTEXM4)
+      endif()
+      if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 14) # SME ACLE supported in GCC >= 14
+        set(DYNAMIC_CORE ${DYNAMIC_CORE} ARMV9SME)
+      endif()
+    endif()
+    
    if (DYNAMIC_LIST)
 	  set(DYNAMIC_CORE ARMV8 ${DYNAMIC_LIST})
    endif ()
@@ -113,6 +113,7 @@ if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI")
 endif ()

 if (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC")
+  set (GCC_VERSION 100)
  if (POWER)
    set(CCOMMON_OPT "${CCOMMON_OPT} -tp pwr8")
  elseif (X86_64)
@@ -213,7 +214,7 @@ endif ()

 if (${CORE} STREQUAL A64FX)
  if (NOT DYNAMIC_ARCH)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVC" AND NOT NO_SVE)
+    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
 	set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=a64fx")
    elseif (${GCC_VERSION} VERSION_GREATER 11.0 OR ${GCC_VERSION} VERSION_EQUAL 11.0)
      set (CCOMMON_OPT  "${CCOMMON_OPT} -march=armv8.2-a+sve -mtune=a64fx")
@@ -227,7 +228,7 @@ if (${CORE} STREQUAL NEOVERSEV2)
 	if (NOT DYNAMIC_ARCH)
 		if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
 			set (CCOMMON_OPT  "${CCOMMON_OPT} -Msve_intrinsics -march=armv8.5-a+sve+sve2+bf16 -mtune=neoverse-v2")
-		elseif (${CMAKE_C_COMPILER_ID} STREQUAL "NVC" AND NOT NO_SVE)
+		elseif (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
 			set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=neoverse-v2")
 		else ()
 			if (${GCC_VERSION} VERSION_GREATER 13.0 OR ${GCC_VERSION} VERSION_EQUAL 13.0)
@@ -245,7 +246,7 @@ if (${CORE} STREQUAL NEOVERSEN2)
  if (NOT DYNAMIC_ARCH)
    if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
 	set (CCOMMON_OPT  "${CCOMMON_OPT} -Msve_intrinsics -march=armv8.5-a+sve+sve2+bf16 -mtune=neoverse-n2")
-    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "NVC" AND NOT NO_SVE)
+    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
 	set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=neoverse-v2")
    else ()
      if (${GCC_VERSION} VERSION_GREATER 11.1 OR ${GCC_VERSION} VERSION_EQUAL 11.1)
@@ -261,7 +262,7 @@ if (${CORE} STREQUAL NEOVERSEV1)
  if (NOT DYNAMIC_ARCH)
    if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
 	set (CCOMMON_OPT  "${CCOMMON_OPT} -Msve_intrinsics -march=armv8.4-a+sve+bf16 -mtune=neoverse-v1")
-    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "NVC" AND NOT NO_SVE)
+    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
 	set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=neoverse-v1")
    else ()
      if (${GCC_VERSION} VERSION_GREATER 10.4 OR ${GCC_VERSION} VERSION_EQUAL 10.4)
@@ -275,7 +276,7 @@ endif ()

 if (${CORE} STREQUAL NEOVERSEN1)
  if (NOT DYNAMIC_ARCH)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVC" AND NOT NO_SVE)
+    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
 	set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=neoverse-n1")
    elseif (${GCC_VERSION} VERSION_GREATER 9.4 OR ${GCC_VERSION} VERSION_EQUAL 9.4)
      set (CCOMMON_OPT  "${CCOMMON_OPT} -march=armv8.2-a -mtune=neoverse-n1")
@@ -287,7 +288,7 @@ endif ()

 if (${CORE} STREQUAL AMPEREONE)
  if (NOT DYNAMIC_ARCH)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVC")
+    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC")
 	set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=neoverse-n1")
    elseif (${GCC_VERSION} VERSION_GREATER 12.1)
      set (CCOMMON_OPT  "${CCOMMON_OPT} -march=armv8.6-a+crypto+crc+fp16+sha3+rng -mtune=ampereone")
@@ -301,7 +302,7 @@ if (${CORE} STREQUAL ARMV8SVE)
  if (NOT DYNAMIC_ARCH)
    if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
 	set (CCOMMON_OPT  "${CCOMMON_OPT} -Msve_intrinsics -march=armv8-a+sve")
-    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "NVC" AND NOT NO_SVE)
+    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
 	    set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=host")
    else ()
      set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8-a+sve")
@@ -310,12 +311,29 @@ if (${CORE} STREQUAL ARMV8SVE)
 endif ()

 if (${CORE} STREQUAL ARMV9SME)
+  if (NOT DYNAMIC_ARCH)
+    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
+      set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=host")
+    else ()
+      set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv9-a+sme")
+      if (CMAKE_SYSTEM_NAME STREQUAL "Windows" AND CMAKE_C_COMPILER_ID MATCHES "Clang")
+        set (CCOMMON_OPT "${CCOMMON_OPT} --aarch64-stack-hazard-size=0")
+      endif ()
+    endif ()
+  endif ()
+endif ()
+
+if (${CORE} STREQUAL VORTEXM4)
  if (NOT DYNAMIC_ARCH)
    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVC" AND NOT NO_SVE)
 	    set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=host")
    else ()
-    set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv9-a+sme")
-    endif ()
+	  if (${CMAKE_C_COMPILER_ID} STREQUAL "AppleClang")
+        set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.4-a+sme -mcpu=apple-m4")
+	  else ()
+	    set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.4-a -mcpu=apple-m4")
+      endif ()
+	endif ()
  endif ()
 endif ()

@@ -391,6 +409,30 @@ if (${CORE} STREQUAL PPCG4)
  endif ()
 endif ()

+
+if ((${CORE} STREQUAL RISCV64_ZVL128B) OR (${CORE} STREQUAL RISCV64_ZVL256B))
+  set (RISCV64_OPT "rv64imafdcv")
+  if (BUILD_BFLOAT16)
+    set (RISCV64_OPT "${RISCV64_OPT}_zvfbfwma")
+  endif()
+  if (BUILD_HFLOAT16)
+    set (RISCV64_OPT "${RISCV64_OPT}_zvfh_zfh")
+  endif()
+  if (${CORE} STREQUAL RISCV64_ZVL256B)
+    set (CCOMMON_OPT "${CCOMMON_OPT} -march=${RISCV64_OPT}_zvl256b -mabi=lp64d")
+  endif()
+  if (${CORE} STREQUAL RISCV64_ZVL128B)
+    set (CCOMMON_OPT "${CCOMMON_OPT} -march=${RISCV64_OPT}_zvl128b -mabi=lp64d")
+  endif()
+endif()
+if (${CORE} STREQUAL RISCV64_GENERIC)
+  set (CCOMMON_OPT "${CCOMMON_OPT} -march=rv64imafdc -mabi=lp64d")
+endif()
+if (${CORE} STREQUAL x280)
+  set (CCOMMON_OPT "${CCOMMON_OPT} -march=rv64imafdcv_zba_zbb_zfh_zvl512b -mabi=lp64d")
+endif()
+
+
 if (NOT DYNAMIC_ARCH)
 	if (HAVE_AVX2)
        set (CCOMMON_OPT  "${CCOMMON_OPT} -mavx2")
@@ -128,7 +128,7 @@ if (${F_COMPILER} STREQUAL "INTEL" OR CMAKE_Fortran_COMPILER_ID MATCHES "Intel")
  endif ()
  set(FCOMMON_OPT "${FCOMMON_OPT} -recursive -fp-model=consistent")
  if (USE_OPENMP)
-    set(OpenMP_Fortran_FLAGS "-openmp" CACHE STRING "OpenMP Fortran compiler flags")
+    set(OpenMP_Fortran_FLAGS "-qopenmp" CACHE STRING "OpenMP Fortran compiler flags")
  endif ()
 endif ()

@@ -175,6 +175,10 @@ if (BUILD_BFLOAT16)
  SetFallback(SBGEMVNKERNEL ../x86_64/sbgemv_n.c)
  SetFallback(SBGEMVTKERNEL ../x86_64/sbgemv_t.c)
 endif ()
+if (BUILD_HFLOAT16)
+  SetFallback(SHGEMVNKERNEL ../generic/gemv_n.c)
+  SetFallback(SHGEMVTKERNEL ../generic/gemv_t.c)
+endif ()
 endmacro ()

 macro(SetDefaultL2)
@@ -228,6 +232,10 @@ if (BUILD_BFLOAT16)
  SetFallback(BGEMVTKERNEL ../generic/gemv_t.c)
  SetFallback(SBGEMVNKERNEL ../x86_64/sbgemv_n.c)
  SetFallback(SBGEMVTKERNEL ../x86_64/sbgemv_t.c)
+endif ()
+if (BUILD_HFLOAT16)
+  SetFallback(SHGEMVNKERNEL ../generic/gemv_n.c)
+  SetFallback(SHGEMVTKERNEL ../generic/gemv_t.c)
  SetFallback(SHGERKERNEL ../generic/ger.c)
 endif ()
 endmacro ()
@@ -260,5 +268,16 @@ if (BUILD_BFLOAT16)
  SetFallback(SBGEMMONCOPYOBJ sbgemm_oncopy.o)
  SetFallback(SBGEMMOTCOPYOBJ sbgemm_otcopy.o)
 endif ()
-
+if (BUILD_HFLOAT16)
+  SetFallback(SHGEMMKERNEL ../generic/gemmkernel_2x2.c)
+  SetFallback(SHGEMM_BETA  ../generic/gemm_beta.c)
+  SetFallback(SHGEMMINCOPY ../generic/gemm_ncopy_2.c)
+  SetFallback(SHGEMMITCOPY ../generic/gemm_tcopy_2.c)
+  SetFallback(SHGEMMONCOPY ../generic/gemm_ncopy_2.c)
+  SetFallback(SHGEMMOTCOPY ../generic/gemm_tcopy_2.c)
+  SetFallback(SHGEMMINCOPYOBJ shgemm_incopy.o)
+  SetFallback(SHGEMMITCOPYOBJ shgemm_itcopy.o)
+  SetFallback(SHGEMMONCOPYOBJ shgemm_oncopy.o)
+  SetFallback(SHGEMMOTCOPYOBJ shgemm_otcopy.o)
+endif ()
 endmacro ()
@@ -70,8 +70,8 @@ set(SLASRC
   slaqgb.f slaqge.f slaqp2.f slaqps.f slaqp2rk.f slaqp3rk.f slaqsb.f slaqsp.f slaqsy.f
   slaqr0.f slaqr1.f slaqr2.f slaqr3.f slaqr4.f slaqr5.f
   slaqtr.f slar1v.f slar2v.f ilaslr.f ilaslc.f
-   slarf.f  slarfb.f slarfb_gett.f slarfg.f slarfgp.f slarft.f slarfx.f slarfy.f slargv.f
-   slarrv.f slartv.f
+   slarf.f  slarfb.f slarfb_gett.f slarfg.f slarfgp.f slarft.f slarft_lvl2.f slarfx.f
+   slarfy.f slargv.f slarf1f.f slarf1l.f slarrv.f slartv.f
   slarz.f  slarzb.f slarzt.f slasy2.f
   slasyf.f slasyf_rook.f slasyf_rk.f slasyf_aa.f
   slatbs.f slatdf.f slatps.f slatrd.f slatrs.f slatrz.f
@@ -177,7 +177,8 @@ set(CLASRC
   claqr0.f claqr1.f claqr2.f claqr3.f claqr4.f claqr5.f
   claqz0.f claqz1.f claqz2.f claqz3.f
   claqsp.f claqsy.f clar1v.f clar2v.f ilaclr.f ilaclc.f
-   clarf.f  clarfb.f clarfb_gett.f clarfg.f clarfgp.f clarft.f
+   clarf.f  clarfb.f clarfb_gett.f clarfg.f clarfgp.f clarft.f clarft_lvl2.f
+   clarf1f.f clarf1l.f
   clarfx.f clarfy.f clargv.f clarnv.f clarrv.f clartg.f90 clartv.f
   clarz.f  clarzb.f clarzt.f clascl.f claset.f clasr.f  classq.f90
   clasyf.f clasyf_rook.f clasyf_rk.f clasyf_aa.f
@@ -261,8 +262,8 @@ set(DLASRC
   dlaqgb.f dlaqge.f dlaqp2.f dlaqp2rk.f dlaqp3rk.f dlaqps.f dlaqsb.f dlaqsp.f dlaqsy.f
   dlaqr0.f dlaqr1.f dlaqr2.f dlaqr3.f dlaqr4.f dlaqr5.f
   dlaqtr.f dlar1v.f dlar2v.f iladlr.f iladlc.f
-   dlarf.f  dlarfb.f dlarfb_gett.f dlarfg.f dlarfgp.f dlarft.f dlarfx.f dlarfy.f
-   dlargv.f dlarrv.f dlartv.f
+   dlarf.f  dlarfb.f dlarfb_gett.f dlarfg.f dlarfgp.f dlarft.f dlarft_lvl2.f
+   dlarfx.f dlarfy.f dlarf1f.f dlarf1l.f dlargv.f dlarrv.f dlartv.f
   dlarz.f  dlarzb.f dlarzt.f dlasy2.f
   dlasyf.f dlasyf_rook.f dlasyf_rk.f dlasyf_aa.f
   dlatbs.f dlatdf.f dlatps.f dlatrd.f dlatrs.f dlatrz.f
@@ -371,7 +372,7 @@ set(ZLASRC
   zlaqr0.f zlaqr1.f zlaqr2.f zlaqr3.f zlaqr4.f zlaqr5.f
   zlaqsp.f zlaqsy.f zlar1v.f zlar2v.f ilazlr.f ilazlc.f
   zlarcm.f zlarf.f  zlarfb.f zlarfb_gett.f
-   zlarfg.f zlarfgp.f zlarft.f
+   zlarfg.f zlarfgp.f zlarft.f zlarft_lvl2.f zlarf1f.f zlarf1l.f
   zlarfx.f zlarfy.f zlargv.f zlarnv.f zlarrv.f zlartg.f90 zlartv.f
   zlarz.f  zlarzb.f zlarzt.f zlascl.f zlaset.f zlasr.f
   zlassq.f90 zlasyf.f zlasyf_rook.f zlasyf_rk.f zlasyf_aa.f
@@ -574,8 +575,8 @@ set(SLASRC
   slaqgb.c slaqge.c slaqp2.c slaqp2rk.c slaqp3rk.c slaqps.c slaqsb.c slaqsp.c slaqsy.c
   slaqr0.c slaqr1.c slaqr2.c slaqr3.c slaqr4.c slaqr5.c
   slaqtr.c slar1v.c slar2v.c ilaslr.c ilaslc.c
-   slarf.c  slarfb.c slarfb_gett.c slarfg.c slarfgp.c slarft.c slarfx.c slarfy.c slargv.c
-   slarrv.c slartv.c
+   slarf.c  slarfb.c slarfb_gett.c slarfg.c slarfgp.c slarft.c slarft_lvl2.c slarfx.c
+   slarfy.c slargv.c slarf1f.c slarf1l.c slarrv.c slartv.c
   slarz.c  slarzb.c slarzt.c slasy2.c
   slasyf.c slasyf_rook.c slasyf_rk.c slasyf_aa.c
   slatbs.c slatdf.c slatps.c slatrd.c slatrs.c slatrz.c
@@ -681,6 +682,7 @@ set(CLASRC
   claqr0.c claqr1.c claqr2.c claqr3.c claqr4.c claqr5.c
   claqsp.c claqsy.c clar1v.c clar2v.c ilaclr.c ilaclc.c
   clarf.c  clarfb.c clarfb_gett.c clarfg.c clarfgp.c clarft.c
+   clarft_lvl2.c clarf1f.c clarf1l.c
   clarfx.c clarfy.c clargv.c clarnv.c clarrv.c clartg.c clartv.c
   clarz.c  clarzb.c clarzt.c clascl.c claset.c clasr.c  classq.c
   clasyf.c clasyf_rook.c clasyf_rk.c clasyf_aa.c
@@ -763,8 +765,8 @@ set(DLASRC
   dlaqgb.c dlaqge.c dlaqp2.c dlaqp2rk.c dlaqp3rk.c dlaqps.c dlaqsb.c dlaqsp.c dlaqsy.c
   dlaqr0.c dlaqr1.c dlaqr2.c dlaqr3.c dlaqr4.c dlaqr5.c
   dlaqtr.c dlar1v.c dlar2v.c iladlr.c iladlc.c
-   dlarf.c  dlarfb.c dlarfb_gett.c dlarfg.c dlarfgp.c dlarft.c dlarfx.c dlarfy.c
-   dlargv.c dlarrv.c dlartv.c
+   dlarf.c  dlarfb.c dlarfb_gett.c dlarfg.c dlarfgp.c dlarft.c dlarft_lvl2.c 
+   dlarfx.c dlarfy.c dlarf1f.c dlarf1l.c dlargv.c dlarrv.c dlartv.c
   dlarz.c  dlarzb.c dlarzt.c dlasy2.c
   dlasyf.c dlasyf_rook.c dlasyf_rk.c dlasyf_aa.c
   dlatbs.c dlatdf.c dlatps.c dlatrd.c dlatrs.c dlatrz.c
@@ -871,8 +873,8 @@ set(ZLASRC
   zlaqhb.c zlaqhe.c zlaqhp.c zlaqp2.c zlaqp2rk.c zlaqp3rk.c zlaqps.c zlaqsb.c
   zlaqr0.c zlaqr1.c zlaqr2.c zlaqr3.c zlaqr4.c zlaqr5.c
   zlaqsp.c zlaqsy.c zlar1v.c zlar2v.c ilazlr.c ilazlc.c
-   zlarcm.c zlarf.c  zlarfb.c zlarfb_gett.c
-   zlarfg.c zlarfgp.c zlarft.c
+   zlarcm.c zlarf.c  zlarfb.c zlarfb_gett.c zlarf1f.c zlarf1l.c
+   zlarfg.c zlarfgp.c zlarft.c zlarft_lvl2.c
   zlarfx.c zlarfy.c zlargv.c zlarnv.c zlarrv.c zlartg.c zlartv.c
   zlarz.c  zlarzb.c zlarzt.c zlascl.c zlaset.c zlasr.c
   zlassq.c zlasyf.c zlasyf_rook.c zlasyf_rk.c zlasyf_aa.c
@@ -98,8 +98,11 @@ if (${COMPILER_ID} STREQUAL "GNU")
  set(COMPILER_ID "GCC")
 endif ()

-string(TOUPPER ${ARCH} UC_ARCH)
+if (HOST_OS STREQUAL "EMSCRIPTEN")
+	set (ARCH wasm)
+endif()

+string(TOUPPER ${ARCH} UC_ARCH)
 file(WRITE ${TARGET_CONF_TEMP}
  "#define OS_${HOST_OS}\t1\n"
  "#define ARCH_${UC_ARCH}\t1\n"
@@ -111,6 +114,10 @@ if (${HOST_OS} STREQUAL "WINDOWSSTORE")
  file(APPEND ${TARGET_CONF_TEMP}
    "#define OS_WINNT\t1\n")
 endif ()
+if (${HOST_OS} STREQUAL CYGWIN)
+  file(APPEND ${TARGET_CONF_TEMP}
+    "#define OS_CYGWIN_NT\t1\n")
+endif ()

 # f_check
 if (NOT NOFORTRAN)
@@ -1252,7 +1259,7 @@ endif ()
    set(ZGEMM_UNROLL_M 4)
    set(ZGEMM_UNROLL_N 4)
    set(SYMV_P 16)
-  elseif ("${TCORE}" STREQUAL "VORTEX")
+  elseif ("${TCORE}" STREQUAL "VORTEX" OR "${TCORE}" STREQUAL "VORTEXM4")
    file(APPEND ${TARGET_CONF_TEMP}
      "#define ARMV8\n"
      "#define L1_CODE_SIZE\t32768\n"
@@ -1497,6 +1504,15 @@ endif ()
      "#define DTB_DEFAULT_ENTRIES 128\n"
      "#define DTB_SIZE 4096\n"
      "#define L2_ASSOCIATIVE 4\n")
+  elseif ("${TCORE}" STREQUAL "WASM128_GENERIC")
+    file(APPEND ${TARGET_CONF_TEMP}
+      "#define L1_DATA_SIZE 32768\n"
+      "#define L1_DATA_LINESIZE 32\n"
+      "#define L2_SIZE 1048576\n"
+      "#define L2_LINESIZE 32 \n"
+      "#define DTB_DEFAULT_ENTRIES 128\n"
+      "#define DTB_SIZE 4096\n"
+      "#define L2_ASSOCIATIVE 4\n")
  elseif ("${TCORE}" STREQUAL "LA64_GENERIC")
    file(APPEND ${TARGET_CONF_TEMP}
      "#define DTB_DEFAULT_ENTRIES 64\n")
@@ -1636,6 +1652,8 @@ else(NOT CMAKE_CROSSCOMPILING)
  unset (HAVE_VFP)
  unset (HAVE_VFPV3)
  unset (HAVE_VFPV4)
+  unset (HAVE_SVE)
+  unset (HAVE_SME)
  message(STATUS "Running getarch")

  # use the cmake binary w/ the -E param to run a shell command in a cross-platform way
@@ -68,10 +68,10 @@ endif ()
 if (DEFINED BINARY AND DEFINED TARGET AND BINARY EQUAL 32)
  message(STATUS "Compiling a ${BINARY}-bit binary.")
  set(NO_AVX 1)
-  if (${TARGET} STREQUAL "HASWELL" OR ${TARGET} STREQUAL "SANDYBRIDGE" OR ${TARGET} STREQUAL "SKYLAKEX" OR ${TARGET} STREQUAL "COOPERLAKE" OR ${TARGET} STREQUAL "SAPPHIRERAPIDS")
+  if (${TARGET} STREQUAL "HASWELL" OR ${TARGET} STREQUAL "ZEN" OR ${TARGET} STREQUAL "SANDYBRIDGE" OR ${TARGET} STREQUAL "SKYLAKEX" OR ${TARGET} STREQUAL "COOPERLAKE" OR ${TARGET} STREQUAL "SAPPHIRERAPIDS")
    set(TARGET "NEHALEM")
  endif ()
-  if (${TARGET} STREQUAL "BULLDOZER" OR ${TARGET} STREQUAL "PILEDRIVER" OR ${TARGET} STREQUAL "ZEN")
+  if (${TARGET} STREQUAL "BULLDOZER" OR ${TARGET} STREQUAL "PILEDRIVER")
    set(TARGET "BARCELONA")
  endif ()
  if (${TARGET} STREQUAL "ARMV8" OR ${TARGET} STREQUAL "CORTEXA57" OR ${TARGET} STREQUAL "CORTEXA53" OR ${TARGET} STREQUAL "CORTEXA55")
@@ -367,11 +367,21 @@ if (${TARGET} STREQUAL NEOVERSEV1)
  endif()
  if (${TARGET} STREQUAL ARMV9SME)
      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -march=armv9-a+sme -O3")
+	  if (${CMAKE_SYSTEM_NAME} STREQUAL Windows AND ${CMAKE_C_COMPILER_ID} MATCHES "Clang")
+	  set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} --aarch64-stack-hazard-size=0")
+	  endif()
+  endif()
+  if (${TARGET} STREQUAL VORTEXM4)
+      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -march=armv8.4-a+sme -O3")
+	  if (${CMAKE_SYSTEM_NAME} STREQUAL Windows AND ${CMAKE_C_COMPILER_ID} MATCHES "Clang")
+	  set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} --aarch64-stack-hazard-size=0")
+	  endif()
  endif()
  if (${TARGET} STREQUAL A64FX)
    if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -Msve-intrinsics -march=armv8.2-a+sve -mtune=a64fx")
    else ()
+	  set (GCC_VERSION 0.0)
      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
      if (${GCC_VERSION} VERSION_GREATER 10.4 OR ${GCC_VERSION} VERSION_EQUAL 10.4)
        set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -march=armv8.2-a+sve -mtune=a64fx")
@@ -381,6 +391,28 @@ if (${TARGET} STREQUAL NEOVERSEV1)
    endif()
  endif()

+  if ((${TARGET} STREQUAL RISCV64_ZVL128B) OR (${TARGET} STREQUAL RISCV64_ZVL256B))
+    set (RISCV64_OPT "rv64imafdcv")
+    if (BUILD_BFLOAT16)
+      set (RISCV64_OPT "${RISCV64_OPT}_zvfbfwma")
+    endif()
+    if (BUILD_HFLOAT16)
+      set (RISCV64_OPT "${RISCV64_OPT}_zvfh_zfh")
+    endif()
+    if (${TARGET} STREQUAL RISCV64_ZVL256B)
+      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=${RISCV64_OPT}_zvl256b -mabi=lp64d")
+    endif()
+    if (${TARGET} STREQUAL RISCV64_ZVL128B)
+      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=${RISCV64_OPT}_zvl128b -mabi=lp64d")
+    endif()
+  endif()
+  if (${TARGET} STREQUAL RISCV64_GENERIC)
+      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=rv64imafdc -mabi=lp64d")
+    endif()
+    if (${TARGET} STREQUAL x280)
+      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=rv64imafdcv_zba_zbb_zfh_zvl512b -mabi=lp64d")
+    endif()
+
 endif()

 if (DEFINED BINARY)
@@ -425,10 +457,16 @@ if (USE_OPENMP)
  if (NOT NOFORTRAN)
    find_package(OpenMP COMPONENTS Fortran REQUIRED)
    # Avoid mixed OpenMP linkage
-    get_target_property(OMP_C_LIB OpenMP::OpenMP_C INTERFACE_LINK_LIBRARIES)
-    get_target_property(OMP_Fortran_LIB OpenMP::OpenMP_Fortran INTERFACE_LINK_LIBRARIES)
-    if (NOT OMP_C_LIB STREQUAL OMP_Fortran_LIB)
-      message(FATAL_ERROR "Multiple OpenMP runtime libraries detected. Mixed OpenMP runtime linkage is dangerous. You may pass -DOpenMP_LANG_LIB_NAMES and -DOpenMP_omp_LIBRARY to manually choose the OpenMP library.")
+    get_target_property(OMP_C_LIBS OpenMP::OpenMP_C INTERFACE_LINK_LIBRARIES)
+    get_target_property(OMP_F_LIBS OpenMP::OpenMP_Fortran INTERFACE_LINK_LIBRARIES)
+    if (NOT OMP_C_LIBS STREQUAL OMP_F_LIBS)
+      message(NOTICE
+        "CMake detected different OpenMP libraries for C and Fortran:\n"
+        "C=${OMP_C_LIBS}\n"
+        "Fortran=${OMP_F_LIBS}\n"
+        "In case you encounter issues, please check that this is correct.\n"
+        "You may pass -DOpenMP_<lang>_LIB_NAMES and -DOpenMP_<libname>_LIBRARY to cmake to manually force the OpenMP library."
+      )
    endif()
  endif ()
 endif ()
@@ -841,6 +879,10 @@ if (DEFINED ARCH)
    set(USE_GEMM3M 1)
  endif ()

+  if (EMSCRIPTEN)
+    set(USE_GEMM3M 0)
+  endif ()
+
  if (${CORE} STREQUAL "generic")
    set(USE_GEMM3M 0)
  endif ()
@@ -40,6 +40,8 @@ if(CMAKE_CL_64 OR MINGW64)
  else()
    set(X86_64 1)
  endif()
+elseif(OS_EMSCRIPTEN)
+    set(WASM 1)
 elseif(MINGW OR (MSVC AND NOT CMAKE_CROSSCOMPILING))
  set(X86 1)
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc.*|power.*|Power.*" OR (CMAKE_SYSTEM_NAME MATCHES "Darwin" AND CMAKE_OSX_ARCHITECTURES MATCHES "ppc.*"))
@@ -145,13 +147,22 @@ endif()
 endif()

 if (ARM64)
+if (NOT NO_SVE)
+  file(WRITE ${PROJECT_BINARY_DIR}/sve.c "#include <arm_sve.h>\n\n int main(void){}\n")
+  execute_process(COMMAND ${CMAKE_C_COMPILER} -march=armv8-a+sve -c -o ${PROJECT_BINARY_DIR}/sve.o ${PROJECT_BINARY_DIR}/sve.c OUTPUT_QUIET ERROR_QUIET RESULT_VARIABLE NO_SVE)
+if (NO_SVE EQUAL 1)
+set (CCOMMON_OPT "${CCOMMON_OPT} -DNO_SVE")
+endif()
+  file(REMOVE "${PROJECT_BINARY_DIR}/sve.c" "${PROJECT_BINARY_DIR}/sve.o")
+endif()
+
 if (NOT NO_SME)
-  file(WRITE ${PROJECT_BINARY_DIR}/sme.c ".text \n.global sme_test\n\nsme_test:\nsmstart\nsmstop\nret\n")
-  execute_process(COMMAND ${CMAKE_C_COMPILER} -march=armv9-a+sve2+sme -c -v -o ${PROJECT_BINARY_DIR}/sme.o ${PROJECT_BINARY_DIR}/sme.c OUTPUT_QUIET ERROR_QUIET RESULT_VARIABLE NO_SME)
+  file(WRITE ${PROJECT_BINARY_DIR}/sme.S ".text \n.global sme_test\n\nsme_test:\nsmstart\nsmstop\nret\n")
+  execute_process(COMMAND ${CMAKE_C_COMPILER} -march=armv9-a+sve2+sme -c -v -o ${PROJECT_BINARY_DIR}/sme.o ${PROJECT_BINARY_DIR}/sme.S OUTPUT_QUIET ERROR_QUIET RESULT_VARIABLE NO_SME)
 if (NO_SME EQUAL 1)
 set (CCOMMON_OPT "${CCOMMON_OPT} -DNO_SME")
 endif()
-  file(REMOVE "${PROJECT_BINARY_DIR}/sme.c" "${PROJECT_BINARY_DIR}/sme.o")
+  file(REMOVE "${PROJECT_BINARY_DIR}/sme.S" "${PROJECT_BINARY_DIR}/sme.o")
 endif()
 endif()

@@ -51,7 +51,7 @@ macro(ParseMakefileVars MAKEFILE_IN)
  if (${OSNAME} STREQUAL Windows)
    set (OSNAME WINNT)
  endif ()
-message(STATUS OS ${OSNAME} COMPILER ${C_COMPILER})
+  #message(STATUS OS ${OSNAME} COMPILER ${C_COMPILER})
  set (IfElse 0)
  set (ElseSeen 0)
  set (SkipIfs 0)
@@ -375,9 +375,12 @@ function(GenerateNamedObjects sources_in)
      if (NOT no_float_type)
        string(SUBSTRING ${float_type} 0 1 float_char)
        string(TOLOWER ${float_char} float_char)
-	if (${float_type} STREQUAL "BFLOAT16" AND NOT "${defines_in}" MATCHES "BGEM")
-		set (float_char "sb")
-	endif ()
+        if (${float_type} STREQUAL "BFLOAT16" AND NOT "${defines_in}" MATCHES "BGEM")
+          set (float_char "sb")
+        endif ()
+        if (${float_type} STREQUAL "HFLOAT16" AND NOT "${defines_in}" MATCHES "HGEM")
+          set (float_char "sh")
+        endif ()
      endif ()

      if (NOT name_in)
@@ -427,6 +430,9 @@ function(GenerateNamedObjects sources_in)
      endif ()
      if (${float_type} STREQUAL "BFLOAT16")
        list(APPEND obj_defines "BFLOAT16")
+      endif ()
+	  if (${float_type} STREQUAL "HFLOAT16")
+        list(APPEND obj_defines "HFLOAT16")
      endif ()
      if (${float_type} STREQUAL "COMPLEX" OR ${float_type} STREQUAL "ZCOMPLEX")
        list(APPEND obj_defines "COMPLEX")
@@ -79,6 +79,22 @@ extern "C" {
 #endif
 #endif

+#ifndef ASSEMBLER
+#ifdef HAVE_C11
+#if defined(C_GCC) && ( __GNUC__ < 7)
+// workaround for GCC bug 65467
+#ifndef _Atomic
+#define _Atomic volatile
+#endif
+#endif
+#include <stdatomic.h>
+#else
+#ifndef _Atomic
+#define _Atomic volatile
+#endif
+#endif
+#endif
+
 #if !defined(NOINCLUDE) && !defined(ASSEMBLER)
 #include <stdio.h>
 #include <stdlib.h>
@@ -362,18 +378,6 @@ typedef int blasint;
 #define MAX_CPU_NUMBER 2
 #endif

-#if defined(OS_SUNOS)
-#define YIELDING	thr_yield()
-#endif
-
-#if defined(OS_WINDOWS)
-#if defined(_MSC_VER) && !defined(__clang__)
-#define YIELDING    YieldProcessor()
-#else
-#define YIELDING	SwitchToThread()
-#endif
-#endif
-
 #if defined(ARMV7) || defined(ARMV6) || defined(ARMV8) || defined(ARMV5)
 #define YIELDING        __asm__ __volatile__ ("nop;nop;nop;nop;nop;nop;nop;nop; \n");
 #endif
@@ -398,14 +402,28 @@ typedef int blasint;
 #endif
 #endif

-
-#ifdef __EMSCRIPTEN__
+#if defined(ARCH_WASM)
+#ifndef YIELDING
 #define YIELDING
 #endif
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#undef YIELDING // MSVC doesn't support assembly code
+#define YIELDING    	YieldProcessor()
+#endif

 #ifndef YIELDING
+#if defined(OS_SUNOS)
+#define YIELDING	thr_yield()
+
+#elif defined(OS_WINDOWS)
+#define YIELDING	SwitchToThread()
+
+#else // assume POSIX.1-2008
 #define YIELDING	sched_yield()
 #endif
+#endif

 /***
 To alloc job_t on heap or stack.
@@ -428,6 +446,12 @@ please https://github.com/xianyi/OpenBLAS/issues/246
 #include "common_quad.h"
 #endif

+#ifndef ASSEMBLER
+#ifdef HAVE_C11
+#define BLAS_LOCK_DEFINED
+#endif
+#endif
+
 #ifdef ARCH_ALPHA
 #include "common_alpha.h"
 #endif
@@ -498,6 +522,10 @@ please https://github.com/xianyi/OpenBLAS/issues/246
 #include "common_csky.h"
 #endif

+#ifdef ARCH_WASM
+#include "common_wasm.h"
+#endif
+
 #ifndef ASSEMBLER
 #ifdef OS_WINDOWSSTORE
 typedef char env_var_t[MAX_PATH];
@@ -551,6 +579,27 @@ static __inline void blas_lock(volatile BLASULONG *address){
 #define BLAS_LOCK_DEFINED
 #endif

+#ifdef HAVE_C11
+static __inline void blas_lock(volatile BLASULONG *address) {
+  BLASULONG expected = 0;
+  while (!atomic_compare_exchange_strong((volatile _Atomic BLASULONG *)address,
+             &expected, (BLASULONG)1)) {
+    expected = 0;
+    YIELDING;
+  }
+}
+#endif
+
+static __inline void blas_unlock(volatile BLASULONG *address){
+#ifdef HAVE_C11
+  atomic_store((volatile _Atomic BLASULONG *)address, (BLASULONG)0);
+#else
+  MB;
+  *address = 0;
+#endif
+}
+
+
 #ifndef RPCC_DEFINED
 #error "rpcc() implementation is missing for your platform"
 #endif
@@ -734,19 +783,6 @@ __declspec(dllimport) int __cdecl omp_in_parallel(void);
 __declspec(dllimport) int __cdecl omp_get_num_procs(void);
 #endif

-#ifdef HAVE_C11
-#if defined(C_GCC) && ( __GNUC__ < 7) 
-// workaround for GCC bug 65467
-#ifndef _Atomic
-#define _Atomic volatile
-#endif
-#endif
-#include <stdatomic.h>
-#else
-#ifndef _Atomic
-#define _Atomic volatile
-#endif
-#endif

 #else
 #ifdef __ELF__
@@ -755,17 +791,13 @@ int omp_get_num_procs(void) __attribute__ ((weak));
 #endif
 #endif

-static __inline void blas_unlock(volatile BLASULONG *address){
-  MB;
-  *address = 0;
-}

 #ifdef OS_WINDOWSSTORE
 static __inline int readenv_atoi(char *env) {
 	return 0;
 }
 #else
-#ifdef OS_WINDOWS
+#if defined(OS_WINDOWS) && !defined(OS_CYGWIN_NT)
 static __inline int readenv_atoi(char *env) {
  env_var_t p;
  return readenv(p,env) ? 0 : atoi(p);
@@ -781,7 +813,7 @@ static __inline int readenv_atoi(char *env) {
 #endif
 #endif

-#if !defined(XDOUBLE) || !defined(QUAD_PRECISION)
+#if !defined(BFLOAT16) && (!defined(XDOUBLE) || !defined(QUAD_PRECISION))

 static __inline void compinv(FLOAT *b, FLOAT ar, FLOAT ai){

@@ -45,6 +45,7 @@
 #define WMB asm("wmb")
 #define RMB asm("mb")

+#ifndef BLAS_LOCK_DEFINED
 static __inline void blas_lock(unsigned long *address){
 #ifndef __DECC
  unsigned long tmp1, tmp2;
@@ -78,6 +79,7 @@ static __inline void blas_lock(unsigned long *address){
 #endif
 }
 #define BLAS_LOCK_DEFINED
+#endif

 static __inline unsigned int rpcc(void){

@@ -53,6 +53,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #if defined(ARMV6) || defined(ARMV7) || defined(ARMV8)

+#ifndef BLAS_LOCK_DEFINED
 static __inline void blas_lock(volatile BLASULONG *address){

  int register ret;
@@ -75,6 +76,7 @@ static __inline void blas_lock(volatile BLASULONG *address){

 #define BLAS_LOCK_DEFINED
 #endif
+#endif

 static inline int blas_quickdivide(blasint x, blasint y){
  return x / y;
@@ -68,6 +68,7 @@ static __inline int WhereAmI(void){
 }
 #endif

+#ifndef BLAS_LOCK_DEFINED
 static __inline void blas_lock(volatile BLASULONG *address){

  BLASULONG ret;
@@ -101,6 +102,7 @@ static __inline void blas_lock(volatile BLASULONG *address){
 }

 #define BLAS_LOCK_DEFINED
+#endif

 #if !defined(OS_DARWIN) && !defined (OS_ANDROID)
 static __inline BLASULONG rpcc(void){
@@ -114,9 +116,9 @@ static __inline BLASULONG rpcc(void){
  #else
  BLASULONG ret = 0;
  blasint shift;
- 
-  __asm__ __volatile__ ("isb; mrs %0,cntvct_el0":"=r"(ret));
-  __asm__ __volatile__ ("mrs %0,cntfrq_el0; clz %w0, %w0":"=&r"(shift));
+
+  __asm__ __volatile__ ("isb\n\tmrs %0,cntvct_el0":"=r"(ret));
+  __asm__ __volatile__ ("mrs %x0,cntfrq_el0\n\tclz %w0, %w0":"=&r"(shift));

  return ret << shift;
  #endif
@@ -56,6 +56,7 @@
 #define RPCC64BIT

 #ifndef __ECC
+#ifndef BLAS_LOCK_DEFINED
 static __inline void blas_lock(volatile unsigned long *address){

  unsigned long ret;
@@ -70,6 +71,7 @@ static __inline void blas_lock(volatile unsigned long *address){
  } while (ret);
 }
 #define BLAS_LOCK_DEFINED
+#endif

 static __inline unsigned long rpcc(void) {
  unsigned long clocks;
@@ -98,11 +100,13 @@ static __inline void ldmxcsr(unsigned long fp) {

 #else

+#ifndef BLAS_LOCK_DEFINED
 static __inline void blas_lock(volatile unsigned long *address){
  while (*address || _InterlockedCompareExchange((volatile int *) address,1,0))
    ;
 }
 #define BLAS_LOCK_DEFINED
+#endif

 static __inline unsigned int rpcc(void) {
  return __getReg(_IA64_REG_AR_ITC);
@@ -261,6 +261,8 @@ void BLASFUNC(bgemv)(char *, blasint *, blasint *, bfloat16  *, bfloat16 *, blas
            bfloat16  *, blasint *, bfloat16  *, bfloat16  *, blasint *);
 void BLASFUNC(sbgemv)(char *, blasint *, blasint *, float  *, bfloat16 *, blasint *,
            bfloat16  *, blasint *, float  *, float  *, blasint *);
+void BLASFUNC(shgemv)(char *, blasint *, blasint *, float  *, hfloat16 *, blasint *,
+            hfloat16  *, blasint *, float  *, float  *, blasint *);
 void BLASFUNC(sgemv)(char *, blasint *, blasint *, float  *, float  *, blasint *,
 		    float  *, blasint *, float  *, float  *, blasint *);
 void BLASFUNC(dgemv)(char *, blasint *, blasint *, double *, double *, blasint *,
@@ -54,6 +54,10 @@ int sbgemv_n(BLASLONG, BLASLONG, float, bfloat16 *, BLASLONG, bfloat16 *, BLASLO
 int sbgemv_t(BLASLONG, BLASLONG, float, bfloat16 *, BLASLONG, bfloat16 *, BLASLONG, float, float *, BLASLONG);
 int sbgemv_thread_n(BLASLONG, BLASLONG, float, bfloat16 *, BLASLONG, bfloat16 *, BLASLONG, float, float *, BLASLONG, int);
 int sbgemv_thread_t(BLASLONG, BLASLONG, float, bfloat16 *, BLASLONG, bfloat16 *, BLASLONG, float, float *, BLASLONG, int);
+int shgemv_n(BLASLONG, BLASLONG, float, hfloat16 *, BLASLONG, hfloat16 *, BLASLONG, float, float *, BLASLONG);
+int shgemv_t(BLASLONG, BLASLONG, float, hfloat16 *, BLASLONG, hfloat16 *, BLASLONG, float, float *, BLASLONG);
+int shgemv_thread_n(BLASLONG, BLASLONG, float, hfloat16 *, BLASLONG, hfloat16 *, BLASLONG, float, float *, BLASLONG, int);
+int shgemv_thread_t(BLASLONG, BLASLONG, float, hfloat16 *, BLASLONG, hfloat16 *, BLASLONG, float, float *, BLASLONG, int);
 int sger_k (BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *);
 int dger_k (BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *);
 int qger_k (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *);
@@ -59,6 +59,82 @@ void sgemm_direct_alpha_beta(BLASLONG M, BLASLONG N, BLASLONG K,
 	float beta,
 	float * R, BLASLONG strideR);

+void ssymm_direct_alpha_betaLU(BLASLONG M, BLASLONG N,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float * B, BLASLONG strideB,
+	float beta,
+	float * R, BLASLONG strideR);
+void ssymm_direct_alpha_betaLL(BLASLONG M, BLASLONG N,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float * B, BLASLONG strideB,
+	float beta,
+	float * R, BLASLONG strideR);
+
+void strmm_direct_LNUN(BLASLONG M, BLASLONG N,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float * B, BLASLONG strideB);
+void strmm_direct_LNLN(BLASLONG M, BLASLONG N,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float * B, BLASLONG strideB);
+void strmm_direct_LTUN(BLASLONG M, BLASLONG N,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float * B, BLASLONG strideB);
+void strmm_direct_LTLN(BLASLONG M, BLASLONG N,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float * B, BLASLONG strideB);
+
+void ssyrk_direct_alpha_betaUN(BLASLONG N, BLASLONG K,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float beta,
+	float * C, BLASLONG strideC);
+void ssyrk_direct_alpha_betaUT(BLASLONG N, BLASLONG K,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float beta,
+	float * C, BLASLONG strideC);
+void ssyrk_direct_alpha_betaLN(BLASLONG N, BLASLONG K,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float beta,
+	float * C, BLASLONG strideC);
+void ssyrk_direct_alpha_betaLT(BLASLONG N, BLASLONG K,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float beta,
+	float * C, BLASLONG strideC);
+
+void ssyr2k_direct_alpha_betaUN(BLASLONG N, BLASLONG K,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float * B, BLASLONG strideB,
+	float beta,
+	float * R, BLASLONG strideR);
+void ssyr2k_direct_alpha_betaUT(BLASLONG N, BLASLONG K,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float * B, BLASLONG strideB,
+	float beta,
+	float * R, BLASLONG strideR);
+void ssyr2k_direct_alpha_betaLN(BLASLONG N, BLASLONG K,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float * B, BLASLONG strideB,
+	float beta,
+	float * R, BLASLONG strideR);
+void ssyr2k_direct_alpha_betaLT(BLASLONG N, BLASLONG K,
+	float alpha,
+	float * A, BLASLONG strideA,
+	float * B, BLASLONG strideB,
+	float beta,
+	float * R, BLASLONG strideR);
+
 int sgemm_direct_performant(BLASLONG M, BLASLONG N, BLASLONG K);

 int shgemm_beta(BLASLONG, BLASLONG, BLASLONG, float,
@@ -70,7 +70,7 @@ extern long int syscall (long int __sysno, ...);
 static inline int my_mbind(void *addr, unsigned long len, int mode,
 			   unsigned long *nodemask, unsigned long maxnode,
 			   unsigned flags) {
-#if defined (__LSB_VERSION__) || defined(ARCH_ZARCH)
+#if defined (__LSB_VERSION__) || defined(ARCH_ZARCH) || defined(__PIZLONATOR_WAS_HERE__)
 // So far,  LSB (Linux Standard Base) don't support syscall().
 // https://lsbbugs.linuxfoundation.org/show_bug.cgi?id=3482
        return 0;
@@ -703,6 +703,9 @@
 #define GEMM_THREAD_RC   SHGEMM_THREAD_NT
 #define GEMM_THREAD_RR   SHGEMM_THREAD_NN

+#define SCAL_K        SSCAL_K
+#define GEMV_N        SHGEMV_N_K
+#define GEMV_T        SHGEMV_T_K

 #elif defined(BFLOAT16) && defined(BGEMM)
 #define SCAL_K        BSCAL_K
@@ -3156,6 +3159,8 @@ typedef struct {
 #define NEG_TCOPY	ZNEG_TCOPY
 #define	LARF_L		ZLARF_L
 #define	LARF_R		ZLARF_R
+#define LAED3_SINGLE	dlaed3_single
+#define LAED3_PARALLEL	dlaed3_parallel
 #else
 #define GETF2	CGETF2
 #define GETRF	CGETRF
@@ -3177,6 +3182,8 @@ typedef struct {
 #define NEG_TCOPY	CNEG_TCOPY
 #define	LARF_L		CLARF_L
 #define	LARF_R		CLARF_R
+#define LAED3_SINGLE	slaed3_single
+#define LAED3_PARALLEL	slaed3_parallel
 #endif
 #endif

@@ -47,6 +47,9 @@
 typedef struct {
  int dtb_entries;
  int switch_ratio;
+  int divide_rate;
+  int divide_limit;
+  int preferred_size;
  int offsetA, offsetB, align;
 #if BUILD_HFLOAT16 == 1
 int shgemm_p, shgemm_q, shgemm_r;
@@ -60,7 +63,8 @@ int (*shgemm_itcopy   )(BLASLONG, BLASLONG, hfloat16 *, BLASLONG, hfloat16 *);
 int (*shgemm_oncopy   )(BLASLONG, BLASLONG, hfloat16 *, BLASLONG, hfloat16 *);
 int (*shgemm_otcopy   )(BLASLONG, BLASLONG, hfloat16 *, BLASLONG, hfloat16 *);

-
+int (*shgemv_n) (BLASLONG, BLASLONG, float, hfloat16 *, BLASLONG, hfloat16 *, BLASLONG, float, float *, BLASLONG);
+int (*shgemv_t) (BLASLONG, BLASLONG, float, hfloat16 *, BLASLONG, hfloat16 *, BLASLONG, float, float *, BLASLONG);
 #endif


@@ -256,7 +260,22 @@ int (*shgemm_otcopy   )(BLASLONG, BLASLONG, hfloat16 *, BLASLONG, hfloat16 *);
 #endif
 #ifdef ARCH_ARM64
  void (*sgemm_direct) (BLASLONG, BLASLONG, BLASLONG, float *, BLASLONG , float *, BLASLONG , float * , BLASLONG);
+  int  (*sgemm_direct_performant) (BLASLONG M, BLASLONG N, BLASLONG K);
  void (*sgemm_direct_alpha_beta) (BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float, float * , BLASLONG);
+  void (*ssymm_direct_alpha_betaLU) (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float, float * , BLASLONG);
+  void (*ssymm_direct_alpha_betaLL) (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float, float * , BLASLONG);
+  void (*strmm_direct_LNUN) (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG);
+  void (*strmm_direct_LNLN) (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG);
+  void (*strmm_direct_LTUN) (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG);
+  void (*strmm_direct_LTLN) (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG);
+  void (*ssyrk_direct_alpha_betaUN) (BLASLONG, BLASLONG, float, float *, BLASLONG, float, float *, BLASLONG);
+  void (*ssyrk_direct_alpha_betaUT) (BLASLONG, BLASLONG, float, float *, BLASLONG, float, float *, BLASLONG);
+  void (*ssyrk_direct_alpha_betaLN) (BLASLONG, BLASLONG, float, float *, BLASLONG, float, float *, BLASLONG);
+  void (*ssyrk_direct_alpha_betaLT) (BLASLONG, BLASLONG, float, float *, BLASLONG, float, float *, BLASLONG);
+  void (*ssyr2k_direct_alpha_betaUN) (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float, float *, BLASLONG);
+  void (*ssyr2k_direct_alpha_betaUT) (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float, float *, BLASLONG);
+  void (*ssyr2k_direct_alpha_betaLN) (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float, float *, BLASLONG);
+  void (*ssyr2k_direct_alpha_betaLT) (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float, float *, BLASLONG);
 #endif

  
@@ -89,6 +89,7 @@

 void *qalloc(int flags, size_t bytes);

+#ifndef BLAS_LOCK_DEFINED
 static inline void blas_lock(volatile unsigned long *address){

  long int ret, val = 1;
@@ -123,6 +124,7 @@ static inline void blas_lock(volatile unsigned long *address){
  } while (ret);
 }
 #define BLAS_LOCK_DEFINED
+#endif

 static inline unsigned long rpcc(void){
  unsigned long ret;
@@ -50,6 +50,20 @@
 #define SGEMM_DIRECT_PERFORMANT    sgemm_direct_performant
 #define SGEMM_DIRECT		sgemm_direct
 #define  SGEMM_DIRECT_ALPHA_BETA		sgemm_direct_alpha_beta
+#define  SSYMM_DIRECT_ALPHA_BETA_LU		ssymm_direct_alpha_betaLU
+#define  SSYMM_DIRECT_ALPHA_BETA_LL		ssymm_direct_alpha_betaLL
+#define  STRMM_DIRECT_LNUN		strmm_direct_LNUN
+#define  STRMM_DIRECT_LNLN		strmm_direct_LNLN
+#define  STRMM_DIRECT_LTUN		strmm_direct_LTUN
+#define  STRMM_DIRECT_LTLN		strmm_direct_LTLN
+#define  SSYRK_DIRECT_ALPHA_BETA_UN         ssyrk_direct_alpha_betaUN
+#define  SSYRK_DIRECT_ALPHA_BETA_UT         ssyrk_direct_alpha_betaUT
+#define  SSYRK_DIRECT_ALPHA_BETA_LN         ssyrk_direct_alpha_betaLN
+#define  SSYRK_DIRECT_ALPHA_BETA_LT         ssyrk_direct_alpha_betaLT
+#define  SSYR2K_DIRECT_ALPHA_BETA_UN         ssyr2k_direct_alpha_betaUN
+#define  SSYR2K_DIRECT_ALPHA_BETA_UT         ssyr2k_direct_alpha_betaUT
+#define  SSYR2K_DIRECT_ALPHA_BETA_LN         ssyr2k_direct_alpha_betaLN
+#define  SSYR2K_DIRECT_ALPHA_BETA_LT         ssyr2k_direct_alpha_betaLT

 #define	SGEMM_ONCOPY		sgemm_oncopy
 #define	SGEMM_OTCOPY		sgemm_otcopy
@@ -217,9 +231,23 @@
 #define SGEMM_DIRECT_PERFORMANT gotoblas -> sgemm_direct_performant
 #define  SGEMM_DIRECT		gotoblas -> sgemm_direct
 #elif ARCH_ARM64
-#define SGEMM_DIRECT_PERFORMANT    sgemm_direct_performant
+#define SGEMM_DIRECT_PERFORMANT gotoblas -> sgemm_direct_performant
 #define  SGEMM_DIRECT		gotoblas -> sgemm_direct
 #define  SGEMM_DIRECT_ALPHA_BETA		gotoblas -> sgemm_direct_alpha_beta
+#define  SSYMM_DIRECT_ALPHA_BETA_LU		gotoblas -> ssymm_direct_alpha_betaLU
+#define  SSYMM_DIRECT_ALPHA_BETA_LL		gotoblas -> ssymm_direct_alpha_betaLL
+#define  STRMM_DIRECT_LNUN		gotoblas -> strmm_direct_LNUN
+#define  STRMM_DIRECT_LNLN		gotoblas -> strmm_direct_LNLN
+#define  STRMM_DIRECT_LTUN		gotoblas -> strmm_direct_LTUN
+#define  STRMM_DIRECT_LTLN		gotoblas -> strmm_direct_LTLN
+#define  SSYRK_DIRECT_ALPHA_BETA_UN     gotoblas -> ssyrk_direct_alpha_betaUN
+#define  SSYRK_DIRECT_ALPHA_BETA_UT     gotoblas -> ssyrk_direct_alpha_betaUT
+#define  SSYRK_DIRECT_ALPHA_BETA_LN     gotoblas -> ssyrk_direct_alpha_betaLN
+#define  SSYRK_DIRECT_ALPHA_BETA_LT     gotoblas -> ssyrk_direct_alpha_betaLT
+#define  SSYR2K_DIRECT_ALPHA_BETA_UN     gotoblas -> ssyr2k_direct_alpha_betaUN
+#define  SSYR2K_DIRECT_ALPHA_BETA_UT     gotoblas -> ssyr2k_direct_alpha_betaUT
+#define  SSYR2K_DIRECT_ALPHA_BETA_LN     gotoblas -> ssyr2k_direct_alpha_betaLN
+#define  SSYR2K_DIRECT_ALPHA_BETA_LT     gotoblas -> ssyr2k_direct_alpha_betaLT
 #endif

 #define	SGEMM_ONCOPY		gotoblas -> sgemm_oncopy
@@ -1,3 +1,31 @@
+/***************************************************************************
+ * Copyright (c) 2025, The OpenBLAS Project
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name of the OpenBLAS project nor the names of
+ * its contributors may be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * *****************************************************************************/
+
 #ifndef COMMON_SH_H
 #define COMMON_SH_H

@@ -17,6 +45,9 @@
 #define SHGEMM_BETA		    shgemm_beta
 #define SHGEMM_KERNEL       shgemm_kernel

+#define SHGEMV_N_K      shgemv_n
+#define SHGEMV_T_K      shgemv_t
+

 #else // #DYNAMIC_ARCH

@@ -32,6 +63,10 @@

 #define SHGEMM_BETA		gotoblas -> shgemm_beta
 #define SHGEMM_KERNEL		gotoblas -> shgemm_kernel
+
+#define SHGEMV_N_K      gotoblas->shgemv_n
+#define SHGEMV_T_K      gotoblas->shgemv_t
+
 #endif // #DYNAMIC_ARCH

 #define SHGEMM_NN        shgemm_nn
@@ -45,6 +45,7 @@

 #ifndef ASSEMBLER

+#ifndef BLAS_LOCK_DEFINED
 static __inline void blas_lock(volatile unsigned long *address){

  long int ret = 1;
@@ -60,6 +61,7 @@ static __inline void blas_lock(volatile unsigned long *address){
  } while (ret);
 }
 #define BLAS_LOCK_DEFINED
+#endif

 static __inline unsigned long rpcc(void){
  unsigned long clocks;
@@ -51,7 +51,7 @@ extern void goto_set_num_threads(int nthreads);
 #undef TIMING_DEBUG

 /* Global Parameter */
-extern int blas_cpu_number;
+extern _Atomic int blas_cpu_number;
 extern int blas_num_threads;
 extern int blas_omp_linked;

@@ -191,6 +191,9 @@ int exec_blas(BLASLONG num_cpu, blas_param_t *param, void *buffer);

 #ifndef ASSEMBLER

+void blas_level3_thread_enter(void);
+void blas_level3_thread_leave(void);
+
 int blas_level1_thread(int mode, BLASLONG m, BLASLONG n, BLASLONG k, void *alpha,
 		       void *a, BLASLONG lda,
 		       void *b, BLASLONG ldb,
@@ -0,0 +1,91 @@
+/*****************************************************************************
+Copyright (c) 2011-2014, The OpenBLAS Project
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the
+      distribution.
+   3. Neither the name of the OpenBLAS project nor the names of 
+      its contributors may be used to endorse or promote products 
+      derived from this software without specific prior written 
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**********************************************************************************/
+
+/*********************************************************************/
+/* Copyright 2009, 2010 The University of Texas at Austin.           */
+/* All rights reserved.                                              */
+/*                                                                   */
+/* Redistribution and use in source and binary forms, with or        */
+/* without modification, are permitted provided that the following   */
+/* conditions are met:                                               */
+/*                                                                   */
+/*   1. Redistributions of source code must retain the above         */
+/*      copyright notice, this list of conditions and the following  */
+/*      disclaimer.                                                  */
+/*                                                                   */
+/*   2. Redistributions in binary form must reproduce the above      */
+/*      copyright notice, this list of conditions and the following  */
+/*      disclaimer in the documentation and/or other materials       */
+/*      provided with the distribution.                              */
+/*                                                                   */
+/*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */
+/*    AUSTIN  ``AS IS''  AND ANY  EXPRESS OR  IMPLIED WARRANTIES,    */
+/*    INCLUDING, BUT  NOT LIMITED  TO, THE IMPLIED  WARRANTIES OF    */
+/*    MERCHANTABILITY  AND FITNESS FOR  A PARTICULAR  PURPOSE ARE    */
+/*    DISCLAIMED.  IN  NO EVENT SHALL THE UNIVERSITY  OF TEXAS AT    */
+/*    AUSTIN OR CONTRIBUTORS BE  LIABLE FOR ANY DIRECT, INDIRECT,    */
+/*    INCIDENTAL,  SPECIAL, EXEMPLARY,  OR  CONSEQUENTIAL DAMAGES    */
+/*    (INCLUDING, BUT  NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE    */
+/*    GOODS  OR  SERVICES; LOSS  OF  USE,  DATA,  OR PROFITS;  OR    */
+/*    BUSINESS INTERRUPTION) HOWEVER CAUSED  AND ON ANY THEORY OF    */
+/*    LIABILITY, WHETHER  IN CONTRACT, STRICT  LIABILITY, OR TORT    */
+/*    (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING IN ANY WAY OUT    */
+/*    OF  THE  USE OF  THIS  SOFTWARE,  EVEN  IF ADVISED  OF  THE    */
+/*    POSSIBILITY OF SUCH DAMAGE.                                    */
+/*                                                                   */
+/* The views and conclusions contained in the software and           */
+/* documentation are those of the authors and should not be          */
+/* interpreted as representing official policies, either expressed   */
+/* or implied, of The University of Texas at Austin.                 */
+/*********************************************************************/
+
+#ifndef COMMON_WASM
+#define COMMON_WASM
+
+#define MB  __sync_synchronize()
+#define WMB __sync_synchronize()
+#define RMB __sync_synchronize()
+
+#ifndef ASSEMBLER
+
+
+static inline int blas_quickdivide(blasint x, blasint y){
+  return x / y;
+}
+
+#endif
+
+#define BUFFER_SIZE     ( 16 << 20)
+#define SEEK_ADDRESS
+
+#endif
+
@@ -54,6 +54,7 @@
 #define	__volatile__
 #endif

+#ifndef BLAS_LOCK_DEFINED
 static __inline void blas_lock(volatile BLASULONG *address){

  int ret;
@@ -83,6 +84,7 @@ static __inline void blas_lock(volatile BLASULONG *address){

 }
 #define BLAS_LOCK_DEFINED
+#endif

 static __inline unsigned long long rpcc(void){
 #if defined(_MSC_VER) && !defined(__clang__)
@@ -70,6 +70,7 @@
 #define RMB
 #endif

+#ifndef BLAS_LOCK_DEFINED
 static __inline void blas_lock(volatile BLASULONG *address){

 	
@@ -83,11 +84,15 @@ static __inline void blas_lock(volatile BLASULONG *address){
    while (*address) {YIELDING;}

 #ifndef C_MSVC
+#ifdef __PIZLONATOR_WAS_HERE__
+    ret=__atomic_exchange_n(address, 1, __ATOMIC_SEQ_CST);
+#else    
    __asm__ __volatile__(
 			 "xchgl %0, %1\n"
 			 : "=r"(ret), "=m"(*address)
 			 : "0"(1), "m"(*address)
 			 : "memory");
+#endif
 #else
    ret=InterlockedExchange64((volatile LONG64 *)(address), 1);
 #endif
@@ -95,6 +100,7 @@ static __inline void blas_lock(volatile BLASULONG *address){

 }
 #define BLAS_LOCK_DEFINED
+#endif

 static __inline BLASULONG rpcc(void){
 #ifdef C_MSVC
@@ -237,7 +243,7 @@ static __inline unsigned int blas_quickdivide(unsigned int x, unsigned int y){
 	
  y = blas_quick_divide_table[y];

-  __asm__ __volatile__  ("mull %0" :"=d" (result), "+a"(x) : "0" (y));
+  __asm__ __volatile__  ("mull %0" :"=d" (result), "+a"(x) : "0" (y) : "cc");
  return result;
 }
 #endif
@@ -5,19 +5,35 @@ enable_language(CXX)

 set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -DADD${BU} -DCBLAS")

-if (USE_OPENMP)
+set(CPP_THREAD_SAFETY_LIBS ${OpenBLAS_LIBNAME})
+find_package(Threads REQUIRED)
+list(APPEND CPP_THREAD_SAFETY_LIBS Threads::Threads)
+add_definitions(-DOPENBLAS_USE_GENERATED_CBLAS_H)
+
+if ((CPP_THREAD_SAFETY_TEST OR CPP_THREAD_SAFETY_GEMV) AND CPP_THREAD_SAFETY_USE_OPENMP)
+  find_package(OpenMP REQUIRED COMPONENTS CXX)
+  list(APPEND CPP_THREAD_SAFETY_LIBS OpenMP::OpenMP_CXX)
+  add_definitions(-DCPP_THREAD_SAFETY_USE_OPENMP)
+endif()
+
+set(CPP_THREAD_SAFETY_DGEMM_ARGS "" CACHE STRING "Arguments passed to the DGEMM thread safety test")
+set(CPP_THREAD_SAFETY_DGEMM_MIXED_ARGS "" CACHE STRING "Arguments passed to the mixed DGEMM thread safety test")
+set(CPP_THREAD_SAFETY_DGEMV_ARGS "" CACHE STRING "Arguments passed to the DGEMV thread safety test")
+
 if (CPP_THREAD_SAFETY_TEST)
-  message(STATUS building thread safety test)
-  add_executable(dgemm_thread_safety dgemm_thread_safety.cpp) 
-  target_link_libraries(dgemm_thread_safety ${OpenBLAS_LIBNAME})
-  add_test( dgemm_thread_safety ${CMAKE_CURRENT_BINARY_DIR}/dgemm_thread_safety)
+  message(STATUS "building thread safety test")
+  add_executable(dgemm_thread_safety dgemm_thread_safety.cpp)
+  target_link_libraries(dgemm_thread_safety ${CPP_THREAD_SAFETY_LIBS})
+  add_test(NAME dgemm_thread_safety COMMAND ${CMAKE_CURRENT_BINARY_DIR}/dgemm_thread_safety ${CPP_THREAD_SAFETY_DGEMM_ARGS})
+
+  add_executable(dgemm_thread_safety_mixed dgemm_thread_safety_mixed.cpp)
+  target_link_libraries(dgemm_thread_safety_mixed ${CPP_THREAD_SAFETY_LIBS})
+  add_test(NAME dgemm_thread_safety_mixed COMMAND ${CMAKE_CURRENT_BINARY_DIR}/dgemm_thread_safety_mixed ${CPP_THREAD_SAFETY_DGEMM_MIXED_ARGS})
 endif()


 if (CPP_THREAD_SAFETY_TEST OR CPP_THREAD_SAFETY_GEMV)
-  add_executable(dgemv_thread_safety dgemv_thread_safety.cpp) 
-  target_link_libraries(dgemv_thread_safety ${OpenBLAS_LIBNAME})
-  add_test(dgemv_thread_safety ${CMAKE_CURRENT_BINARY_DIR}/dgemv_thread_safety)
-endif()
-
+  add_executable(dgemv_thread_safety dgemv_thread_safety.cpp)
+  target_link_libraries(dgemv_thread_safety ${CPP_THREAD_SAFETY_LIBS})
+  add_test(NAME dgemv_thread_safety COMMAND ${CMAKE_CURRENT_BINARY_DIR}/dgemv_thread_safety ${CPP_THREAD_SAFETY_DGEMV_ARGS})
 endif()
@@ -1,15 +1,19 @@
 TOPDIR = ..
 include $(TOPDIR)/Makefile.system

-all :: dgemv_tester dgemm_tester
+all :: dgemv_tester dgemm_tester dgemm_mixed_tester

 dgemv_tester :
-	$(CXX) $(COMMON_OPT) -Wall -Wextra -Wshadow -fopenmp -std=c++11 dgemv_thread_safety.cpp ../$(LIBNAME) $(EXTRALIB) $(FEXTRALIB) -o dgemv_tester
+	$(CXX) $(COMMON_OPT) -Wall -Wextra -Wshadow -std=c++11 dgemv_thread_safety.cpp ../$(LIBNAME) $(EXTRALIB) $(FEXTRALIB) -o dgemv_tester
 	./dgemv_tester

 dgemm_tester : dgemv_tester
-	$(CXX) $(COMMON_OPT) -Wall -Wextra -Wshadow -fopenmp -std=c++11 dgemm_thread_safety.cpp ../$(LIBNAME) $(EXTRALIB) $(FEXTRALIB) -o dgemm_tester
+	$(CXX) $(COMMON_OPT) -Wall -Wextra -Wshadow -std=c++11 dgemm_thread_safety.cpp ../$(LIBNAME) $(EXTRALIB) $(FEXTRALIB) -o dgemm_tester
 	./dgemm_tester

+dgemm_mixed_tester : dgemm_tester
+	$(CXX) $(COMMON_OPT) -Wall -Wextra -Wshadow -std=c++11 dgemm_thread_safety_mixed.cpp ../$(LIBNAME) $(EXTRALIB) $(FEXTRALIB) -o dgemm_mixed_tester
+	./dgemm_mixed_tester
+
 clean ::
-	rm -f dgemv_tester dgemm_tester
+	rm -f dgemv_tester dgemm_tester dgemm_mixed_tester
@@ -1,3 +1,9 @@
+#ifdef CPP_THREAD_SAFETY_USE_OPENMP
+#include <omp.h>
+#else
+#include <thread>
+#endif
+
 inline void pauser(){
    /// a portable way to pause a program
    std::string dummy;
@@ -13,6 +19,29 @@ void FailIfThreadsAreZero(uint32_t numConcurrentThreads) {
 	}
 }

+uint32_t GetMaxHwThreads() {
+#ifdef CPP_THREAD_SAFETY_USE_OPENMP
+	return omp_get_max_threads();
+#else
+	const uint32_t maxHwThreads = std::thread::hardware_concurrency();
+	return maxHwThreads == 0 ? 1 : maxHwThreads;
+#endif
+}
+
+void SetLauncherThreads(uint32_t numConcurrentThreads) {
+#ifdef CPP_THREAD_SAFETY_USE_OPENMP
+	omp_set_num_threads(numConcurrentThreads);
+#endif
+}
+
+const char *LauncherName() {
+#ifdef CPP_THREAD_SAFETY_USE_OPENMP
+	return " using OpenMP";
+#else
+	return "";
+#endif
+}
+
 void FillMatrices(std::vector<std::vector<double>>& matBlock, std::mt19937_64& PRNG, std::uniform_real_distribution<double>& rngdist, const blasint randomMatSize, const uint32_t numConcurrentThreads, const uint32_t numMat){
 	for(uint32_t i=0; i<numMat; i++){
 		for(uint32_t j = 0; j < static_cast<uint32_t>(randomMatSize*randomMatSize); j++){
@@ -2,8 +2,11 @@
 #include <vector>
 #include <random>
 #include <future>
-#include <omp.h>
+#ifdef OPENBLAS_USE_GENERATED_CBLAS_H
+#include "generated/cblas.h"
+#else
 #include "../cblas.h"
+#endif
 #include "cpp_thread_safety_common.h"

 void launch_cblas_dgemm(double* A, double* B, double* C, const blasint randomMatSize){
@@ -14,7 +17,7 @@ int main(int argc, char* argv[]){
 	blasint randomMatSize = 1024; //dimension of the random square matrices used
 	uint32_t numConcurrentThreads = 96; //number of concurrent calls of the functions being tested
 	uint32_t numTestRounds = 16; //number of testing rounds before success exit
-	uint32_t maxHwThreads = omp_get_max_threads();
+	uint32_t maxHwThreads = GetMaxHwThreads();
 	
 	if (maxHwThreads < 96)
 		numConcurrentThreads = maxHwThreads;
@@ -65,11 +68,13 @@ int main(int argc, char* argv[]){
 	//PrintMatrices(matBlock, randomMatSize, numConcurrentThreads, 3);
 	std::cout<<"done\n";
 	std::cout<<"Testing CBLAS DGEMM thread safety\n";
-	omp_set_num_threads(numConcurrentThreads);
+	SetLauncherThreads(numConcurrentThreads);
 	for(uint32_t R=0; R<numTestRounds; R++){
 		std::cout<<"DGEMM round #"<<R<<std::endl;
-		std::cout<<"Launching "<<numConcurrentThreads<<" threads simultaneously using OpenMP..."<<std::flush;
+		std::cout<<"Launching "<<numConcurrentThreads<<" threads simultaneously"<<LauncherName()<<"..."<<std::flush;
+		#ifdef CPP_THREAD_SAFETY_USE_OPENMP
 		#pragma omp parallel for default(none) shared(futureBlock, matBlock, randomMatSize, numConcurrentThreads)
+		#endif
 		for(uint32_t i=0; i<numConcurrentThreads; i++){
 			futureBlock[i] = std::async(std::launch::async, launch_cblas_dgemm, &matBlock[i*3][0], &matBlock[i*3+1][0], &matBlock[i*3+2][0], randomMatSize);
 			//launch_cblas_dgemm( &matBlock[i][0], &matBlock[i+1][0], &matBlock[i+2][0]);
@@ -0,0 +1,139 @@
+#include <atomic>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <random>
+#include <string>
+#include <thread>
+#include <vector>
+#ifdef OPENBLAS_USE_GENERATED_CBLAS_H
+#include "generated/cblas.h"
+#else
+#include "../cblas.h"
+#endif
+#include "cpp_thread_safety_common.h"
+
+void compute_dgemm_pair(std::vector<double>& transA, std::vector<double>& noTransA, std::vector<double>& B, double* firstOutput, double* secondOutput, const blasint randomMatSize, const bool sameVariant){
+	cblas_dgemm(CblasRowMajor, CblasTrans, CblasNoTrans, randomMatSize, 2, 2, 1.0, &transA[0], randomMatSize, &B[0], 2, 0.0, firstOutput, 2);
+	if (sameVariant)
+		cblas_dgemm(CblasRowMajor, CblasTrans, CblasNoTrans, randomMatSize, 2, 4, 1.0, &transA[0], randomMatSize, &B[0], 2, 0.0, secondOutput, 2);
+	else
+		cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, randomMatSize, 2, 4, 1.0, &noTransA[0], 4, &B[0], 2, 0.0, secondOutput, 2);
+}
+
+void run_worker(std::vector<double>& transA, std::vector<double>& noTransA, std::vector<double>& B, const std::vector<double>& referenceFirst, const std::vector<double>& referenceSecond, const blasint randomMatSize, const uint32_t numTestRounds, const bool sameVariant, std::atomic<uint32_t>& readyThreads, std::atomic<bool>& startThreads, uint32_t& mismatches){
+	std::vector<double> firstOutput(static_cast<size_t>(randomMatSize) * 2);
+	std::vector<double> secondOutput(static_cast<size_t>(randomMatSize) * 2);
+	const size_t outputBytes = static_cast<size_t>(randomMatSize) * 2 * sizeof(double);
+	uint32_t localMismatches = 0;
+
+	readyThreads.fetch_add(1);
+	while (!startThreads.load())
+		std::this_thread::yield();
+
+	for(uint32_t i=0; i<numTestRounds; i++){
+		compute_dgemm_pair(transA, noTransA, B, &firstOutput[0], &secondOutput[0], randomMatSize, sameVariant);
+		if (std::memcmp(&firstOutput[0], &referenceFirst[0], outputBytes) != 0 ||
+		    std::memcmp(&secondOutput[0], &referenceSecond[0], outputBytes) != 0)
+			localMismatches++;
+	}
+
+	mismatches = localMismatches;
+}
+
+int main(int argc, char* argv[]){
+	blasint randomMatSize = 262144;
+	uint32_t numConcurrentThreads = 8;
+	uint32_t numTestRounds = 200;
+	uint32_t maxHwThreads = GetMaxHwThreads();
+	bool sameVariant = false;
+
+	if (maxHwThreads < numConcurrentThreads)
+		numConcurrentThreads = maxHwThreads;
+
+	if (argc != 1 && argc != 4 && argc != 5){
+		std::cout<<"ERROR: expected zero arguments, or: <M> <threads> <rounds> [sameVariant]"<<std::endl;
+		return 1;
+	}
+
+	if(argc == 4 || argc == 5){
+		std::vector<std::string> cliArgs;
+		for (int i = 1; i < argc; i++){
+			cliArgs.push_back(argv[i]);
+			std::cout<<argv[i]<<std::endl;
+		}
+		randomMatSize = std::stoul(cliArgs[0]);
+		numConcurrentThreads = std::stoul(cliArgs[1]);
+		numTestRounds = std::stoul(cliArgs[2]);
+		if (argc == 5)
+			sameVariant = std::stoul(cliArgs[3]) != 0;
+	}
+
+	FailIfThreadsAreZero(numConcurrentThreads);
+
+	const size_t matrixElements = static_cast<size_t>(randomMatSize) * 4;
+	const size_t outputElements = static_cast<size_t>(randomMatSize) * 2;
+	std::vector<double> transA(matrixElements);
+	std::vector<double> noTransA(matrixElements);
+	std::vector<double> B(8);
+	std::vector<double> referenceFirst(outputElements);
+	std::vector<double> referenceSecond(outputElements);
+	std::vector<std::thread> threads(numConcurrentThreads);
+	std::vector<uint32_t> mismatchBlock(numConcurrentThreads);
+	std::atomic<uint32_t> readyThreads(0);
+	std::atomic<bool> startThreads(false);
+
+	std::cout<<"*----------------------------------*\n";
+	std::cout<<"| Mixed DGEMM thread safety tester |\n";
+	std::cout<<"*----------------------------------*\n";
+	std::cout<<"Tall-skinny DGEMM M dimension: "<<randomMatSize<<'\n';
+	std::cout<<"Number of concurrent calls into OpenBLAS : "<<numConcurrentThreads<<'\n';
+	std::cout<<"Number of testing rounds : "<<numTestRounds<<'\n';
+	std::cout<<"Second DGEMM uses "<<(sameVariant ? "the same transpose variant" : "a different transpose variant")<<'\n';
+	std::cout<<"OpenBLAS internal threads : "<<openblas_get_num_threads()<<'\n';
+	std::cout<<"This test will need "<<(static_cast<uint64_t>(matrixElements) * 2 * 8 + static_cast<uint64_t>(outputElements) * (2 + 2 * numConcurrentThreads) * 8)/static_cast<double>(1024*1024)<<" MiB of RAM\n"<<std::endl;
+
+	std::cout<<"Filling matrices with deterministic values..."<<std::flush;
+	for(size_t i=0; i<matrixElements; i++){
+		transA[i] = static_cast<double>(i % 512);
+		noTransA[i] = static_cast<double>((i * 7) % 512);
+	}
+	std::cout<<"done\n";
+	std::cout<<"Filling RHS matrix..."<<std::flush;
+	for(uint32_t i=0; i<8; i++){
+		B[i] = 0.1 * static_cast<double>(i + 1);
+	}
+	std::cout<<"done\n";
+
+	std::cout<<"Computing reference results..."<<std::flush;
+	compute_dgemm_pair(transA, noTransA, B, &referenceFirst[0], &referenceSecond[0], randomMatSize, sameVariant);
+	std::cout<<"done\n";
+
+	std::cout<<"Testing mixed CBLAS DGEMM thread safety\n";
+	std::cout<<"Launching "<<numConcurrentThreads<<" worker threads..."<<std::flush;
+	for(uint32_t i=0; i<numConcurrentThreads; i++){
+		threads[i] = std::thread(run_worker, std::ref(transA), std::ref(noTransA), std::ref(B), std::cref(referenceFirst), std::cref(referenceSecond), randomMatSize, numTestRounds, sameVariant, std::ref(readyThreads), std::ref(startThreads), std::ref(mismatchBlock[i]));
+	}
+	while (readyThreads.load() != numConcurrentThreads)
+		std::this_thread::yield();
+	startThreads.store(true);
+	std::cout<<"done\n";
+
+	std::cout<<"Waiting for worker threads to finish..."<<std::flush;
+	uint32_t mismatches = 0;
+	for(uint32_t i=0; i<numConcurrentThreads; i++){
+		threads[i].join();
+		mismatches += mismatchBlock[i];
+	}
+	std::cout<<"done\n";
+
+	std::cout<<"Mixed DGEMM mismatches: "<<mismatches<<std::endl;
+	if (mismatches != 0) {
+		std::cout<<"Mixed CBLAS DGEMM thread safety test FAILED!"<<std::endl;
+		return 1;
+	}
+
+	std::cout<<"Mixed CBLAS DGEMM thread safety test PASSED!\n"<<std::endl;
+	return 0;
+}
@@ -2,8 +2,11 @@
 #include <vector>
 #include <random>
 #include <future>
-#include <omp.h>
+#ifdef OPENBLAS_USE_GENERATED_CBLAS_H
+#include "generated/cblas.h"
+#else
 #include "../cblas.h"
+#endif
 #include "cpp_thread_safety_common.h"

 void launch_cblas_dgemv(double* A, double* x, double* y, const blasint randomMatSize)
@@ -17,7 +20,7 @@ int main(int argc, char* argv[])
 	blasint randomMatSize = 1024; //dimension of the random square matrices and vectors being used
 	uint32_t numConcurrentThreads = 52; //number of concurrent calls of the functions being tested
 	uint32_t numTestRounds = 16; //number of testing rounds before success exit
-	uint32_t maxHwThreads = omp_get_max_threads();
+	uint32_t maxHwThreads = GetMaxHwThreads();
 	
 	if (maxHwThreads < 52)
 		numConcurrentThreads = maxHwThreads;
@@ -84,12 +87,14 @@ int main(int argc, char* argv[])
 	std::cout<<"done\n";
 	
 	std::cout<<"Testing CBLAS DGEMV thread safety"<<std::endl;
-	omp_set_num_threads(numConcurrentThreads);
+	SetLauncherThreads(numConcurrentThreads);
 	for(uint32_t R=0; R<numTestRounds; R++)
 		{
 		std::cout<<"DGEMV round #"<<R<<std::endl;
-		std::cout<<"Launching "<<numConcurrentThreads<<" threads simultaneously using OpenMP..."<<std::flush;
+		std::cout<<"Launching "<<numConcurrentThreads<<" threads simultaneously"<<LauncherName()<<"..."<<std::flush;
+		#ifdef CPP_THREAD_SAFETY_USE_OPENMP
 		#pragma omp parallel for default(none) shared(futureBlock, matBlock, vecBlock, randomMatSize, numConcurrentThreads)
+		#endif
 		for(uint32_t i=0; i<numConcurrentThreads; i++)
 			{
 			futureBlock[i] = std::async(std::launch::async, launch_cblas_dgemv, &matBlock[i][0], &vecBlock[i*2][0], &vecBlock[i*2+1][0], randomMatSize);
@@ -82,6 +82,7 @@ size_t length64=sizeof(value64);
 #define CPU_AMPERE1      25
 // Apple
 #define CPU_VORTEX       13
+#define CPU_VORTEXM4     26 
 // Fujitsu
 #define CPU_A64FX	 15
 // Phytium
@@ -113,7 +114,8 @@ static char *cpuname[] = {
  "FT2000",
  "CORTEXA76",
  "NEOVERSEV2",
-  "AMPERE1"
+  "AMPERE1",
+  "VORTEXM4",
 };

 static char *cpuname_lower[] = {
@@ -143,13 +145,15 @@ static char *cpuname_lower[] = {
  "cortexa76",
  "neoversev2",
  "ampere1",
-  "ampere1a"
+  "vortexm4"
 };

 static int cpulowperf=0;
 static int cpumidperf=0;
 static int cpuhiperf=0;

+int aliased = 0;
+
 int get_feature(char *search)
 {

@@ -317,8 +321,11 @@ int detect(void)
 	return CPU_CORTEXX2;
      else if (strstr(cpu_part, "0xd4e")) //X3
 	return CPU_CORTEXX2;
-      else if (strstr(cpu_part, "0xd4f")) //NVIDIA Grace et al.
+      else if (strstr(cpu_part, "0xd4f"))
        return CPU_NEOVERSEV2;
+	  else if (strstr(cpu_part, "0xd87") || strstr(cpu_part, "0xd85")  // A725,X925
+		|| strstr(cpu_part, "0xd84") || strstr(cpu_part, "0xd83")) // V3,V3AE
+		return CPU_NEOVERSEV2;
      else if (strstr(cpu_part, "0xd0b")) 
       return CPU_CORTEXA76;
    }
@@ -346,7 +353,7 @@ int detect(void)
    else if (strstr(cpu_implementer, "0x46") && strstr(cpu_part, "0x001"))
                        return CPU_A64FX;
    // Apple
-    else if (strstr(cpu_implementer, "0x61") && strstr(cpu_part, "0x022"))
+    else if (strstr(cpu_implementer, "0x61") /* && strstr(cpu_part, "0x022")*/)
 	    		return CPU_VORTEX;
   // Phytium
   else if (strstr(cpu_implementer, "0x70") && (strstr(cpu_part, "0x660") || strstr(cpu_part, "0x661") 
@@ -400,7 +407,8 @@ int detect(void)
 	if (value64 ==131287967|| value64 == 458787763 ) return CPU_VORTEX; //A12/M1
 	if (value64 == 3660830781) return CPU_VORTEX; //A15/M2
        if (value64 == 2271604202) return CPU_VORTEX; //A16/M3
-        if (value64 == 1867590060) return CPU_VORTEX; //M4
+        if (value64 == 1867590060) return CPU_VORTEXM4; //M4
+	    if (value64 == 492472296) return CPU_VORTEXM4; //M5
 #else
 #ifdef OS_WINDOWS
 	HKEY reghandle;
@@ -418,7 +426,10 @@ int detect(void)
 	if (errcode != ERROR_SUCCESS) wprintf(L"Error reading cpuname from registry:%x\n",errcode);
 //wprintf(stderr,L"%s\n",(PWSTR)valstring);
 	RegCloseKey(reghandle);
-	if (strstr(valstring, "Snapdragon(R) X Elite")) return CPU_NEOVERSEN1;
+	if (strstr(valstring, "Snapdragon(R) X Elite")) {
+		aliased = 1;
+		return CPU_NEOVERSEN1;
+	}
 	if (strstr(valstring, "Ampere(R) Altra")) return CPU_NEOVERSEN1;
 	if (strstr(valstring, "Snapdragon (TM) 8cx Gen 3")) return CPU_CORTEXX1;
 	if (strstr(valstring, "Snapdragon Compute Platform")) return CPU_CORTEXX1;
@@ -541,6 +552,7 @@ void get_cpuconfig(void)
 		break;
 	    case CPU_NEOVERSEN1:
 		printf("#define %s\n", cpuname[d]);
+		if (aliased == 0) {
 		printf("#define L1_CODE_SIZE 65536\n");
 		printf("#define L1_CODE_LINESIZE 64\n");
 		printf("#define L1_CODE_ASSOCIATIVE 4\n");
@@ -552,6 +564,23 @@ void get_cpuconfig(void)
 		printf("#define L2_ASSOCIATIVE 8\n");
 		printf("#define DTB_DEFAULT_ENTRIES 48\n");
 		printf("#define DTB_SIZE 4096\n");
+		} else {
+		printf("#define L1_CODE_SIZE 196608\n");
+		printf("#define L1_CODE_LINESIZE 64\n");
+		printf("#define L1_CODE_ASSOCIATIVE 6\n");
+		printf("#define L1_DATA_SIZE 98304\n");
+		printf("#define L1_DATA_LINESIZE 64\n");
+		printf("#define L1_DATA_ASSOCIATIVE 6\n");
+		printf("#define L2_SIZE 12582912\n");
+		printf("#define L2_LINESIZE 32\n");
+		printf("#define L2_ASSOCIATIVE 12\n");
+		printf("#define ITB_SIZE 4096\n");
+		printf("#define ITB_ASSOCIATIVE 8\n");
+		printf("#define ITB_DEFAULT_ENTRIES 256\n");
+		printf("#define DTB_DEFAULT_ENTRIES 224\n");
+		printf("#define DTB_ASSOCIATIVE 7\n");
+		printf("#define DTB_SIZE 4096\n");
+		}	
 		break;

 	    case CPU_NEOVERSEV1:
@@ -726,6 +755,29 @@ void get_cpuconfig(void)
 		break;
 	    case CPU_VORTEX:
 		printf("#define VORTEX			      \n");
+#ifdef __APPLE__
+		length64 = sizeof(value64);
+		sysctlbyname("hw.l1icachesize",&value64,&length64,NULL,0);
+		printf("#define L1_CODE_SIZE	     %lld       \n",value64);
+		length64 = sizeof(value64);
+		sysctlbyname("hw.cachelinesize",&value64,&length64,NULL,0);
+		printf("#define L1_CODE_LINESIZE     %lld       \n",value64);
+		printf("#define L1_DATA_LINESIZE     %lld       \n",value64);
+		length64 = sizeof(value64);
+		sysctlbyname("hw.l1dcachesize",&value64,&length64,NULL,0);
+		printf("#define L1_DATA_SIZE	     %lld       \n",value64);
+		length64 = sizeof(value64);
+		sysctlbyname("hw.l2cachesize",&value64,&length64,NULL,0);
+		printf("#define L2_SIZE	     %lld       \n",value64);
+#endif	
+		printf("#define DTB_DEFAULT_ENTRIES  64       \n");
+		printf("#define DTB_SIZE             4096     \n");
+		break;
+	    case CPU_VORTEXM4:
+		printf("#define VORTEXM4		      \n");
+#ifdef __clang__
+		printf("#define HAVE_SME 1		      \n");
+#endif
 #ifdef __APPLE__
 		length64 = sizeof(value64);
 		sysctlbyname("hw.l1icachesize",&value64,&length64,NULL,0);
@@ -395,8 +395,8 @@ void get_cpuconfig(void) {
    }
  }

-  if(os_support_lsx)  printf("#define HAVE_LSX\n");
-  if(os_support_lasx) printf("#define HAVE_LASX\n");
+  if(os_support_lsx())  printf("#define HAVE_LSX\n");
+  if(os_support_lasx()) printf("#define HAVE_LASX\n");

  get_cpucount(&num_cores);
  if (num_cores)
@@ -1,5 +1,5 @@
 /*****************************************************************************
-Copyright (c) 2011-2014, The OpenBLAS Project
+Copyright (c) 2011-2026, The OpenBLAS Project
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
@@ -13,9 +13,9 @@ met:
      notice, this list of conditions and the following disclaimer in
      the documentation and/or other materials provided with the
      distribution.
-   3. Neither the name of the OpenBLAS project nor the names of 
-      its contributors may be used to endorse or promote products 
-      derived from this software without specific prior written 
+   3. Neither the name of the OpenBLAS project nor the names of
+      its contributors may be used to endorse or promote products
+      derived from this software without specific prior written
      permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
@@ -109,7 +109,7 @@ int detect(void){
    return CPU_1004K;
  } else if (strstr(p, " 24K")) {
    return CPU_24K;
-  } else  
+  } else
    return CPU_UNKNOWN;
  }
 #endif
@@ -136,6 +136,40 @@ void get_subdirname(void){
  printf("mips");
 }

+int get_feature(char *search) {
+
+#ifdef __linux
+  FILE *infile;
+  char buffer[2048], *p, *t;
+  p = (char *)NULL;
+
+  infile = fopen("/proc/cpuinfo", "r");
+
+  while (fgets(buffer, sizeof(buffer), infile)) {
+
+    if (!strncmp("Features", buffer, 8) ||
+        !strncmp("ASEs implemented", buffer, 16)) {
+      p = strchr(buffer, ':') + 2;
+      break;
+    }
+  }
+
+  fclose(infile);
+
+  if (p == NULL)
+    return 0;
+
+  t = strtok(p, " ");
+  while (t = strtok(NULL, " ")) {
+    if (strstr(t, search)) {
+      return (1);
+    }
+  }
+
+#endif
+  return (0);
+}
+
 void get_cpuconfig(void){
  if(detect()==CPU_P5600){
    printf("#define P5600\n");
@@ -165,7 +199,7 @@ void get_cpuconfig(void){
  }else{
    printf("#define UNKNOWN\n");
  }
-#ifndef NO_MSA  
+#ifndef NO_MSA
  if (get_feature("msa")) printf("#define HAVE_MSA\n");
 #endif
 }
@@ -181,38 +215,3 @@ void get_libname(void){
    printf("mips\n");
  }
 }
-
-int get_feature(char *search)
-{
-
-#ifdef __linux
-        FILE *infile;
-        char buffer[2048], *p,*t;
-        p = (char *) NULL ;
-
-        infile = fopen("/proc/cpuinfo", "r");
-
-        while (fgets(buffer, sizeof(buffer), infile))
-        {
-
-                if (!strncmp("Features", buffer, 8) || !strncmp("ASEs implemented", buffer, 16))
-                {
-                        p = strchr(buffer, ':') + 2;
-                        break;
-                }
-        }
-
-        fclose(infile);
-
-        if( p == NULL ) return 0;
-
-        t = strtok(p," ");
-        while( t = strtok(NULL," "))
-        {
-                if (strstr(t, search))   { return(1); }
-        }
-
-#endif
-        return(0);
-}
-
@@ -1,5 +1,5 @@
 /*****************************************************************************
-Copyright (c) 2011-2014, The OpenBLAS Project
+Copyright (c) 2011-2026, The OpenBLAS Project
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
@@ -13,9 +13,9 @@ met:
      notice, this list of conditions and the following disclaimer in
      the documentation and/or other materials provided with the
      distribution.
-   3. Neither the name of the OpenBLAS project nor the names of 
-      its contributors may be used to endorse or promote products 
-      derived from this software without specific prior written 
+   3. Neither the name of the OpenBLAS project nor the names of
+      its contributors may be used to endorse or promote products
+      derived from this software without specific prior written
      permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
@@ -145,13 +145,47 @@ void get_subarchitecture(void){
    printf("SICORTEX");
  }else{
    printf("MIPS64_GENERIC");
-  } 
+  }
 }

 void get_subdirname(void){
  printf("mips64");
 }

+int get_feature(char *search) {
+
+#ifdef __linux
+  FILE *infile;
+  char buffer[2048], *p, *t;
+  p = (char *)NULL;
+
+  infile = fopen("/proc/cpuinfo", "r");
+
+  while (fgets(buffer, sizeof(buffer), infile)) {
+
+    if (!strncmp("Features", buffer, 8) ||
+        !strncmp("ASEs implemented", buffer, 16)) {
+      p = strchr(buffer, ':') + 2;
+      break;
+    }
+  }
+
+  fclose(infile);
+
+  if (p == NULL)
+    return 0;
+
+  t = strtok(p, " ");
+  while (t = strtok(NULL, " ")) {
+    if (strstr(t, search)) {
+      return (1);
+    }
+  }
+
+#endif
+  return (0);
+}
+
 void get_cpuconfig(void){
  if(detect()==CPU_LOONGSON3R3) {
    printf("#define LOONGSON3R3\n");
@@ -228,38 +262,3 @@ void get_libname(void){
    printf("mips64_generic\n");
  }
 }
-
-int get_feature(char *search)
-{
-
-#ifdef __linux
-        FILE *infile;
-        char buffer[2048], *p,*t;
-        p = (char *) NULL ;
-
-        infile = fopen("/proc/cpuinfo", "r");
-
-        while (fgets(buffer, sizeof(buffer), infile))
-        {
-
-                if (!strncmp("Features", buffer, 8) || !strncmp("ASEs implemented", buffer, 16))
-                {
-                        p = strchr(buffer, ':') + 2;
-                        break;
-                }
-        }
-
-        fclose(infile);
-
-        if( p == NULL ) return 0;
-
-        t = strtok(p," ");
-        while( t = strtok(NULL," "))
-        {
-                if (strstr(t, search))   { return(1); }
-        }
-
-#endif
-        return(0);
-}
-
@@ -178,7 +178,10 @@ ARCH_CSKY
 #endif

 #if defined(__EMSCRIPTEN__)
-ARCH_RISCV64
+ARCH_WASM
 OS_WINDOWS
 #endif

+#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
+OS_IOS
+#endif
@@ -67,16 +67,16 @@ ztestl3o_3m = c_zblas3_3m.o c_z3chke_3m.o auxiliary.o c_xerbla.o constant.o
 all :: all1 all2 all3

 ifeq ($(BUILD_SINGLE),1)
-all1targets += xscblat1
+all1targets += xscblat1$(EXE)
 endif
 ifeq ($(BUILD_DOUBLE),1)
-all1targets += xdcblat1
+all1targets += xdcblat1$(EXE)
 endif
 ifeq ($(BUILD_COMPLEX),1)
-all1targets += xccblat1
+all1targets += xccblat1$(EXE)
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-all1targets += xzcblat1
+all1targets += xzcblat1$(EXE)
 endif

 all1: $(all1targets)
@@ -84,44 +84,44 @@ all1: $(all1targets)
 ifneq ($(CROSS), 1)
 ifeq ($(USE_OPENMP), 1)
 ifeq ($(BUILD_SINGLE),1)
-	OMP_NUM_THREADS=2 ./xscblat1
+	OMP_NUM_THREADS=2 ./xscblat1$(EXE)
 endif
 ifeq ($(BUILD_DOUBLE),1)
-	OMP_NUM_THREADS=2 ./xdcblat1
-endif	
+	OMP_NUM_THREADS=2 ./xdcblat1$(EXE)
+endif
 ifeq ($(BUILD_COMPLEX),1)
-	OMP_NUM_THREADS=2 ./xccblat1
+	OMP_NUM_THREADS=2 ./xccblat1$(EXE)
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-	OMP_NUM_THREADS=2 ./xzcblat1
+	OMP_NUM_THREADS=2 ./xzcblat1$(EXE)
 endif
 else
 ifeq ($(BUILD_SINGLE),1)
-	OPENBLAS_NUM_THREADS=2 ./xscblat1
+	OPENBLAS_NUM_THREADS=2 ./xscblat1$(EXE)
 endif
 ifeq ($(BUILD_DOUBLE),1)
-	OPENBLAS_NUM_THREADS=2 ./xdcblat1
+	OPENBLAS_NUM_THREADS=2 ./xdcblat1$(EXE)
 endif
 ifeq ($(BUILD_COMPLEX),1)
-	OPENBLAS_NUM_THREADS=2 ./xccblat1
+	OPENBLAS_NUM_THREADS=2 ./xccblat1$(EXE)
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-	OPENBLAS_NUM_THREADS=2 ./xzcblat1
+	OPENBLAS_NUM_THREADS=2 ./xzcblat1$(EXE)
 endif
 endif
 endif

 ifeq ($(BUILD_SINGLE),1)
-all2targets += xscblat2
+all2targets += xscblat2$(EXE)
 endif
 ifeq ($(BUILD_DOUBLE),1)
-all2targets += xdcblat2
+all2targets += xdcblat2$(EXE)
 endif
 ifeq ($(BUILD_COMPLEX),1)
-all2targets += xccblat2
+all2targets += xccblat2$(EXE)
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-all2targets += xzcblat2
+all2targets += xzcblat2$(EXE)
 endif

 all2: $(all2targets)
@@ -129,50 +129,50 @@ all2: $(all2targets)
 ifneq ($(CROSS), 1)
 ifeq ($(USE_OPENMP), 1)
 ifeq ($(BUILD_SINGLE),1)
-	OMP_NUM_THREADS=2 ./xscblat2 < sin2
+	OMP_NUM_THREADS=2 ./xscblat2$(EXE) < sin2
 endif
 ifeq ($(BUILD_DOUBLE),1)
-	OMP_NUM_THREADS=2 ./xdcblat2 < din2
+	OMP_NUM_THREADS=2 ./xdcblat2$(EXE) < din2
 endif
 ifeq ($(BUILD_COMPLEX),1)
-	OMP_NUM_THREADS=2 ./xccblat2 < cin2
+	OMP_NUM_THREADS=2 ./xccblat2$(EXE) < cin2
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-	OMP_NUM_THREADS=2 ./xzcblat2 < zin2
+	OMP_NUM_THREADS=2 ./xzcblat2$(EXE) < zin2
 endif
 else
 ifeq ($(BUILD_SINGLE),1)
-	OPENBLAS_NUM_THREADS=2 ./xscblat2 < sin2
+	OPENBLAS_NUM_THREADS=2 ./xscblat2$(EXE) < sin2
 endif
 ifeq ($(BUILD_DOUBLE),1)
-	OPENBLAS_NUM_THREADS=2 ./xdcblat2 < din2
+	OPENBLAS_NUM_THREADS=2 ./xdcblat2$(EXE) < din2
 endif
 ifeq ($(BUILD_COMPLEX),1)
-	OPENBLAS_NUM_THREADS=2 ./xccblat2 < cin2
+	OPENBLAS_NUM_THREADS=2 ./xccblat2$(EXE) < cin2
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-	OPENBLAS_NUM_THREADS=2 ./xzcblat2 < zin2
+	OPENBLAS_NUM_THREADS=2 ./xzcblat2$(EXE) < zin2
 endif
 endif
 endif


 ifeq ($(BUILD_SINGLE),1)
-all3targets += xscblat3
+all3targets += xscblat3$(EXE)
 endif
 ifeq ($(BUILD_DOUBLE),1)
-all3targets += xdcblat3
+all3targets += xdcblat3$(EXE)
 endif
 ifeq ($(BUILD_COMPLEX),1)
-all3targets += xccblat3
+all3targets += xccblat3$(EXE)
 ifeq ($(SUPPORT_GEMM3M),1)
-all3targets += xccblat3_3m
+all3targets += xccblat3_3m$(EXE)
 endif
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-all3targets += xzcblat3
+all3targets += xzcblat3$(EXE)
 ifeq ($(SUPPORT_GEMM3M),1)
-all3targets += xzcblat3_3m
+all3targets += xzcblat3_3m$(EXE)
 endif
 endif

@@ -181,46 +181,46 @@ all3: $(all3targets)
 ifneq ($(CROSS), 1)
 ifeq ($(USE_OPENMP), 1)
 ifeq ($(BUILD_SINGLE),1)
-	OMP_NUM_THREADS=2 ./xscblat3 < sin3
+	OMP_NUM_THREADS=2 ./xscblat3$(EXE) < sin3
 endif
 ifeq ($(BUILD_DOUBLE),1)
-	OMP_NUM_THREADS=2 ./xdcblat3 < din3
+	OMP_NUM_THREADS=2 ./xdcblat3$(EXE) < din3
 endif
 ifeq ($(BUILD_COMPLEX),1)
-	OMP_NUM_THREADS=2 ./xccblat3 < cin3
+	OMP_NUM_THREADS=2 ./xccblat3$(EXE) < cin3
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-	OMP_NUM_THREADS=2 ./xzcblat3 < zin3
+	OMP_NUM_THREADS=2 ./xzcblat3$(EXE) < zin3
 endif
 else
 ifeq ($(BUILD_SINGLE),1)
-	OPENBLAS_NUM_THREADS=2 ./xscblat3 < sin3
+	OPENBLAS_NUM_THREADS=2 ./xscblat3$(EXE) < sin3
 endif
 ifeq ($(BUILD_DOUBLE),1)
-	OPENBLAS_NUM_THREADS=2 ./xdcblat3 < din3
+	OPENBLAS_NUM_THREADS=2 ./xdcblat3$(EXE) < din3
 endif
 ifeq ($(BUILD_COMPLEX),1)
-	OPENBLAS_NUM_THREADS=2 ./xccblat3 < cin3
+	OPENBLAS_NUM_THREADS=2 ./xccblat3$(EXE) < cin3
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-	OPENBLAS_NUM_THREADS=2 ./xzcblat3 < zin3
+	OPENBLAS_NUM_THREADS=2 ./xzcblat3$(EXE) < zin3
 endif
 endif

 ifeq ($(SUPPORT_GEMM3M),1)
 ifeq ($(USE_OPENMP), 1)
 ifeq ($(BUILD_COMPLEX),1)
-	OMP_NUM_THREADS=2 ./xccblat3_3m < cin3_3m
+	OMP_NUM_THREADS=2 ./xccblat3_3m$(EXE) < cin3_3m
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-	OMP_NUM_THREADS=2 ./xzcblat3_3m < zin3_3m
+	OMP_NUM_THREADS=2 ./xzcblat3_3m$(EXE) < zin3_3m
 endif
 else
 ifeq ($(BUILD_COMPLEX),1)
-	OPENBLAS_NUM_THREADS=2 ./xccblat3_3m < cin3_3m
+	OPENBLAS_NUM_THREADS=2 ./xccblat3_3m$(EXE) < cin3_3m
 endif
 ifeq ($(BUILD_COMPLEX16),1)
-	OPENBLAS_NUM_THREADS=2 ./xzcblat3_3m < zin3_3m
+	OPENBLAS_NUM_THREADS=2 ./xzcblat3_3m$(EXE) < zin3_3m
 endif
 endif
 endif
@@ -254,64 +254,64 @@ endif
 ifeq ($(BUILD_SINGLE),1)
 # Single real
 ifeq ($(NOFORTRAN), $(filter 0 2,$(NOFORTRAN)))
-xscblat1: $(stestl1o) c_sblat1.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xscblat1 c_sblat1.o $(stestl1o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
-xscblat2: $(stestl2o) c_sblat2.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xscblat2 c_sblat2.o $(stestl2o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
-xscblat3: $(stestl3o) c_sblat3.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xscblat3 c_sblat3.o $(stestl3o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xscblat1$(EXE): $(stestl1o) c_sblat1.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_sblat1.o $(stestl1o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xscblat2$(EXE): $(stestl2o) c_sblat2.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_sblat2.o $(stestl2o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xscblat3$(EXE): $(stestl3o) c_sblat3.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_sblat3.o $(stestl3o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
 else
-xscblat1: $(stestl1o) c_sblat1c.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xscblat1 c_sblat1c.o $(stestl1o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
-xscblat2: $(stestl2o) c_sblat2c.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xscblat2 c_sblat2c.o $(stestl2o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
-xscblat3: $(stestl3o) c_sblat3c.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xscblat3 c_sblat3c.o $(stestl3o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
+xscblat1$(EXE): $(stestl1o) c_sblat1c.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_sblat1c.o $(stestl1o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
+xscblat2$(EXE): $(stestl2o) c_sblat2c.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_sblat2c.o $(stestl2o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
+xscblat3$(EXE): $(stestl3o) c_sblat3c.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_sblat3c.o $(stestl3o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
 endif
 endif

 ifeq ($(BUILD_DOUBLE),1)
 # Double real
 ifeq ($(NOFORTRAN), $(filter 0 2,$(NOFORTRAN)))
-xdcblat1: $(dtestl1o) c_dblat1.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xdcblat1 c_dblat1.o $(dtestl1o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
-xdcblat2: $(dtestl2o) c_dblat2.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xdcblat2 c_dblat2.o $(dtestl2o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
-xdcblat3: $(dtestl3o) c_dblat3.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xdcblat3 c_dblat3.o $(dtestl3o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xdcblat1$(EXE): $(dtestl1o) c_dblat1.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_dblat1.o $(dtestl1o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xdcblat2$(EXE): $(dtestl2o) c_dblat2.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_dblat2.o $(dtestl2o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xdcblat3$(EXE): $(dtestl3o) c_dblat3.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_dblat3.o $(dtestl3o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
 else
-xdcblat1: $(dtestl1o) c_dblat1c.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xdcblat1 c_dblat1c.o $(dtestl1o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
-xdcblat2: $(dtestl2o) c_dblat2c.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xdcblat2 c_dblat2c.o $(dtestl2o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
-xdcblat3: $(dtestl3o) c_dblat3c.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xdcblat3 c_dblat3c.o $(dtestl3o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
+xdcblat1$(EXE): $(dtestl1o) c_dblat1c.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_dblat1c.o $(dtestl1o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
+xdcblat2$(EXE): $(dtestl2o) c_dblat2c.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_dblat2c.o $(dtestl2o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
+xdcblat3$(EXE): $(dtestl3o) c_dblat3c.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_dblat3c.o $(dtestl3o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
 endif
 endif

 ifeq ($(BUILD_COMPLEX),1)
 # Single complex
 ifeq ($(NOFORTRAN), $(filter 0 2,$(NOFORTRAN)))
-xccblat1: $(ctestl1o) c_cblat1.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xccblat1 c_cblat1.o $(ctestl1o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
-xccblat2: $(ctestl2o) c_cblat2.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xccblat2 c_cblat2.o $(ctestl2o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
-xccblat3: $(ctestl3o) c_cblat3.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xccblat3 c_cblat3.o $(ctestl3o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xccblat1$(EXE): $(ctestl1o) c_cblat1.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_cblat1.o $(ctestl1o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xccblat2$(EXE): $(ctestl2o) c_cblat2.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_cblat2.o $(ctestl2o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xccblat3$(EXE): $(ctestl3o) c_cblat3.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_cblat3.o $(ctestl3o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
 ifeq ($(SUPPORT_GEMM3M),1)
-xccblat3_3m: $(ctestl3o_3m) c_cblat3_3m.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xccblat3_3m c_cblat3_3m.o $(ctestl3o_3m) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xccblat3_3m$(EXE): $(ctestl3o_3m) c_cblat3_3m.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_cblat3_3m.o $(ctestl3o_3m) $(LIB) $(EXTRALIB) $(CEXTRALIB)
 endif
 else
-xccblat1: $(ctestl1o) c_cblat1c.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xccblat1 c_cblat1c.o $(ctestl1o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB)) 
-xccblat2: $(ctestl2o) c_cblat2c.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xccblat2 c_cblat2c.o $(ctestl2o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
-xccblat3: $(ctestl3o) c_cblat3c.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xccblat3 c_cblat3c.o $(ctestl3o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
+xccblat1$(EXE): $(ctestl1o) c_cblat1c.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_cblat1c.o $(ctestl1o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
+xccblat2$(EXE): $(ctestl2o) c_cblat2c.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_cblat2c.o $(ctestl2o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
+xccblat3$(EXE): $(ctestl3o) c_cblat3c.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_cblat3c.o $(ctestl3o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
 ifeq ($(SUPPORT_GEMM3M),1)
-xccblat3_3m: $(ctestl3o_3m) c_cblat3c_3m.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xccblat3_3m c_cblat3c_3m.o $(ctestl3o_3m) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xccblat3_3m$(EXE): $(ctestl3o_3m) c_cblat3c_3m.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_cblat3c_3m.o $(ctestl3o_3m) $(LIB) $(EXTRALIB) $(CEXTRALIB)
 endif
 endif
 endif
@@ -320,26 +320,26 @@ endif
 ifeq ($(BUILD_COMPLEX16),1)
 # Double complex
 ifeq ($(NOFORTRAN), $(filter 0 2,$(NOFORTRAN)))
-xzcblat1: $(ztestl1o) c_zblat1.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xzcblat1 c_zblat1.o $(ztestl1o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
-xzcblat2: $(ztestl2o) c_zblat2.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xzcblat2 c_zblat2.o $(ztestl2o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
-xzcblat3: $(ztestl3o) c_zblat3.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xzcblat3 c_zblat3.o $(ztestl3o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xzcblat1$(EXE): $(ztestl1o) c_zblat1.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_zblat1.o $(ztestl1o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xzcblat2$(EXE): $(ztestl2o) c_zblat2.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_zblat2.o $(ztestl2o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xzcblat3$(EXE): $(ztestl3o) c_zblat3.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_zblat3.o $(ztestl3o) $(LIB) $(EXTRALIB) $(CEXTRALIB)
 ifeq ($(SUPPORT_GEMM3M),1)
-xzcblat3_3m: $(ztestl3o_3m) c_zblat3_3m.o $(TOPDIR)/$(LIBNAME)
-	$(FC) $(FLDFLAGS) -o xzcblat3_3m c_zblat3_3m.o $(ztestl3o_3m) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xzcblat3_3m$(EXE): $(ztestl3o_3m) c_zblat3_3m.o $(TOPDIR)/$(LIBNAME)
+	$(FC) $(FLDFLAGS) -o $@ c_zblat3_3m.o $(ztestl3o_3m) $(LIB) $(EXTRALIB) $(CEXTRALIB)
 endif
 else
-xzcblat1: $(ztestl1o) c_zblat1c.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xzcblat1 c_zblat1c.o $(ztestl1o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB)) 
-xzcblat2: $(ztestl2o) c_zblat2c.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xzcblat2 c_zblat2c.o $(ztestl2o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
-xzcblat3: $(ztestl3o) c_zblat3c.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xzcblat3 c_zblat3c.o $(ztestl3o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
+xzcblat1$(EXE): $(ztestl1o) c_zblat1c.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_zblat1c.o $(ztestl1o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
+xzcblat2$(EXE): $(ztestl2o) c_zblat2c.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_zblat2c.o $(ztestl2o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
+xzcblat3$(EXE): $(ztestl3o) c_zblat3c.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_zblat3c.o $(ztestl3o) $(LIB) $(CEXTRALIB) $(filter-out -lgfortran,$(EXTRALIB))
 ifeq ($(SUPPORT_GEMM3M),1)
-xzcblat3_3m: $(ztestl3o_3m) c_zblat3c_3m.o $(TOPDIR)/$(LIBNAME)
-	$(CC) $(CFLAGS) -o xzcblat3_3m c_zblat3c_3m.o $(ztestl3o_3m) $(LIB) $(EXTRALIB) $(CEXTRALIB)
+xzcblat3_3m$(EXE): $(ztestl3o_3m) c_zblat3c_3m.o $(TOPDIR)/$(LIBNAME)
+	$(CC) $(CFLAGS) -o $@ c_zblat3c_3m.o $(ztestl3o_3m) $(LIB) $(EXTRALIB) $(CEXTRALIB)
 endif
 endif
 endif
@@ -23,17 +23,10 @@ typedef struct { real r, i; } complex;
 typedef struct { doublereal r, i; } doublecomplex;
 #ifdef _MSC_VER
 static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
-static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
 static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
-static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
 #else
 static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
-static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
 #endif
-#define pCf(z) (*_pCf(z))
-#define pCd(z) (*_pCd(z))
 typedef int logical;
 typedef short int shortlogical;
 typedef char logical1;
@@ -440,12 +433,12 @@ static real c_b43 = (float)1.;
    extern /* Subroutine */ int ctest_(integer*, complex*, complex*, complex*, real*);
    static complex mwpcs[5], mwpct[5];
    extern /* Subroutine */ int itest1_(integer*, integer*), stest1_(real*,real*,real*,real*);
-    extern /* Subroutine */ int cscaltest_(integer*, complex*, complex*, integer*);
+    extern /* Subroutine */ void cscaltest_(integer*, complex*, complex*, integer*);
    static complex cx[8];
    extern real scnrm2test_(integer*, complex*, integer*);
    static integer np1;
    extern integer icamaxtest_(integer*, complex*, integer*);
-    extern /* Subroutine */ int csscaltest_(integer*, real*, complex*, integer*);
+    extern /* Subroutine */ void csscaltest_(integer*, real*, complex*, integer*);
    extern real scasumtest_(integer*, complex*, integer*);
    static integer len;

@@ -468,7 +461,7 @@ static real c_b43 = (float)1.;
 	    i__1 = len;
 	    for (i__ = 1; i__ <= i__1; ++i__) {
 		i__2 = i__ - 1;
-		i__3 = i__ + (np1 + combla_1.incx * 5 << 3) - 49;
+		i__3 = i__ + ((np1 + combla_1.incx * 5) << 3) - 49;
 		cx[i__2].r = cv[i__3].r, cx[i__2].i = cv[i__3].i;
 /* L20: */
 	    }
@@ -483,13 +476,13 @@ static real c_b43 = (float)1.;
 	    } else if (combla_1.icase == 8) {
 /*              .. CSCAL .. */
 		cscaltest_(&combla_1.n, &ca, cx, &combla_1.incx);
-		ctest_(&len, cx, &ctrue5[(np1 + combla_1.incx * 5 << 3) - 48],
-			 &ctrue5[(np1 + combla_1.incx * 5 << 3) - 48], sfac);
+		ctest_(&len, cx, &ctrue5[((np1 + combla_1.incx * 5) << 3) - 48],
+			 &ctrue5[((np1 + combla_1.incx * 5) << 3) - 48], sfac);
 	    } else if (combla_1.icase == 9) {
 /*              .. CSSCALTEST .. */
 		csscaltest_(&combla_1.n, &sa, cx, &combla_1.incx);
-		ctest_(&len, cx, &ctrue6[(np1 + combla_1.incx * 5 << 3) - 48],
-			 &ctrue6[(np1 + combla_1.incx * 5 << 3) - 48], sfac);
+		ctest_(&len, cx, &ctrue6[((np1 + combla_1.incx * 5) << 3) - 48],
+			 &ctrue6[((np1 + combla_1.incx * 5) << 3) - 48], sfac);
 	    } else if (combla_1.icase == 10) {
 /*              .. ICAMAXTEST .. */
 		i__1 = icamaxtest_(&combla_1.n, cx, &combla_1.incx);
@@ -737,7 +730,7 @@ static real c_b43 = (float)1.;
    static complex ctemp;
    extern /* Subroutine */ int ctest_(integer*, complex*, complex*, complex*, real*);
    static integer ksize;
-    extern /* Subroutine */ int cdotctest_(integer*, complex*, integer*, complex*, integer*,complex*), ccopytest_(integer*, complex*, integer*, complex*, integer*), cdotutest_(integer*, complex*, integer*, complex*, integer*, complex*), 
+    extern /* Subroutine */ void cdotctest_(integer*, complex*, integer*, complex*, integer*,complex*), ccopytest_(integer*, complex*, integer*, complex*, integer*), cdotutest_(integer*, complex*, integer*, complex*, integer*, complex*), 
 	    cswaptest_(integer*, complex*, integer*, complex*, integer*), caxpytest_(integer*, complex*, complex*, integer*, complex*, integer*);
    static integer ki, kn;
    static complex cx[7], cy[7];
@@ -23,17 +23,12 @@ typedef struct { real r, i; } complex;
 typedef struct { doublereal r, i; } doublecomplex;
 #ifdef _MSC_VER
 static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
-static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
 static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
-static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
 #else
 static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
 static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
-static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
 #endif
 #define pCf(z) (*_pCf(z))
-#define pCd(z) (*_pCd(z))
 typedef int logical;
 typedef short int shortlogical;
 typedef char logical1;
@@ -319,7 +314,7 @@ static logical c_false = FALSE_;
    static char snamet[12];
    static real thresh;
    static logical rorder;
-    extern /* Subroutine */ void cc2chke_(char*, ftnlen);
+    extern /* Subroutine */ void cc2chke_(char*);
    static integer layout;
    static logical ltestt, tsterr;
    static complex alf[7];
@@ -712,7 +707,7 @@ L100:
 		    ftnlen)12);
 /*           Test error exits. */
 	    if (tsterr) {
-		cc2chke_(snames[isnum - 1], (ftnlen)12);
+		cc2chke_(snames[isnum - 1]);
 	    }
 /*           Test computations. */
 	    infoc_1.infot = 0;
@@ -892,8 +887,8 @@ L240:
    static integer ia, ib, ic;
    static logical banded;
    static integer nc, nd, im, in, kl, ml, nk, nl, ku, ix, iy, ms, lx, ly, ns;
-    extern /* Subroutine */ int ccgbmv_(integer*, char*, integer*, integer*, integer*, integer*, complex*, complex*, integer*, complex*, integer*, complex*, complex*, integer*, ftnlen);
-    extern /* Subroutine */ void ccgemv_(integer*, char*, integer*, integer*, complex*, complex*, integer*, complex*, integer*, complex*, complex*, integer*, ftnlen);
+    extern /* Subroutine */ void ccgbmv_(integer*, char*, integer*, integer*, integer*, integer*, complex*, complex*, integer*, complex*, integer*, complex*, complex*, integer*);
+    extern /* Subroutine */ void ccgemv_(integer*, char*, integer*, integer*, complex*, complex*, integer*, complex*, integer*, complex*, complex*, integer*);
    extern logical lceres_(char*, char*, integer*, integer*, complex*, complex*, integer*, ftnlen, ftnlen);
    static char ctrans[14];
    static real errmax;
@@ -1142,8 +1137,7 @@ L240:
 					}
 					ccgemv_(iorder, trans, &m, &n, &alpha,
 						 &aa[1], &lda, &xx[1], &incx, 
-						&beta, &yy[1], &incy, (ftnlen)
-						1);
+						&beta, &yy[1], &incy);
 				    } else if (banded) {
 					if (*trace) {
 /*
@@ -1158,8 +1152,7 @@ L240:
 					}
 					ccgbmv_(iorder, trans, &m, &n, &kl, &
 						ku, &alpha, &aa[1], &lda, &xx[
-						1], &incx, &beta, &yy[1], &
-						incy, (ftnlen)1);
+						1], &incx, &beta, &yy[1], &incy);
 				    }

 /*                            Check if error-exit was taken incorrectly. */
@@ -1347,10 +1340,10 @@ L140:
    static integer nc, ik, in;
    static logical packed;
    static integer nk, ks, ix, iy, ns, lx, ly;
-    extern /* Subroutine */ void cchbmv_(integer*, char*, integer*, integer*, complex*, complex*, integer*, complex*, integer*, complex*, complex*, integer*, ftnlen);
-    extern /* Subroutine */ void cchemv_(integer*, char*, integer*, complex*, complex*, integer*, complex*, integer*, complex*, complex*, integer*, ftnlen);
+    extern /* Subroutine */ void cchbmv_(integer*, char*, integer*, integer*, complex*, complex*, integer*, complex*, integer*, complex*, complex*, integer*);
+    extern /* Subroutine */ void cchemv_(integer*, char*, integer*, complex*, complex*, integer*, complex*, integer*, complex*, complex*, integer*);
    extern logical lceres_(char*, char*, integer*, integer*, complex*, complex*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void cchpmv_(integer*, char*, integer*, complex*, complex*, complex*, integer*, complex*, complex*, integer*, ftnlen);
+    extern /* Subroutine */ void cchpmv_(integer*, char*, integer*, complex*, complex*, complex*, integer*, complex*, complex*, integer*);
    static real errmax;
    static complex transl;
    static integer laa, lda;
@@ -1566,7 +1559,7 @@ L140:
 				    }
 				    cchemv_(iorder, uplo, &n, &alpha, &aa[1], 
 					    &lda, &xx[1], &incx, &beta, &yy[1]
-					    , &incy, (ftnlen)1);
+					    , &incy);
 				} else if (banded) {
 				    if (*trace) {
 /*
@@ -1581,7 +1574,7 @@ L140:
 				    }
 				    cchbmv_(iorder, uplo, &n, &k, &alpha, &aa[
 					    1], &lda, &xx[1], &incx, &beta, &
-					    yy[1], &incy, (ftnlen)1);
+					    yy[1], &incy);
 				} else if (packed) {
 				    if (*trace) {
 /*
@@ -1596,7 +1589,7 @@ L140:
 				    }
 				    cchpmv_(iorder, uplo, &n, &alpha, &aa[1], 
 					    &xx[1], &incx, &beta, &yy[1], &
-					    incy, (ftnlen)1);
+					    incy);
 				}

 /*                          Check if error-exit was taken incorrectly. */
@@ -1792,15 +1785,15 @@ L130:
    static logical packed;
    static integer nk, ks, ix, ns, lx;
    extern logical lceres_(char*, char*, integer*, integer*, complex*, complex*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void cctbmv_(integer*, char*, char*, char*, integer*, integer*, complex*, integer*, complex*, integer*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cctbsv_(integer*, char*, char*, char*, integer*, integer*, complex*, integer*, complex*, integer*, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cctbmv_(integer*, char*, char*, char*, integer*, integer*, complex*, integer*, complex*, integer*);
+    extern /* Subroutine */ void cctbsv_(integer*, char*, char*, char*, integer*, integer*, complex*, integer*, complex*, integer*);
    static char ctrans[14];
-    extern /* Subroutine */ void cctpmv_(integer*, char*, char*, char*, integer*, complex*, complex*, integer*, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cctpmv_(integer*, char*, char*, char*, integer*, complex*, complex*, integer*);
    static real errmax;
-    extern /* Subroutine */ void cctrmv_(integer*, char*, char*, char*, integer*, complex*, integer*, complex*, integer*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cctpsv_(integer*, char*, char*, char*, integer*, complex*, complex*, integer*, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cctrmv_(integer*, char*, char*, char*, integer*, complex*, integer*, complex*, integer*);
+    extern /* Subroutine */ void cctpsv_(integer*, char*, char*, char*, integer*, complex*, complex*, integer*);
    static complex transl;
-    extern /* Subroutine */ void cctrsv_(integer*, char*, char*, char*, integer*, complex*, integer*, complex*, integer*, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cctrsv_(integer*, char*, char*, char*, integer*, complex*, integer*, complex*, integer*);
    static char transs[1];
    static integer laa, icd, lda;
    extern logical lce_(complex*, complex*, integer*);
@@ -2010,8 +2003,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cctrmv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					    aa[1], &lda, &xx[1], &incx);
 				} else if (banded) {
 				    if (*trace) {
 /*
@@ -2025,8 +2017,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cctbmv_(iorder, uplo, trans, diag, &n, &k,
-					     &aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					     &aa[1], &lda, &xx[1], &incx);
 				} else if (packed) {
 				    if (*trace) {
 /*
@@ -2040,8 +2031,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cctpmv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &xx[1], &incx, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    aa[1], &xx[1], &incx);
 				}
 			    } else if (s_cmp(sname + 9, "sv", (ftnlen)2, (
 				    ftnlen)2) == 0) {
@@ -2058,8 +2048,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cctrsv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					    aa[1], &lda, &xx[1], &incx);
 				} else if (banded) {
 				    if (*trace) {
 /*
@@ -2073,8 +2062,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cctbsv_(iorder, uplo, trans, diag, &n, &k,
-					     &aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					     &aa[1], &lda, &xx[1], &incx);
 				} else if (packed) {
 				    if (*trace) {
 /*
@@ -2088,8 +2076,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cctpsv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &xx[1], &incx, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    aa[1], &xx[1], &incx);
 				}
 			    }

@@ -2634,10 +2621,10 @@ L150:
    static char uplo[1];
    static integer i__, j, n;
    extern /* Subroutine */ int cmake_(char*, char*, char*, integer*, integer*, complex*, integer*, complex*, integer*, integer*, integer*, logical*, complex*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void ccher_(integer*, char*, integer*, real*, complex*, integer*, complex*, integer*, ftnlen);
+    extern /* Subroutine */ void ccher_(integer*, char*, integer*, real*, complex*, integer*, complex*, integer*);
    static complex alpha, w[1];
    static logical isame[13];
-    extern /* Subroutine */ void cchpr_(integer*, char*, integer*, real*, complex*, integer*, complex*, ftnlen);
+    extern /* Subroutine */ void cchpr_(integer*, char*, integer*, real*, complex*, integer*, complex*);
    extern /* Subroutine */ int cmvch_(char*, integer*, integer*, complex*, complex*, integer*, complex*, integer*, complex*, complex*, integer*, complex*, real*, complex*, real*, real*, logical*, integer*, logical*, ftnlen);
    static integer nargs;
    static logical reset;
@@ -2812,7 +2799,7 @@ L150:
 			    f_rew(&al__1);*/
 			}
 			ccher_(iorder, uplo, &n, &ralpha, &xx[1], &incx, &aa[
-				1], &lda, (ftnlen)1);
+				1], &lda);
 		    } else if (packed) {
 			if (*trace) {
 /*
@@ -2825,8 +2812,7 @@ L150:
 			    al__1.aunit = *ntra;
 			    f_rew(&al__1);*/
 			}
-			cchpr_(iorder, uplo, &n, &ralpha, &xx[1], &incx, &aa[
-				1], (ftnlen)1);
+			cchpr_(iorder, uplo, &n, &ralpha, &xx[1], &incx, &aa[1]);
 		    }

 /*                 Check if error-exit was taken incorrectly. */
@@ -3005,8 +2991,8 @@ L130:
    static integer incxs, incys;
    static logical upper;
    static char uplos[1];
-    extern /* Subroutine */ void ccher2_(integer*, char*, integer*, complex*, complex*, integer*, complex*, integer*, complex*, integer*, ftnlen);
-    extern /* Subroutine */ void cchpr2_(integer*, char*, integer*, complex*, complex*, integer*, complex*, integer*, complex*, ftnlen);
+    extern /* Subroutine */ void ccher2_(integer*, char*, integer*, complex*, complex*, integer*, complex*, integer*, complex*, integer*);
+    extern /* Subroutine */ void cchpr2_(integer*, char*, integer*, complex*, complex*, integer*, complex*, integer*, complex*);
    static integer ia, ja, ic, nc, jj, lj, in;
    static logical packed;
    static integer ix, iy, ns, lx, ly;
@@ -3202,7 +3188,7 @@ L130:
 				f_rew(&al__1);*/
 			    }
 			    ccher2_(iorder, uplo, &n, &alpha, &xx[1], &incx, &
-				    yy[1], &incy, &aa[1], &lda, (ftnlen)1);
+				    yy[1], &incy, &aa[1], &lda);
 			} else if (packed) {
 			    if (*trace) {
 /*
@@ -3216,7 +3202,7 @@ L130:
 				f_rew(&al__1);*/
 			    }
 			    cchpr2_(iorder, uplo, &n, &alpha, &xx[1], &incx, &
-				    yy[1], &incy, &aa[1], (ftnlen)1);
+				    yy[1], &incy, &aa[1]);
 			}

 /*                    Check if error-exit was taken incorrectly. */
@@ -23,17 +23,12 @@ typedef struct { real r, i; } complex;
 typedef struct { doublereal r, i; } doublecomplex;
 #ifdef _MSC_VER
 static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
-static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
 static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
-static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
 #else
 static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
 static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
-static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
 #endif
 #define pCf(z) (*_pCf(z))
-#define pCd(z) (*_pCd(z))
 typedef int logical;
 typedef short int shortlogical;
 typedef char logical1;
@@ -284,10 +279,10 @@ int /* Main program */ main(void)
    real r__1;

    /* Local variables */
-    integer nalf, idim[9];
-    logical same;
-    integer nbet, ntra;
-    logical rewi;
+    static integer nalf, idim[9];
+    static logical same;
+    static integer nbet, ntra;
+    static logical rewi;
    extern /* Subroutine */ int cchk1_(char *, real *, real *, integer *, 
 	    integer *, logical *, logical *, logical *, integer *, integer *, 
 	    integer *, complex *, integer *, complex *, integer *, complex *, 
@@ -311,35 +306,35 @@ int /* Main program */ main(void)
 	    integer *, complex *, integer *, complex *, integer *, complex *, 
 	    complex *, complex *, complex *, complex *, complex *, complex *, 
 	    complex *, complex *, real *, complex *, integer *);
-    complex c__[4225]	/* was [65][65] */;
-    real g[65];
-    integer i__, j, n;
-    logical fatal;
-    complex w[130];
+    static complex c__[4225]	/* was [65][65] */;
+    static real g[65];
+    static integer i__, j, n;
+    static logical fatal;
+    static complex w[130];
    extern /* Subroutine */ int cmmch_(char *, char *, integer *, integer *, 
 	    integer *, complex *, complex *, integer *, complex *, integer *, 
 	    complex *, complex *, integer *, complex *, real *, complex *, 
 	    integer *, real *, real *, logical *, integer *, logical *);
    extern real sdiff_(real *, real *);
-    logical trace;
-    integer nidim;
-    char snaps[32];
-    integer isnum;
-    logical ltest[9];
-    complex aa[4225], ab[8450]	/* was [65][130] */, bb[4225], cc[4225], as[
+    static logical trace;
+    static integer nidim;
+    static char snaps[32];
+    static integer isnum;
+    static logical ltest[9];
+    static complex aa[4225], ab[8450]	/* was [65][130] */, bb[4225], cc[4225], as[
 	    4225], bs[4225], cs[4225], ct[65];
-    logical sfatal, corder;
-    char snamet[12], transa[1], transb[1];
-    real thresh;
-    logical rorder;
-    extern /* Subroutine */ int cc3chke_(char *);
-    integer layout;
-    logical ltestt, tsterr;
-    complex alf[7];
+    static logical sfatal, corder;
+    static char snamet[12], transa[1], transb[1];
+    static real thresh;
+    static logical rorder;
+    extern /* Subroutine */ void cc3chke_(char *);
+    static integer layout;
+    static logical ltestt, tsterr;
+    static complex alf[7];
    extern logical lce_(complex *, complex *, integer *);
-    complex bet[7];
-    real eps, err;
-    char tmpchar;
+    static complex bet[7];
+    static real eps, err;
+    static char tmpchar;

 /*  Test program for the COMPLEX          Level 3 Blas. */

@@ -856,7 +851,7 @@ L230:
 	    *, char *, char *, integer *, integer *, integer *, complex *, 
 	    integer *, integer *, complex *, integer *);
    integer ia, ib, ma, mb, na, nb, nc, ik, im, in;
-    extern /* Subroutine */ int ccgemm_(integer *, char *, char *, integer *, 
+    extern /* Subroutine */ void ccgemm_(integer *, char *, char *, integer *, 
 	    integer *, integer *, complex *, complex *, integer *, complex *, 
 	    integer *, complex *, complex *, integer *);
    integer ks, ms, ns;
@@ -1268,13 +1263,13 @@ L130:
 	    *, char *, char *, integer *, integer *, complex *, integer *, 
 	    integer *, complex *, integer *);
    integer ia, ib, na, nc, im, in;
-    extern /* Subroutine */ int cchemm_(integer *, char *, char *, integer *, 
+    extern /* Subroutine */ void cchemm_(integer *, char *, char *, integer *, 
 	    integer *, complex *, complex *, integer *, complex *, integer *, 
 	    complex *, complex *, integer *);
    integer ms, ns;
    extern logical lceres_(char *, char *, integer *, integer *, complex *, 
 	    complex *, integer *);
-    extern /* Subroutine */ int ccsymm_(integer *, char *, char *, integer *, 
+    extern /* Subroutine */ void ccsymm_(integer *, char *, char *, integer *, 
 	    integer *, complex *, complex *, integer *, complex *, integer *, 
 	    complex *, complex *, integer *);
    real errmax;
@@ -1668,11 +1663,11 @@ L120:
    integer ia, na, nc, im, in, ms, ns;
    extern logical lceres_(char *, char *, integer *, integer *, complex *, 
 	    complex *, integer *);
-    extern /* Subroutine */ int cctrmm_(integer *, char *, char *, char *, 
+    extern /* Subroutine */ void cctrmm_(integer *, char *, char *, char *, 
 	    char *, integer *, integer *, complex *, complex *, integer *, 
 	    complex *, integer *);
    char tranas[1], transa[1];
-    extern /* Subroutine */ int cctrsm_(integer *, char *, char *, char *, 
+    extern /* Subroutine */ void cctrsm_(integer *, char *, char *, char *, 
 	    char *, integer *, integer *, complex *, complex *, integer *, 
 	    complex *, integer *);
    real errmax;
@@ -2143,7 +2138,7 @@ L160:
 	    integer *, char *, integer *, char *, char *, integer *, integer *
 	    , real *, integer *, real *, integer *);
    integer ia, ib, jc, ma, na, nc, ik, in, jj, lj, ks;
-    extern /* Subroutine */ int ccherk_(integer *, char *, char *, integer *, 
+    extern /* Subroutine */ void ccherk_(integer *, char *, char *, integer *, 
 	    integer *, real *, complex *, integer *, real *, complex *, 
 	    integer *);
    integer ns;
@@ -2151,7 +2146,7 @@ L160:
    extern logical lceres_(char *, char *, integer *, integer *, complex *, 
 	    complex *, integer *);
    real errmax;
-    extern /* Subroutine */ int ccsyrk_(integer *, char *, char *, integer *, 
+    extern /* Subroutine */ void ccsyrk_(integer *, char *, char *, integer *, 
 	    integer *, complex *, complex *, integer *, complex *, complex *, 
 	    integer *);
    char transs[1], transt[1];
@@ -2643,12 +2638,12 @@ L130:
 	    complex *, integer *);
    real errmax;
    char transs[1], transt[1];
-    extern /* Subroutine */ int ccher2k_(integer *, char *, char *, integer *,
+    extern /* Subroutine */ void ccher2k_(integer *, char *, char *, integer *,
 	     integer *, complex *, complex *, integer *, complex *, integer *,
 	     real *, complex *, integer *);
    integer laa, lbb, lda, lcc, ldb, ldc;
    extern logical lce_(complex *, complex *, integer *);
-    extern /* Subroutine */ int ccsyr2k_(integer *, char *, char *, integer *,
+    extern /* Subroutine */ void ccsyr2k_(integer *, char *, char *, integer *,
 	     integer *, complex *, complex *, integer *, complex *, integer *,
 	     complex *, complex *, integer *);
    complex als;
@@ -54,7 +54,7 @@ void F77_drot( const int *N, double *X, const int *incX, double *Y,
 }

 void F77_drotm(const int *N, double *X, const int *incX, double *Y,
-               const int *incY, const double *dparam)
+               const int *incY, double *dparam)
 {
   cblas_drotm(*N, X, *incX, Y, *incY, dparam);
   return;
@@ -332,7 +332,8 @@ static doublereal c_b34 = 1.;

    /* Local variables */
    static integer k;
-    extern /* Subroutine */ int drotgtest_(doublereal*,doublereal*,doublereal*,doublereal*), stest1_(doublereal*,doublereal*,doublereal*,doublereal*);
+    extern /* Subroutine */ void drotgtest_(doublereal*,doublereal*,doublereal*,doublereal*);
+    extern int stest1_(doublereal*,doublereal*,doublereal*,doublereal*);
    static doublereal sa, sb, sc, ss;

 /*     .. Parameters .. */
@@ -404,7 +405,8 @@ L40:
    static integer i__;
    extern doublereal dnrm2test_(integer*, doublereal*, integer*);
    static doublereal stemp[1], strue[8];
-    extern /* Subroutine */ int stest_(integer*,doublereal*,doublereal*,doublereal*,doublereal*), dscaltest_(integer*,doublereal*,doublereal*,integer*);
+    extern /* Subroutine */ int stest_(integer*,doublereal*,doublereal*,doublereal*,doublereal*);
+    extern void dscaltest_(integer*,doublereal*,doublereal*,integer*);
    extern doublereal dasumtest_(integer*,doublereal*,integer*);
    extern /* Subroutine */ int itest1_(integer*,integer*), stest1_(doublereal*,doublereal*,doublereal*,doublereal*);
    static doublereal sx[8];
@@ -430,7 +432,7 @@ L40:
 /*           .. Set vector arguments .. */
 	    i__1 = len;
 	    for (i__ = 1; i__ <= i__1; ++i__) {
-		sx[i__ - 1] = dv[i__ + (np1 + combla_1.incx * 5 << 3) - 49];
+		sx[i__ - 1] = dv[i__ + ((np1 + combla_1.incx * 5) << 3) - 49];
 /* L20: */
 	    }

@@ -450,7 +452,7 @@ L40:
 			, sx, &combla_1.incx);
 		i__1 = len;
 		for (i__ = 1; i__ <= i__1; ++i__) {
-		    strue[i__ - 1] = dtrue5[i__ + (np1 + combla_1.incx * 5 << 
+		    strue[i__ - 1] = dtrue5[i__ + ((np1 + combla_1.incx * 5) << 
 			    3) - 49];
 /* L40: */
 		}
@@ -517,8 +519,10 @@ L40:
    static integer lenx, leny;
    extern doublereal ddottest_(integer*,doublereal*,integer*,doublereal*,integer*);
    static integer i__, j, ksize;
-    extern /* Subroutine */ int stest_(integer*,doublereal*,doublereal*,doublereal*,doublereal*), dcopytest_(integer*,doublereal*,integer*,doublereal*,integer*), dswaptest_(integer*,doublereal*,integer*,doublereal*,integer*), 
-	    daxpytest_(integer*,doublereal*,doublereal*,integer*,doublereal*,integer*), stest1_(doublereal*,doublereal*,doublereal*,doublereal*);
+    extern /* Subroutine */ int stest_(integer*,doublereal*,doublereal*,doublereal*,doublereal*);
+    extern void dcopytest_(integer*,doublereal*,integer*,doublereal*,integer*), dswaptest_(integer*,doublereal*,integer*,doublereal*,integer*), 
+	    daxpytest_(integer*,doublereal*,doublereal*,integer*,doublereal*,integer*);
+    extern int stest1_(doublereal*,doublereal*,doublereal*,doublereal*);
    static integer ki, kn, mx, my;
    static doublereal sx[7], sy[7], stx[7], sty[7];

@@ -618,9 +622,10 @@ L40:
 	    ;

    /* Local variables */
-    extern /* Subroutine */ int drottest_(integer*,doublereal*,integer*,doublereal*,integer*,doublereal*,doublereal*);
+    extern /* Subroutine */ void drottest_(integer*,doublereal*,integer*,doublereal*,integer*,doublereal*,doublereal*);
    static integer i__, k, ksize;
-    extern /* Subroutine */int stest_(integer*,doublereal*,doublereal*,doublereal*,doublereal*), drotmtest_(integer*,doublereal*,integer*,doublereal*,integer*,doublereal*);
+    extern /* Subroutine */int stest_(integer*,doublereal*,doublereal*,doublereal*,doublereal*);
+    extern void drotmtest_(integer*,doublereal*,integer*,doublereal*,integer*,doublereal*);
    static integer ki, kn;
    static doublereal dparam[5], sx[10], sy[10], stx[10], sty[10];

@@ -21,19 +21,6 @@ typedef float real;
 typedef double doublereal;
 typedef struct { real r, i; } complex;
 typedef struct { doublereal r, i; } doublecomplex;
-#ifdef _MSC_VER
-static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
-static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
-static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
-static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
-#else
-static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
-static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
-#endif
-#define pCf(z) (*_pCf(z))
-#define pCd(z) (*_pCd(z))
 typedef int logical;
 typedef short int shortlogical;
 typedef char logical1;
@@ -318,7 +305,7 @@ static logical c_false = FALSE_;
    static char snamet[12];
    static doublereal thresh;
    static logical rorder;
-    extern /* Subroutine */ void cd2chke_(char*, ftnlen);
+    extern /* Subroutine */ void cd2chke_(char*);
    static integer layout;
    static logical ltestt, tsterr;
    static doublereal alf[7];
@@ -706,7 +693,7 @@ L100:
 		    ftnlen)12);
 /*           Test error exits. */
 	    if (tsterr) {
-		cd2chke_(snames[isnum - 1], (ftnlen)12);
+		cd2chke_(snames[isnum - 1]);
 	    }
 /*           Test computations. */
 	    infoc_1.infot = 0;
@@ -885,8 +872,8 @@ L240:
    static integer ia, ib, ic;
    static logical banded;
    static integer nc, nd, im, in, kl, ml, nk, nl, ku, ix, iy, ms, lx, ly, ns;
-    extern /* Subroutine */ void cdgbmv_(integer*, char*, integer*, integer*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*, ftnlen);
-    extern /* Subroutine */ void cdgemv_(integer*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*, ftnlen);
+    extern /* Subroutine */ void cdgbmv_(integer*, char*, integer*, integer*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*);
+    extern /* Subroutine */ void cdgemv_(integer*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*);
    extern logical lderes_(char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen);
    static char ctrans[14];
    static doublereal errmax, transl;
@@ -1118,8 +1105,7 @@ L240:
 					}
 					cdgemv_(iorder, trans, &m, &n, &alpha,
 						 &aa[1], &lda, &xx[1], &incx, 
-						&beta, &yy[1], &incy, (ftnlen)
-						1);
+						&beta, &yy[1], &incy);
 				    } else if (banded) {
 					if (*trace) {
 /*
@@ -1135,7 +1121,7 @@ L240:
 					cdgbmv_(iorder, trans, &m, &n, &kl, &
 						ku, &alpha, &aa[1], &lda, &xx[
 						1], &incx, &beta, &yy[1], &
-						incy, (ftnlen)1);
+						incy);
 				    }

 /*                             Check if error-exit was taken incorrectly. */
@@ -1329,10 +1315,10 @@ L140:
    static logical packed;
    static integer nk, ks, ix, iy, ns, lx, ly;
    extern logical lderes_(char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void cdsbmv_(integer*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*, ftnlen);
-    extern /* Subroutine */ void cdspmv_(integer*, char*, integer*, doublereal*, doublereal*, doublereal*, integer*, doublereal*, doublereal*, integer*, ftnlen);
+    extern /* Subroutine */ void cdsbmv_(integer*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*);
+    extern /* Subroutine */ void cdspmv_(integer*, char*, integer*, doublereal*, doublereal*, doublereal*, integer*, doublereal*, doublereal*, integer*);
    static doublereal errmax, transl;
-    extern /* Subroutine */ void cdsymv_(integer*, char*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*, ftnlen);
+    extern /* Subroutine */ void cdsymv_(integer*, char*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*);
    static integer laa, lda;
    extern logical lde_(doublereal*, doublereal*, integer*);
    static doublereal als, bls, err;
@@ -1536,7 +1522,7 @@ L140:
 				    }
 				    cdsymv_(iorder, uplo, &n, &alpha, &aa[1], 
 					    &lda, &xx[1], &incx, &beta, &yy[1]
-					    , &incy, (ftnlen)1);
+					    , &incy);
 				} else if (banded) {
 				    if (*trace) {
 /*
@@ -1551,7 +1537,7 @@ L140:
 				    }
 				    cdsbmv_(iorder, uplo, &n, &k, &alpha, &aa[
 					    1], &lda, &xx[1], &incx, &beta, &
-					    yy[1], &incy, (ftnlen)1);
+					    yy[1], &incy);
 				} else if (packed) {
 				    if (*trace) {
 /*
@@ -1566,7 +1552,7 @@ L140:
 				    }
 				    cdspmv_(iorder, uplo, &n, &alpha, &aa[1], 
 					    &xx[1], &incx, &beta, &yy[1], &
-					    incy, (ftnlen)1);
+					    incy);
 				}

 /*                          Check if error-exit was taken incorrectly. */
@@ -1770,15 +1756,15 @@ L130:
    static logical packed;
    static integer nk, ks, ix, ns, lx;
    extern logical lderes_(char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void cdtbmv_(integer*, char*, char*, char*, integer*, integer*, doublereal*, integer*, doublereal*, integer*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cdtbsv_(integer*, char*, char*, char*, integer*, integer*, doublereal*, integer*, doublereal*, integer*, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cdtbmv_(integer*, char*, char*, char*, integer*, integer*, doublereal*, integer*, doublereal*, integer*);
+    extern /* Subroutine */ void cdtbsv_(integer*, char*, char*, char*, integer*, integer*, doublereal*, integer*, doublereal*, integer*);
    static char ctrans[14];
    static doublereal errmax;
-    extern /* Subroutine */ void cdtpmv_(integer*, char*, char*, char*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cdtrmv_(integer*, char*, char*, char*, integer*, doublereal*, integer*, doublereal*, integer*, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cdtpmv_(integer*, char*, char*, char*, integer*, doublereal*, doublereal*, integer*);
+    extern /* Subroutine */ void cdtrmv_(integer*, char*, char*, char*, integer*, doublereal*, integer*, doublereal*, integer*);
    static doublereal transl;
-    extern /* Subroutine */ void cdtpsv_(integer*, char*, char*, char*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cdtrsv_(integer*, char*, char*, char*, integer*, doublereal*, integer*, doublereal*, integer*, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cdtpsv_(integer*, char*, char*, char*, integer*, doublereal*, doublereal*, integer*);
+    extern /* Subroutine */ void cdtrsv_(integer*, char*, char*, char*, integer*, doublereal*, integer*, doublereal*, integer*);
    static char transs[1];
    static integer laa, icd, lda;
    extern logical lde_(doublereal*, doublereal*, integer*);
@@ -1978,8 +1964,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cdtrmv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					    aa[1], &lda, &xx[1], &incx);
 				} else if (banded) {
 				    if (*trace) {
 /*
@@ -1993,8 +1978,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cdtbmv_(iorder, uplo, trans, diag, &n, &k,
-					     &aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					     &aa[1], &lda, &xx[1], &incx);
 				} else if (packed) {
 				    if (*trace) {
 /*
@@ -2008,8 +1992,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cdtpmv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &xx[1], &incx, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    aa[1], &xx[1], &incx);
 				}
 			    } else if (s_cmp(sname + 9, "sv", (ftnlen)2, (
 				    ftnlen)2) == 0) {
@@ -2026,8 +2009,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cdtrsv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					    aa[1], &lda, &xx[1], &incx);
 				} else if (banded) {
 				    if (*trace) {
 /*
@@ -2041,8 +2023,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cdtbsv_(iorder, uplo, trans, diag, &n, &k,
-					     &aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					     &aa[1], &lda, &xx[1], &incx);
 				} else if (packed) {
 				    if (*trace) {
 /*
@@ -2056,8 +2037,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cdtpsv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &xx[1], &incx, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    aa[1], &xx[1], &incx);
 				}
 			    }

@@ -2587,11 +2567,11 @@ L150:
    static logical isame[13];
    extern /* Subroutine */ int dmvch_(char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*, doublereal*, doublereal*, doublereal*, doublereal*, doublereal*, logical*, integer*, logical*, ftnlen);
    static integer nargs;
-    extern /* Subroutine */ void cdspr_(integer*, char*, integer*, doublereal*, doublereal*, integer*, doublereal*, ftnlen);
+    extern /* Subroutine */ void cdspr_(integer*, char*, integer*, doublereal*, doublereal*, integer*, doublereal*);
    static logical reset;
    static char cuplo[14];
    static integer incxs;
-    extern /* Subroutine */ void cdsyr_(integer*, char*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, ftnlen);
+    extern /* Subroutine */ void cdsyr_(integer*, char*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*);
    static logical upper;
    static char uplos[1];
    static integer ia, ja, ic, nc, jj, lj, in;
@@ -2751,7 +2731,7 @@ L150:
 			    f_rew(&al__1);*/
 			}
 			cdsyr_(iorder, uplo, &n, &alpha, &xx[1], &incx, &aa[1]
-				, &lda, (ftnlen)1);
+				, &lda);
 		    } else if (packed) {
 			if (*trace) {
 /*
@@ -2764,8 +2744,7 @@ L150:
 			    al__1.aunit = *ntra;
 			    f_rew(&al__1);*/
 			}
-			cdspr_(iorder, uplo, &n, &alpha, &xx[1], &incx, &aa[1]
-				, (ftnlen)1);
+			cdspr_(iorder, uplo, &n, &alpha, &xx[1], &incx, &aa[1]);
 		    }

 /*                 Check if error-exit was taken incorrectly. */
@@ -2948,8 +2927,8 @@ L130:
    static integer incxs, incys;
    static logical upper;
    static char uplos[1];
-    extern /* Subroutine */ void cdspr2_(integer*, char*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, ftnlen);
-    extern /* Subroutine */ void cdsyr2_(integer*, char*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, integer*, ftnlen);
+    extern /* Subroutine */ void cdspr2_(integer*, char*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*);
+    extern /* Subroutine */ void cdsyr2_(integer*, char*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, integer*);
    static integer ia, ja, ic, nc, jj, lj, in;
    static logical packed;
    static integer ix, iy, ns, lx, ly;
@@ -3132,7 +3111,7 @@ L130:
 				f_rew(&al__1);*/
 			    }
 			    cdsyr2_(iorder, uplo, &n, &alpha, &xx[1], &incx, &
-				    yy[1], &incy, &aa[1], &lda, (ftnlen)1);
+				    yy[1], &incy, &aa[1], &lda);
 			} else if (packed) {
 			    if (*trace) {
 /*
@@ -3146,7 +3125,7 @@ L130:
 				f_rew(&al__1);*/
 			    }
 			    cdspr2_(iorder, uplo, &n, &alpha, &xx[1], &incx, &
-				    yy[1], &incy, &aa[1], (ftnlen)1);
+				    yy[1], &incy, &aa[1]);
 			}

 /*                    Check if error-exit was taken incorrectly. */
@@ -21,19 +21,6 @@ typedef float real;
 typedef double doublereal;
 typedef struct { real r, i; } complex;
 typedef struct { doublereal r, i; } doublecomplex;
-#ifdef _MSC_VER
-static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
-static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
-static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
-static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
-#else
-static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
-static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
-#endif
-#define pCf(z) (*_pCf(z))
-#define pCd(z) (*_pCd(z))
 typedef int logical;
 typedef short int shortlogical;
 typedef char logical1;
@@ -309,7 +296,7 @@ static logical c_false = FALSE_;
    static char snamet[12], transa[1], transb[1];
    static doublereal thresh;
    static logical rorder;
-    extern /* Subroutine */ void cd3chke_(char*, ftnlen);
+    extern /* Subroutine */ void cd3chke_(char*);
    static integer layout;
    static logical ltestt, tsterr;
    static doublereal alf[7];
@@ -658,7 +645,7 @@ L80:
 		    ftnlen)12);
 /*           Test error exits. */
 	    if (tsterr) {
-		cd3chke_(snames[isnum - 1], (ftnlen)12);
+		cd3chke_(snames[isnum - 1]);
 	    }
 /*           Test computations. */
 	    infoc_1.infot = 0;
@@ -807,7 +794,7 @@ L230:
    static logical reset;
    extern /* Subroutine */ void dprcn1_(integer*, integer*, char*, integer*, char*, char*, integer*, integer*, integer*, doublereal*, integer*, integer*, doublereal*, integer*, ftnlen, ftnlen, ftnlen);
    static integer ia, ib, ma, mb, na, nb, nc, ik, im, in;
-    extern /* Subroutine */ void cdgemm_(integer*, char*, char*, integer*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void cdgemm_(integer*, char*, char*, integer*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*);
    static integer ks, ms, ns;
    extern logical lderes_(char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen);
    static char tranas[1], tranbs[1], transa[1], transb[1];
@@ -1012,8 +999,7 @@ L230:
 				}
 				cdgemm_(iorder, transa, transb, &m, &n, &k, &
 					alpha, &aa[1], &lda, &bb[1], &ldb, &
-					beta, &cc[1], &ldc, (ftnlen)1, (
-					ftnlen)1);
+					beta, &cc[1], &ldc);

 /*                          Check if error-exit was taken incorrectly. */

@@ -1204,7 +1190,7 @@ L130:
    extern /* Subroutine */ void dprcn2_(integer*, integer*, char*, integer*, char*, char*, integer*, integer*, doublereal*, integer*, integer*, doublereal*, integer*, ftnlen, ftnlen, ftnlen);
    static integer ia, ib, na, nc, im, in, ms, ns;
    extern logical lderes_(char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void cdsymm_(integer*, char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void cdsymm_(integer*, char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*);
    static doublereal errmax;
    static integer laa, lbb, lda, lcc, ldb, ldc;
    extern logical lde_(doublereal*, doublereal*, integer*);
@@ -1386,8 +1372,7 @@ L130:
 				f_rew(&al__1);*/
 			    }
 			    cdsymm_(iorder, side, uplo, &m, &n, &alpha, &aa[1]
-				    , &lda, &bb[1], &ldb, &beta, &cc[1], &ldc,
-				     (ftnlen)1, (ftnlen)1);
+				    , &lda, &bb[1], &ldb, &beta, &cc[1], &ldc);

 /*                       Check if error-exit was taken incorrectly. */

@@ -1580,9 +1565,9 @@ L120:
    extern /* Subroutine */ void dprcn3_(integer*, integer*, char*, integer*, char*, char*, char*, char*, integer*, integer*, doublereal*, integer*, integer*, ftnlen, ftnlen, ftnlen, ftnlen, ftnlen);
    static integer ia, na, nc, im, in, ms, ns;
    extern logical lderes_(char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void cdtrmm_(integer*, char*, char*, char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, ftnlen, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cdtrmm_(integer*, char*, char*, char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*);
    static char tranas[1], transa[1];
-    extern /* Subroutine */ void cdtrsm_(integer*, char*, char*, char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, ftnlen, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cdtrsm_(integer*, char*, char*, char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*);
    static doublereal errmax;
    static integer laa, icd, lbb, lda, ldb;
    extern logical lde_(doublereal*, doublereal*, integer*);
@@ -1762,8 +1747,7 @@ L120:
 				    }
 				    cdtrmm_(iorder, side, uplo, transa, diag, 
 					    &m, &n, &alpha, &aa[1], &lda, &bb[
-					    1], &ldb, (ftnlen)1, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    1], &ldb);
 				} else if (s_cmp(sname + 9, "sm", (ftnlen)2, (
 					ftnlen)2) == 0) {
 				    if (*trace) {
@@ -1780,8 +1764,7 @@ L120:
 				    }
 				    cdtrsm_(iorder, side, uplo, transa, diag, 
 					    &m, &n, &alpha, &aa[1], &lda, &bb[
-					    1], &ldb, (ftnlen)1, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    1], &ldb);
 				}

 /*                          Check if error-exit was taken incorrectly. */
@@ -2038,7 +2021,7 @@ L160:
    static integer ia, ib, jc, ma, na, nc, ik, in, jj, lj, ks, ns;
    extern logical lderes_(char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen);
    static doublereal errmax;
-    extern /* Subroutine */ void cdsyrk_(integer*, char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void cdsyrk_(integer*, char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, doublereal*, integer*);
    static char transs[1];
    static integer laa, lda, lcc, ldc;
    extern logical lde_(doublereal*, doublereal*, integer*);
@@ -2199,8 +2182,7 @@ L160:
 				f_rew(&al__1);*/
 			    }
 			    cdsyrk_(iorder, uplo, trans, &n, &k, &alpha, &aa[
-				    1], &lda, &beta, &cc[1], &ldc, (ftnlen)1, 
-				    (ftnlen)1);
+				    1], &lda, &beta, &cc[1], &ldc);

 /*                       Check if error-exit was taken incorrectly. */

@@ -2420,7 +2402,7 @@ L130:
    static char transs[1];
    static integer laa, lbb, lda, lcc, ldb, ldc;
    extern logical lde_(doublereal*, doublereal*, integer*);
-    extern /* Subroutine */ void cdsyr2k_(integer*, char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void cdsyr2k_(integer*, char*, char*, integer*, integer*, doublereal*, doublereal*, integer*, doublereal*, integer*, doublereal*, doublereal*, integer*);
    static doublereal als;
    static integer ict, icu;
    static doublereal err;
@@ -2604,7 +2586,7 @@ L130:
 			    }
 			    cdsyr2k_(iorder, uplo, trans, &n, &k, &alpha, &aa[
 				    1], &lda, &bb[1], &ldb, &beta, &cc[1], &
-				    ldc, (ftnlen)1, (ftnlen)1);
+				    ldc);

 /*                       Check if error-exit was taken incorrectly. */

@@ -342,7 +342,8 @@ static real c_b34 = (float)1.;

    /* Local variables */
    static integer k;
-    extern /* Subroutine */ int srotgtest_(real*,real*,real*,real*), stest1_(real*,real*,real*,real*);
+    extern /* Subroutine */ void srotgtest_(real*,real*,real*,real*);
+    extern int stest1_(real*,real*,real*,real*);
    static real sa, sb, sc, ss;

 /*     .. Parameters .. */
@@ -435,7 +436,8 @@ L40:
    static integer i__;
    extern real snrm2test_(integer*,real*,integer*);
    static real stemp[1], strue[8];
-    extern /* Subroutine */ int stest_(integer*, real*,real*,real*,real*), sscaltest_(integer*,real*,real*,integer*);
+    extern /* Subroutine */ int stest_(integer*, real*,real*,real*,real*);
+    extern void sscaltest_(integer*,real*,real*,integer*);
    extern real sasumtest_(integer*,real*,integer*);
    extern /* Subroutine */ int itest1_(integer*,integer*), stest1_(real*,real*,real*,real*);
    static real sx[8];
@@ -462,7 +464,7 @@ L40:
 /*           .. Set vector arguments .. */
 	    i__1 = len;
 	    for (i__ = 1; i__ <= i__1; ++i__) {
-		sx[i__ - 1] = dv[i__ + (np1 + combla_1.incx * 5 << 3) - 49];
+		sx[i__ - 1] = dv[i__ + ((np1 + combla_1.incx * 5) << 3) - 49];
 /* L20: */
 	    }

@@ -482,7 +484,7 @@ L40:
 			, sx, &combla_1.incx);
 		i__1 = len;
 		for (i__ = 1; i__ <= i__1; ++i__) {
-		    strue[i__ - 1] = dtrue5[i__ + (np1 + combla_1.incx * 5 << 
+		    strue[i__ - 1] = dtrue5[i__ + ((np1 + combla_1.incx * 5) << 
 			    3) - 49];
 /* L40: */
 		}
@@ -592,7 +594,8 @@ L40:
    static integer lenx, leny;
    extern real sdottest_(integer*,real*,integer*,real*,integer*);
    static integer i__, j, ksize;
-    extern /* Subroutine */ int stest_(integer*,real*,real*,real*,real*), scopytest_(integer*,real*,integer*,real*,integer*), sswaptest_(integer*,real*,integer*,real*,integer*), 
+    extern /* Subroutine */ int stest_(integer*,real*,real*,real*,real*);
+    extern void scopytest_(integer*,real*,integer*,real*,integer*), sswaptest_(integer*,real*,integer*,real*,integer*), 
 	    saxpytest_(integer*,real*,real*,integer*,real*,integer*);
    static integer ki;
    extern /* Subroutine */ int stest1_(real*,real*,real*,real*);
@@ -710,7 +713,8 @@ L40:
    /* Local variables */
    extern /* Subroutine */ void srottest_(integer*,real*,integer*,real*,integer*,real*,real*);
    static integer i__, k, ksize;
-    extern /* Subroutine */ int stest_(integer*,real*,real*,real*,real*), srotmtest_(integer*,real*,integer*,real*,integer*,real*);
+    extern /* Subroutine */ int stest_(integer*,real*,real*,real*,real*);
+    extern void srotmtest_(integer*,real*,integer*,real*,integer*,real*);
    static integer ki, kn;
    static real sx[19], sy[19], sparam[5], stx[19], sty[19];

@@ -21,19 +21,6 @@ typedef float real;
 typedef double doublereal;
 typedef struct { real r, i; } complex;
 typedef struct { doublereal r, i; } doublecomplex;
-#ifdef _MSC_VER
-static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
-static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
-static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
-static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
-#else
-static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
-static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
-#endif
-#define pCf(z) (*_pCf(z))
-#define pCd(z) (*_pCd(z))
 typedef int logical;
 typedef short int shortlogical;
 typedef char logical1;
@@ -319,7 +306,7 @@ extern /* Subroutine */ int schk6_(char* sname, real* eps, real* thresh, integer
    static logical rorder;
    static integer layout;
    static logical ltestt;
-    extern /* Subroutine */ int cs2chke_(char*, ftnlen);
+    extern /* Subroutine */ void cs2chke_(char*);
    static logical tsterr;
    static real alf[7];
    static integer inc[7], nkb;
@@ -702,7 +689,7 @@ L100:
 		    ftnlen)12);
 /*           Test error exits. */
 	    if (tsterr) {
-		cs2chke_(snames[isnum - 1], (ftnlen)12);
+		cs2chke_(snames[isnum - 1]);
 	    }
 /*           Test computations. */
 	    infoc_1.infot = 0;
@@ -880,8 +867,8 @@ L240:
    static integer ia, ib, ic;
    static logical banded;
    static integer nc, nd, im, in, kl, ml, nk, nl, ku, ix, iy, ms, lx, ly, ns;
-    extern /* Subroutine */ void csgbmv_(integer*, char*, integer*, integer*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*, ftnlen);
-    extern /* Subroutine */ void csgemv_(integer*, char*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*, ftnlen);
+    extern /* Subroutine */ void csgbmv_(integer*, char*, integer*, integer*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*);
+    extern /* Subroutine */ void csgemv_(integer*, char*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*);
    static char ctrans[14];
    static real errmax;
    extern logical lseres_(char* type__, char* uplo, integer* m, integer* n, real* aa, real* as, integer* lda, ftnlen ltype_len, ftnlen uplo_len);
@@ -1115,8 +1102,7 @@ L240:
 					}
 					csgemv_(iorder, trans, &m, &n, &alpha,
 						 &aa[1], &lda, &xx[1], &incx, 
-						&beta, &yy[1], &incy, (ftnlen)
-						1);
+						&beta, &yy[1], &incy);
 				    } else if (banded) {
 					if (*trace) {
 /*
@@ -1132,7 +1118,7 @@ L240:
 					csgbmv_(iorder, trans, &m, &n, &kl, &
 						ku, &alpha, &aa[1], &lda, &xx[
 						1], &incx, &beta, &yy[1], &
-						incy, (ftnlen)1);
+						incy);
 				    }

 /*                             Check if error-exit was taken incorrectly. */
@@ -1327,10 +1313,10 @@ L140:
    static integer nk, ks, ix, iy, ns, lx, ly;
    static real errmax;
    extern logical lseres_(char* , char*, integer*, integer*, real*, real*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void cssbmv_(integer*, char*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*, ftnlen);
+    extern /* Subroutine */ void cssbmv_(integer*, char*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*);
    static real transl;
-    extern /* Subroutine */ void csspmv_(integer*, char*, integer*, real*, real*, real*, integer*, real*, real*, integer*, ftnlen);
-    extern /* Subroutine */ void cssymv_(integer*, char*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*, ftnlen);
+    extern /* Subroutine */ void csspmv_(integer*, char*, integer*, real*, real*, real*, integer*, real*, real*, integer*);
+    extern /* Subroutine */ void cssymv_(integer*, char*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*);
    static integer laa, lda;
    static real als, bls;
    extern logical lse_(real*, real*, integer*);
@@ -1531,7 +1517,7 @@ L140:
 				    }
 				    cssymv_(iorder, uplo, &n, &alpha, &aa[1], 
 					    &lda, &xx[1], &incx, &beta, &yy[1]
-					    , &incy, (ftnlen)1);
+					    , &incy);
 				} else if (banded) {
 				    if (*trace) {
 /*
@@ -1546,7 +1532,7 @@ L140:
 				    }
 				    cssbmv_(iorder, uplo, &n, &k, &alpha, &aa[
 					    1], &lda, &xx[1], &incx, &beta, &
-					    yy[1], &incy, (ftnlen)1);
+					    yy[1], &incy);
 				} else if (packed) {
 				    if (*trace) {
 /*
@@ -1561,7 +1547,7 @@ L140:
 				    }
 				    csspmv_(iorder, uplo, &n, &alpha, &aa[1], 
 					    &xx[1], &incx, &beta, &yy[1], &
-					    incy, (ftnlen)1);
+					    incy);
 				}

 /*                          Check if error-exit was taken incorrectly. */
@@ -1767,14 +1753,14 @@ L130:
    static char ctrans[14];
    static real errmax;
    extern logical lseres_(char*, char*, integer*, integer*, real*, real*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void cstbmv_(integer*, char*, char*, char*, integer*, integer*, real*, integer*, real*, integer*, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cstbmv_(integer*, char*, char*, char*, integer*, integer*, real*, integer*, real*, integer*);
    static real transl;
-    extern /* Subroutine */ void cstbsv_(integer*, char*, char*, char*, integer*, integer*, real*, integer*, real*, integer*, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cstbsv_(integer*, char*, char*, char*, integer*, integer*, real*, integer*, real*, integer*);
    static char transs[1];
-    extern /* Subroutine */ void cstpmv_(integer*, char*, char*, char*, integer*, real*, real*, integer*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cstrmv_(integer*, char*, char*, char*, integer*, real*, integer*, real*, integer*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cstpsv_(integer*, char*, char*, char*, integer*, real*, real*, integer*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cstrsv_(integer*, char*, char*, char*, integer*, real*, integer*, real*, integer*, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cstpmv_(integer*, char*, char*, char*, integer*, real*, real*, integer*);
+    extern /* Subroutine */ void cstrmv_(integer*, char*, char*, char*, integer*, real*, integer*, real*, integer*);
+    extern /* Subroutine */ void cstpsv_(integer*, char*, char*, char*, integer*, real*, real*, integer*);
+    extern /* Subroutine */ void cstrsv_(integer*, char*, char*, char*, integer*, real*, integer*, real*, integer*);
    static integer laa, icd, lda, ict, icu;
    extern logical lse_(real*, real*, integer*);
    static real err;
@@ -1972,8 +1958,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cstrmv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					    aa[1], &lda, &xx[1], &incx);
 				} else if (banded) {
 				    if (*trace) {
 /*
@@ -1987,8 +1972,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cstbmv_(iorder, uplo, trans, diag, &n, &k,
-					     &aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					     &aa[1], &lda, &xx[1], &incx);
 				} else if (packed) {
 				    if (*trace) {
 /*
@@ -2002,8 +1986,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cstpmv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &xx[1], &incx, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    aa[1], &xx[1], &incx);
 				}
 			    } else if (s_cmp(sname + 9, "sv", (ftnlen)2, (
 				    ftnlen)2) == 0) {
@@ -2020,8 +2003,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cstrsv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					    aa[1], &lda, &xx[1], &incx);
 				} else if (banded) {
 				    if (*trace) {
 /*
@@ -2035,8 +2017,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cstbsv_(iorder, uplo, trans, diag, &n, &k,
-					     &aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					     &aa[1], &lda, &xx[1], &incx);
 				} else if (packed) {
 				    if (*trace) {
 /*
@@ -2050,8 +2031,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cstpsv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &xx[1], &incx, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    aa[1], &xx[1], &incx);
 				}
 			    }

@@ -2585,10 +2565,10 @@ L150:
    static logical reset;
    static char cuplo[14];
    static integer incxs;
-    extern /* Subroutine */ void csspr_(integer*, char*, integer*, real*, real*, integer*, real*, ftnlen);
+    extern /* Subroutine */ void csspr_(integer*, char*, integer*, real*, real*, integer*, real*);
    static logical upper;
    static char uplos[1];
-    extern /* Subroutine */ void cssyr_(integer*, char*, integer*, real*, real*, integer*, real*, integer*, ftnlen);
+    extern /* Subroutine */ void cssyr_(integer*, char*, integer*, real*, real*, integer*, real*, integer*);
    static integer ia, ja, ic, nc, jj, lj, in;
    static logical packed;
    static integer ix, ns, lx;
@@ -2747,7 +2727,7 @@ L150:
 			    f_rew(&al__1);*/
 			}
 			cssyr_(iorder, uplo, &n, &alpha, &xx[1], &incx, &aa[1]
-				, &lda, (ftnlen)1);
+				, &lda);
 		    } else if (packed) {
 			if (*trace) {
 /*
@@ -2760,8 +2740,7 @@ L150:
 			    al__1.aunit = *ntra;
 			    f_rew(&al__1);*/
 			}
-			csspr_(iorder, uplo, &n, &alpha, &xx[1], &incx, &aa[1]
-				, (ftnlen)1);
+			csspr_(iorder, uplo, &n, &alpha, &xx[1], &incx, &aa[1]);
 		    }

 /*                 Check if error-exit was taken incorrectly. */
@@ -2945,13 +2924,13 @@ L130:
    static logical upper;
    static char uplos[1];
    static integer ia, ja, ic;
-    extern /* Subroutine */ void csspr2_(integer*, char*, integer*, real*, real*, integer*, real*, integer*, real*, ftnlen);
+    extern /* Subroutine */ void csspr2_(integer*, char*, integer*, real*, real*, integer*, real*, integer*, real*);
    static integer nc, jj, lj, in;
    static logical packed;
-    extern /* Subroutine */ void cssyr2_(integer*, char*, integer*, real*, real*, integer*, real*, integer*, real*, integer*, ftnlen);
+    extern /* Subroutine */ void cssyr2_(integer*, char*, integer*, real*, real*, integer*, real*, integer*, real*, integer*);
    static integer ix, iy, ns, lx, ly;
    static real errmax;
-    extern logical lseres_(char* type__, char* uplo, integer* m, integer* n, real* aa, real* as, integer* lda, ftnlen ltype_len, ftnlen uplo_len);
+    extern logical lseres_(char* type__, char* uplo, integer* m, integer* n, real* aa, real* as, integer* lda, ftnlen, ftnlen);
    static real transl;
    static integer laa, lda;
    static real als;
@@ -3131,7 +3110,7 @@ L130:
 				f_rew(&al__1);*/
 			    }
 			    cssyr2_(iorder, uplo, &n, &alpha, &xx[1], &incx, &
-				    yy[1], &incy, &aa[1], &lda, (ftnlen)1);
+				    yy[1], &incy, &aa[1], &lda);
 			} else if (packed) {
 			    if (*trace) {
 /*
@@ -3145,7 +3124,7 @@ L130:
 				f_rew(&al__1);*/
 			    }
 			    csspr2_(iorder, uplo, &n, &alpha, &xx[1], &incx, &
-				    yy[1], &incy, &aa[1], (ftnlen)1);
+				    yy[1], &incy, &aa[1]);
 			}

 /*                    Check if error-exit was taken incorrectly. */
@@ -3380,7 +3359,7 @@ L170:
 	i__2 = *m;
 	for (i__ = 1; i__ <= i__2; ++i__) {
 	    if (gen || (upper && i__ <= j) || (lower && i__ >= j)) {
-		if (i__ <= j && (j - i__ <= *ku || i__ >= j && i__ - j <= *kl)) 
+		if (((i__ <= j && j - i__ <= *ku) || (i__ >= j && i__ - j <= *kl))) 
 			{
 		    a[i__ + j * a_dim1] = sbeg_(reset) + *transl;
 		} else {
@@ -21,19 +21,6 @@ typedef float real;
 typedef double doublereal;
 typedef struct { real r, i; } complex;
 typedef struct { doublereal r, i; } doublecomplex;
-#ifdef _MSC_VER
-static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
-static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
-static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
-static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
-#else
-static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
-static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
-#endif
-#define pCf(z) (*_pCf(z))
-#define pCd(z) (*_pCd(z))
 typedef int logical;
 typedef short int shortlogical;
 typedef char logical1;
@@ -309,7 +296,7 @@ static logical c_false = FALSE_;
    static logical rorder;
    static integer layout;
    static logical ltestt, tsterr;
-    extern /* Subroutine */ void cs3chke_(char*, ftnlen);
+    extern /* Subroutine */ void cs3chke_(char*);
    static real alf[7], bet[7];
    extern logical lse_(real*, real*, integer*);
    static real eps, err;
@@ -522,7 +509,7 @@ L30:
    if (i__1 < 2) {
        goto L60;
    }
-    for (i__ = 1; i__ <= 9; ++i__) {
+    for (i__ = 1; i__ <= 6; ++i__) {
        if (s_cmp(snamet, snames[i__ - 1] , (ftnlen)12, (ftnlen)12) == 
                0) {
            goto L50;
@@ -656,7 +643,7 @@ L80:
 		    ftnlen)12);
 /*           Test error exits. */
 	    if (tsterr) {
-		cs3chke_(snames[isnum - 1], (ftnlen)12);
+		cs3chke_(snames[isnum - 1]);
 	    }
 /*           Test computations. */
 	    infoc_1.infot = 0;
@@ -800,7 +787,7 @@ L230:
    extern /* Subroutine */ int smake_(char*, char*, char*, integer*, integer*, real*, integer*, real*, integer*, logical*, real*, ftnlen, ftnlen, ftnlen);
    extern /* Subroutine */ int smmch_(char*, char*, integer*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*, real*, real*, real*, integer*, real*, real*, logical*, integer*, logical*, ftnlen, ftnlen);
    static integer ia, ib, ma, mb, na, nb, nc, ik, im, in, ks, ms, ns;
-    extern /* Subroutine */ void csgemm_(integer*, char*, char*, integer*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void csgemm_(integer*, char*, char*, integer*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*);
    static char tranas[1], tranbs[1], transa[1], transb[1];
    static real errmax;
    extern logical lseres_(char*, char*, integer*, integer*, real*, real*, integer*, ftnlen, ftnlen);
@@ -1003,8 +990,7 @@ L230:
 				}
 				csgemm_(iorder, transa, transb, &m, &n, &k, &
 					alpha, &aa[1], &lda, &bb[1], &ldb, &
-					beta, &cc[1], &ldc, (ftnlen)1, (
-					ftnlen)1);
+					beta, &cc[1], &ldc);

 /*                          Check if error-exit was taken incorrectly. */

@@ -1197,7 +1183,7 @@ L130:
    static integer ia, ib, na, nc, im, in, ms, ns;
    static real errmax;
    extern logical lseres_(char*, char*, integer*, integer*, real*, real*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void cssymm_(integer*, char*, char*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void cssymm_(integer*, char*, char*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*);
    extern void sprcn2_(integer*, integer*, char*, integer*, char*, char*, integer*, integer*, real*, integer*, integer*, real*, integer*, ftnlen, ftnlen, ftnlen);
    extern /* Subroutine */ int smake_(char*, char*, char*, integer*, integer*, real*, integer*, real*, integer*, logical*, real*, ftnlen, ftnlen, ftnlen);
    extern /* Subroutine */ int smmch_(char*, char*, integer*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*, real*, real*, real*, integer*, real*, real*, logical*, integer*, logical*, ftnlen, ftnlen);
@@ -1378,8 +1364,7 @@ L130:
 //				f_rew(&al__1);
 			    }
 			    cssymm_(iorder, side, uplo, &m, &n, &alpha, &aa[1]
-				    , &lda, &bb[1], &ldb, &beta, &cc[1], &ldc,
-				     (ftnlen)1, (ftnlen)1);
+				    , &lda, &bb[1], &ldb, &beta, &cc[1], &ldc);

 /*                       Check if error-exit was taken incorrectly. */

@@ -1575,8 +1560,8 @@ L120:
    extern /* Subroutine */ int smake_(char*, char*, char*, integer*, integer*, real*, integer*, real*, integer*, logical*, real*, ftnlen, ftnlen, ftnlen);
    extern /* Subroutine */ int smmch_(char*, char*, integer*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*, real*, real*, real*, integer*, real*, real*, logical*, integer*, logical*, ftnlen, ftnlen);
    extern logical lseres_(char*, char*, integer*, integer*, real*, real*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void cstrmm_(integer*, char*, char*, char*, char*, integer*, integer*, real*, real*, integer*, real*, integer*, ftnlen, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cstrsm_(integer*, char*, char*, char*, char*, integer*, integer*, real*, real*, integer*, real*, integer*, ftnlen, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cstrmm_(integer*, char*, char*, char*, char*, integer*, integer*, real*, real*, integer*, real*, integer*);
+    extern /* Subroutine */ void cstrsm_(integer*, char*, char*, char*, char*, integer*, integer*, real*, real*, integer*, real*, integer*);
    static integer laa, icd, lbb, lda, ldb, ics;
    static real als;
    static integer ict, icu;
@@ -1752,8 +1737,7 @@ L120:
 				    }
 				    cstrmm_(iorder, side, uplo, transa, diag, 
 					    &m, &n, &alpha, &aa[1], &lda, &bb[
-					    1], &ldb, (ftnlen)1, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    1], &ldb);
 				} else if (s_cmp(sname + 9, "sm", (ftnlen)2, (
 					ftnlen)2) == 0) {
 				    if (*trace) {
@@ -1768,8 +1752,7 @@ L120:
 				    }
 				    cstrsm_(iorder, side, uplo, transa, diag, 
 					    &m, &n, &alpha, &aa[1], &lda, &bb[
-					    1], &ldb, (ftnlen)1, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    1], &ldb);
 				}

 /*                          Check if error-exit was taken incorrectly. */
@@ -2028,7 +2011,7 @@ L160:
    static real errmax;
    extern logical lseres_(char*, char*, integer*, integer*, real*, real*, integer*, ftnlen, ftnlen);
    static char transs[1];
-    extern /* Subroutine */ void cssyrk_(integer*, char*, char*, integer*, integer*, real*, real*, integer*, real*, real*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void cssyrk_(integer*, char*, char*, integer*, integer*, real*, real*, integer*, real*, real*, integer*);
    static integer laa, lda, lcc, ldc;
    static real als;
    static integer ict, icu;
@@ -2186,8 +2169,7 @@ L160:
 //				f_rew(&al__1);
 			    }
 			    cssyrk_(iorder, uplo, trans, &n, &k, &alpha, &aa[
-				    1], &lda, &beta, &cc[1], &ldc, (ftnlen)1, 
-				    (ftnlen)1);
+				    1], &lda, &beta, &cc[1], &ldc);

 /*                       Check if error-exit was taken incorrectly. */

@@ -2409,7 +2391,7 @@ L130:
    static integer laa, lbb, lda, lcc, ldb, ldc;
    static real als;
    static integer ict, icu;
-    extern /* Subroutine */ void cssyr2k_(integer*, char*, char*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void cssyr2k_(integer*, char*, char*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*);
    extern logical lse_(real*, real*, integer*);
    extern /* Subroutine */ int smmch_(char*, char*, integer*, integer*, integer*, real*, real*, integer*, real*, integer*, real*, real*, integer*, real*, real*, real*, integer*, real*, real*, logical*, integer*, logical*, ftnlen, ftnlen);
    static real err;
@@ -2591,7 +2573,7 @@ L130:
 			    }
 			    cssyr2k_(iorder, uplo, trans, &n, &k, &alpha, &aa[
 				    1], &lda, &bb[1], &ldb, &beta, &cc[1], &
-				    ldc, (ftnlen)1, (ftnlen)1);
+				    ldc);

 /*                       Check if error-exit was taken incorrectly. */

@@ -22,18 +22,10 @@ typedef double doublereal;
 typedef struct { real r, i; } complex;
 typedef struct { doublereal r, i; } doublecomplex;
 #ifdef _MSC_VER
-static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
 static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
-static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
-static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
 #else
-static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
 static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
-static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
 #endif
-#define pCf(z) (*_pCf(z))
-#define pCd(z) (*_pCd(z))
 typedef int logical;
 typedef short int shortlogical;
 typedef char logical1;
@@ -380,11 +372,12 @@ static doublereal c_b43 = 1.;
    static integer i__;
    extern /* Subroutine */ int ctest_(integer*, doublecomplex*, doublecomplex*, doublecomplex*, doublereal*);
    static doublecomplex mwpcs[5], mwpct[5];
-    extern /* Subroutine */ int zscaltest_(integer*, doublecomplex*, doublecomplex*, integer*), itest1_(integer*, integer*), stest1_(doublereal*, doublereal*, doublereal*, doublereal*);
+    extern /* Subroutine */ void zscaltest_(integer*, doublecomplex*, doublecomplex*, integer*);
+    extern int itest1_(integer*, integer*), stest1_(doublereal*, doublereal*, doublereal*, doublereal*);
    static doublecomplex cx[8];
    extern doublereal dznrm2test_(integer*, doublecomplex*, integer*);
    static integer np1;
-    extern /* Subroutine */ int zdscaltest_(integer*, doublereal*, doublecomplex*, integer*);
+    extern /* Subroutine */ void zdscaltest_(integer*, doublereal*, doublecomplex*, integer*);
    extern integer izamaxtest_(integer*, doublecomplex*, integer*);
    extern doublereal dzasumtest_(integer*, doublecomplex*, integer*);
    static integer len;
@@ -408,7 +401,7 @@ static doublereal c_b43 = 1.;
 	    i__1 = len;
 	    for (i__ = 1; i__ <= i__1; ++i__) {
 		i__2 = i__ - 1;
-		i__3 = i__ + (np1 + combla_1.incx * 5 << 3) - 49;
+		i__3 = i__ + ((np1 + combla_1.incx * 5) << 3) - 49;
 		cx[i__2].r = cv[i__3].r, cx[i__2].i = cv[i__3].i;
 /* L20: */
 	    }
@@ -423,13 +416,13 @@ static doublereal c_b43 = 1.;
 	    } else if (combla_1.icase == 8) {
 /*              .. ZSCALTEST .. */
 		zscaltest_(&combla_1.n, &ca, cx, &combla_1.incx);
-		ctest_(&len, cx, &ctrue5[(np1 + combla_1.incx * 5 << 3) - 48],
-			 &ctrue5[(np1 + combla_1.incx * 5 << 3) - 48], sfac);
+		ctest_(&len, cx, &ctrue5[((np1 + combla_1.incx * 5) << 3) - 48],
+			 &ctrue5[((np1 + combla_1.incx * 5) << 3) - 48], sfac);
 	    } else if (combla_1.icase == 9) {
 /*              .. ZDSCALTEST .. */
 		zdscaltest_(&combla_1.n, &sa, cx, &combla_1.incx);
-		ctest_(&len, cx, &ctrue6[(np1 + combla_1.incx * 5 << 3) - 48],
-			 &ctrue6[(np1 + combla_1.incx * 5 << 3) - 48], sfac);
+		ctest_(&len, cx, &ctrue6[((np1 + combla_1.incx * 5) << 3) - 48],
+			 &ctrue6[((np1 + combla_1.incx * 5) << 3) - 48], sfac);
 	    } else if (combla_1.icase == 10) {
 /*              .. IZAMAXTEST .. */
 		i__1 = izamaxtest_(&combla_1.n, cx, &combla_1.incx);
@@ -591,11 +584,11 @@ static doublereal c_b43 = 1.;
    extern /* Subroutine */ int ctest_(integer*, doublecomplex*, doublecomplex*, doublecomplex*, doublereal*);
    static integer ksize;
    static doublecomplex ztemp;
-    extern /* Subroutine */ int zdotctest_(integer*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*), zcopytest_(integer*, doublecomplex*, integer*, doublecomplex*, integer*);
+    extern /* Subroutine */ void zdotctest_(integer*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*), zcopytest_(integer*, doublecomplex*, integer*, doublecomplex*, integer*);
    static integer ki;
-    extern /* Subroutine */ int zdotutest_(integer*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*), zswaptest_(integer*, doublecomplex*, integer*, doublecomplex*, integer*);
+    extern /* Subroutine */ void zdotutest_(integer*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*), zswaptest_(integer*, doublecomplex*, integer*, doublecomplex*, integer*);
    static integer kn;
-    extern /* Subroutine */ int zaxpytest_(integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*);
+    extern /* Subroutine */ void zaxpytest_(integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*);
    static doublecomplex cx[7], cy[7];
    static integer mx, my;

@@ -22,17 +22,12 @@ typedef double doublereal;
 typedef struct { real r, i; } complex;
 typedef struct { doublereal r, i; } doublecomplex;
 #ifdef _MSC_VER
-static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
 static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
-static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
 static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
 #else
-static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
 static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
-static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
 static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
 #endif
-#define pCf(z) (*_pCf(z))
 #define pCd(z) (*_pCd(z))
 typedef int logical;
 typedef short int shortlogical;
@@ -322,7 +317,7 @@ static logical c_false = FALSE_;
    static logical rorder;
    static integer layout;
    static logical ltestt, tsterr;
-    extern /* Subroutine */ void cz2chke_(char*, ftnlen);
+    extern /* Subroutine */ void cz2chke_(char*);
    static doublecomplex alf[7];
    static integer inc[7], nkb;
    static doublecomplex bet[7];
@@ -713,7 +708,7 @@ L100:
 		    ftnlen)12);
 /*           Test error exits. */
 	    if (tsterr) {
-		cz2chke_(snames[isnum - 1], (ftnlen)12);
+		cz2chke_(snames[isnum - 1]);
 	    }
 /*           Test computations. */
 	    infoc_1.infot = 0;
@@ -893,9 +888,9 @@ L240:
    static integer ia, ib, ic;
    static logical banded;
    static integer nc, nd, im, in, kl, ml, nk, nl, ku, ix, iy, ms, lx, ly, ns;
-    extern /* Subroutine */ void czgbmv_(integer*, char*, integer*, integer*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen);
+    extern /* Subroutine */ void czgbmv_(integer*, char*, integer*, integer*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*);
    static char ctrans[14];
-    extern /* Subroutine */ void czgemv_(integer*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen);
+    extern /* Subroutine */ void czgemv_(integer*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*);
    static doublereal errmax;
    static doublecomplex transl;
    extern logical lzeres_(char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
@@ -1144,8 +1139,7 @@ L240:
 					}
 					czgemv_(iorder, trans, &m, &n, &alpha,
 						 &aa[1], &lda, &xx[1], &incx, 
-						&beta, &yy[1], &incy, (ftnlen)
-						1);
+						&beta, &yy[1], &incy);
 				    } else if (banded) {
 					if (*trace) {
 /*
@@ -1160,8 +1154,7 @@ L240:
 					}
 					czgbmv_(iorder, trans, &m, &n, &kl, &
 						ku, &alpha, &aa[1], &lda, &xx[
-						1], &incx, &beta, &yy[1], &
-						incy, (ftnlen)1);
+						1], &incx, &beta, &yy[1], &incy);
 				    }

 /*                            Check if error-exit was taken incorrectly. */
@@ -1349,12 +1342,12 @@ L140:
    static integer nc, ik, in;
    static logical packed;
    static integer nk, ks, ix, iy, ns, lx, ly;
-    extern /* Subroutine */ void czhbmv_(integer*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen);
-    extern /* Subroutine */ void czhemv_(integer*, char*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen);
+    extern /* Subroutine */ void czhbmv_(integer*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*);
+    extern /* Subroutine */ void czhemv_(integer*, char*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*);
    static doublereal errmax;
    static doublecomplex transl;
    extern logical lzeres_(char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void czhpmv_(integer*, char*, integer*, doublecomplex*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen);
+    extern /* Subroutine */ void czhpmv_(integer*, char*, integer*, doublecomplex*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*);
    static integer laa, lda;
    static doublecomplex als, bls;
    static doublereal err;
@@ -1568,7 +1561,7 @@ L140:
 				    }
 				    czhemv_(iorder, uplo, &n, &alpha, &aa[1], 
 					    &lda, &xx[1], &incx, &beta, &yy[1]
-					    , &incy, (ftnlen)1);
+					    , &incy);
 				} else if (banded) {
 				    if (*trace) {
 /*
@@ -1583,7 +1576,7 @@ L140:
 				    }
 				    czhbmv_(iorder, uplo, &n, &k, &alpha, &aa[
 					    1], &lda, &xx[1], &incx, &beta, &
-					    yy[1], &incy, (ftnlen)1);
+					    yy[1], &incy);
 				} else if (packed) {
 				    if (*trace) {
 /*
@@ -1597,8 +1590,7 @@ L140:
 					f_rew(&al__1);*/
 				    }
 				    czhpmv_(iorder, uplo, &n, &alpha, &aa[1], 
-					    &xx[1], &incx, &beta, &yy[1], &
-					    incy, (ftnlen)1);
+					    &xx[1], &incx, &beta, &yy[1], &incy);
 				}

 /*                          Check if error-exit was taken incorrectly. */
@@ -1798,13 +1790,13 @@ L130:
    static doublereal errmax;
    static doublecomplex transl;
    extern logical lzeres_(char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void cztbmv_(integer*, char*, char*, char*, integer*, integer*, doublecomplex*, integer*, doublecomplex*, integer*, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cztbmv_(integer*, char*, char*, char*, integer*, integer*, doublecomplex*, integer*, doublecomplex*, integer*);
    static char transs[1];
-    extern /* Subroutine */ void cztbsv_(integer*, char*, char*, char*, integer*, integer*, doublecomplex*, integer*, doublecomplex*, integer*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cztpmv_(integer*, char*, char*, char*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cztpsv_(integer*, char*, char*, char*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cztrmv_(integer*, char*, char*, char*, integer*, doublecomplex*, integer*, doublecomplex*, integer*, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cztrsv_(integer*, char*, char*, char*, integer*, doublecomplex*, integer*, doublecomplex*, integer*, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cztbsv_(integer*, char*, char*, char*, integer*, integer*, doublecomplex*, integer*, doublecomplex*, integer*);
+    extern /* Subroutine */ void cztpmv_(integer*, char*, char*, char*, integer*, doublecomplex*, doublecomplex*, integer*);
+    extern /* Subroutine */ void cztpsv_(integer*, char*, char*, char*, integer*, doublecomplex*, doublecomplex*, integer*);
+    extern /* Subroutine */ void cztrmv_(integer*, char*, char*, char*, integer*, doublecomplex*, integer*, doublecomplex*, integer*);
+    extern /* Subroutine */ void cztrsv_(integer*, char*, char*, char*, integer*, doublecomplex*, integer*, doublecomplex*, integer*);
    static integer laa, icd, lda, ict, icu;
    static doublereal err;
    extern logical lze_(doublecomplex*, doublecomplex*, integer*);
@@ -2014,8 +2006,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cztrmv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					    aa[1], &lda, &xx[1], &incx);
 				} else if (banded) {
 				    if (*trace) {
 /*
@@ -2029,8 +2020,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cztbmv_(iorder, uplo, trans, diag, &n, &k,
-					     &aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					     &aa[1], &lda, &xx[1], &incx);
 				} else if (packed) {
 				    if (*trace) {
 /*
@@ -2044,8 +2034,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cztpmv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &xx[1], &incx, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    aa[1], &xx[1], &incx);
 				}
 			    } else if (s_cmp(sname + 9, "sv", (ftnlen)2, (
 				    ftnlen)2) == 0) {
@@ -2062,8 +2051,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cztrsv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					    aa[1], &lda, &xx[1], &incx);
 				} else if (banded) {
 				    if (*trace) {
 /*
@@ -2077,8 +2065,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cztbsv_(iorder, uplo, trans, diag, &n, &k,
-					     &aa[1], &lda, &xx[1], &incx, (
-					    ftnlen)1, (ftnlen)1, (ftnlen)1);
+					     &aa[1], &lda, &xx[1], &incx);
 				} else if (packed) {
 				    if (*trace) {
 /*
@@ -2092,8 +2079,7 @@ L130:
 					f_rew(&al__1);*/
 				    }
 				    cztpsv_(iorder, uplo, trans, diag, &n, &
-					    aa[1], &xx[1], &incx, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    aa[1], &xx[1], &incx);
 				}
 			    }

@@ -2644,11 +2630,11 @@ L150:
    static logical isame[13];
    extern /* Subroutine */ int zmake_(char*, char*, char*, integer*, integer*, doublecomplex*, integer*, doublecomplex*, integer*, integer*, integer*, logical*, doublecomplex*, ftnlen, ftnlen, ftnlen);
    static integer nargs;
-    extern /* Subroutine */ void czher_(integer*, char*, integer*, doublereal*, doublecomplex*, integer*, doublecomplex*, integer*, ftnlen);
+    extern /* Subroutine */ void czher_(integer*, char*, integer*, doublereal*, doublecomplex*, integer*, doublecomplex*, integer*);
    static logical reset;
    static char cuplo[14];
    static integer incxs;
-    extern /* Subroutine */ void czhpr_(integer*, char*, integer*, doublereal*, doublecomplex*, integer*, doublecomplex*, ftnlen);
+    extern /* Subroutine */ void czhpr_(integer*, char*, integer*, doublereal*, doublecomplex*, integer*, doublecomplex*);
    extern /* Subroutine */ int zmvch_(char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, doublereal*, doublecomplex*, doublereal*, doublereal*, logical*, integer*, logical*, ftnlen);
    static logical upper;
    static char uplos[1];
@@ -2817,8 +2803,7 @@ L150:
 			    al__1.aunit = *ntra;
 			    f_rew(&al__1);*/
 			}
-			czher_(iorder, uplo, &n, &ralpha, &xx[1], &incx, &aa[
-				1], &lda, (ftnlen)1);
+			czher_(iorder, uplo, &n, &ralpha, &xx[1], &incx, &aa[1], &lda);
 		    } else if (packed) {
 			if (*trace) {
 /*
@@ -2831,8 +2816,7 @@ L150:
 			    al__1.aunit = *ntra;
 			    f_rew(&al__1);*/
 			}
-			czhpr_(iorder, uplo, &n, &ralpha, &xx[1], &incx, &aa[
-				1], (ftnlen)1);
+			czhpr_(iorder, uplo, &n, &ralpha, &xx[1], &incx, &aa[1]);
 		    }

 /*                 Check if error-exit was taken incorrectly. */
@@ -3011,8 +2995,8 @@ L130:
    extern /* Subroutine */ int zmvch_(char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, doublereal*, doublecomplex*, doublereal*, doublereal*, logical*, integer*, logical*, ftnlen);
    static logical upper;
    static char uplos[1];
-    extern /* Subroutine */ void czher2_(integer*, char*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, integer*, ftnlen);
-    extern /* Subroutine */ void czhpr2_(integer*, char*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, ftnlen);
+    extern /* Subroutine */ void czher2_(integer*, char*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, integer*);
+    extern /* Subroutine */ void czhpr2_(integer*, char*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*);
    static integer ia, ja, ic, nc, jj, lj, in;
    static logical packed;
    static integer ix, iy, ns, lx, ly;
@@ -3208,7 +3192,7 @@ L130:
 				f_rew(&al__1);*/
 			    }
 			    czher2_(iorder, uplo, &n, &alpha, &xx[1], &incx, &
-				    yy[1], &incy, &aa[1], &lda, (ftnlen)1);
+				    yy[1], &incy, &aa[1], &lda);
 			} else if (packed) {
 			    if (*trace) {
 /*
@@ -3222,7 +3206,7 @@ L130:
 				f_rew(&al__1);*/
 			    }
 			    czhpr2_(iorder, uplo, &n, &alpha, &xx[1], &incx, &
-				    yy[1], &incy, &aa[1], (ftnlen)1);
+				    yy[1], &incy, &aa[1]);
 			}

 /*                    Check if error-exit was taken incorrectly. */
@@ -25,11 +25,9 @@ typedef struct { doublereal r, i; } doublecomplex;
 static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
 static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
 #else
-static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
 static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
 static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
 #endif
-#define pCf(z) (*_pCf(z))
 #define pCd(z) (*_pCd(z))
 typedef int logical;
 typedef short int shortlogical;
@@ -314,7 +312,7 @@ static logical c_false = FALSE_;
    static logical rorder;
    static integer layout;
    static logical ltestt, tsterr;
-    extern /* Subroutine */ int cz3chke_(char*, ftnlen);
+    extern /* Subroutine */ void cz3chke_(char*);
    static doublecomplex alf[7], bet[7];
    static doublereal eps, err;
    extern logical lze_(doublecomplex*, doublecomplex*, integer*);
@@ -679,7 +677,7 @@ L80:
 		    ftnlen)12);
 /*           Test error exits. */
 	    if (tsterr) {
-		cz3chke_(snames[isnum - 1], (ftnlen)12);
+		cz3chke_(snames[isnum - 1]);
 	    }
 /*           Test computations. */
 	    infoc_1.infot = 0;
@@ -831,7 +829,7 @@ L230:
    static integer ia, ib;
    extern /* Subroutine */ int zprcn1_(integer*, integer*, char*, integer*, char*, char*, integer*, integer*, integer*, doublecomplex*, integer*, integer*, doublecomplex*, integer*, ftnlen, ftnlen, ftnlen);
    static integer ma, mb, na, nb, nc, ik, im, in, ks, ms, ns;
-    extern /* Subroutine */ void czgemm_(integer*, char*, char*, integer*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void czgemm_(integer*, char*, char*, integer*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*);
    static char tranas[1], tranbs[1], transa[1], transb[1];
    static doublereal errmax;
    extern logical lzeres_(char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
@@ -1047,8 +1045,7 @@ L230:
 				}
 				czgemm_(iorder, transa, transb, &m, &n, &k, &
 					alpha, &aa[1], &lda, &bb[1], &ldb, &
-					beta, &cc[1], &ldc, (ftnlen)1, (
-					ftnlen)1);
+					beta, &cc[1], &ldc);

 /*                          Check if error-exit was taken incorrectly. */

@@ -1242,10 +1239,10 @@ return 0;
    static integer ia, ib;
    extern /* Subroutine */ int zprcn2_(integer*, integer*, char*, integer*, char*, char*, integer*, integer*, doublecomplex*, integer*, integer*, doublecomplex*, integer*, ftnlen, ftnlen, ftnlen);
    static integer na, nc, im, in, ms, ns;
-    extern /* Subroutine */ void czhemm_(integer*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void czhemm_(integer*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*);
    static doublereal errmax;
    extern logical lzeres_(char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void czsymm_(integer*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void czsymm_(integer*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*);
    static integer laa, lbb, lda, lcc, ldb, ldc, ics;
    static doublecomplex als, bls;
    static integer icu;
@@ -1438,11 +1435,11 @@ return 0;
 			    if (isconj) {
 				czhemm_(iorder, side, uplo, &m, &n, &alpha, &
 					aa[1], &lda, &bb[1], &ldb, &beta, &cc[
-					1], &ldc, (ftnlen)1, (ftnlen)1);
+					1], &ldc);
 			    } else {
 				czsymm_(iorder, side, uplo, &m, &n, &alpha, &
 					aa[1], &lda, &bb[1], &ldb, &beta, &cc[
-					1], &ldc, (ftnlen)1, (ftnlen)1);
+					1], &ldc);
 			    }

 /*                       Check if error-exit was taken incorrectly. */
@@ -1641,8 +1638,8 @@ return 0;
    static char tranas[1], transa[1];
    static doublereal errmax;
    extern logical lzeres_(char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
-    extern /* Subroutine */ void cztrmm_(integer*, char*, char*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, ftnlen, ftnlen, ftnlen, ftnlen);
-    extern /* Subroutine */ void cztrsm_(integer*, char*, char*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, ftnlen, ftnlen, ftnlen, ftnlen);
+    extern /* Subroutine */ void cztrmm_(integer*, char*, char*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*);
+    extern /* Subroutine */ void cztrsm_(integer*, char*, char*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*);
    static integer laa, icd, lbb, lda, ldb, ics;
    static doublecomplex als;
    static integer ict, icu;
@@ -1828,8 +1825,7 @@ return 0;
 				    }
 				    cztrmm_(iorder, side, uplo, transa, diag, 
 					    &m, &n, &alpha, &aa[1], &lda, &bb[
-					    1], &ldb, (ftnlen)1, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    1], &ldb);
 				} else if (s_cmp(sname + 9, "sm", (ftnlen)2, (
 					ftnlen)2) == 0) {
 				    if (*trace) {
@@ -1846,8 +1842,7 @@ return 0;
 				    }
 				    cztrsm_(iorder, side, uplo, transa, diag, 
 					    &m, &n, &alpha, &aa[1], &lda, &bb[
-					    1], &ldb, (ftnlen)1, (ftnlen)1, (
-					    ftnlen)1, (ftnlen)1);
+					    1], &ldb);
 				}

 /*                          Check if error-exit was taken incorrectly. */
@@ -2119,11 +2114,11 @@ return 0;
    extern /* Subroutine */ int zprcn6_(integer*, integer*, char*, integer*, char*, char*, integer*, integer*, doublereal*, integer*, doublereal*, integer*, ftnlen, ftnlen, ftnlen);
    static integer ik, in, jj, lj, ks, ns;
    static doublereal ralpha;
-    extern /* Subroutine */ int czherk_(integer*, char*, char*, integer*, integer*, doublereal*, doublecomplex*, integer*, doublereal*, doublecomplex*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void czherk_(integer*, char*, char*, integer*, integer*, doublereal*, doublecomplex*, integer*, doublereal*, doublecomplex*, integer*);
    static doublereal errmax;
    extern logical lzeres_(char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
    static char transs[1], transt[1];
-    extern /* Subroutine */ int czsyrk_(integer*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void czsyrk_(integer*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*);
    static integer laa, lda, lcc, ldc;
    static doublecomplex als;
    static integer ict, icu;
@@ -2319,8 +2314,7 @@ return 0;
 				    f_rew(&al__1);*/
 				}
 				czherk_(iorder, uplo, trans, &n, &k, &ralpha, 
-					&aa[1], &lda, &rbeta, &cc[1], &ldc, (
-					ftnlen)1, (ftnlen)1);
+					&aa[1], &lda, &rbeta, &cc[1], &ldc);
 			    } else {
 				if (*trace) {
 				    zprcn4_(ntra, &nc, sname, iorder, uplo, 
@@ -2334,8 +2328,7 @@ return 0;
 				    f_rew(&al__1);*/
 				}
 				czsyrk_(iorder, uplo, trans, &n, &k, &alpha, &
-					aa[1], &lda, &beta, &cc[1], &ldc, (
-					ftnlen)1, (ftnlen)1);
+					aa[1], &lda, &beta, &cc[1], &ldc);
 			    }

 /*                       Check if error-exit was taken incorrectly. */
@@ -2615,11 +2608,11 @@ return 0;
    static doublereal errmax;
    extern logical lzeres_(char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
    static char transs[1], transt[1];
-    extern /* Subroutine */ int czher2k_(integer*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublereal*, doublecomplex*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void czher2k_(integer*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublereal*, doublecomplex*, integer*);
    static integer laa, lbb, lda, lcc, ldb, ldc;
    static doublecomplex als;
    static integer ict, icu;
-    extern /* Subroutine */ int czsyr2k_(integer*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*, ftnlen, ftnlen);
+    extern /* Subroutine */ void czsyr2k_(integer*, char*, char*, integer*, integer*, doublecomplex*, doublecomplex*, integer*, doublecomplex*, integer*, doublecomplex*, doublecomplex*, integer*);
    static doublereal err;
    extern logical lze_(doublecomplex*, doublecomplex*, integer*);

@@ -2830,7 +2823,7 @@ return 0;
 				}
 				czher2k_(iorder, uplo, trans, &n, &k, &alpha, 
 					&aa[1], &lda, &bb[1], &ldb, &rbeta, &
-					cc[1], &ldc, (ftnlen)1, (ftnlen)1);
+					cc[1], &ldc);
 			    } else {
 				if (*trace) {
 				    zprcn5_(ntra, &nc, sname, iorder, uplo, 
@@ -2845,7 +2838,7 @@ return 0;
 				}
 				czsyr2k_(iorder, uplo, trans, &n, &k, &alpha, 
 					&aa[1], &lda, &bb[1], &ldb, &beta, &
-					cc[1], &ldc, (ftnlen)1, (ftnlen)1);
+					cc[1], &ldc);
 			    }

 /*                       Check if error-exit was taken incorrectly. */
@@ -98,7 +98,7 @@ though - please read the linked Makefiles if you want to see all variables.
 - `BUILD_DOUBLE`: build the double-precision real functions
 - `BUILD_COMPLEX`: build the single-precision complex functions
 - `BUILD_COMPLEX16`: build the double-precision complex functions
- `BUILD_BFLOAT16`: build the "half precision brainfloat" real functions 
+- `BUILD_BFLOAT16`: build the `bfloat16` real functions
 - `EXPRECISION`: (do not use, this is a work in progress) option to use `long
  double` functions

@@ -22,14 +22,24 @@
 | x86_64      | " |macOS11|gmake |arm64| XCode 12.4 | - | | + | - | both | Azure |  |
 | x86_64      | " |macOS11|gmake |arm | XCode 12.4 | - | | + | - | both | Azure |  |
 | x86_64      | " |Alpine Linux(musl)|gmake| - | gcc | gfortran | pthreads | + | - | both | Azure |  |
-| arm64       |Apple M1   |OSX    |CMAKE/XCode| - | LLVM   | - | OpenMP | - | - | static | Cirrus |   |
-| arm64       |Apple M1   |OSX    |CMAKE/Xcode| - | LLVM   | - | OpenMP | - | + | static | Cirrus |  |  
-| arm64       |Apple M1   |OSX    |CMAKE/XCode|x86_64| LLVM| - | - | + | - | static | Cirrus |   |
-| arm64       |Neoverse N1|Linux  |gmake      | -    |gcc10.2| -| pthreads| - | - | both   | Cirrus |   |
-| arm64       |Neoverse N1|Linux  |gmake      | -    |gcc10.2| -| pthreads| - | + | both   | Cirrus |  |
-| arm64       |Neoverse N1|Linux  |gmake      |-     |gcc10.2| -| OpenMP | - | - | both   |Cirrus | 8 |
-| x86_64      | Ryzen|   FreeBSD  |gmake      | - | gcc12.2|gfortran| pthreads| - | - | both | Cirrus | |
-| x86_64      | Ryzen|   FreeBSD  |gmake      |   | gcc12.2|gfortran| pthreads| - | + | both | Cirrus | |
+| arm64       |Apple M1   |macOS14|CMAKE      | - | LLVM   |gfortran| pthreads | + | - | static | Github |  |
+| arm64       |Apple M1   |macOS14|CMAKE      | - | LLVM   |gfortran| pthreads | + | + | static | Github |  |
+| arm64       |Apple M1   |macOS14|CMAKE      | - | LLVM   |gfortran| OpenMP | + | - | static | Github |  |
+| arm64       |Apple M1   |macOS14|CMAKE      | - | LLVM   |gfortran| OpenMP | + | + | static | Github |  |
+| arm64       |Apple M1   |macOS14|gmake      | - | LLVM   |gfortran| pthreads | + | - | both | Github |   |
+| arm64       |Apple M1   |macOS14|gmake      | - | LLVM   |gfortran| pthreads | + | + | both | Github |  |
+| arm64       |Apple M1   |macOS14|gmake      | - | LLVM   |gfortran| OpenMP | + | - | both | Github |  |
+| arm64       |Apple M1   |macOS14|gmake      | - | LLVM   |gfortran| OpenMP | + | + | both | Github |  |
+| arm64       |Apple M1   |macOS26|gmake      |x86_64| XCode| - | | + | - | both | Github |   |
+| arm64       |Apple M1   |macOS26|gmake      |arm64| XCode| - | | + | - | both | Github |   |
+| arm64       |Apple M1   |macOS26|gmake      |arm| AndroidNDK-llvm | - | | - | - | both | Github |   |
+| arm64       |Neoverse N1|Linux  |gmake      | -    |gcc|gfortran| pthreads| - | - | both   | Github |   |
+| arm64       |Neoverse N1|Linux  |gmake      | -    |gcc|gfortran| pthreads| - | + | both   | Github |  |
+| arm64       |Neoverse N1|Linux  |gmake      |-     |gcc|gfortran| OpenMP | - | - | both   | Github |  |
+| arm64       |Graviton3  |Linux  |CMAKE      | - |gcc|gfortran| pthreads| + | - | static | Github | |
+| arm64       |Graviton3  |Linux  |gmake      | - |gcc|gfortran| pthreads| + | - | both | Github | |
+| x86_64      |generic|FreeBSD  |gmake      | - | gcc15|gfortran15| pthreads| - | - | both | Github | |
+| arm64       |generic|FreeBSD  |gmake      | - | gcc15|gfortran15| pthreads| - | - | both | Github | |
 | x86_64       |GENERIC    |QEMU   |gmake| mips64 | gcc | gfortran | pthreads | - | - | static | Github |  |
 | x86_64      |SICORTEX   |QEMU   |gmake| mips64 | gcc | gfortran | pthreads | - | - | static | Github |  |
 | x86_64      |I6400      |QEMU   |gmake| mips64 | gcc | gfortran | pthreads | - | - | static | Github |  |
@@ -80,8 +80,8 @@ According to the above `KERNEL.HASWELL`, OpenBLAS Haswell dgemm kernel file is `
    ["Anatomy of High-Performance Matrix Multiplication"](http://delivery.acm.org/10.1145/1360000/1356053/a12-goto.pdf?ip=155.68.162.54&id=1356053&acc=ACTIVE%20SERVICE&key=A79D83B43E50B5B8%2EF070BBE7E45C3F17%2E4D4702B0C3E38B35%2E4D4702B0C3E38B35&__acm__=1517932837_edfe766f1e295d9a7830812371e1d173).
    ACM Transactions on Mathematical Software 34 (3): Article 12

-    (The above link is available only to ACM members, but this and many related
-    papers is also available on [the pages of van de Geijn's FLAME project](http://www.cs.utexas.edu/~flame/web/FLAMEPublications.html))
+    (The above link is available only to ACM members, but this paper and many
+    related papers are also available on [the pages of van de Geijn's FLAME project](http://www.cs.utexas.edu/~flame/web/FLAMEPublications.html))

 The `driver/level3/level3.c` is the implementation of Goto's algorithm.
 Meanwhile, you can look at `kernel/generic/gemmkernel_2x2.c`, which is a naive
@@ -4,13 +4,14 @@
    This document contains recommendations only - packagers and other
    redistributors are in charge of how OpenBLAS is built and distributed in their
    systems, and may have good reasons to deviate from the guidance given on this
-    page. These recommendations are aimed at general packaging systems, with a user
-    base that typically is large, open source (or freely available at least), and
-    doesn't behave uniformly or that the packager is directly connected with.*
+    page. These recommendations are aimed at general packaging systems that are
+    open source (or at least freely available) and typically serve a large user
+    base that does not behave uniformly and is not directly connected with the
+    packager.

 OpenBLAS has a large number of build-time options which can be used to change
 how it behaves at runtime, how artifacts or symbols are named, etc. Variation
-in build configuration can be necessary to acheive a given end goal within a
+in build configuration can be necessary to achieve a given end goal within a
 distribution or as an end user. However, such variation can also make it more
 difficult to build on top of OpenBLAS and ship code or other packages in a way
 that works across many different distros. Here we provide guidance about the
@@ -42,7 +43,7 @@ settings):
   while it does make up a significant part of the binary size of the installed
   library, that does not outweigh the regression in usability when deviating
   from the default here.[^1]
-3. Always distribute the pkg-config (`.pc`) and CMake `.cmake`) dependency
+3. Always distribute the pkg-config (`.pc`) and CMake (`.cmake`) dependency
   detection files. These files are used by build systems when users want to
   link against OpenBLAS, and there is no benefit of leaving them out.
 4. Provide the LP64 interface by default, and if in addition to that you choose
@@ -13,7 +13,8 @@ This page documents those non-standard APIs.
 | ?omatcopy     | s,d,c,z       | out-of-place transposition/copying              |
 | ?geadd        | s,d,c,z       | ATLAS-like matrix add `B = &alpha;*A+&beta;*B`  |
 | ?gemmt        | s,d,c,z       | `gemm` but only a triangular part updated       |
-
+| cblas_?gemm_batch | s,d,c,z,b | `gemm` with several groups of input data |
+| cblas_?gemm_batch_strided | s,d,c,z,b | `gemm` with groups of data stored at fixed offsets in the input arrays |

 ## bfloat16 functionality

@@ -26,6 +27,15 @@ BLAS-like and conversion functions for `bfloat16` (available when OpenBLAS was c
 * `float cblas_sbdot` computes the dot product of two bfloat16 arrays
 * `void cblas_sbgemv` performs the matrix-vector operations of GEMV with the input matrix and X vector as bfloat16
 * `void cblas_sbgemm` performs the matrix-matrix operations of GEMM with both input arrays containing bfloat16
+* `void cblas_bgemv` performs the matrix-vector operations of GEMV with the input matrix, X vector and result as bfloat16
+* `void cblas_bgemm` performs the matrix-matrix operations of GEMM with both input arrays containing bfloat16 and the output being bfloat16 as well
+
+## half-precision float or fp16 functionality
+
+BLAS-like and conversion functions for `hfloat16` (available when OpenBLAS was compiled with `BUILD_HFLOAT16=1`):
+
+* `void cblas_shgemm` performs the matrix-matrix operations of GEMM with both input arrays containing hfloat16
+

 ## Utility functions

@@ -36,4 +46,4 @@ BLAS-like and conversion functions for `bfloat16` (available when OpenBLAS was c
 * `char * openblas_get_config()` returns the options OpenBLAS was built with, something like `NO_LAPACKE DYNAMIC_ARCH NO_AFFINITY Haswell`
 * `int openblas_set_affinity(int thread_index, size_t cpusetsize, cpu_set_t *cpuset)` sets the CPU affinity mask of the given thread
  to the provided cpuset. Only available on Linux, with semantics identical to `pthread_setaffinity_np`.
-
+* `openblas_set_thread_callback_function` overrides the default multithreading backend with the provided argument
@@ -47,7 +47,8 @@ You can find the full list of modifications in Changelog.txt.
 The detailed explanation is probably in the original publication authored by Kazushige Goto - Goto, Kazushige; van de Geijn, Robert A; Anatomy of high-performance matrix multiplication. ACM Transactions on Mathematical Software (TOMS). Volume 34 Issue 3, May 2008
 While this article is paywalled and too old for preprints to be available on arxiv.org, more recent
 publications like https://arxiv.org/pdf/1609.00076 contain at least a brief description of the algorithm.
-In practice, the values are derived by experimentation to yield the block sizes that give the highest performance. A general rule of thumb for selecting a starting point seems to be that PxQ is about half the size of L2 cache.
+In practice, the values are derived by experimentation to yield the block sizes that give the highest performance. A general rule of thumb for selecting a starting point seems to be that PxQ is about half the size of L2 cache. R needs to be greater than the bigger of P and Q by
+at least 64, or bad things will happen with the work splitting in (at least) POTRF.

 ### <a name="reportbug"></a>How can I report a bug?

@@ -109,7 +110,7 @@ Zaheer has fixed this bug. You can now use the structure instead of C99 complex

 ### <a name="Linux_SEGFAULT"></a>I get a SEGFAULT with multi-threading on Linux. What's wrong?

-This may be related to a bug in the Linux kernel 2.6.32 (?). Try applying the patch segaults.patch to disable mbind using
+This may be related to a bug in the Linux kernel 2.6.32 (?). Try applying the patch segfaults.patch to disable mbind using

     patch < segfaults.patch

@@ -212,7 +213,7 @@ AVX-512 (SKYLAKEX) support requires devtoolset-8-gcc-gfortran (which exceeds for

 ### <a name="qemu"></a>Building OpenBLAS in QEMU/KVM/XEN

-By default, QEMU reports the CPU as "QEMU Virtual CPU version 2.2.0", which shares CPUID with existing 32bit CPU even in 64bit virtual machine, and OpenBLAS recognizes it as PENTIUM2. Depending on the exact combination of CPU features the hypervisor choses to expose, this may not correspond to any CPU that exists, and OpenBLAS will error when trying to build. To fix this, pass `-cpu host` or `-cpu passthough` to QEMU, or another CPU model.
+By default, QEMU reports the CPU as "QEMU Virtual CPU version 2.2.0", which shares CPUID with existing 32bit CPU even in 64bit virtual machine, and OpenBLAS recognizes it as PENTIUM2. Depending on the exact combination of CPU features the hypervisor chooses to expose, this may not correspond to any CPU that exists, and OpenBLAS will error when trying to build. To fix this, pass `-cpu host` to QEMU, or choose another CPU model.
 Similarly, the XEN hypervisor may not pass through all features of the host cpu while reporting the cpu type itself correctly, which can
 lead to compiler error messages about an "ABI change" when compiling AVX512 code. Again changing the Xen configuration by running e.g. 
 "xen-cmdline --set-xen cpuid=avx512" should get around this (as would building OpenBLAS for an older cpu lacking that particular feature, e.g. TARGET=HASWELL)
@@ -289,7 +290,7 @@ There have been a few reports of wrong calculation results and build-time test f

 ### <a name="allocmorebuffers"></a>Program is Terminated. Because you tried to allocate too many memory regions

-In OpenBLAS, we mange a pool of memory buffers and allocate the number of buffers as the following.
+In OpenBLAS, we manage a pool of memory buffers and set the number of buffers as follows.
 ```
 #define NUM_BUFFERS (MAX_CPU_NUMBER * 2)
 ```
@@ -300,7 +301,7 @@ In `Makefile.system`, we will set `MAX_CPU_NUMBER=NUM_THREADS`.

 ### <a name="choose_target_dynamic"></a>How to choose TARGET manually at runtime when compiled with DYNAMIC_ARCH

-The environment variable which control the kernel selection is `OPENBLAS_CORETYPE` (see `driver/others/dynamic.c`)
+The environment variable that controls the kernel selection is `OPENBLAS_CORETYPE` (see `driver/others/dynamic.c`)
 e.g. `export OPENBLAS_CORETYPE=Haswell`. And the function `char* openblas_get_corename()` returns the used target.

 ### <a name="missgoto"></a>After updating the installed OpenBLAS, a program complains about "undefined symbol gotoblas"
@@ -324,7 +325,7 @@ Specifying the "correct" library location with the `-L` flag (like `-L /opt/Open

 ### <a name="cudahpl"></a>I want to use OpenBLAS with CUDA in the HPL 2.3 benchmark code but it keeps looking for Intel MKL

-You need to edit file src/cuda/cuda_dgemm.c in the NVIDIA version of HPL, change the "handle2" and "handle" dlopen calls to use libopenblas.so instead of libmkl_intel_lp64.so, and add an trailing underscore in the dlsym lines for dgemm_mkl and dtrsm_mkl (like  `dgemm_mkl = (void(*)())dlsym(handle, “dgemm_”);`)
+You need to edit file src/cuda/cuda_dgemm.c in the NVIDIA version of HPL, change the "handle2" and "handle" dlopen calls to use libopenblas.so instead of libmkl_intel_lp64.so, and add a trailing underscore in the dlsym lines for dgemm_mkl and dtrsm_mkl (like  `dgemm_mkl = (void(*)())dlsym(handle, "dgemm_");`)

 ### <a name="cpusoffline"></a>Multithreaded OpenBLAS runs no faster or is even slower than singlethreaded on my ARMV7 board

@@ -344,7 +345,12 @@ Multithreading support in OpenBLAS requires the use of internal buffers for shar
 If you get a message "error while loading shared libraries: libopenblas.so.0: ELF load command address/offset not properly aligned" when starting a program that is (dynamically) linked to OpenBLAS, this is very likely due to a bug in the GNU linker (ld) that is part of the
 GNU binutils package. This error was specifically observed on older versions of Ubuntu Linux updated with the (at the time) most recent binutils version 2.38, but an internet search turned up sporadic reports involving various other libraries dating back several years. A bugfix was created by the binutils developers and should be available in later versions of binutils.(See issue 3708 for details)

-#### <a name="OpenMP"></a>Using OpenBLAS with OpenMP
+### <a name="CallingConvention"></a>The tests work fine, but calling any complex function from my code produces wrong or no results
+
+This is almost certainly a problem with the calling convention used, in particular with the way the computed result is transported back to the caller. By default, OpenBLAS follows the F2C convention of returning the result on the stack rather than as the first argument to the function. So if your code has a prototype like "void cdotu ( complex *res, int n,...)" change it to "complex cdotu (int n,...)". Better yet,
+use the CBLAS interface rather than the Fortran one.
+
+### <a name="OpenMP"></a>Using OpenBLAS with OpenMP

 OpenMP provides its own locking mechanisms, so when your code makes BLAS/LAPACK calls from inside OpenMP parallel regions it is imperative
 that you use an OpenBLAS that is built with USE_OPENMP=1, as otherwise deadlocks might occur. Furthermore, OpenBLAS will automatically restrict itself to using only a single thread when called from an OpenMP parallel region. When it is certain that calls will only occur
@@ -120,8 +120,8 @@ Distro-specific installation commands:
 === "OpenBLAS releases"

    Windows is the only platform for which binaries are made available by the
-    OpenBLAS project itself. They can be downloaded from the GitHub
-    Releases](https://github.com/OpenMathLib/OpenBLAS/releases) page. These
+    OpenBLAS project itself. They can be downloaded from the
+    [GitHub Releases](https://github.com/OpenMathLib/OpenBLAS/releases) page. These
    binaries are built with MinGW, using the following build options:
    ```
    NUM_THREADS=64 TARGET=GENERIC DYNAMIC_ARCH=1 DYNAMIC_OLDER=1 CONSISTENT_FPCSR=1 INTERFACE=0
@@ -215,10 +215,13 @@ in this section, since the process for each is quite different.
 #### Visual Studio & native Windows ABI

 For Visual Studio, you can use CMake to generate Visual Studio solution files;
-note that you will need at least CMake 3.11 for linking to work correctly).
+note that you will need at least CMake 3.11 for linking to work correctly.

-Note that you need a Fortran compiler if you plan to build and use the LAPACK
-functions included with OpenBLAS. The sections below describe using either
+Note that you need a Fortran compiler if you plan to build and use the latest version 
+of the LAPACK functions included with OpenBLAS. (If you do not have a Fortran compiler
+installed, you can build an older version of the LAPACK sources that has been converted
+to C - but its performance will likely be slower and accuracy may be poorer too.) 
+The sections below describe using either
 `flang` as an add-on to clang/LLVM or `gfortran` as part of MinGW for this
 purpose. If you want to use the Intel Fortran compiler (`ifort` or `ifx`) for
 this, be sure to also use the Intel C compiler (`icc` or `icx`) for building
@@ -226,21 +229,22 @@ the C parts, as the ABI imposed by `ifort` is incompatible with MSVC

 A fully-optimized OpenBLAS that can be statically or dynamically linked to your
 application can currently be built for the 64-bit architecture with the LLVM
-compiler infrastructure. We're going to use [Miniconda3](https://docs.anaconda.com/miniconda/)
+compiler infrastructure. We're going to use [Miniforge3](https://github.com/conda-forge/miniforge), the pre-configured
+and more versatile alternative to [Miniconda](https://docs.anaconda.com/miniconda/)
 to grab all of the tools we need, since some of them are in an experimental
 status. Before you begin, you'll need to have Microsoft Visual Studio 2015 or
 newer installed.

-1. Install Miniconda3 for 64-bit Windows using `winget install --id Anaconda.Miniconda3`,
-   or easily download from [conda.io](https://docs.conda.io/en/latest/miniconda.html).
-2. Open the "Anaconda Command Prompt" now available in the Start Menu, or at `%USERPROFILE%\miniconda3\shell\condabin\conda-hook.ps1`.
+1. Install Miniforge for 64-bit Windows with the latest version of the installer Miniforge3-Windows-x86_64.exe
+   available on [github.com](https://github.com/conda-forge/miniforge/releases/)
+2. Open the "Miniforge Command Prompt" now available in the Start Menu, or at `%USERPROFILE%\miniforge3\shell\condabin\conda-hook.ps1`.
 3. In that command prompt window, use `cd` to change to the directory where you want to build OpenBLAS.
 4. Now install all of the tools we need:
   ```
   conda update -n base conda
-   conda config --add channels conda-forge
-   conda install -y cmake flang clangdev perl libflang ninja
+   conda install -y cmake flang_win-64 clangdev perl libflang ninja
   ```
+   (if you want to build with OpenMP support, add `llvm-openmp` and `llvm-openmp-fortran`)
 5.  Still in the Anaconda Command Prompt window, activate the 64-bit MSVC environment with `vcvarsall x64`.
    On Windows 11 with Visual Studio 2022, this would be done by invoking:
    
@@ -389,7 +393,7 @@ OpenBLAS can be built targeting [Universal Windows Platform](https://en.wikipedi
 To build OpenBLAS on Windows with MinGW:

 1.  Install the MinGW (GCC) compiler suite, either the 32-bit
-    [MinGW]((http://www.mingw.org/) or the 64-bit
+    [MinGW](http://www.mingw.org/) or the 64-bit
    [MinGW-w64](http://mingw-w64.sourceforge.net/) toolchain. Be sure to install
    its `gfortran` package as well (unless you really want to build the BLAS part
    of OpenBLAS only) and check that `gcc` and `gfortran` are the same version.
@@ -439,13 +443,17 @@ To then use the built OpenBLAS shared library in Visual Studio:

 ### Windows on Arm

+If you want to use a regular x64 Windows build of OpenBLAS with x64 software in the Prism emulator, be sure to use the latest version of Prism, and to check the box
+to "Disable floating point optimization" in the Emulation settings. (Right-click on the executable to open "Properties", then on the "Compatibility" tab click on
+"Change emulation settings").
+
 A fully functional native OpenBLAS for WoA that can be built as both a static and dynamic library using LLVM toolchain and Visual Studio 2022. Before starting to build, make sure that you have installed Visual Studio 2022 on your ARM device, including the "Desktop Development with C++" component (that contains the cmake tool).
 (Note that you can use the free "Visual Studio 2022 Community Edition" for this task. In principle it would be possible to build with VisualStudio alone, but using
 the LLVM toolchain enables native compilation of the Fortran sources of LAPACK and of all the optimized assembly files, which VisualStudio cannot handle on its own)

 1. Clone OpenBLAS to your local machine and checkout to latest release of
   OpenBLAS (unless you want to build the latest development snapshot - here we
-   are using  the 0.3.28 release as the example, of course this exact version
+   are using the 0.3.28 release as the example, of course this exact version
   may be outdated by the time you read this)
  
       ```cmd
@@ -561,7 +569,7 @@ The next two sections below describe how to build with Clang for ARMV7 and
 ARMV8 targets, respectively. The same basic principles as described below for
 ARMV8 should also apply to building an x86 or x86-64 version (substitute
 something like `NEHALEM` for the target instead of `ARMV8`, and replace all the
-`aarch64` in the toolchain paths with `x86` or `x96_64` as appropriate).
+`aarch64` in the toolchain paths with `x86` or `x86_64` as appropriate).

 !!! info "Historic note"

@@ -636,14 +644,16 @@ If you prefer building with CMake, running
 cmake -DANDROID_ABI=arm64-v8a -DTARGET=ARMV8 -DCMAKE_TOOLCHAIN_FILE=/opt/android-ndk-r27/build/cmake/android.toolchain.cmake -DNOFORTRAN=1 -DANDROID_PLATFORM=android-23 ..
 cmake --build .
 ```
-in your build directory should work (be sure to adjust the toolchain_file argument according to where you installed the NDK, and the ANDROID_PLATFORM
-according to the minimum version of Android you want to support. (If you leave out the ANDROID_PLATFORM parameter, the build will fail with an error 
-message about a missing declaration or missing header file complex.h)
+in your build directory should work. Be sure to adjust the toolchain file
+argument according to where you installed the NDK, and `ANDROID_PLATFORM`
+according to the minimum version of Android you want to support. If you leave
+out the `ANDROID_PLATFORM` parameter, the build will fail with an error message
+about a missing declaration or missing header file `complex.h`.

-??? note "Alternative build script for 3 architectures"
+??? note "Alternative build script for 4 Android ABIs"

-    This script will build OpenBLAS for 3 architecture (`ARMV7`, `ARMV8`,
-    `X86`) and install them to `/opt/OpenBLAS/lib`. Of course you can also copy
+    This script will build OpenBLAS for 4 Android ABIs (`armeabi-v7a`, `arm64-v8a`,
+    `x86`, `x86_64`) and install them to `/opt/OpenBLAS/lib`. Of course you can also copy
    only the section that is of interest to you - also notice that the `AR=`
    line may need adapting to the name of the ar tool provided in your
    `$TOOLCHAIN/bin` - for example `llvm-ar` in some recent NDK versions.
@@ -702,19 +712,19 @@ message about a missing declaration or missing header file complex.h)

 ### iPhone/iOS

-As none of the current developers uses iOS, the following instructions are what
+As few of the current developers use iOS, the following instructions are what
 was found to work in our Azure CI setup, but as far as we know this builds a
 fully working OpenBLAS for this platform.

 Go to the directory where you unpacked OpenBLAS,and enter the following commands:
 ```bash
-CC=/Applications/Xcode_12.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
+CC="$(xcrun --sdk iphoneos --find clang)"
+SDKROOT="$(xcrun --sdk iphoneos --show-sdk-path)"

-CFLAGS= -O2 -Wno-macro-redefined -isysroot /Applications/Xcode_12.4.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS14.4.sdk -arch arm64 -miphoneos-version-min=10.0
-
-make TARGET=ARMV8 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1
+make TARGET=ARMV8 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1 \
+  CC="${CC}" CFLAGS="-O2 -Wno-macro-redefined -isysroot ${SDKROOT} -arch arm64 -miphoneos-version-min=10.0"
 ```
-Adjust `MIN_IOS_VERSION` as necessary for your installation. E.g., change the version number
+Adjust `-miphoneos-version-min` as necessary for your installation. E.g., change the version number
 to the minimum iOS version you want to target and execute this file to build the library.

 ### HarmonyOS
@@ -725,14 +735,14 @@ toolchain has been tested so far, but the following instructions may apply
 similarly to Windows:

 Download [this HarmonyOS 4.1.1 SDK](https://repo.huaweicloud.com/harmonyos/os/4.1.1-Release/ohos-sdk-windows_linux-public.tar.gz),
-or whatever newer version may be available in the future). Use `tar -xvf
-ohos-sdk-windows_linux_public.tar.gz` to unpack it somewhere on your system.
+or whatever newer version may be available in the future. Use `tar -xvf
+ohos-sdk-windows_linux-public.tar.gz` to unpack it somewhere on your system.
 This will create a folder named "ohos-sdk" with subfolders "linux" and
 "windows". In the linux one you will find a ZIP archive named
 `native-linux-x64-4.1.7.8-Release.zip` - you need to unzip this where you want
 to install the cross-compiler, for example in `/opt/ohos-sdk`.

-In the directory where you unpacked OpenBLAS, create a build directory for cmake, and change into it :
+In the directory where you unpacked OpenBLAS, create a build directory for cmake, and change into it:
 ```bash
 mkdir build
 cd build
@@ -746,7 +756,7 @@ contains no Fortran compiler):
      -DCMAKE_TOOLCHAIN_FILE=/opt/ohos-sdk/linux/native/build/cmake/ohos.toolchain.cmake \
      -DOHOS_ARCH="arm64-v8a" -DTARGET=ARMV8 -DNOFORTRAN=1 ..
 ```
-Additional other OpenBLAS build options like `USE_OPENMP=1` or `DYNAMIC_ARCH=1`
+Additional OpenBLAS build options like `USE_OPENMP=1` or `DYNAMIC_ARCH=1`
 will probably work too. Finally do the build:
 ```bash
 /opt/ohos-sdk/linux/native/build-tools/cmake/bin/cmake --build .
@@ -788,6 +798,55 @@ make BINARY=32 BINARY32=1 CC=$MTI_TOOLCHAIN-gcc AR=$MTI_TOOLCHAIN-ar FC="$MTI_TO
 ```


+### RISC-V
+
+OpenBLAS supports several RISC-V targets. Target selection determines whether
+the resulting build is vectorized.
+
+#### Target selection
+
+| Target              | Vectorization                  | Use when                                                |
+| ------------------- | ------------------------------ | ------------------------------------------------------- |
+| `RISCV64_GENERIC`   | None — scalar reference path   | Non-vector cores, or as a baseline reference build      |
+| `RISCV64_ZVL128B`   | RVV 1.0, VLEN >= 128 bits      | Generic RVV-1.0 hardware with 128-bit vector registers  |
+| `RISCV64_ZVL256B`   | RVV 1.0, VLEN >= 256 bits      | Generic RVV-1.0 hardware with 256-bit vector registers  |
+| `C910V`             | RVV 0.7.1 (legacy)             | T-Head C910 (Allwinner D1, etc.)                        |
+| `x280`              | RVV 1.0, SiFive-tuned          | SiFive x280 cores                                       |
+
+As with the `GENERIC` and `ARCH_GENERIC` targets on other architectures,
+`RISCV64_GENERIC` maps all BLAS operations to the non-vectorized plain-C
+reference path. On RISC-V specifically, `Makefile.riscv64` also appends a
+scalar `-march` override for this target that takes precedence over any
+user-supplied `-march=rv64gcv` flag, so passing the V extension on the
+command line will not produce a vectorized build under this target.
+
+For RVV 1.0 vectorized builds, use `RISCV64_ZVL128B` or `RISCV64_ZVL256B`.
+These targets route all three BLAS levels including DGEMM to the
+`_rvv.c` kernel set introduced in 2022; see
+[issue #3808](https://github.com/OpenMathLib/OpenBLAS/issues/3808) for the
+design rationale and the `_vector.c` (legacy RVV 0.7) / `_rvv.c` (RVV 1.0)
+codebase separation.
+
+#### Compiler requirements for ZVL targets
+
+GCC 14 or later is required on current OpenBLAS releases when building the
+`RISCV64_ZVL128B` or `RISCV64_ZVL256B` targets. GCC 13 does not implement
+the segmented load/store intrinsics (`__riscv_vsseg*`) used by the
+`_rvv.c` kernels; under GCC 13 the build still completes and produces a
+library, but the affected routines fall back to scalar code paths.
+Functional tests will pass on the resulting library; only
+disassembly-level verification detects the regression.
+
+For a correct `RISCV64_ZVL128B` build on OpenBLAS 0.3.33,
+
+```bash
+riscv64-linux-gnu-objdump -d libopenblas*.a | \
+    grep -c 'vle64\|vfmacc\|vsetvli\|vlse64\|vfmul\|vfadd\|vfredosum'
+```
+
+returns approximately 12,000-14,000 (GCC 14: ~12,691; GCC 15: ~14,355).
+
+
 ### FreeBSD

 You will need to install the following tools from the FreeBSD ports tree:
--- a/Show More
+++ b/Show More