diff --git a/sw/riscvTests/isa/rv64uv/vadd.c b/sw/riscvTests/isa/rv64uv/vadd.c
index b2353d3c..cfe9eac0 100644
--- a/sw/riscvTests/isa/rv64uv/vadd.c
+++ b/sw/riscvTests/isa/rv64uv/vadd.c
@@ -8,182 +8,182 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vadd.vv v6, v2, v4");
-  VCMP_U8(1, v6, 2, 4, 6, 8, 10, 12, 14, 16, 2, 4, 6, 8, 10, 12, 14, 16);
-
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vadd.vv v6, v2, v4");
-  VCMP_U16(2, v6, 2, 4, 6, 8, 10, 12, 14, 16, 2, 4, 6, 8, 10, 12, 14, 16);
-
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vadd.vv v6, v2, v4");
-  VCMP_U32(3, v6, 2, 4, 6, 8, 10, 12, 14, 16, 2, 4, 6, 8, 10, 12, 14, 16);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vadd.vv v24, v8, v16");
+  VCMP_U8(1, v24, 2, 4, 6, 8, 10, 12, 14, 16, 2, 4, 6, 8, 10, 12, 14, 16);
+
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vadd.vv v24, v8, v16");
+  VCMP_U16(2, v24, 2, 4, 6, 8, 10, 12, 14, 16, 2, 4, 6, 8, 10, 12, 14, 16);
+
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vadd.vv v24, v8, v16");
+  VCMP_U32(3, v24, 2, 4, 6, 8, 10, 12, 14, 16, 2, 4, 6, 8, 10, 12, 14, 16);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vadd.vv v6, v2, v4");
-  VCMP_U64(4, v6, 2, 4, 6, 8, 10, 12, 14, 16, 2, 4, 6, 8, 10, 12, 14, 16);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vadd.vv v24, v8, v16");
+  VCMP_U64(4, v24, 2, 4, 6, 8, 10, 12, 14, 16, 2, 4, 6, 8, 10, 12, 14, 16);
 #endif
 }
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vadd.vv v6, v2, v4, v0.t");
-  VCMP_U8(5, v6, 0, 4, 0, 8, 0, 12, 0, 16, 0, 4, 0, 8, 0, 12, 0, 16);
+  VCLEAR(v24);
+  asm volatile("vadd.vv v24, v8, v16, v0.t");
+  VCMP_U8(5, v24, 0, 4, 0, 8, 0, 12, 0, 16, 0, 4, 0, 8, 0, 12, 0, 16);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vadd.vv v6, v2, v4, v0.t");
-  VCMP_U16(6, v6, 0, 4, 0, 8, 0, 12, 0, 16, 0, 4, 0, 8, 0, 12, 0, 16);
+  VCLEAR(v24);
+  asm volatile("vadd.vv v24, v8, v16, v0.t");
+  VCMP_U16(6, v24, 0, 4, 0, 8, 0, 12, 0, 16, 0, 4, 0, 8, 0, 12, 0, 16);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vadd.vv v6, v2, v4, v0.t");
-  VCMP_U32(7, v6, 0, 4, 0, 8, 0, 12, 0, 16, 0, 4, 0, 8, 0, 12, 0, 16);
+  VCLEAR(v24);
+  asm volatile("vadd.vv v24, v8, v16, v0.t");
+  VCMP_U32(7, v24, 0, 4, 0, 8, 0, 12, 0, 16, 0, 4, 0, 8, 0, 12, 0, 16);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vadd.vv v6, v2, v4, v0.t");
-  VCMP_U64(8, v6, 0, 4, 0, 8, 0, 12, 0, 16, 0, 4, 0, 8, 0, 12, 0, 16);
+  VCLEAR(v24);
+  asm volatile("vadd.vv v24, v8, v16, v0.t");
+  VCMP_U64(8, v24, 0, 4, 0, 8, 0, 12, 0, 16, 0, 4, 0, 8, 0, 12, 0, 16);
 #endif
 }
 
 void TEST_CASE3(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vadd.vi v6, v2, 5");
-  VCMP_U8(9, v6, 6, 7, 8, 9, 10, 11, 12, 13, 6, 7, 8, 9, 10, 11, 12, 13);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vadd.vi v24, v8, 5");
+  VCMP_U8(9, v24, 6, 7, 8, 9, 10, 11, 12, 13, 6, 7, 8, 9, 10, 11, 12, 13);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vadd.vi v6, v2, 5");
-  VCMP_U16(10, v6, 6, 7, 8, 9, 10, 11, 12, 13, 6, 7, 8, 9, 10, 11, 12, 13);
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vadd.vi v24, v8, 5");
+  VCMP_U16(10, v24, 6, 7, 8, 9, 10, 11, 12, 13, 6, 7, 8, 9, 10, 11, 12, 13);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vadd.vi v6, v2, 5");
-  VCMP_U32(11, v6, 6, 7, 8, 9, 10, 11, 12, 13, 6, 7, 8, 9, 10, 11, 12, 13);
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vadd.vi v24, v8, 5");
+  VCMP_U32(11, v24, 6, 7, 8, 9, 10, 11, 12, 13, 6, 7, 8, 9, 10, 11, 12, 13);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vadd.vi v6, v2, 5");
-  VCMP_U64(12, v6, 6, 7, 8, 9, 10, 11, 12, 13, 6, 7, 8, 9, 10, 11, 12, 13);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vadd.vi v24, v8, 5");
+  VCMP_U64(12, v24, 6, 7, 8, 9, 10, 11, 12, 13, 6, 7, 8, 9, 10, 11, 12, 13);
 #endif
 }
 
 void TEST_CASE4(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vadd.vi v6, v2, 5, v0.t");
-  VCMP_U8(13, v6, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
+  VCLEAR(v24);
+  asm volatile("vadd.vi v24, v8, 5, v0.t");
+  VCMP_U8(13, v24, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vadd.vi v6, v2, 5, v0.t");
-  VCMP_U16(14, v6, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
+  VCLEAR(v24);
+  asm volatile("vadd.vi v24, v8, 5, v0.t");
+  VCMP_U16(14, v24, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vadd.vi v6, v2, 5, v0.t");
-  VCMP_U32(15, v6, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
+  VCLEAR(v24);
+  asm volatile("vadd.vi v24, v8, 5, v0.t");
+  VCMP_U32(15, v24, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vadd.vi v6, v2, 5, v0.t");
-  VCMP_U64(16, v6, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
+  VCLEAR(v24);
+  asm volatile("vadd.vi v24, v8, 5, v0.t");
+  VCMP_U64(16, v24, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
 #endif
 }
 
 void TEST_CASE5(void) {
   const uint32_t scalar = 5;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 1, -2, 3, -4, 5, -6, 7, -8, 9, -10, 11, -12, 13, -14, 15, -16);
-  asm volatile("vadd.vx v6, v2, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(17, v6, 6, 3, 8, 1, 10, -1, 12, -3, 14, -5, 16, -7, 18, -9, 20, -11);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 1, -2, 3, -4, 5, -6, 7, -8, 9, -10, 11, -12, 13, -14, 15, -16);
+  asm volatile("vadd.vx v24, v8, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(17, v24, 6, 3, 8, 1, 10, -1, 12, -3, 14, -5, 16, -7, 18, -9, 20, -11);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 1, -2, 3, -4, 5, -6, 7, -8, 9, -10, 11, -12, 13, -14, 15, -16);
-  asm volatile("vadd.vx v6, v2, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(18, v6, 6, 3, 8, 1, 10, -1, 12, -3, 14, -5, 16, -7, 18, -9, 20, -11);
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 1, -2, 3, -4, 5, -6, 7, -8, 9, -10, 11, -12, 13, -14, 15, -16);
+  asm volatile("vadd.vx v24, v8, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(18, v24, 6, 3, 8, 1, 10, -1, 12, -3, 14, -5, 16, -7, 18, -9, 20, -11);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 1, -2, 3, -4, 5, -6, 7, -8, 9, -10, 11, -12, 13, -14, 15, -16);
-  asm volatile("vadd.vx v6, v2, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(19, v6, 6, 3, 8, 1, 10, -1, 12, -3, 14, -5, 16, -7, 18, -9, 20, -11);
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 1, -2, 3, -4, 5, -6, 7, -8, 9, -10, 11, -12, 13, -14, 15, -16);
+  asm volatile("vadd.vx v24, v8, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(19, v24, 6, 3, 8, 1, 10, -1, 12, -3, 14, -5, 16, -7, 18, -9, 20, -11);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 1, -2, 3, -4, 5, -6, 7, -8, 9, -10, 11, -12, 13, -14, 15, -16);
-  asm volatile("vadd.vx v6, v2, %[A]" ::[A] "r"(scalar));
-  VCMP_U64(20, v6, 6, 3, 8, 1, 10, -1, 12, -3, 14, -5, 16, -7, 18, -9, 20, -11);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 1, -2, 3, -4, 5, -6, 7, -8, 9, -10, 11, -12, 13, -14, 15, -16);
+  asm volatile("vadd.vx v24, v8, %[A]" ::[A] "r"(scalar));
+  VCMP_U64(20, v24, 6, 3, 8, 1, 10, -1, 12, -3, 14, -5, 16, -7, 18, -9, 20, -11);
 #endif
 }
 
 void TEST_CASE6(void) {
   const uint32_t scalar = 5;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vadd.vx v6, v2, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U8(21, v6, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
+  VCLEAR(v24);
+  asm volatile("vadd.vx v24, v8, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U8(21, v24, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vadd.vx v6, v2, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U16(22, v6, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
+  VCLEAR(v24);
+  asm volatile("vadd.vx v24, v8, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U16(22, v24, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vadd.vx v6, v2, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U32(23, v6, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
+  VCLEAR(v24);
+  asm volatile("vadd.vx v24, v8, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U32(23, v24, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vadd.vx v6, v2, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U64(24, v6, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
+  VCLEAR(v24);
+  asm volatile("vadd.vx v24, v8, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U64(24, v24, 0, 7, 0, 9, 0, 11, 0, 13, 0, 7, 0, 9, 0, 11, 0, 13);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vand.c b/sw/riscvTests/isa/rv64uv/vand.c
index b50a5c08..99c76169 100644
--- a/sw/riscvTests/isa/rv64uv/vand.c
+++ b/sw/riscvTests/isa/rv64uv/vand.c
@@ -8,48 +8,48 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
-  VLOAD_8(v6, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03,
+  VLOAD_8(v24, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03,
           0xf0);
-  asm volatile("vand.vv v2, v4, v6");
-  VCMP_U8(1, v2, 0xf0, 0x01, 0xf0, 0xf0, 0x01, 0xf0, 0xf0, 0x01, 0xf0, 0xf0,
+  asm volatile("vand.vv v8, v16, v24");
+  VCMP_U8(1, v8, 0xf0, 0x01, 0xf0, 0xf0, 0x01, 0xf0, 0xf0, 0x01, 0xf0, 0xf0,
           0x01, 0xf0);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
-  VLOAD_16(v6, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003,
+  VLOAD_16(v24, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003,
            0xf0f0, 0xff00, 0x0003, 0xf0f0);
-  asm volatile("vand.vv v2, v4, v6");
-  VCMP_U16(2, v2, 0xff00, 0x0001, 0xf0f0, 0xff00, 0x0001, 0xf0f0, 0xff00,
+  asm volatile("vand.vv v8, v16, v24");
+  VCMP_U16(2, v8, 0xff00, 0x0001, 0xf0f0, 0xff00, 0x0001, 0xf0f0, 0xff00,
            0x0001, 0xf0f0, 0xff00, 0x0001, 0xf0f0);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
-  VLOAD_32(v6, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000, 0x00000003,
+  VLOAD_32(v24, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000, 0x00000003,
            0xf0f0f0f0, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000,
            0x00000003, 0xf0f0f0f0);
-  asm volatile("vand.vv v2, v4, v6");
-  VCMP_U32(3, v2, 0xffff0000, 0x00000001, 0xf0f0f0f0, 0xffff0000, 0x00000001,
+  asm volatile("vand.vv v8, v16, v24");
+  VCMP_U32(3, v8, 0xffff0000, 0x00000001, 0xf0f0f0f0, 0xffff0000, 0x00000001,
            0xf0f0f0f0, 0xffff0000, 0x00000001, 0xf0f0f0f0, 0xffff0000,
            0x00000001, 0xf0f0f0f0);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
-  VLOAD_64(v6, 0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
+  VLOAD_64(v24, 0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0);
-  asm volatile("vand.vv v2, v4, v6");
-  VCMP_U64(4, v2, 0xffffffff00000000, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  asm volatile("vand.vv v8, v16, v24");
+  VCMP_U64(4, v8, 0xffffffff00000000, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
@@ -57,63 +57,63 @@ void TEST_CASE1() {
 }
 
 void TEST_CASE2() {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
-  VLOAD_8(v6, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03,
+  VLOAD_8(v24, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03,
           0xf0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef);
-  asm volatile("vand.vv v2, v4, v6, v0.t");
-  VCMP_U8(5, v2, 0xf0, 0xef, 0xf0, 0xf0, 0xef, 0xf0, 0xf0, 0xef, 0xf0, 0xf0,
+  asm volatile("vand.vv v8, v16, v24, v0.t");
+  VCMP_U8(5, v8, 0xf0, 0xef, 0xf0, 0xf0, 0xef, 0xf0, 0xf0, 0xef, 0xf0, 0xf0,
           0xef, 0xf0);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
-  VLOAD_16(v6, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003,
+  VLOAD_16(v24, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003,
            0xf0f0, 0xff00, 0x0003, 0xf0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vand.vv v2, v4, v6, v0.t");
-  VCMP_U16(6, v2, 0xff00, 0xbeef, 0xf0f0, 0xff00, 0xbeef, 0xf0f0, 0xff00,
+  asm volatile("vand.vv v8, v16, v24, v0.t");
+  VCMP_U16(6, v8, 0xff00, 0xbeef, 0xf0f0, 0xff00, 0xbeef, 0xf0f0, 0xff00,
            0xbeef, 0xf0f0, 0xff00, 0xbeef, 0xf0f0);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
-  VLOAD_32(v6, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000, 0x00000003,
+  VLOAD_32(v24, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000, 0x00000003,
            0xf0f0f0f0, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000,
            0x00000003, 0xf0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef);
-  asm volatile("vand.vv v2, v4, v6, v0.t");
-  VCMP_U32(7, v2, 0xffff0000, 0xdeadbeef, 0xf0f0f0f0, 0xffff0000, 0xdeadbeef,
+  asm volatile("vand.vv v8, v16, v24, v0.t");
+  VCMP_U32(7, v8, 0xffff0000, 0xdeadbeef, 0xf0f0f0f0, 0xffff0000, 0xdeadbeef,
            0xf0f0f0f0, 0xffff0000, 0xdeadbeef, 0xf0f0f0f0, 0xffff0000,
            0xdeadbeef, 0xf0f0f0f0);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
-  VLOAD_64(v6, 0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
+  VLOAD_64(v24, 0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef);
-  asm volatile("vand.vv v2, v4, v6, v0.t");
-  VCMP_U64(8, v2, 0xffffffff00000000, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0f0,
+  asm volatile("vand.vv v8, v16, v24, v0.t");
+  VCMP_U64(8, v8, 0xffffffff00000000, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0f0);
@@ -123,37 +123,37 @@ void TEST_CASE2() {
 void TEST_CASE3() {
   const uint32_t scalar = 0x0ff00ff0;
 
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
-  asm volatile("vand.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(9, v2, 0xf0, 0x00, 0xf0, 0xf0, 0x00, 0xf0, 0xf0, 0x00, 0xf0, 0xf0,
+  asm volatile("vand.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(9, v8, 0xf0, 0x00, 0xf0, 0xf0, 0x00, 0xf0, 0xf0, 0x00, 0xf0, 0xf0,
           0x00, 0xf0);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
-  asm volatile("vand.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(10, v2, 0x0ff0, 0x0000, 0x00f0, 0x0ff0, 0x0000, 0x00f0, 0x0ff0,
+  asm volatile("vand.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(10, v8, 0x0ff0, 0x0000, 0x00f0, 0x0ff0, 0x0000, 0x00f0, 0x0ff0,
            0x0000, 0x00f0, 0x0ff0, 0x0000, 0x00f0);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
-  asm volatile("vand.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(11, v2, 0x0ff00ff0, 0x00000000, 0x00f000f0, 0x0ff00ff0, 0x00000000,
+  asm volatile("vand.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(11, v8, 0x0ff00ff0, 0x00000000, 0x00f000f0, 0x0ff00ff0, 0x00000000,
            0x00f000f0, 0x0ff00ff0, 0x00000000, 0x00f000f0, 0x0ff00ff0,
            0x00000000, 0x00f000f0);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
-  asm volatile("vand.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U64(12, v2, 0x000000000ff00ff0, 0x0000000000000000, 0x0000000000f000f0,
+  asm volatile("vand.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U64(12, v8, 0x000000000ff00ff0, 0x0000000000000000, 0x0000000000f000f0,
            0x000000000ff00ff0, 0x0000000000000000, 0x0000000000f000f0,
            0x000000000ff00ff0, 0x0000000000000000, 0x0000000000f000f0,
            0x000000000ff00ff0, 0x0000000000000000, 0x0000000000f000f0);
@@ -163,52 +163,52 @@ void TEST_CASE3() {
 void TEST_CASE4() {
   const uint32_t scalar = 0x0ff00ff0;
 
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef);
-  asm volatile("vand.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U8(13, v2, 0xf0, 0xef, 0xf0, 0xf0, 0xef, 0xf0, 0xf0, 0xef, 0xf0, 0xf0,
+  asm volatile("vand.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U8(13, v8, 0xf0, 0xef, 0xf0, 0xf0, 0xef, 0xf0, 0xf0, 0xef, 0xf0, 0xf0,
           0xef, 0xf0);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vand.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U16(14, v2, 0x0ff0, 0xbeef, 0x00f0, 0x0ff0, 0xbeef, 0x00f0, 0x0ff0,
+  asm volatile("vand.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U16(14, v8, 0x0ff0, 0xbeef, 0x00f0, 0x0ff0, 0xbeef, 0x00f0, 0x0ff0,
            0xbeef, 0x00f0, 0x0ff0, 0xbeef, 0x00f0);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef);
-  asm volatile("vand.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U32(15, v2, 0x0ff00ff0, 0xdeadbeef, 0x00f000f0, 0x0ff00ff0, 0xdeadbeef,
+  asm volatile("vand.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U32(15, v8, 0x0ff00ff0, 0xdeadbeef, 0x00f000f0, 0x0ff00ff0, 0xdeadbeef,
            0x00f000f0, 0x0ff00ff0, 0xdeadbeef, 0x00f000f0, 0x0ff00ff0,
            0xdeadbeef, 0x00f000f0);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef);
-  asm volatile("vand.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U64(16, v2, 0x000000000ff00ff0, 0xdeadbeefdeadbeef, 0x00f000f000f000f0,
+  asm volatile("vand.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U64(16, v8, 0x000000000ff00ff0, 0xdeadbeefdeadbeef, 0x00f000f000f000f0,
            0x000000000ff00ff0, 0xdeadbeefdeadbeef, 0x00f000f000f000f0,
            0x000000000ff00ff0, 0xdeadbeefdeadbeef, 0x00f000f000f000f0,
            0x000000000ff00ff0, 0xdeadbeefdeadbeef, 0x00f000f000f000f0);
@@ -216,37 +216,37 @@ void TEST_CASE4() {
 }
 
 void TEST_CASE5() {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
-  asm volatile("vand.vi v2, v4, 15");
-  VCMP_U8(17, v2, 0x0f, 0x01, 0x00, 0x0f, 0x01, 0x00, 0x0f, 0x01, 0x00, 0x0f,
+  asm volatile("vand.vi v8, v16, 15");
+  VCMP_U8(17, v8, 0x0f, 0x01, 0x00, 0x0f, 0x01, 0x00, 0x0f, 0x01, 0x00, 0x0f,
           0x01, 0x00);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
-  asm volatile("vand.vi v2, v4, 15");
-  VCMP_U16(18, v2, 0x000f, 0x0001, 0x0000, 0x000f, 0x0001, 0x0000, 0x000f,
+  asm volatile("vand.vi v8, v16, 15");
+  VCMP_U16(18, v8, 0x000f, 0x0001, 0x0000, 0x000f, 0x0001, 0x0000, 0x000f,
            0x0001, 0x0000, 0x000f, 0x0001, 0x0000);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
-  asm volatile("vand.vi v2, v4, 15");
-  VCMP_U32(19, v2, 0x0000000f, 0x00000001, 0x00000000, 0x0000000f, 0x00000001,
+  asm volatile("vand.vi v8, v16, 15");
+  VCMP_U32(19, v8, 0x0000000f, 0x00000001, 0x00000000, 0x0000000f, 0x00000001,
            0x00000000, 0x0000000f, 0x00000001, 0x00000000, 0x0000000f,
            0x00000001, 0x00000000);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
-  asm volatile("vand.vi v2, v4, 15");
-  VCMP_U64(20, v2, 0x000000000000000f, 0x0000000000000001, 0x0000000000000000,
+  asm volatile("vand.vi v8, v16, 15");
+  VCMP_U64(20, v8, 0x000000000000000f, 0x0000000000000001, 0x0000000000000000,
            0x000000000000000f, 0x0000000000000001, 0x0000000000000000,
            0x000000000000000f, 0x0000000000000001, 0x0000000000000000,
            0x000000000000000f, 0x0000000000000001, 0x0000000000000000);
@@ -254,52 +254,52 @@ void TEST_CASE5() {
 }
 
 void TEST_CASE6() {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef);
-  asm volatile("vand.vi v2, v4, 15, v0.t");
-  VCMP_U8(21, v2, 0x0f, 0xef, 0x00, 0x0f, 0xef, 0x00, 0x0f, 0xef, 0x00, 0x0f,
+  asm volatile("vand.vi v8, v16, 15, v0.t");
+  VCMP_U8(21, v8, 0x0f, 0xef, 0x00, 0x0f, 0xef, 0x00, 0x0f, 0xef, 0x00, 0x0f,
           0xef, 0x00);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vand.vi v2, v4, 15, v0.t");
-  VCMP_U16(22, v2, 0x000f, 0xbeef, 0x0000, 0x000f, 0xbeef, 0x0000, 0x000f,
+  asm volatile("vand.vi v8, v16, 15, v0.t");
+  VCMP_U16(22, v8, 0x000f, 0xbeef, 0x0000, 0x000f, 0xbeef, 0x0000, 0x000f,
            0xbeef, 0x0000, 0x000f, 0xbeef, 0x0000);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef);
-  asm volatile("vand.vi v2, v4, 15, v0.t");
-  VCMP_U32(23, v2, 0x0000000f, 0xdeadbeef, 0x00000000, 0x0000000f, 0xdeadbeef,
+  asm volatile("vand.vi v8, v16, 15, v0.t");
+  VCMP_U32(23, v8, 0x0000000f, 0xdeadbeef, 0x00000000, 0x0000000f, 0xdeadbeef,
            0x00000000, 0x0000000f, 0xdeadbeef, 0x00000000, 0x0000000f,
            0xdeadbeef, 0x00000000);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef);
-  asm volatile("vand.vi v2, v4, 15, v0.t");
-  VCMP_U64(24, v2, 0x000000000000000f, 0xdeadbeefdeadbeef, 0x0000000000000000,
+  asm volatile("vand.vi v8, v16, 15, v0.t");
+  VCMP_U64(24, v8, 0x000000000000000f, 0xdeadbeefdeadbeef, 0x0000000000000000,
            0x000000000000000f, 0xdeadbeefdeadbeef, 0x0000000000000000,
            0x000000000000000f, 0xdeadbeefdeadbeef, 0x0000000000000000,
            0x000000000000000f, 0xdeadbeefdeadbeef, 0x0000000000000000);
diff --git a/sw/riscvTests/isa/rv64uv/vdiv.c b/sw/riscvTests/isa/rv64uv/vdiv.c
index 70d30359..03012cd9 100644
--- a/sw/riscvTests/isa/rv64uv/vdiv.c
+++ b/sw/riscvTests/isa/rv64uv/vdiv.c
@@ -8,56 +8,56 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0xcd, 0x42, 0x2c, 0xc4, 0x7a, 0x7b, 0xd1, 0x21, 0x38, 0x1d, 0x2e,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0xcd, 0x42, 0x2c, 0xc4, 0x7a, 0x7b, 0xd1, 0x21, 0x38, 0x1d, 0x2e,
           0x4f, 0xe7, 0x3d, 0x63, 0xd8);
-  VLOAD_8(v6, 0x11, 0xa1, 0x7c, 0xde, 0x02, 0x38, 0x4e, 0x03, 0x1e, 0xc6, 0x16,
+  VLOAD_8(v24, 0x11, 0xa1, 0x7c, 0xde, 0x02, 0x38, 0x4e, 0x03, 0x1e, 0xc6, 0x16,
           0xa0, 0xca, 0x83, 0x54, 0x90);
-  asm volatile("vdiv.vv v2, v4, v6");
-  VCMP_I8(1, v2, 0xfd, 0x00, 0x00, 0x01, 0x3d, 0x02, 0x00, 0x0b, 0x01, 0x00,
+  asm volatile("vdiv.vv v8, v16, v24");
+  VCMP_I8(1, v8, 0xfd, 0x00, 0x00, 0x01, 0x3d, 0x02, 0x00, 0x0b, 0x01, 0x00,
           0x02, 0x00, 0x00, 0x00, 0x01, 0x00);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x9e55, 0xf806, 0xa137, 0xa5fc, 0x38ae, 0x58c3, 0x2a66, 0x6bd7,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x9e55, 0xf806, 0xa137, 0xa5fc, 0x38ae, 0x58c3, 0x2a66, 0x6bd7,
            0x74e7, 0xa845, 0x2052, 0x6f9a, 0x6d88, 0x2861, 0xdaea, 0x2075);
-  VLOAD_16(v6, 0x5e64, 0x0a44, 0xdde5, 0x813f, 0x78b9, 0x29be, 0x28b4, 0x1b2f,
+  VLOAD_16(v24, 0x5e64, 0x0a44, 0xdde5, 0x813f, 0x78b9, 0x29be, 0x28b4, 0x1b2f,
            0xc4a3, 0x4a05, 0x5501, 0x49bb, 0xe5f8, 0xfa20, 0x4edf, 0xf892);
-  asm volatile("vdiv.vv v2, v4, v6");
-  VCMP_I16(2, v2, 0xffff, 0x0000, 0x0002, 0x0000, 0x0000, 0x0002, 0x0001,
+  asm volatile("vdiv.vv v8, v16, v24");
+  VCMP_I16(2, v8, 0xffff, 0x0000, 0x0002, 0x0000, 0x0000, 0x0002, 0x0001,
            0x0003, 0xffff, 0xffff, 0x0000, 0x0001, 0xfffc, 0xfffa, 0x0000,
            0xfffc);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xed578a38, 0xba7b1912, 0xb99934ef, 0x21a85df9, 0xb01c09f2,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xed578a38, 0xba7b1912, 0xb99934ef, 0x21a85df9, 0xb01c09f2,
            0xd0cb54fc, 0x9b617331, 0xd32cf029, 0xaea08daa, 0xd76f06e2,
            0x99b8e084, 0x9fdc6bfc, 0x3103b573, 0xaf1e96b4, 0x54fe9ea1,
            0x0ceff9c0);
-  VLOAD_32(v6, 0x0000002d, 0x0000001e, 0x0000003e, 0xffffffe0, 0x0000004b,
+  VLOAD_32(v24, 0x0000002d, 0x0000001e, 0x0000003e, 0xffffffe0, 0x0000004b,
            0x00000064, 0xffffff88, 0x0000003b, 0x00000011, 0xffffffc3,
            0xffffffa2, 0x0000004b, 0xffffffcc, 0xffffffb1, 0xffffff9d,
            0xffffffba);
-  asm volatile("vdiv.vv v2, v4, v6");
-  VCMP_I32(3, v2, 0xff95db40, 0xfdaec51b, 0xfedd4f4f, 0xfef2bd11, 0xfeef4ea4,
+  asm volatile("vdiv.vv v8, v16, v24");
+  VCMP_I32(3, v8, 0xff95db40, 0xfdaec51b, 0xfedd4f4f, 0xfef2bd11, 0xfeef4ea4,
            0xff872740, 0x00d6a792, 0xff3d81e7, 0xfb369eec, 0x00aa3ed6,
            0x01168b3a, 0xfeb7d87b, 0xff0eb2ab, 0x01061804, 0xff24374a,
            0xffd0afa2);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x7954dd7fc5e0687c, 0xfcf310f44f869aa0, 0x375fcbcf6aae0cac,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x7954dd7fc5e0687c, 0xfcf310f44f869aa0, 0x375fcbcf6aae0cac,
            0x6038c1825cfb5a72, 0x59046c6b324e7fb3, 0xbac247d729fb18e6,
            0x0cecf04984784b3f, 0x2cd8e8ea5be0c201, 0xcab2cf17c48b57cb,
            0xcb53d1b55097656d, 0xbeeb18a6fab9af8d, 0xbf94f3a0fa74670b,
            0x817c1dfb5ab3bfd7, 0x40951ef6459642d1, 0x4b5f994556f6ba42,
            0x63a8eaa417e6d29c);
-  VLOAD_64(v6, 0xffffff9bd8e00c88, 0x0000002057c200e4, 0x0000004c4c93640e,
+  VLOAD_64(v24, 0xffffff9bd8e00c88, 0x0000002057c200e4, 0x0000004c4c93640e,
            0x000000497b7bfcdd, 0x00000001feebe76a, 0xffffffb93a2c242c,
            0xffffff8523c47d2a, 0x00000019f01c4433, 0xffffffd940862ecc,
            0x00000016ac4df9c8, 0x0000001e9f15d00c, 0xffffffd0af22d791,
            0xffffff9feca249bc, 0xffffffac5eae7985, 0x0000003567fe8027,
            0x000000175355cab3);
-  asm volatile("vdiv.vv v2, v4, v6");
-  VCMP_I64(4, v2, 0xfffffffffec9dd87, 0xffffffffffe7dac0, 0x0000000000b9cad9,
+  asm volatile("vdiv.vv v8, v16, v24");
+  VCMP_I64(4, v8, 0xfffffffffec9dd87, 0xffffffffffe7dac0, 0x0000000000b9cad9,
            0x00000000014f3850, 0x000000002c9a4382, 0x0000000000fa75a9,
            0xffffffffffe51146, 0x0000000001baa14f, 0x000000000160270e,
            0xfffffffffdad470e, 0xfffffffffddfe832, 0x00000000015c87ee,
@@ -67,99 +67,99 @@ void TEST_CASE1(void) {
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0xcd, 0x42, 0x2c, 0xc4, 0x7a, 0x7b, 0xd1, 0x21, 0x38, 0x1d, 0x2e,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0xcd, 0x42, 0x2c, 0xc4, 0x7a, 0x7b, 0xd1, 0x21, 0x38, 0x1d, 0x2e,
           0x4f, 0xe7, 0x3d, 0x63, 0xd8);
-  VLOAD_8(v6, 0x11, 0xa1, 0x7c, 0xde, 0x02, 0x38, 0x4e, 0x03, 0x1e, 0xc6, 0x16,
+  VLOAD_8(v24, 0x11, 0xa1, 0x7c, 0xde, 0x02, 0x38, 0x4e, 0x03, 0x1e, 0xc6, 0x16,
           0xa0, 0xca, 0x83, 0x54, 0x90);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdiv.vv v2, v4, v6, v0.t");
-  VCMP_I8(5, v2, 0, 0x00, 0, 0x01, 0, 0x02, 0, 0x0b, 0, 0x00, 0, 0x00, 0, 0x00,
+  VCLEAR(v8);
+  asm volatile("vdiv.vv v8, v16, v24, v0.t");
+  VCMP_I8(5, v8, 0, 0x00, 0, 0x01, 0, 0x02, 0, 0x0b, 0, 0x00, 0, 0x00, 0, 0x00,
           0, 0x00);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x9e55, 0xf806, 0xa137, 0xa5fc, 0x38ae, 0x58c3, 0x2a66, 0x6bd7,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x9e55, 0xf806, 0xa137, 0xa5fc, 0x38ae, 0x58c3, 0x2a66, 0x6bd7,
            0x74e7, 0xa845, 0x2052, 0x6f9a, 0x6d88, 0x2861, 0xdaea, 0x2075);
-  VLOAD_16(v6, 0x5e64, 0x0a44, 0xdde5, 0x813f, 0x78b9, 0x29be, 0x28b4, 0x1b2f,
+  VLOAD_16(v24, 0x5e64, 0x0a44, 0xdde5, 0x813f, 0x78b9, 0x29be, 0x28b4, 0x1b2f,
            0xc4a3, 0x4a05, 0x5501, 0x49bb, 0xe5f8, 0xfa20, 0x4edf, 0xf892);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdiv.vv v2, v4, v6, v0.t");
-  VCMP_I16(6, v2, 0, 0x0000, 0, 0x0000, 0, 0x0002, 0, 0x0003, 0, 0xffff, 0,
+  VCLEAR(v8);
+  asm volatile("vdiv.vv v8, v16, v24, v0.t");
+  VCMP_I16(6, v8, 0, 0x0000, 0, 0x0000, 0, 0x0002, 0, 0x0003, 0, 0xffff, 0,
            0x0001, 0, 0xfffa, 0, 0xfffc);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xed578a38, 0xba7b1912, 0xb99934ef, 0x21a85df9, 0xb01c09f2,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xed578a38, 0xba7b1912, 0xb99934ef, 0x21a85df9, 0xb01c09f2,
            0xd0cb54fc, 0x9b617331, 0xd32cf029, 0xaea08daa, 0xd76f06e2,
            0x99b8e084, 0x9fdc6bfc, 0x3103b573, 0xaf1e96b4, 0x54fe9ea1,
            0x0ceff9c0);
-  VLOAD_32(v6, 0x0000002d, 0x0000001e, 0x0000003e, 0xffffffe0, 0x0000004b,
+  VLOAD_32(v24, 0x0000002d, 0x0000001e, 0x0000003e, 0xffffffe0, 0x0000004b,
            0x00000064, 0xffffff88, 0x0000003b, 0x00000011, 0xffffffc3,
            0xffffffa2, 0x0000004b, 0xffffffcc, 0xffffffb1, 0xffffff9d,
            0xffffffba);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdiv.vv v2, v4, v6, v0.t");
-  VCMP_I32(7, v2, 0, 0xfdaec51b, 0, 0xfef2bd11, 0, 0xff872740, 0, 0xff3d81e7, 0,
+  VCLEAR(v8);
+  asm volatile("vdiv.vv v8, v16, v24, v0.t");
+  VCMP_I32(7, v8, 0, 0xfdaec51b, 0, 0xfef2bd11, 0, 0xff872740, 0, 0xff3d81e7, 0,
            0x00aa3ed6, 0, 0xfeb7d87b, 0, 0x01061804, 0, 0xffd0afa2);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x7954dd7fc5e0687c, 0xfcf310f44f869aa0, 0x375fcbcf6aae0cac,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x7954dd7fc5e0687c, 0xfcf310f44f869aa0, 0x375fcbcf6aae0cac,
            0x6038c1825cfb5a72, 0x59046c6b324e7fb3, 0xbac247d729fb18e6,
            0x0cecf04984784b3f, 0x2cd8e8ea5be0c201, 0xcab2cf17c48b57cb,
            0xcb53d1b55097656d, 0xbeeb18a6fab9af8d, 0xbf94f3a0fa74670b,
            0x817c1dfb5ab3bfd7, 0x40951ef6459642d1, 0x4b5f994556f6ba42,
            0x63a8eaa417e6d29c);
-  VLOAD_64(v6, 0xffffff9bd8e00c88, 0x0000002057c200e4, 0x0000004c4c93640e,
+  VLOAD_64(v24, 0xffffff9bd8e00c88, 0x0000002057c200e4, 0x0000004c4c93640e,
            0x000000497b7bfcdd, 0x00000001feebe76a, 0xffffffb93a2c242c,
            0xffffff8523c47d2a, 0x00000019f01c4433, 0xffffffd940862ecc,
            0x00000016ac4df9c8, 0x0000001e9f15d00c, 0xffffffd0af22d791,
            0xffffff9feca249bc, 0xffffffac5eae7985, 0x0000003567fe8027,
            0x000000175355cab3);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdiv.vv v2, v4, v6, v0.t");
-  VCMP_I64(8, v2, 0, 0xffffffffffe7dac0, 0, 0x00000000014f3850, 0,
+  VCLEAR(v8);
+  asm volatile("vdiv.vv v8, v16, v24, v0.t");
+  VCMP_I64(8, v8, 0, 0xffffffffffe7dac0, 0, 0x00000000014f3850, 0,
            0x0000000000fa75a9, 0, 0x0000000001baa14f, 0, 0xfffffffffdad470e, 0,
            0x00000000015c87ee, 0, 0xffffffffff3a4e84, 0, 0x000000000445c6cf);
 #endif
 };
 
 void TEST_CASE3(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x14, 0xab, 0x4d, 0xcd, 0xc3, 0x7c, 0xb5, 0xf0, 0xc1, 0x90, 0x14,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x14, 0xab, 0x4d, 0xcd, 0xc3, 0x7c, 0xb5, 0xf0, 0xc1, 0x90, 0x14,
           0x59, 0x98, 0xda, 0x76, 0x84);
   int64_t scalar = 5;
-  asm volatile("vdiv.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I8(9, v2, 0x04, 0xef, 0x0f, 0xf6, 0xf4, 0x18, 0xf1, 0xfd, 0xf4, 0xea,
+  asm volatile("vdiv.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I8(9, v8, 0x04, 0xef, 0x0f, 0xf6, 0xf4, 0x18, 0xf1, 0xfd, 0xf4, 0xea,
           0x04, 0x11, 0xec, 0xf9, 0x17, 0xe8);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x19c9, 0x865a, 0x3063, 0xd5c2, 0xbe39, 0x98c7, 0x1ca7, 0x5d1e,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x19c9, 0x865a, 0x3063, 0xd5c2, 0xbe39, 0x98c7, 0x1ca7, 0x5d1e,
            0x8fdc, 0x3396, 0x9442, 0xee77, 0x7da8, 0xf200, 0xaba3, 0x4cd6);
   scalar = -538;
-  asm volatile("vdiv.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I16(10, v2, 0xfff4, 0x0039, 0xffe9, 0x0014, 0x001f, 0x0031, 0xfff3,
+  asm volatile("vdiv.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I16(10, v8, 0xfff4, 0x0039, 0xffe9, 0x0014, 0x001f, 0x0031, 0xfff3,
            0xffd4, 0x0035, 0xffe8, 0x0033, 0x0008, 0xffc5, 0x0006, 0x0028,
            0xffdc);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x49dd393c, 0xfc1d701e, 0x7670b541, 0x5ef6c28f, 0x60da5cab,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x49dd393c, 0xfc1d701e, 0x7670b541, 0x5ef6c28f, 0x60da5cab,
            0x6be56bc4, 0x6f629cde, 0xf1ab595a, 0x3d99363b, 0xb8a7840e,
            0x84071026, 0x6697d435, 0x3768cf44, 0x82f1a5a1, 0xf5d4f40e,
            0xcda97e6d);
   scalar = 649;
-  asm volatile("vdiv.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I32(11, v2, 0x001d22cc, 0xfffe77b2, 0x002eb818, 0x00257573, 0x00263435,
+  asm volatile("vdiv.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I32(11, v8, 0x001d22cc, 0xfffe77b2, 0x002eb818, 0x00257573, 0x00263435,
            0x002a8f5a, 0x002befac, 0xfffa58e4, 0x00184c36, 0xffe3db85,
            0xffcf1946, 0x002877d8, 0x0015db3d, 0xffceabd8, 0xfffbfd39,
            0xffec24e2);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
-  /*   VLOAD_64(v4, 0xeea1bad034de2c3e, 0x5acd284816152166, 0x52a24c3b98af20f9,
+  /*   VSET(16, e64, m8); */
+  /*   VLOAD_64(v16, 0xeea1bad034de2c3e, 0x5acd284816152166, 0x52a24c3b98af20f9,
    */
   /*            0x843d3c2e39d3221e, 0xda6c4bef77118459, 0x8c7e991a77cc3ddc, */
   /*            0x58f56c82eceafc72, 0xb4b1bac0a66d4984, 0x126283c905985ab8, */
@@ -167,8 +167,8 @@ void TEST_CASE3(void) {
   /*            0xde91f735ce81d174, 0x3d254eb16d0c87f4, 0xc06ebbe7936e6774, */
   /*            0xb17ccbc475c8724e); */
   /*   scalar = -59223; */
-  /*   asm volatile("vdiv.vx v2, v4, %[A]" ::[A] "r"(scalar)); */
-  /*   VCMP_I64(12, v2, 0x000013383ad25844, 0xffff9b84f9ef594c,
+  /*   asm volatile("vdiv.vx v8, v16, %[A]" ::[A] "r"(scalar)); */
+  /*   VCMP_I64(12, v8, 0x000013383ad25844, 0xffff9b84f9ef594c,
    * 0xffffa48eb726f738, */
   /*            0x000088f40e45bbd1, 0x0000299522c72a62, 0x00007fd16a16b1db, */
   /*            0xffff9d8efec5cf15, 0x000053554738ae55, 0xffffeba7c8cdd664, */
@@ -179,41 +179,41 @@ void TEST_CASE3(void) {
 };
 
 void TEST_CASE4(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x14, 0xab, 0x4d, 0xcd, 0xc3, 0x7c, 0xb5, 0xf0, 0xc1, 0x90, 0x14,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x14, 0xab, 0x4d, 0xcd, 0xc3, 0x7c, 0xb5, 0xf0, 0xc1, 0x90, 0x14,
           0x59, 0x98, 0xda, 0x76, 0x84);
   int64_t scalar = 5;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdiv.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I8(13, v2, 0, 0xef, 0, 0xf6, 0, 0x18, 0, 0xfd, 0, 0xea, 0, 0x11, 0, 0xf9,
+  VCLEAR(v8);
+  asm volatile("vdiv.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I8(13, v8, 0, 0xef, 0, 0xf6, 0, 0x18, 0, 0xfd, 0, 0xea, 0, 0x11, 0, 0xf9,
           0, 0xe8);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x19c9, 0x865a, 0x3063, 0xd5c2, 0xbe39, 0x98c7, 0x1ca7, 0x5d1e,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x19c9, 0x865a, 0x3063, 0xd5c2, 0xbe39, 0x98c7, 0x1ca7, 0x5d1e,
            0x8fdc, 0x3396, 0x9442, 0xee77, 0x7da8, 0xf200, 0xaba3, 0x4cd6);
   scalar = -538;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdiv.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I16(14, v2, 0, 0x0039, 0, 0x0014, 0, 0x0031, 0, 0xffd4, 0, 0xffe8, 0,
+  VCLEAR(v8);
+  asm volatile("vdiv.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I16(14, v8, 0, 0x0039, 0, 0x0014, 0, 0x0031, 0, 0xffd4, 0, 0xffe8, 0,
            0x0008, 0, 0x0006, 0, 0xffdc);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x49dd393c, 0xfc1d701e, 0x7670b541, 0x5ef6c28f, 0x60da5cab,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x49dd393c, 0xfc1d701e, 0x7670b541, 0x5ef6c28f, 0x60da5cab,
            0x6be56bc4, 0x6f629cde, 0xf1ab595a, 0x3d99363b, 0xb8a7840e,
            0x84071026, 0x6697d435, 0x3768cf44, 0x82f1a5a1, 0xf5d4f40e,
            0xcda97e6d);
   scalar = 649;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdiv.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I32(15, v2, 0, 0xfffe77b2, 0, 0x00257573, 0, 0x002a8f5a, 0, 0xfffa58e4,
+  VCLEAR(v8);
+  asm volatile("vdiv.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I32(15, v8, 0, 0xfffe77b2, 0, 0x00257573, 0, 0x002a8f5a, 0, 0xfffa58e4,
            0, 0xffe3db85, 0, 0x002877d8, 0, 0xffceabd8, 0, 0xffec24e2);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
-  /*   VLOAD_64(v4, 0xeea1bad034de2c3e, 0x5acd284816152166, 0x52a24c3b98af20f9,
+  /*   VSET(16, e64, m8); */
+  /*   VLOAD_64(v16, 0xeea1bad034de2c3e, 0x5acd284816152166, 0x52a24c3b98af20f9,
    */
   /*            0x843d3c2e39d3221e, 0xda6c4bef77118459, 0x8c7e991a77cc3ddc, */
   /*            0x58f56c82eceafc72, 0xb4b1bac0a66d4984, 0x126283c905985ab8, */
@@ -222,9 +222,9 @@ void TEST_CASE4(void) {
   /*            0xb17ccbc475c8724e); */
   /*   scalar = -59223; */
   /*   VLOAD_8(v0, 0xAA, 0xAA); */
-  /*   VCLEAR(v2); */
-  /*   asm volatile("vdiv.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar)); */
-  /*   VCMP_I64(16, v2, 0, 0xffff9b84f9ef594c, 0, 0x000088f40e45bbd1, 0, */
+  /*   VCLEAR(v8); */
+  /*   asm volatile("vdiv.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar)); */
+  /*   VCMP_I64(16, v8, 0, 0xffff9b84f9ef594c, 0, 0x000088f40e45bbd1, 0, */
   /*            0x00007fd16a16b1db, 0, 0x000053554738ae55, 0,
    * 0xffffbf3d66c69bdf, 0, */
   /*            0xffffface02d012e3, 0, 0xffffbc56186f1f3d, 0,
diff --git a/sw/riscvTests/isa/rv64uv/vdivu.c b/sw/riscvTests/isa/rv64uv/vdivu.c
index fb6e4429..0b6cb55b 100644
--- a/sw/riscvTests/isa/rv64uv/vdivu.c
+++ b/sw/riscvTests/isa/rv64uv/vdivu.c
@@ -8,56 +8,56 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x85, 0x1d, 0x9f, 0x31, 0x8c, 0x4c, 0x4c, 0xf2, 0x11, 0xfc, 0xc8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x85, 0x1d, 0x9f, 0x31, 0x8c, 0x4c, 0x4c, 0xf2, 0x11, 0xfc, 0xc8,
           0xab, 0xc2, 0xff, 0xf5, 0xc2);
-  VLOAD_8(v6, 0x3d, 0x06, 0x32, 0x36, 0x02, 0x0f, 0x27, 0x35, 0x1e, 0x0f, 0x36,
+  VLOAD_8(v24, 0x3d, 0x06, 0x32, 0x36, 0x02, 0x0f, 0x27, 0x35, 0x1e, 0x0f, 0x36,
           0x1c, 0x24, 0x1a, 0x22, 0x01);
-  asm volatile("vdivu.vv v2, v4, v6");
-  VCMP_I8(1, v2, 0x02, 0x04, 0x03, 0x00, 0x46, 0x05, 0x01, 0x04, 0x00, 0x10,
+  asm volatile("vdivu.vv v8, v16, v24");
+  VCMP_I8(1, v8, 0x02, 0x04, 0x03, 0x00, 0x46, 0x05, 0x01, 0x04, 0x00, 0x10,
           0x03, 0x06, 0x05, 0x09, 0x07, 0xc2);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xd200, 0xa047, 0x7af8, 0x453d, 0xd6eb, 0xfabb, 0x604a, 0xea35,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xd200, 0xa047, 0x7af8, 0x453d, 0xd6eb, 0xfabb, 0x604a, 0xea35,
            0xbc2d, 0x45e7, 0x8407, 0x3845, 0x1495, 0x8ee6, 0x7da4, 0xf34a);
-  VLOAD_16(v6, 0x03ad, 0x00b8, 0x001b, 0x0353, 0x013f, 0x008c, 0x015e, 0x01e6,
+  VLOAD_16(v24, 0x03ad, 0x00b8, 0x001b, 0x0353, 0x013f, 0x008c, 0x015e, 0x01e6,
            0x00cd, 0x0093, 0x00ba, 0x03d0, 0x0117, 0x009d, 0x007b, 0x02cf);
-  asm volatile("vdivu.vv v2, v4, v6");
-  VCMP_I16(2, v2, 0x0039, 0x00de, 0x048d, 0x0014, 0x00ac, 0x01ca, 0x0046,
+  asm volatile("vdivu.vv v8, v16, v24");
+  VCMP_I16(2, v8, 0x0039, 0x00de, 0x048d, 0x0014, 0x00ac, 0x01ca, 0x0046,
            0x007b, 0x00ea, 0x0079, 0x00b5, 0x000e, 0x0012, 0x00e9, 0x0105,
            0x0056);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xd56bd03a, 0x1036c5ff, 0xaa01847f, 0x988dc35d, 0x4d8615dc,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xd56bd03a, 0x1036c5ff, 0xaa01847f, 0x988dc35d, 0x4d8615dc,
            0xb62269e2, 0xe842ba75, 0x02fecbf9, 0xe536c712, 0xe93e2160,
            0x9ba34297, 0x554d290d, 0x319f668c, 0x0d6c2fbb, 0x6a7eb54a,
            0x3fa1cc84);
-  VLOAD_32(v6, 0x00000025, 0x00000057, 0x0000002e, 0x0000004c, 0x00000052,
+  VLOAD_32(v24, 0x00000025, 0x00000057, 0x0000002e, 0x0000004c, 0x00000052,
            0x00000021, 0x0000001d, 0x0000002f, 0x00000029, 0x00000008,
            0x00000015, 0x00000029, 0x00000048, 0x00000051, 0x0000003f,
            0x00000007);
-  asm volatile("vdivu.vv v2, v4, v6");
-  VCMP_I32(3, v2, 0x05c4a4c3, 0x002fb5c5, 0x03b21eb4, 0x0201dd84, 0x00f20682,
+  asm volatile("vdivu.vv v8, v16, v24");
+  VCMP_I32(3, v8, 0x05c4a4c3, 0x002fb5c5, 0x03b21eb4, 0x0201dd84, 0x00f20682,
            0x0584ebef, 0x08024d0c, 0x00105098, 0x05973090, 0x1d27c42c,
            0x07694c50, 0x02149d19, 0x00b06fa5, 0x002a6c0b, 0x01b0bdcc,
            0x09171d37);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0xf251717441f02108, 0x2668b5d7f073b9d1, 0x4708b49fd356a60a,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0xf251717441f02108, 0x2668b5d7f073b9d1, 0x4708b49fd356a60a,
            0x195bedcb9ce5956b, 0x41ce2b35b4280568, 0x32e5b89eed21de3b,
            0x73f17f3d0e1f243f, 0x0d0aa119af3b0e95, 0x024cbba6ba662213,
            0xf7df98f44da5e55f, 0x3cf2951aa7e4c0a9, 0x0ed8987446e84f30,
            0xd983a7a0d4c648b4, 0x60eb8249069801a5, 0x529967e8b06df477,
            0x776410b4b0cc22ad);
-  VLOAD_64(v6, 0x000000000000695b, 0x0000000000007420, 0x000000000001850c,
+  VLOAD_64(v24, 0x000000000000695b, 0x0000000000007420, 0x000000000001850c,
            0x000000000000b46f, 0x000000000000e92c, 0x0000000000024e72,
            0x0000000000032774, 0x000000000001c36f, 0x00000000000063d2,
            0x0000000000037bb4, 0x000000000003692c, 0x000000000001d60c,
            0x000000000002cf7b, 0x0000000000037899, 0x0000000000038bcf,
            0x000000000003d0e4);
-  asm volatile("vdivu.vv v2, v4, v6");
-  VCMP_I64(4, v2, 0x00024ccd25dd5faf, 0x000054ac6a930494, 0x00002ebddee9df57,
+  asm volatile("vdivu.vv v8, v16, v24");
+  VCMP_I64(4, v8, 0x00024ccd25dd5faf, 0x000054ac6a930494, 0x00002ebddee9df57,
            0x000023fac7321f85, 0x0000483f73b2e3e2, 0x000016114f5d8a9e,
            0x000024c26869df0e, 0x00000765470f410f, 0x000005e5de9b769d,
            0x0000472988fa89c3, 0x000011de6d57a394, 0x00000815e7b8df73,
@@ -67,107 +67,107 @@ void TEST_CASE1(void) {
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x85, 0x1d, 0x9f, 0x31, 0x8c, 0x4c, 0x4c, 0xf2, 0x11, 0xfc, 0xc8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x85, 0x1d, 0x9f, 0x31, 0x8c, 0x4c, 0x4c, 0xf2, 0x11, 0xfc, 0xc8,
           0xab, 0xc2, 0xff, 0xf5, 0xc2);
-  VLOAD_8(v6, 0x3d, 0x06, 0x32, 0x36, 0x02, 0x0f, 0x27, 0x35, 0x1e, 0x0f, 0x36,
+  VLOAD_8(v24, 0x3d, 0x06, 0x32, 0x36, 0x02, 0x0f, 0x27, 0x35, 0x1e, 0x0f, 0x36,
           0x1c, 0x24, 0x1a, 0x22, 0x01);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdivu.vv v2, v4, v6, v0.t");
-  VCMP_I8(5, v2, 0, 0x04, 0, 0x00, 0, 0x05, 0, 0x04, 0, 0x10, 0, 0x06, 0, 0x09,
+  VCLEAR(v8);
+  asm volatile("vdivu.vv v8, v16, v24, v0.t");
+  VCMP_I8(5, v8, 0, 0x04, 0, 0x00, 0, 0x05, 0, 0x04, 0, 0x10, 0, 0x06, 0, 0x09,
           0, 0xc2);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xd200, 0xa047, 0x7af8, 0x453d, 0xd6eb, 0xfabb, 0x604a, 0xea35,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xd200, 0xa047, 0x7af8, 0x453d, 0xd6eb, 0xfabb, 0x604a, 0xea35,
            0xbc2d, 0x45e7, 0x8407, 0x3845, 0x1495, 0x8ee6, 0x7da4, 0xf34a);
-  VLOAD_16(v6, 0x03ad, 0x00b8, 0x001b, 0x0353, 0x013f, 0x008c, 0x015e, 0x01e6,
+  VLOAD_16(v24, 0x03ad, 0x00b8, 0x001b, 0x0353, 0x013f, 0x008c, 0x015e, 0x01e6,
            0x00cd, 0x0093, 0x00ba, 0x03d0, 0x0117, 0x009d, 0x007b, 0x02cf);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdivu.vv v2, v4, v6, v0.t");
-  VCMP_I16(6, v2, 0, 0x00de, 0, 0x0014, 0, 0x01ca, 0, 0x007b, 0, 0x0079, 0,
+  VCLEAR(v8);
+  asm volatile("vdivu.vv v8, v16, v24, v0.t");
+  VCMP_I16(6, v8, 0, 0x00de, 0, 0x0014, 0, 0x01ca, 0, 0x007b, 0, 0x0079, 0,
            0x000e, 0, 0x00e9, 0, 0x0056);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xd56bd03a, 0x1036c5ff, 0xaa01847f, 0x988dc35d, 0x4d8615dc,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xd56bd03a, 0x1036c5ff, 0xaa01847f, 0x988dc35d, 0x4d8615dc,
            0xb62269e2, 0xe842ba75, 0x02fecbf9, 0xe536c712, 0xe93e2160,
            0x9ba34297, 0x554d290d, 0x319f668c, 0x0d6c2fbb, 0x6a7eb54a,
            0x3fa1cc84);
-  VLOAD_32(v6, 0x00000025, 0x00000057, 0x0000002e, 0x0000004c, 0x00000052,
+  VLOAD_32(v24, 0x00000025, 0x00000057, 0x0000002e, 0x0000004c, 0x00000052,
            0x00000021, 0x0000001d, 0x0000002f, 0x00000029, 0x00000008,
            0x00000015, 0x00000029, 0x00000048, 0x00000051, 0x0000003f,
            0x00000007);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdivu.vv v2, v4, v6, v0.t");
-  VCMP_I32(7, v2, 0, 0x002fb5c5, 0, 0x0201dd84, 0, 0x0584ebef, 0, 0x00105098, 0,
+  VCLEAR(v8);
+  asm volatile("vdivu.vv v8, v16, v24, v0.t");
+  VCMP_I32(7, v8, 0, 0x002fb5c5, 0, 0x0201dd84, 0, 0x0584ebef, 0, 0x00105098, 0,
            0x1d27c42c, 0, 0x02149d19, 0, 0x002a6c0b, 0, 0x09171d37);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0xf251717441f02108, 0x2668b5d7f073b9d1, 0x4708b49fd356a60a,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0xf251717441f02108, 0x2668b5d7f073b9d1, 0x4708b49fd356a60a,
            0x195bedcb9ce5956b, 0x41ce2b35b4280568, 0x32e5b89eed21de3b,
            0x73f17f3d0e1f243f, 0x0d0aa119af3b0e95, 0x024cbba6ba662213,
            0xf7df98f44da5e55f, 0x3cf2951aa7e4c0a9, 0x0ed8987446e84f30,
            0xd983a7a0d4c648b4, 0x60eb8249069801a5, 0x529967e8b06df477,
            0x776410b4b0cc22ad);
-  VLOAD_64(v6, 0x000000000000695b, 0x0000000000007420, 0x000000000001850c,
+  VLOAD_64(v24, 0x000000000000695b, 0x0000000000007420, 0x000000000001850c,
            0x000000000000b46f, 0x000000000000e92c, 0x0000000000024e72,
            0x0000000000032774, 0x000000000001c36f, 0x00000000000063d2,
            0x0000000000037bb4, 0x000000000003692c, 0x000000000001d60c,
            0x000000000002cf7b, 0x0000000000037899, 0x0000000000038bcf,
            0x000000000003d0e4);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdivu.vv v2, v4, v6, v0.t");
-  VCMP_I64(8, v2, 0, 0x000054ac6a930494, 0, 0x000023fac7321f85, 0,
+  VCLEAR(v8);
+  asm volatile("vdivu.vv v8, v16, v24, v0.t");
+  VCMP_I64(8, v8, 0, 0x000054ac6a930494, 0, 0x000023fac7321f85, 0,
            0x000016114f5d8a9e, 0, 0x00000765470f410f, 0, 0x0000472988fa89c3, 0,
            0x00000815e7b8df73, 0, 0x00001bec0e79307a, 0, 0x00001f497ec0ff30);
 #endif
 };
 
 void TEST_CASE3(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x0f, 0xbd, 0x0a, 0x58, 0x8e, 0x09, 0xa7, 0x02, 0x4b, 0xe8, 0xd2,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x0f, 0xbd, 0x0a, 0x58, 0x8e, 0x09, 0xa7, 0x02, 0x4b, 0xe8, 0xd2,
           0xfc, 0xa9, 0x8e, 0x67, 0x49);
   uint64_t scalar = 5;
-  asm volatile("vdivu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I8(9, v2, 0x03, 0x25, 0x02, 0x11, 0x1c, 0x01, 0x21, 0x00, 0x0f, 0x2e,
+  asm volatile("vdivu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I8(9, v8, 0x03, 0x25, 0x02, 0x11, 0x1c, 0x01, 0x21, 0x00, 0x0f, 0x2e,
           0x2a, 0x32, 0x21, 0x1c, 0x14, 0x0e);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xcf2f, 0x0c02, 0x1417, 0x1747, 0x5e43, 0x9552, 0xe03e, 0x5367,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xcf2f, 0x0c02, 0x1417, 0x1747, 0x5e43, 0x9552, 0xe03e, 0x5367,
            0xb2f9, 0x09d8, 0x3b19, 0x8ed0, 0x4740, 0xa628, 0x5560, 0x713b);
   scalar = 538;
-  asm volatile("vdivu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I16(10, v2, 0x0062, 0x0005, 0x0009, 0x000b, 0x002c, 0x0047, 0x006a,
+  asm volatile("vdivu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I16(10, v8, 0x0062, 0x0005, 0x0009, 0x000b, 0x002c, 0x0047, 0x006a,
            0x0027, 0x0055, 0x0004, 0x001c, 0x0043, 0x0021, 0x004f, 0x0028,
            0x0035);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x643498d4, 0xe1e4c6d4, 0x2fef6b6f, 0xe68ef651, 0x9943599a,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x643498d4, 0xe1e4c6d4, 0x2fef6b6f, 0xe68ef651, 0x9943599a,
            0x68af922e, 0x09a3beb2, 0x117ff561, 0x86a1a3f7, 0x03566f4f,
            0xc3c0c7de, 0x8cb524f8, 0x532e1652, 0xb0c26bf2, 0x886d0b1c,
            0xf94d6b63);
   scalar = 649;
-  asm volatile("vdivu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I32(11, v2, 0x002786be, 0x00591abc, 0x0012e87f, 0x005af1c8, 0x003c7480,
+  asm volatile("vdivu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I32(11, v8, 0x002786be, 0x00591abc, 0x0012e87f, 0x005af1c8, 0x003c7480,
            0x00294b2b, 0x0003cd68, 0x0006e722, 0x00351b13, 0x00015108,
            0x004d3723, 0x003780a6, 0x0020cf84, 0x0045b92a, 0x0035d049,
            0x0062568c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x751ea878eaf9f85f, 0x9843aba4c3e313af, 0xc2f56d78083dc0f2,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x751ea878eaf9f85f, 0x9843aba4c3e313af, 0xc2f56d78083dc0f2,
            0x4fcb920a2a4ebc8d, 0x33a71e7364643a7c, 0x76f96f8403af4ad7,
            0xcdbbb2002ea6ac93, 0xc380d0b6a5182bcc, 0x93b79fcc64af88cf,
            0x85d32b075e613f6c, 0x4f1f75bfa6d8f319, 0xd2a34a8d9a02d7f1,
            0x8679a27b237a032e, 0x7e0881a487bbb235, 0x17d97d9849271cec,
            0x1c85ac87ba3c7d1e);
   scalar = 9223;
-  asm volatile("vdivu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I64(12, v2, 0x000340383152452b, 0x000439f263aaf34a, 0x000569521e089c7c,
+  asm volatile("vdivu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I64(12, v8, 0x000340383152452b, 0x000439f263aaf34a, 0x000569521e089c7c,
            0x0002370079144c76, 0x00016f07b37c5546, 0x00034d65d36c535c,
            0x0005b5e194247d88, 0x00056d3090f69ef0, 0x000419a3026cfde7,
            0x0003b6ebd974c870, 0x000232398140d5dd, 0x0005d8bb7bec2e99,
@@ -177,41 +177,41 @@ void TEST_CASE3(void) {
 };
 
 void TEST_CASE4(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x0f, 0xbd, 0x0a, 0x58, 0x8e, 0x09, 0xa7, 0x02, 0x4b, 0xe8, 0xd2,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x0f, 0xbd, 0x0a, 0x58, 0x8e, 0x09, 0xa7, 0x02, 0x4b, 0xe8, 0xd2,
           0xfc, 0xa9, 0x8e, 0x67, 0x49);
   uint64_t scalar = 5;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdivu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I8(13, v2, 0, 0x25, 0, 0x11, 0, 0x01, 0, 0x00, 0, 0x2e, 0, 0x32, 0, 0x1c,
+  VCLEAR(v8);
+  asm volatile("vdivu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I8(13, v8, 0, 0x25, 0, 0x11, 0, 0x01, 0, 0x00, 0, 0x2e, 0, 0x32, 0, 0x1c,
           0, 0x0e);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xcf2f, 0x0c02, 0x1417, 0x1747, 0x5e43, 0x9552, 0xe03e, 0x5367,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xcf2f, 0x0c02, 0x1417, 0x1747, 0x5e43, 0x9552, 0xe03e, 0x5367,
            0xb2f9, 0x09d8, 0x3b19, 0x8ed0, 0x4740, 0xa628, 0x5560, 0x713b);
   scalar = 538;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdivu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I16(14, v2, 0, 0x0005, 0, 0x000b, 0, 0x0047, 0, 0x0027, 0, 0x0004, 0,
+  VCLEAR(v8);
+  asm volatile("vdivu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I16(14, v8, 0, 0x0005, 0, 0x000b, 0, 0x0047, 0, 0x0027, 0, 0x0004, 0,
            0x0043, 0, 0x004f, 0, 0x0035);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x643498d4, 0xe1e4c6d4, 0x2fef6b6f, 0xe68ef651, 0x9943599a,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x643498d4, 0xe1e4c6d4, 0x2fef6b6f, 0xe68ef651, 0x9943599a,
            0x68af922e, 0x09a3beb2, 0x117ff561, 0x86a1a3f7, 0x03566f4f,
            0xc3c0c7de, 0x8cb524f8, 0x532e1652, 0xb0c26bf2, 0x886d0b1c,
            0xf94d6b63);
   scalar = 649;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdivu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I32(15, v2, 0, 0x00591abc, 0, 0x005af1c8, 0, 0x00294b2b, 0, 0x0006e722,
+  VCLEAR(v8);
+  asm volatile("vdivu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I32(15, v8, 0, 0x00591abc, 0, 0x005af1c8, 0, 0x00294b2b, 0, 0x0006e722,
            0, 0x00015108, 0, 0x003780a6, 0, 0x0045b92a, 0, 0x0062568c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x751ea878eaf9f85f, 0x9843aba4c3e313af, 0xc2f56d78083dc0f2,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x751ea878eaf9f85f, 0x9843aba4c3e313af, 0xc2f56d78083dc0f2,
            0x4fcb920a2a4ebc8d, 0x33a71e7364643a7c, 0x76f96f8403af4ad7,
            0xcdbbb2002ea6ac93, 0xc380d0b6a5182bcc, 0x93b79fcc64af88cf,
            0x85d32b075e613f6c, 0x4f1f75bfa6d8f319, 0xd2a34a8d9a02d7f1,
@@ -219,9 +219,9 @@ void TEST_CASE4(void) {
            0x1c85ac87ba3c7d1e);
   scalar = 9223;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vdivu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I64(16, v2, 0, 0x000439f263aaf34a, 0, 0x0002370079144c76, 0,
+  VCLEAR(v8);
+  asm volatile("vdivu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I64(16, v8, 0, 0x000439f263aaf34a, 0, 0x0002370079144c76, 0,
            0x00034d65d36c535c, 0, 0x00056d3090f69ef0, 0, 0x0003b6ebd974c870, 0,
            0x0005d8bb7bec2e99, 0, 0x00037f8e5aab0783, 0, 0x0000caab9b4a8885);
 #endif
diff --git a/sw/riscvTests/isa/rv64uv/vfadd.c b/sw/riscvTests/isa/rv64uv/vfadd.c
index e3c361a6..0cfac68a 100644
--- a/sw/riscvTests/isa/rv64uv/vfadd.c
+++ b/sw/riscvTests/isa/rv64uv/vfadd.c
@@ -14,31 +14,31 @@
 
 // Simple random test with similar values + 1 subnormal
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //             -0.8896, -0.3406,  0.7324, -0.6846, -0.2969, -0.7739,  0.5737,
   //             0.4331,  0.8940, -0.4900,  0.4219,  0.4639,  0.6694,  0.4382,
   //             0.1356,  0.5337
-  VLOAD_16(v4, 0xbb1e, 0xb573, 0x39dc, 0xb97a, 0xb4c0, 0xba31, 0x3897, 0x36ee,
+  VLOAD_16(v16, 0xbb1e, 0xb573, 0x39dc, 0xb97a, 0xb4c0, 0xba31, 0x3897, 0x36ee,
            0x3b27, 0xb7d7, 0x36c0, 0x376c, 0x395b, 0x3703, 0x3057, 0x0001);
   //             -0.8164,  0.6533, -0.4685,  0.6284,  0.1666,  0.9438,  0.0445,
   //             -0.1342, -0.8071, -0.3167, -0.8350,  0.2178, -0.0896, -0.3057,
   //             -0.3064,  0.2073
-  VLOAD_16(v6, 0xba88, 0x393a, 0xb77f, 0x3907, 0x3155, 0x3b8d, 0x29b3, 0xb04b,
+  VLOAD_16(v24, 0xba88, 0x393a, 0xb77f, 0x3907, 0x3155, 0x3b8d, 0x29b3, 0xb04b,
            0xba75, 0xb511, 0xbaae, 0x32f8, 0xadbc, 0xb4e4, 0xb4e7, 0x8010);
-  asm volatile("vfadd.vv v2, v4, v6");
+  asm volatile("vfadd.vv v8, v16, v24");
   //             -1.7061,  0.3127,  0.2639, -0.0562, -0.1302,  0.1699,  0.6182,
   //             0.2988,  0.0869, -0.8066, -0.4131,  0.6816,  0.5801,  0.1326,
   //             -0.1708,  0.7412
-  VCMP_U16(1, v2, 0xbed3, 0x3501, 0x3439, 0xab30, 0xb02b, 0x3170, 0x38f2,
+  VCMP_U16(1, v8, 0xbed3, 0x3501, 0x3439, 0xab30, 0xb02b, 0x3170, 0x38f2,
            0x34c8, 0x2d90, 0xba74, 0xb69c, 0x3974, 0x38a4, 0x303e, 0xb177,
            0x800f);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //             -0.28968573,  0.40292332,  0.33936000,  0.53889370, 0.39942014,
   //             -0.27004066,  0.78120714, -0.15632398, -0.49984047,
   //             -0.69259918, -0.03384063, -0.62385744,  0.00338853, 0.33711585,
   //             -0.34673852,  0.11450682
-  VLOAD_32(v4, 0xbe9451b0, 0x3ece4bf7, 0x3eadc098, 0x3f09f4f0, 0x3ecc80cc,
+  VLOAD_32(v16, 0xbe9451b0, 0x3ece4bf7, 0x3eadc098, 0x3f09f4f0, 0x3ecc80cc,
            0xbe8a42c5, 0x3f47fd31, 0xbe201365, 0xbeffeb17, 0xbf314e2e,
            0xbd0a9c78, 0xbf1fb51f, 0x3b5e1209, 0x3eac9a73, 0xbeb187b6,
            0x3dea828d);
@@ -46,29 +46,29 @@ void TEST_CASE1(void) {
   //             -0.78492641, -0.44331804, -0.84668529,  0.13981950, 0.84909225,
   //             0.23569171,  0.34283128,  0.56619811,  0.22596644,  0.55843508,
   //             0.53194439,  0.02510819
-  VLOAD_32(v6, 0xbf1f15f7, 0x3f221093, 0x3e87bc88, 0x3f5b7dc5, 0xbf48f0f0,
+  VLOAD_32(v24, 0xbf1f15f7, 0x3f221093, 0x3e87bc88, 0x3f5b7dc5, 0xbf48f0f0,
            0xbee2fa95, 0xbf58c05e, 0x3e0f2cd8, 0x3f595e1c, 0x3e71592b,
            0x3eaf8795, 0x3f10f25c, 0x3e6763bf, 0x3f0ef59a, 0x3f082d82,
            0x3ccdafb0);
-  asm volatile("vfadd.vv v2, v4, v6");
+  asm volatile("vfadd.vv v8, v16, v24");
   //             -0.91111463,  1.03598869,  0.60447025,  1.39628148,
   //             -0.38550627, -0.71335870, -0.06547815, -0.01650448, 0.34925178,
   //             -0.45690745,  0.30899066, -0.05765933,  0.22935496, 0.89555097,
   //             0.18520588,  0.13961500
-  VCMP_U32(2, v2, 0xbf693ecf, 0x3f849b47, 0x3f1abe90, 0x3fb2b95a, 0xbec56114,
+  VCMP_U32(2, v8, 0xbf693ecf, 0x3f849b47, 0x3f1abe90, 0x3fb2b95a, 0xbec56114,
            0xbf369ead, 0xbd861968, 0xbc873468, 0x3eb2d121, 0xbee9efc6,
            0x3e9e3406, 0xbd6c2c30, 0x3e6adc07, 0x3f6542d4, 0x3e3da69c,
            0x3e0ef73c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //             -0.1192486190170796,  0.7099687505713703, -0.6001652243371716,
   //             -0.9559723926483070,  0.7987976623002717, -0.3314459653039117,
   //             0.7678805321182058, -0.3118871679402779, -0.7580588930783800,
   //             0.5940681950113129,  0.6471754222100761,  0.4175915562917139,
   //             -0.3690504607938143,  0.0740574148132984, -0.1493616685664843,
   //             0.3560295367616439
-  VLOAD_64(v4, 0xbfbe8713d6c58260, 0x3fe6b810629c5a40, 0xbfe3348db3573060,
+  VLOAD_64(v16, 0xbfbe8713d6c58260, 0x3fe6b810629c5a40, 0xbfe3348db3573060,
            0xbfee97536a49b50a, 0x3fe98fc01d766dee, 0xbfd536692357c5dc,
            0x3fe8927a3195d944, 0xbfd3f5f598961d8c, 0xbfe84204b946d5d6,
            0x3fe3029b4da55ad8, 0x3fe4b5a93b255a44, 0x3fdab9d1ef56f430,
@@ -80,20 +80,20 @@ void TEST_CASE1(void) {
   //             -0.7130864084314152, -0.5516927493459973, -0.4203081001100177,
   //             0.6487326796833275, -0.5631384800254344, -0.0996872955425372,
   //             -0.4382844162164241
-  VLOAD_64(v6, 0xbfe8d9d3f67536d2, 0x3fdad9e3e9cdd5bc, 0xbfd90875fda29450,
+  VLOAD_64(v24, 0xbfe8d9d3f67536d2, 0x3fdad9e3e9cdd5bc, 0xbfd90875fda29450,
            0x3fe62686e0339faa, 0x3fe2208e74273f2c, 0xbfc21587add90b50,
            0xbfc7a755744afe30, 0xbfdf67da0cc99808, 0xbfed4488f52c57bc,
            0xbfe6d19a966debbe, 0xbfe1a7778d7c344c, 0xbfdae653f20dd9d4,
            0x3fe4c26b0962c342, 0xbfe2053afd5a822c, 0xbfb9851b4a2e8ff0,
            0xbfdc0cda147fbe5c);
-  asm volatile("vfadd.vv v2, v4, v6");
+  asm volatile("vfadd.vv v8, v16, v24");
   //             -0.8958389485335123,  1.1295177182420593, -0.9913066367769980,
   //             -0.2637694069859826,  1.3652718395291317, -0.4727280086528298,
   //             0.5830864096285984, -0.8026007761935372, -1.6726749808525929,
   //             -0.1190182134201023,  0.0954826728640787, -0.0027165438183039,
   //             0.2796822188895132, -0.4890810652121360, -0.2490489641090214,
   //             -0.0822548794547802
-  VCMP_U64(3, v2, 0xbfecaab6714de71e, 0x3ff212812bc1a28f, 0xbfefb8c8b2287a88,
+  VCMP_U64(3, v8, 0xbfecaab6714de71e, 0x3ff212812bc1a28f, 0xbfefb8c8b2287a88,
            0xbfd0e199142c2ac0, 0x3ff5d82748ced68d, 0xbfde412cfa444b84,
            0x3fe2a8a4d48319b8, 0xbfe9aee7d2afdaca, 0xbffac346d73996c9,
            0xbfbe77fa46448730, 0x3fb8718d6d492fc0, 0xbf6641015b72d200,
@@ -105,50 +105,50 @@ void TEST_CASE1(void) {
 // Simple random test with similar values + 1 subnormal (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xbb1e, 0xb573, 0x39dc, 0xb97a, 0xb4c0, 0xba31, 0x3897, 0x36ee,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xbb1e, 0xb573, 0x39dc, 0xb97a, 0xb4c0, 0xba31, 0x3897, 0x36ee,
            0x3b27, 0xb7d7, 0x36c0, 0x376c, 0x395b, 0x3703, 0x3057, 0x0001);
-  VLOAD_16(v6, 0xba88, 0x393a, 0xb77f, 0x3907, 0x3155, 0x3b8d, 0x29b3, 0xb04b,
+  VLOAD_16(v24, 0xba88, 0x393a, 0xb77f, 0x3907, 0x3155, 0x3b8d, 0x29b3, 0xb04b,
            0xba75, 0xb511, 0xbaae, 0x32f8, 0xadbc, 0xb4e4, 0xb4e7, 0x8010);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfadd.vv v2, v4, v6, v0.t");
-  VCMP_U16(4, v2, 0, 0x3501, 0, 0xab30, 0, 0x3170, 0, 0x34c8, 0, 0xba74, 0,
+  VCLEAR(v8);
+  asm volatile("vfadd.vv v8, v16, v24, v0.t");
+  VCMP_U16(4, v8, 0, 0x3501, 0, 0xab30, 0, 0x3170, 0, 0x34c8, 0, 0xba74, 0,
            0x3974, 0, 0x303e, 0, 0x800f);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xbe9451b0, 0x3ece4bf7, 0x3eadc098, 0x3f09f4f0, 0x3ecc80cc,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xbe9451b0, 0x3ece4bf7, 0x3eadc098, 0x3f09f4f0, 0x3ecc80cc,
            0xbe8a42c5, 0x3f47fd31, 0xbe201365, 0xbeffeb17, 0xbf314e2e,
            0xbd0a9c78, 0xbf1fb51f, 0x3b5e1209, 0x3eac9a73, 0xbeb187b6,
            0x3dea828d);
-  VLOAD_32(v6, 0xbf1f15f7, 0x3f221093, 0x3e87bc88, 0x3f5b7dc5, 0xbf48f0f0,
+  VLOAD_32(v24, 0xbf1f15f7, 0x3f221093, 0x3e87bc88, 0x3f5b7dc5, 0xbf48f0f0,
            0xbee2fa95, 0xbf58c05e, 0x3e0f2cd8, 0x3f595e1c, 0x3e71592b,
            0x3eaf8795, 0x3f10f25c, 0x3e6763bf, 0x3f0ef59a, 0x3f082d82,
            0x3ccdafb0);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfadd.vv v2, v4, v6, v0.t");
-  VCMP_U32(5, v2, 0, 0x3f849b47, 0, 0x3fb2b95a, 0, 0xbf369ead, 0, 0xbc873468, 0,
+  VCLEAR(v8);
+  asm volatile("vfadd.vv v8, v16, v24, v0.t");
+  VCMP_U32(5, v8, 0, 0x3f849b47, 0, 0x3fb2b95a, 0, 0xbf369ead, 0, 0xbc873468, 0,
            0xbee9efc6, 0, 0xbd6c2c30, 0, 0x3f6542d4, 0, 0x3e0ef73c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0xbfbe8713d6c58260, 0x3fe6b810629c5a40, 0xbfe3348db3573060,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0xbfbe8713d6c58260, 0x3fe6b810629c5a40, 0xbfe3348db3573060,
            0xbfee97536a49b50a, 0x3fe98fc01d766dee, 0xbfd536692357c5dc,
            0x3fe8927a3195d944, 0xbfd3f5f598961d8c, 0xbfe84204b946d5d6,
            0x3fe3029b4da55ad8, 0x3fe4b5a93b255a44, 0x3fdab9d1ef56f430,
            0xbfd79e85d2ebb8f0, 0x3fb2f56d3ea64090, 0xbfc31e487ce26ff0,
            0x3fd6c9301c334858);
-  VLOAD_64(v6, 0xbfe8d9d3f67536d2, 0x3fdad9e3e9cdd5bc, 0xbfd90875fda29450,
+  VLOAD_64(v24, 0xbfe8d9d3f67536d2, 0x3fdad9e3e9cdd5bc, 0xbfd90875fda29450,
            0x3fe62686e0339faa, 0x3fe2208e74273f2c, 0xbfc21587add90b50,
            0xbfc7a755744afe30, 0xbfdf67da0cc99808, 0xbfed4488f52c57bc,
            0xbfe6d19a966debbe, 0xbfe1a7778d7c344c, 0xbfdae653f20dd9d4,
            0x3fe4c26b0962c342, 0xbfe2053afd5a822c, 0xbfb9851b4a2e8ff0,
            0xbfdc0cda147fbe5c);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfadd.vv v2, v4, v6, v0.t");
-  VCMP_U64(6, v2, 0, 0x3ff212812bc1a28f, 0, 0xbfd0e199142c2ac0, 0,
+  VCLEAR(v8);
+  asm volatile("vfadd.vv v8, v16, v24, v0.t");
+  VCMP_U64(6, v8, 0, 0x3ff212812bc1a28f, 0, 0xbfd0e199142c2ac0, 0,
            0xbfde412cfa444b84, 0, 0xbfe9aee7d2afdaca, 0, 0xbfbe77fa46448730, 0,
            0xbf6641015b72d200, 0, 0xbfdf4d1aab0b7434, 0, 0xbfb50ea7e131d810);
 #endif
@@ -156,33 +156,33 @@ void TEST_CASE2(void) {
 
 // Edge-case tests
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v4, pInfh, pInfh, mInfh, qNaNh, pMaxh, pMaxh, pZero, mZeroh, pZero,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, pInfh, pInfh, mInfh, qNaNh, pMaxh, pMaxh, pZero, mZeroh, pZero,
            pMaxh, pZero, qNaNh, mInfh, pInfh, qNaNh, qNaNh);
-  VLOAD_16(v6, mInfh, pInfh, mInfh, pZero, pMaxh, mMaxh, pZero, mZeroh, mZeroh,
+  VLOAD_16(v24, mInfh, pInfh, mInfh, pZero, pMaxh, mMaxh, pZero, mZeroh, mZeroh,
            mZeroh, mMaxh, 0x1, 0xba88, pZero, qNaNh, 0xba88);
-  asm volatile("vfadd.vv v2, v4, v6");
-  VCMP_U16(7, v2, qNaNh, pInfh, mInfh, qNaNh, pInfh, pZero, pZero, mZeroh,
+  asm volatile("vfadd.vv v8, v16, v24");
+  VCMP_U16(7, v8, qNaNh, pInfh, mInfh, qNaNh, pInfh, pZero, pZero, mZeroh,
            pZero, pMaxh, mMaxh, qNaNh, mInfh, pInfh, qNaNh, qNaNh);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, pInff, pInff, mInff, qNaNf, pMaxf, pMaxf, pZero, mZerof, pZero,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, pInff, pInff, mInff, qNaNf, pMaxf, pMaxf, pZero, mZerof, pZero,
            pMaxf, pZero, qNaNf, mInff, pInff, qNaNf, qNaNf);
-  VLOAD_32(v6, mInff, pInff, mInff, pZero, pMaxf, mMaxf, pZero, mZerof, mZerof,
+  VLOAD_32(v24, mInff, pInff, mInff, pZero, pMaxf, mMaxf, pZero, mZerof, mZerof,
            mZerof, mMaxf, 0x1, 0xbf48f0f0, pZero, qNaNf, 0xbf48f0f0);
-  asm volatile("vfadd.vv v2, v4, v6");
-  VCMP_U32(8, v2, qNaNf, pInff, mInff, qNaNf, pInff, pZero, pZero, mZerof,
+  asm volatile("vfadd.vv v8, v16, v24");
+  VCMP_U32(8, v8, qNaNf, pInff, mInff, qNaNf, pInff, pZero, pZero, mZerof,
            pZero, pMaxf, mMaxf, qNaNf, mInff, pInff, qNaNf, qNaNf);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, pInfd, pInfd, mInfd, qNaNd, pMaxd, pMaxd, pZero, mZerod, pZero,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, pInfd, pInfd, mInfd, qNaNd, pMaxd, pMaxd, pZero, mZerod, pZero,
            pMaxd, pZero, qNaNd, mInfd, pInfd, qNaNd, qNaNd);
-  VLOAD_64(v6, mInfd, pInfd, mInfd, pZero, pMaxd, mMaxd, pZero, mZerod, mZerod,
+  VLOAD_64(v24, mInfd, pInfd, mInfd, pZero, pMaxd, mMaxd, pZero, mZerod, mZerod,
            mZerod, mMaxd, 0x1, 0xbfd90875fda29450, pZero, qNaNd,
            0xbfd90875fda29450);
-  asm volatile("vfadd.vv v2, v4, v6");
-  VCMP_U64(9, v2, qNaNd, pInfd, mInfd, qNaNd, pInfd, pZero, pZero, mZerod,
+  asm volatile("vfadd.vv v8, v16, v24");
+  VCMP_U64(9, v8, qNaNd, pInfd, mInfd, qNaNd, pInfd, pZero, pZero, mZerod,
            pZero, pMaxd, mMaxd, qNaNd, mInfd, pInfd, qNaNd, qNaNd);
 #endif
 };
@@ -193,39 +193,39 @@ void TEST_CASE3(void) {
 void TEST_CASE4(void) {
   // Overflow + Inexact
   CLEAR_FFLAGS;
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   CHECK_FFLAGS(0);
-  VLOAD_16(v4, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh,
+  VLOAD_16(v16, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh,
            pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh);
-  VLOAD_16(v6, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh,
+  VLOAD_16(v24, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh,
            pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh, pMaxh);
-  asm volatile("vfadd.vv v2, v4, v6");
-  VCMP_U16(10, v2, pInfh, pInfh, pInfh, pInfh, pInfh, pInfh, pInfh, pInfh,
+  asm volatile("vfadd.vv v8, v16, v24");
+  VCMP_U16(10, v8, pInfh, pInfh, pInfh, pInfh, pInfh, pInfh, pInfh, pInfh,
            pInfh, pInfh, pInfh, pInfh, pInfh, pInfh, pInfh, pInfh);
 
   // Invalid operation, overflow
   CLEAR_FFLAGS;
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   CHECK_FFLAGS(0);
-  VLOAD_32(v4, pInff, pInff, pInff, pInff, pInff, pInff, pInff, pInff, pInff,
+  VLOAD_32(v16, pInff, pInff, pInff, pInff, pInff, pInff, pInff, pInff, pInff,
            pInff, pInff, pInff, pInff, pInff, pInff, pInff);
-  VLOAD_32(v6, mInff, mInff, mInff, mInff, mInff, mInff, mInff, mInff, mInff,
+  VLOAD_32(v24, mInff, mInff, mInff, mInff, mInff, mInff, mInff, mInff, mInff,
            mInff, mInff, mInff, mInff, mInff, mInff, mInff);
-  asm volatile("vfadd.vv v2, v4, v6");
-  VCMP_U32(11, v2, qNaNf, qNaNf, qNaNf, qNaNf, qNaNf, qNaNf, qNaNf, qNaNf,
+  asm volatile("vfadd.vv v8, v16, v24");
+  VCMP_U32(11, v8, qNaNf, qNaNf, qNaNf, qNaNf, qNaNf, qNaNf, qNaNf, qNaNf,
            qNaNf, qNaNf, qNaNf, qNaNf, qNaNf, qNaNf, qNaNf, qNaNf);
 
 #if ELEN == 64
   // Invalid operation, overflow, inexact
   CLEAR_FFLAGS;
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   CHECK_FFLAGS(0);
-  VLOAD_64(v4, pMaxd, pInfd, pMaxd, pMaxd, pMaxd, pMaxd, pMaxd, pMaxd, pMaxd,
+  VLOAD_64(v16, pMaxd, pInfd, pMaxd, pMaxd, pMaxd, pMaxd, pMaxd, pMaxd, pMaxd,
            pMaxd, pMaxd, pMaxd, pMaxd, pMaxd, pMaxd, pMaxd);
-  VLOAD_64(v6, pMaxd, mInfd, 8000000000000001, pMaxd, pMaxd, pMaxd, pMaxd,
+  VLOAD_64(v24, pMaxd, mInfd, 8000000000000001, pMaxd, pMaxd, pMaxd, pMaxd,
            pMaxd, pMaxd, pMaxd, pMaxd, pMaxd, pMaxd, pMaxd, pMaxd, pMaxd);
-  asm volatile("vfadd.vv v2, v4, v6");
-  VCMP_U64(12, v2, pInfd, qNaNd, pMaxd, pInfd, pInfd, pInfd, pInfd, pInfd,
+  asm volatile("vfadd.vv v8, v16, v24");
+  VCMP_U64(12, v8, pInfd, qNaNd, pMaxd, pInfd, pInfd, pInfd, pInfd, pInfd,
            pInfd, pInfd, pInfd, pInfd, pInfd, pInfd, pInfd, pInfd);
 #endif
 };
@@ -233,97 +233,97 @@ void TEST_CASE4(void) {
 // Different rounding-mode + Back-to-back rm change and vfp operation
 // Index 12 (starting from 0) rounds differently for RNE and RTZ
 void TEST_CASE5(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //             -0.8896, -0.3406,  0.7324, -0.6846, -0.2969, -0.7739,  0.5737,
   //             0.4331,  0.8940, -0.4900,  0.4219,  0.4639,  0.6694,  0.4382,
   //             0.1356,  0.5337
-  VLOAD_16(v4, 0xbb1e, 0xb573, 0x39dc, 0xb97a, 0xb4c0, 0xba31, 0x3897, 0x36ee,
+  VLOAD_16(v16, 0xbb1e, 0xb573, 0x39dc, 0xb97a, 0xb4c0, 0xba31, 0x3897, 0x36ee,
            0x3b27, 0xb7d7, 0x36c0, 0x376c, 0x395b, 0x3703, 0x3057, 0x0001);
   //             -0.8164,  0.6533, -0.4685,  0.6284,  0.1666,  0.9438,  0.0445,
   //             -0.1342, -0.8071, -0.3167, -0.8350,  0.2178, -0.0896, -0.3057,
   //             -0.3064,  0.2073
-  VLOAD_16(v6, 0xba88, 0x393a, 0xb77f, 0x3907, 0x3155, 0x3b8d, 0x29b3, 0xb04b,
+  VLOAD_16(v24, 0xba88, 0x393a, 0xb77f, 0x3907, 0x3155, 0x3b8d, 0x29b3, 0xb04b,
            0xba75, 0xb511, 0xbaae, 0x32f8, 0xadbc, 0xb4e4, 0xb4e7, 0x8010);
   CHANGE_RM(RM_RTZ);
-  asm volatile("vfadd.vv v2, v4, v6");
+  asm volatile("vfadd.vv v8, v16, v24");
   //              -1.7061,  0.3127,  0.2639, -0.0562, -0.1302,  0.1699,  0.6182,
   //              0.2988,  0.0869, -0.8066, -0.4131,  0.6816,  0.5801,  0.1326,
   //              -0.1708,  0.7412
-  VCMP_U16(13, v2, 0xbed3, 0x3501, 0x3439, 0xab30, 0xb02b, 0x3170, 0x38f2,
+  VCMP_U16(13, v8, 0xbed3, 0x3501, 0x3439, 0xab30, 0xb02b, 0x3170, 0x38f2,
            0x34c8, 0x2d90, 0xba74, 0xb69c, 0x3974, 0x38a3, 0x303e, 0xb177,
            0x800f);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //             -0.8896, -0.3406,  0.7324, -0.6846, -0.2969, -0.7739,  0.5737,
   //             0.4331,  0.8940, -0.4900,  0.4219,  0.4639,  0.6694,  0.4382,
   //             0.1356,  0.5337
-  VLOAD_16(v4, 0xbb1e, 0xb573, 0x39dc, 0xb97a, 0xb4c0, 0xba31, 0x3897, 0x36ee,
+  VLOAD_16(v16, 0xbb1e, 0xb573, 0x39dc, 0xb97a, 0xb4c0, 0xba31, 0x3897, 0x36ee,
            0x3b27, 0xb7d7, 0x36c0, 0x376c, 0x395b, 0x3703, 0x3057, 0x0001);
   //             -0.8164,  0.6533, -0.4685,  0.6284,  0.1666,  0.9438,  0.0445,
   //             -0.1342, -0.8071, -0.3167, -0.8350,  0.2178, -0.0896, -0.3057,
   //             -0.3064,  0.2073
-  VLOAD_16(v6, 0xba88, 0x393a, 0xb77f, 0x3907, 0x3155, 0x3b8d, 0x29b3, 0xb04b,
+  VLOAD_16(v24, 0xba88, 0x393a, 0xb77f, 0x3907, 0x3155, 0x3b8d, 0x29b3, 0xb04b,
            0xba75, 0xb511, 0xbaae, 0x32f8, 0xadbc, 0xb4e4, 0xb4e7, 0x8010);
   CHANGE_RM(RM_RNE);
-  asm volatile("vfadd.vv v2, v4, v6");
+  asm volatile("vfadd.vv v8, v16, v24");
   //              -1.7061,  0.3127,  0.2639, -0.0562, -0.1302,  0.1699,  0.6182,
   //              0.2988,  0.0869, -0.8066, -0.4131,  0.6816,  0.5801,  0.1326,
   //              -0.1708,  0.7412
-  VCMP_U16(14, v2, 0xbed3, 0x3501, 0x3439, 0xab30, 0xb02b, 0x3170, 0x38f2,
+  VCMP_U16(14, v8, 0xbed3, 0x3501, 0x3439, 0xab30, 0xb02b, 0x3170, 0x38f2,
            0x34c8, 0x2d90, 0xba74, 0xb69c, 0x3974, 0x38a4, 0x303e, 0xb177,
            0x800f);
 };
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE6(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.1481, -0.1797, -0.5454,  0.3228,  0.3237, -0.7212, -0.5195,
   //              -0.4500,  0.2681,  0.7300,  0.5059,  0.5830,  0.3198, -0.1713,
   //              -0.6431,  0.4841
-  VLOAD_16(v4, 0xb0bd, 0xb1c0, 0xb85d, 0x352a, 0x352e, 0xb9c5, 0xb828, 0xb733,
+  VLOAD_16(v16, 0xb0bd, 0xb1c0, 0xb85d, 0x352a, 0x352e, 0xb9c5, 0xb828, 0xb733,
            0x344a, 0x39d7, 0x380c, 0x38aa, 0x351e, 0xb17b, 0xb925, 0x37bf);
   float fscalar_16;
   //                         -0.9380
   BOX_HALF_IN_FLOAT(fscalar_16, 0xbb81);
-  asm volatile("vfadd.vf v2, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfadd.vf v8, v16, %[A]" ::[A] "f"(fscalar_16));
   //               -1.0859, -1.1172, -1.4834, -0.6152, -0.6143, -1.6592,
   //               -1.4570, -1.3877, -0.6699, -0.2080, -0.4321, -0.3550,
   //               -0.6182, -1.1094, -1.5811, -0.4539
-  VCMP_U16(15, v2, 0xbc58, 0xbc78, 0xbdef, 0xb8ec, 0xb8ea, 0xbea3, 0xbdd4,
+  VCMP_U16(15, v8, 0xbc58, 0xbc78, 0xbdef, 0xb8ec, 0xb8ea, 0xbea3, 0xbdd4,
            0xbd8d, 0xb95c, 0xb2a8, 0xb6ea, 0xb5ae, 0xb8f2, 0xbc70, 0xbe53,
            0xb743);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.86539453, -0.53925377, -0.47128764,  0.99265540,
   //               0.32128176, -0.47335613, -0.30028856,  0.44394016,
   //               -0.72540921, -0.26464799,  0.77351445, -0.21725702,
   //               -0.25191557, -0.53123665,  0.80404943,  0.81841671
-  VLOAD_32(v4, 0x3f5d8a7f, 0xbf0a0c89, 0xbef14c9d, 0x3f7e1eaa, 0x3ea47f0b,
+  VLOAD_32(v16, 0x3f5d8a7f, 0xbf0a0c89, 0xbef14c9d, 0x3f7e1eaa, 0x3ea47f0b,
            0xbef25bbc, 0xbe99bf6c, 0x3ee34c20, 0xbf39b46b, 0xbe877ff1,
            0x3f46050b, 0xbe5e78a0, 0xbe80fb14, 0xbf07ff20, 0x3f4dd62f,
            0x3f5183c2);
   float fscalar_32;
   //                             -0.96056187
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbf75e762);
-  asm volatile("vfadd.vf v2, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfadd.vf v8, v16, %[A]" ::[A] "f"(fscalar_32));
   //              -0.09516734, -1.49981570, -1.43184948,  0.03209352,
   //              -0.63928008, -1.43391800, -1.26085043, -0.51662171,
   //              -1.68597102, -1.22520983, -0.18704742, -1.17781889,
   //              -1.21247745, -1.49179852, -0.15651244, -0.14214516
-  VCMP_U32(16, v2, 0xbdc2e718, 0xbfbff9f6, 0xbfb746d8, 0x3d037480, 0xbf23a7dc,
+  VCMP_U32(16, v8, 0xbdc2e718, 0xbfbff9f6, 0xbfb746d8, 0x3d037480, 0xbf23a7dc,
            0xbfb78aa0, 0xbfa1638c, 0xbf044152, 0xbfd7cde6, 0xbf9cd3ad,
            0xbe3f895c, 0xbf96c2c5, 0xbf9b3276, 0xbfbef341, 0xbe2044cc,
            0xbe118e80);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               -0.3488917150781869, -0.4501495513738740, 0.8731197104152684,
   //               0.3256432550932964,  0.6502591178769535, -0.3169358689246526,
   //               -0.5396694979141685, -0.5417807430937591,
   //               -0.7971574213160249, -0.1764794100111047, 0.3564275916066595,
   //               -0.3754449946313438,  0.6580947137446858,
   //               -0.3328857144699515,  0.1761214464164236,  0.1429774118511240
-  VLOAD_64(v4, 0xbfd6543dea86cb60, 0xbfdccf40105d6e5c, 0x3febf098bf37400c,
+  VLOAD_64(v16, 0xbfd6543dea86cb60, 0xbfdccf40105d6e5c, 0x3febf098bf37400c,
            0x3fd4d756ceb279f4, 0x3fe4ceec35a6a266, 0xbfd448ad61fd7c88,
            0xbfe144f8f7861540, 0xbfe1564491a616b8, 0xbfe9825047ca1cd6,
            0xbfc696e097352100, 0x3fd6cfb5ac55edec, 0xbfd8074a7158dd78,
@@ -332,14 +332,14 @@ void TEST_CASE6(void) {
   double dscalar_64;
   //                               0.9108707261227378
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fed25da5d7296fe);
-  asm volatile("vfadd.vf v2, v4, %[A]" ::[A] "f"(dscalar_64));
+  asm volatile("vfadd.vf v8, v16, %[A]" ::[A] "f"(dscalar_64));
   //                0.5619790110445508, 0.4607211747488638,  1.7839904365380062,
   //                1.2365139812160342,  1.5611298439996912, 0.5939348571980851,
   //                0.3712012282085693,  0.3690899830289787, 0.1137133048067129,
   //                0.7343913161116331,  1.2672983177293973, 0.5354257314913939,
   //                1.5689654398674235, 0.5779850116527863,  1.0869921725391614,
   //                1.0538481379738618
-  VCMP_U64(17, v2, 0x3fe1fbbb682f314e, 0x3fdd7c74aa87bfa0, 0x3ffc8b398e54eb85,
+  VCMP_U64(17, v8, 0x3fe1fbbb682f314e, 0x3fdd7c74aa87bfa0, 0x3ffc8b398e54eb85,
            0x3ff3c8c2e265e9fc, 0x3ff8fa63498c9cb2, 0x3fe30183ac73d8ba,
            0x3fd7c1c2cbd9037c, 0x3fd79f2b9799008c, 0x3fbd1c50ad43d140,
            0x3fe7802237a54ebe, 0x3ff446da99cec6fa, 0x3fe1223524c62842,
@@ -350,33 +350,33 @@ void TEST_CASE6(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE7(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xb0bd, 0xb1c0, 0xb85d, 0x352a, 0x352e, 0xb9c5, 0xb828, 0xb733,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xb0bd, 0xb1c0, 0xb85d, 0x352a, 0x352e, 0xb9c5, 0xb828, 0xb733,
            0x344a, 0x39d7, 0x380c, 0x38aa, 0x351e, 0xb17b, 0xb925, 0x37bf);
   float fscalar_16;
   BOX_HALF_IN_FLOAT(fscalar_16, 0xbb81);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfadd.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
-  VCMP_U16(18, v2, 0, 0xbc78, 0, 0xb8ec, 0, 0xbea3, 0, 0xbd8d, 0, 0xb2a8, 0,
+  VCLEAR(v8);
+  asm volatile("vfadd.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCMP_U16(18, v8, 0, 0xbc78, 0, 0xb8ec, 0, 0xbea3, 0, 0xbd8d, 0, 0xb2a8, 0,
            0xb5ae, 0, 0xbc70, 0, 0xb743);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x3f5d8a7f, 0xbf0a0c89, 0xbef14c9d, 0x3f7e1eaa, 0x3ea47f0b,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x3f5d8a7f, 0xbf0a0c89, 0xbef14c9d, 0x3f7e1eaa, 0x3ea47f0b,
            0xbef25bbc, 0xbe99bf6c, 0x3ee34c20, 0xbf39b46b, 0xbe877ff1,
            0x3f46050b, 0xbe5e78a0, 0xbe80fb14, 0xbf07ff20, 0x3f4dd62f,
            0x3f5183c2);
   float fscalar_32;
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbf75e762);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfadd.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
-  VCMP_U32(19, v2, 0, 0xbfbff9f6, 0, 0x3d037480, 0, 0xbfb78aa0, 0, 0xbf044152,
+  VCLEAR(v8);
+  asm volatile("vfadd.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCMP_U32(19, v8, 0, 0xbfbff9f6, 0, 0x3d037480, 0, 0xbfb78aa0, 0, 0xbf044152,
            0, 0xbf9cd3ad, 0, 0xbf96c2c5, 0, 0xbfbef341, 0, 0xbe118e80);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0xbfd6543dea86cb60, 0xbfdccf40105d6e5c, 0x3febf098bf37400c,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0xbfd6543dea86cb60, 0xbfdccf40105d6e5c, 0x3febf098bf37400c,
            0x3fd4d756ceb279f4, 0x3fe4ceec35a6a266, 0xbfd448ad61fd7c88,
            0xbfe144f8f7861540, 0xbfe1564491a616b8, 0xbfe9825047ca1cd6,
            0xbfc696e097352100, 0x3fd6cfb5ac55edec, 0xbfd8074a7158dd78,
@@ -385,9 +385,9 @@ void TEST_CASE7(void) {
   double dscalar_64;
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fed25da5d7296fe);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfadd.vf v2, v4, %[A], v0.t" ::[A] "f"(dscalar_64));
-  VCMP_U64(20, v2, 0, 0x3fdd7c74aa87bfa0, 0, 0x3ff3c8c2e265e9fc, 0,
+  VCLEAR(v8);
+  asm volatile("vfadd.vf v8, v16, %[A], v0.t" ::[A] "f"(dscalar_64));
+  VCMP_U64(20, v8, 0, 0x3fdd7c74aa87bfa0, 0, 0x3ff3c8c2e265e9fc, 0,
            0x3fe30183ac73d8ba, 0, 0x3fd79f2b9799008c, 0, 0x3fe7802237a54ebe, 0,
            0x3fe1223524c62842, 0, 0x3fe27eda6c540f88, 0, 0x3ff0dc8fdd78c58f);
 #endif
@@ -397,45 +397,45 @@ void TEST_CASE7(void) {
 void TEST_CASE8(void) {
   // Overflow and Inexact. Invalid operation should not be raised.
   CLEAR_FFLAGS;
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   CHECK_FFLAGS(0);
-  VLOAD_16(v4, pInfh, pMaxh, pInfh, pMaxh, pInfh, pMaxh, pInfh, pMaxh, pInfh,
+  VLOAD_16(v16, pInfh, pMaxh, pInfh, pMaxh, pInfh, pMaxh, pInfh, pMaxh, pInfh,
            pMaxh, pInfh, pMaxh, pInfh, pMaxh, pInfh, pMaxh);
-  VLOAD_16(v6, mInfh, pMaxh, mInfh, pMaxh, mInfh, pMaxh, mInfh, pMaxh, mInfh,
+  VLOAD_16(v24, mInfh, pMaxh, mInfh, pMaxh, mInfh, pMaxh, mInfh, pMaxh, mInfh,
            pMaxh, mInfh, pMaxh, mInfh, pMaxh, mInfh, pMaxh);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfadd.vv v2, v4, v6, v0.t");
-  VCMP_U16(21, v2, 0, pInfh, 0, pInfh, 0, pInfh, 0, pInfh, 0, pInfh, 0, pInfh,
+  VCLEAR(v8);
+  asm volatile("vfadd.vv v8, v16, v24, v0.t");
+  VCMP_U16(21, v8, 0, pInfh, 0, pInfh, 0, pInfh, 0, pInfh, 0, pInfh, 0, pInfh,
            0, pInfh, 0, pInfh);
 
   // Invalid operation. Overflow and Inexact should not be raised.
   CLEAR_FFLAGS;
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   CHECK_FFLAGS(0);
-  VLOAD_32(v4, pMaxf, pInff, pMaxf, pInff, pMaxf, pInff, pMaxf, pInff, pMaxf,
+  VLOAD_32(v16, pMaxf, pInff, pMaxf, pInff, pMaxf, pInff, pMaxf, pInff, pMaxf,
            pInff, pMaxf, pInff, pMaxf, pInff, pMaxf, pInff);
-  VLOAD_32(v6, pMaxf, mInff, pMaxf, mInff, pMaxf, mInff, pMaxf, mInff, pMaxf,
+  VLOAD_32(v24, pMaxf, mInff, pMaxf, mInff, pMaxf, mInff, pMaxf, mInff, pMaxf,
            mInff, pMaxf, mInff, pMaxf, mInff, pMaxf, mInff);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfadd.vv v2, v4, v6, v0.t");
-  VCMP_U32(22, v2, 0, qNaNf, 0, qNaNf, 0, qNaNf, 0, qNaNf, 0, qNaNf, 0, qNaNf,
+  VCLEAR(v8);
+  asm volatile("vfadd.vv v8, v16, v24, v0.t");
+  VCMP_U32(22, v8, 0, qNaNf, 0, qNaNf, 0, qNaNf, 0, qNaNf, 0, qNaNf, 0, qNaNf,
            0, qNaNf, 0, qNaNf);
 
 #if ELEN == 64
   // No exception should be raised
   CLEAR_FFLAGS;
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   CHECK_FFLAGS(0);
-  VLOAD_64(v4, pMaxd, 0, pInfd, 0, pMaxd, 0, pMaxd, 0, pMaxd, 0, pMaxd, 0,
+  VLOAD_64(v16, pMaxd, 0, pInfd, 0, pMaxd, 0, pMaxd, 0, pMaxd, 0, pMaxd, 0,
            pMaxd, 0, pMaxd, 0);
-  VLOAD_64(v6, pMaxd, 0, mInfd, 0, pMaxd, 0, pMaxd, 0, pMaxd, 0, pMaxd, 0,
+  VLOAD_64(v24, pMaxd, 0, mInfd, 0, pMaxd, 0, pMaxd, 0, pMaxd, 0, pMaxd, 0,
            pMaxd, 0, pMaxd, 0);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfadd.vv v2, v4, v6, v0.t");
-  VCMP_U64(23, v2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  VCLEAR(v8);
+  asm volatile("vfadd.vv v8, v16, v24, v0.t");
+  VCMP_U64(23, v8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 #endif
 };
 
diff --git a/sw/riscvTests/isa/rv64uv/vfcvt.c b/sw/riscvTests/isa/rv64uv/vfcvt.c
index f4c89e8a..61f7949a 100644
--- a/sw/riscvTests/isa/rv64uv/vfcvt.c
+++ b/sw/riscvTests/isa/rv64uv/vfcvt.c
@@ -15,59 +15,59 @@
 ////////////////
 
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -2372.000,   2978.000, -5132.000, -3426.000, -3878.000,
   //              9680.000,   76.000, -8128.000, -2314.000, -4660.000, 8672.000,
   //              8824.000, -5732.000, -1557.000, -2302.000, -407.250
-  VLOAD_16(v4, 0xe8a2, 0x69d1, 0xed03, 0xeab1, 0xeb93, 0x70ba, 0x54c0, 0xeff0,
+  VLOAD_16(v8, 0xe8a2, 0x69d1, 0xed03, 0xeab1, 0xeb93, 0x70ba, 0x54c0, 0xeff0,
            0xe885, 0xec8d, 0x703c, 0x704f, 0xed99, 0xe615, 0xe87f, 0xde5d);
-  asm volatile("vfcvt.xu.f.v v6, v4");
+  asm volatile("vfcvt.xu.f.v v16, v8");
   //                       0,       2978,          0,          0,          0,
   //                       9680,         76,          0,          0,          0,
   //                       8672,       8824,          0,          0,          0,
   //                       0
-  VCMP_U16(1, v6, 0x0000, 0x0ba2, 0x0000, 0x0000, 0x0000, 0x25d0, 0x004c,
+  VCMP_U16(1, v16, 0x0000, 0x0ba2, 0x0000, 0x0000, 0x0000, 0x25d0, 0x004c,
            0x0000, 0x0000, 0x0000, 0x21e0, 0x2278, 0x0000, 0x0000, 0x0000,
            0x0000);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -82436.352, -5427.481, -30119.082,   53784.066,   76500.719,
   //              65152.020, -94151.375,   71894.320, -20547.545,   95485.906,
   //              92834.711, -28081.711, -9716.506,   62508.508,   90410.883,
   //              42708.285
-  VLOAD_32(v4, 0xc7a1022d, 0xc5a99bd9, 0xc6eb4e2a, 0x47521811, 0x47956a5c,
+  VLOAD_32(v8, 0xc7a1022d, 0xc5a99bd9, 0xc6eb4e2a, 0x47521811, 0x47956a5c,
            0x477e8005, 0xc7b7e3b0, 0x478c6b29, 0xc6a08717, 0x47ba7ef4,
            0x47b5515b, 0xc6db636c, 0xc617d206, 0x47742c82, 0x47b09571,
            0x4726d449);
-  asm volatile("vfcvt.xu.f.v v6, v4");
+  asm volatile("vfcvt.xu.f.v v16, v8");
   //                           0,              0,              0, 53784, 76501,
   //                           65152,              0,          71894, 0, 95486,
   //                           92835,              0,              0, 62509,
   //                           90411,          42708
-  VCMP_U32(2, v6, 0x00000000, 0x00000000, 0x00000000, 0x0000d218, 0x00012ad5,
+  VCMP_U32(2, v16, 0x00000000, 0x00000000, 0x00000000, 0x0000d218, 0x00012ad5,
            0x0000fe80, 0x00000000, 0x000118d6, 0x00000000, 0x000174fe,
            0x00016aa3, 0x00000000, 0x00000000, 0x0000f42d, 0x0001612b,
            0x0000a6d4);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                3554390.405,   3670449.443,   3880983.535,   3452087.537,
   //                -5447847.496,   498812.179,   9535291.051,   113884.868,
   //                2124622.198, -2164534.614,   1377445.305, -2114478.485,
   //                -4704971.356, -7866057.432,   7002504.380, -2981734.692
-  VLOAD_64(v4, 0x414b1e2b33d13be4, 0x414c00d8b8b34d48, 0x414d9c0bc4751d78,
+  VLOAD_64(v8, 0x414b1e2b33d13be4, 0x414c00d8b8b34d48, 0x414d9c0bc4751d78,
            0x414a565bc4adf2d0, 0xc154c829dfc2d9f6, 0x411e71f0b7161c00,
            0x41622fe7619e55e2, 0x40fbcdcde34f1a00, 0x414035a7194d9794,
            0xc140839b4e886550, 0x413504a54df56888, 0xc14021d73e1606dc,
            0xc151f2b2d6cc57c8, 0xc15e01b25baceaba, 0x415ab6621850fa94,
            0xc146bfb358869da2);
-  asm volatile("vfcvt.xu.f.v v6, v4");
+  asm volatile("vfcvt.xu.f.v v16, v8");
   //                             3554390,                3670449, 3880984,
   //                             3452088,                      0, 498812,
   //                             9535291,                 113885, 2124622, 0,
   //                             1377445,                      0, 0, 0, 7002504,
   //                             0
-  VCMP_U64(3, v6, 0x0000000000363c56, 0x00000000003801b1, 0x00000000003b3818,
+  VCMP_U64(3, v16, 0x0000000000363c56, 0x00000000003801b1, 0x00000000003b3818,
            0x000000000034acb8, 0x0000000000000000, 0x0000000000079c7c,
            0x0000000000917f3b, 0x000000000001bcdd, 0x0000000000206b4e,
            0x0000000000000000, 0x00000000001504a5, 0x0000000000000000,
@@ -79,63 +79,63 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -2372.000,   2978.000, -5132.000, -3426.000, -3878.000,
   //              9680.000,   76.000, -8128.000, -2314.000, -4660.000, 8672.000,
   //              8824.000, -5732.000, -1557.000, -2302.000, -407.250
-  VLOAD_16(v4, 0xe8a2, 0x69d1, 0xed03, 0xeab1, 0xeb93, 0x70ba, 0x54c0, 0xeff0,
+  VLOAD_16(v8, 0xe8a2, 0x69d1, 0xed03, 0xeab1, 0xeb93, 0x70ba, 0x54c0, 0xeff0,
            0xe885, 0xec8d, 0x703c, 0x704f, 0xed99, 0xe615, 0xe87f, 0xde5d);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.xu.f.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.xu.f.v v16, v8, v0.t");
   //                       0,       2978,          0,          0,          0,
   //                       9680,          0,          0,          0,          0,
   //                       0,       8824,          0,          0,          0, 0
-  VCMP_U16(4, v6, 0x0000, 0x0ba2, 0x0000, 0x0000, 0x0000, 0x25d0, 0x0000,
+  VCMP_U16(4, v16, 0x0000, 0x0ba2, 0x0000, 0x0000, 0x0000, 0x25d0, 0x0000,
            0x0000, 0x0000, 0x0000, 0x0000, 0x2278, 0x0000, 0x0000, 0x0000,
            0x0000);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -82436.352, -5427.481, -30119.082,   53784.066,   76500.719,
   //              65152.020, -94151.375,   71894.320, -20547.545,   95485.906,
   //              92834.711, -28081.711, -9716.506,   62508.508,   90410.883,
   //              42708.285
-  VLOAD_32(v4, 0xc7a1022d, 0xc5a99bd9, 0xc6eb4e2a, 0x47521811, 0x47956a5c,
+  VLOAD_32(v8, 0xc7a1022d, 0xc5a99bd9, 0xc6eb4e2a, 0x47521811, 0x47956a5c,
            0x477e8005, 0xc7b7e3b0, 0x478c6b29, 0xc6a08717, 0x47ba7ef4,
            0x47b5515b, 0xc6db636c, 0xc617d206, 0x47742c82, 0x47b09571,
            0x4726d449);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.xu.f.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.xu.f.v v16, v8, v0.t");
   //                           0,              0,              0, 53784, 0,
   //                           65152,              0,          71894, 0, 95486,
   //                           0,              0,              0, 62509, 0,
   //                           42708
-  VCMP_U32(5, v6, 0x00000000, 0x00000000, 0x00000000, 0x0000d218, 0x00000000,
+  VCMP_U32(5, v16, 0x00000000, 0x00000000, 0x00000000, 0x0000d218, 0x00000000,
            0x0000fe80, 0x00000000, 0x000118d6, 0x00000000, 0x000174fe,
            0x00000000, 0x00000000, 0x00000000, 0x0000f42d, 0x00000000,
            0x0000a6d4);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                3554390.405,   3670449.443,   3880983.535,   3452087.537,
   //                -5447847.496,   498812.179,   9535291.051,   113884.868,
   //                2124622.198, -2164534.614,   1377445.305, -2114478.485,
   //                -4704971.356, -7866057.432,   7002504.380, -2981734.692
-  VLOAD_64(v4, 0x414b1e2b33d13be4, 0x414c00d8b8b34d48, 0x414d9c0bc4751d78,
+  VLOAD_64(v8, 0x414b1e2b33d13be4, 0x414c00d8b8b34d48, 0x414d9c0bc4751d78,
            0x414a565bc4adf2d0, 0xc154c829dfc2d9f6, 0x411e71f0b7161c00,
            0x41622fe7619e55e2, 0x40fbcdcde34f1a00, 0x414035a7194d9794,
            0xc140839b4e886550, 0x413504a54df56888, 0xc14021d73e1606dc,
            0xc151f2b2d6cc57c8, 0xc15e01b25baceaba, 0x415ab6621850fa94,
            0xc146bfb358869da2);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.xu.f.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.xu.f.v v16, v8, v0.t");
   //                                   0,                3670449, 0, 3452088, 0,
   //                                   498812,                      0, 113885,
   //                                   0,                      0, 0, 0, 0, 0, 0,
   //                                   0
-  VCMP_U64(6, v6, 0x0000000000000000, 0x00000000003801b1, 0x0000000000000000,
+  VCMP_U64(6, v16, 0x0000000000000000, 0x00000000003801b1, 0x0000000000000000,
            0x000000000034acb8, 0x0000000000000000, 0x0000000000079c7c,
            0x0000000000000000, 0x000000000001bcdd, 0x0000000000000000,
            0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
@@ -150,63 +150,63 @@ void TEST_CASE2(void) {
 
 // Unmasked vfcvt.x.f.c
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //                4144.000, -861.500, -8680.000,   3792.000,   8800.000,
   //                -2330.000, -3066.000, -6148.000,   4776.000,   7360.000,
   //                -7880.000, -1843.000, -7896.000, -6520.000, -7092.000,
   //                -8344.000
-  VLOAD_16(v4, 0x6c0c, 0xe2bb, 0xf03d, 0x6b68, 0x704c, 0xe88d, 0xe9fd, 0xee01,
+  VLOAD_16(v8, 0x6c0c, 0xe2bb, 0xf03d, 0x6b68, 0x704c, 0xe88d, 0xe9fd, 0xee01,
            0x6caa, 0x6f30, 0xefb2, 0xe733, 0xefb6, 0xee5e, 0xeeed, 0xf013);
-  asm volatile("vfcvt.x.f.v v6, v4");
+  asm volatile("vfcvt.x.f.v v16, v8");
   //                    4144,       -862,      -8680,       3792,       8800,
   //                    -2330,      -3066,      -6148,       4776,       7360,
   //                    -7880,      -1843,      -7896,      -6520,      -7092,
   //                    -8344
-  VCMP_U16(7, v6, 0x1030, 0xfca2, 0xde18, 0x0ed0, 0x2260, 0xf6e6, 0xf406,
+  VCMP_U16(7, v16, 0x1030, 0xfca2, 0xde18, 0x0ed0, 0x2260, 0xf6e6, 0xf406,
            0xe7fc, 0x12a8, 0x1cc0, 0xe138, 0xf8cd, 0xe128, 0xe688, 0xe44c,
            0xdf68);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -28075.818, -5455.616,   6106.086, -11952.592, -50887.914,
   //              -23028.832, -9221.246, -71657.047, -6655.005, -21208.561,
   //              -30018.096, -19766.838,   48541.953, -62313.625,   13515.192,
   //              -83224.820
-  VLOAD_32(v4, 0xc6db57a3, 0xc5aa7ced, 0x45bed0b1, 0xc63ac25e, 0xc746c7ea,
+  VLOAD_32(v8, 0xc6db57a3, 0xc5aa7ced, 0x45bed0b1, 0xc63ac25e, 0xc746c7ea,
            0xc6b3e9aa, 0xc61014fc, 0xc78bf486, 0xc5cff80a, 0xc6a5b11f,
            0xc6ea8431, 0xc69a6dad, 0x473d9df4, 0xc77369a0, 0x46532cc5,
            0xc7a28c69);
-  asm volatile("vfcvt.x.f.v v6, v4");
+  asm volatile("vfcvt.x.f.v v16, v8");
   //                      -28076,          -5456,           6106, -11953,
   //                      -50888,         -23029,          -9221, -71657, -6655,
   //                      -21209,         -30018,         -19767, 48542, -62314,
   //                      13515,         -83225
-  VCMP_U32(8, v6, 0xffff9254, 0xffffeab0, 0x000017da, 0xffffd14f, 0xffff3938,
+  VCMP_U32(8, v16, 0xffff9254, 0xffffeab0, 0x000017da, 0xffffd14f, 0xffff3938,
            0xffffa60b, 0xffffdbfb, 0xfffee817, 0xffffe601, 0xffffad27,
            0xffff8abe, 0xffffb2c9, 0x0000bd9e, 0xffff0c96, 0x000034cb,
            0xfffebae7);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                         3087905.033,           -2534011.630, 7824302.813,
   //                         -9294206.521,   6436555.847,   6645117.193,
   //                         1358075.867,   5694551.012, -9840938.636,
   //                         4621816.383,   2584370.751,   5569558.860,
   //                         495487.041,   4759865.418, -6831172.669,
   //                         8371055.296
-  VLOAD_64(v4, 0x41478f10842c8b9c, 0xc143553dd0971c82, 0x415dd8ebb40e1fe0,
+  VLOAD_64(v8, 0x41478f10842c8b9c, 0xc143553dd0971c82, 0x415dd8ebb40e1fe0,
            0xc161ba2fd0a8a593, 0x41588db2f632700c, 0x4159595f4c588b60,
            0x4134b8fbde131210, 0x4155b915c0cb4294, 0xc162c52554566300,
            0x4151a17e187d1aa8, 0x4143b7996029dc68, 0x41553f05b70b6824,
            0x411e3dfc2a598ba0, 0x4152284e5ac4da5a, 0xc15a0f112acbf258,
            0x415feedbd2ed6038);
-  asm volatile("vfcvt.x.f.v v6, v4");
+  asm volatile("vfcvt.x.f.v v16, v8");
   //                             3087905,               -2534012, 7824303,
   //                             -9294207,                6436556, 6645117,
   //                             1358076,                5694551, -9840939,
   //                             4621816,                2584371, 5569559,
   //                             495487,                4759865, -6831173,
   //                             8371055
-  VCMP_U64(9, v6, 0x00000000002f1e21, 0xffffffffffd95584, 0x00000000007763af,
+  VCMP_U64(9, v16, 0x00000000002f1e21, 0xffffffffffd95584, 0x00000000007763af,
            0xffffffffff722e81, 0x00000000006236cc, 0x000000000065657d,
            0x000000000014b8fc, 0x000000000056e457, 0xffffffffff69d6d5,
            0x00000000004685f8, 0x0000000000276f33, 0x000000000054fc17,
@@ -217,64 +217,64 @@ void TEST_CASE3(void) {
 
 // Masked vfcvt.x.f.c
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //                4144.000, -861.500, -8680.000,   3792.000,   8800.000,
   //                -2330.000, -3066.000, -6148.000,   4776.000,   7360.000,
   //                -7880.000, -1843.000, -7896.000, -6520.000, -7092.000,
   //                -8344.000
-  VLOAD_16(v4, 0x6c0c, 0xe2bb, 0xf03d, 0x6b68, 0x704c, 0xe88d, 0xe9fd, 0xee01,
+  VLOAD_16(v8, 0x6c0c, 0xe2bb, 0xf03d, 0x6b68, 0x704c, 0xe88d, 0xe9fd, 0xee01,
            0x6caa, 0x6f30, 0xefb2, 0xe733, 0xefb6, 0xee5e, 0xeeed, 0xf013);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.x.f.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.x.f.v v16, v8, v0.t");
   //                       0,       -862,          0,       3792,          0,
   //                       -2330,          0,      -6148,          0, 7360, 0,
   //                       -1843,          0,      -6520,          0,      -8344
-  VCMP_U16(10, v6, 0x0000, 0xfca2, 0x0000, 0x0ed0, 0x0000, 0xf6e6, 0x0000,
+  VCMP_U16(10, v16, 0x0000, 0xfca2, 0x0000, 0x0ed0, 0x0000, 0xf6e6, 0x0000,
            0xe7fc, 0x0000, 0x1cc0, 0x0000, 0xf8cd, 0x0000, 0xe688, 0x0000,
            0xdf68);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //                  -28075.818,      -5455.616,       6106.086, -11952.592,
   //                  -50887.914,     -23028.832,      -9221.246, -71657.047,
   //                  -6655.005, -21208.561, -30018.096, -19766.838, 48541.953,
   //                  -62313.625,   13515.192, -83224.820
-  VLOAD_32(v4, 0xc6db57a3, 0xc5aa7ced, 0x45bed0b1, 0xc63ac25e, 0xc746c7ea,
+  VLOAD_32(v8, 0xc6db57a3, 0xc5aa7ced, 0x45bed0b1, 0xc63ac25e, 0xc746c7ea,
            0xc6b3e9aa, 0xc61014fc, 0xc78bf486, 0xc5cff80a, 0xc6a5b11f,
            0xc6ea8431, 0xc69a6dad, 0x473d9df4, 0xc77369a0, 0x46532cc5,
            0xc7a28c69);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.x.f.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.x.f.v v16, v8, v0.t");
   //                           0,          -5456,              0, -11953, 0,
   //                           -23029,              0,         -71657, 0,
   //                           -21209,              0,         -19767, 0,
   //                           -62314,              0,         -83225
-  VCMP_U32(11, v6, 0x00000000, 0xffffeab0, 0x00000000, 0xffffd14f, 0x00000000,
+  VCMP_U32(11, v16, 0x00000000, 0xffffeab0, 0x00000000, 0xffffd14f, 0x00000000,
            0xffffa60b, 0x00000000, 0xfffee817, 0x00000000, 0xffffad27,
            0x00000000, 0xffffb2c9, 0x00000000, 0xffff0c96, 0x00000000,
            0xfffebae7);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                3087905.033, -2534011.630,   7824302.813, -9294206.521,
   //                6436555.847,   6645117.193,   1358075.867,   5694551.012,
   //                -9840938.636,   4621816.383,   2584370.751,   5569558.860,
   //                495487.041,   4759865.418, -6831172.669,   8371055.296
-  VLOAD_64(v4, 0x41478f10842c8b9c, 0xc143553dd0971c82, 0x415dd8ebb40e1fe0,
+  VLOAD_64(v8, 0x41478f10842c8b9c, 0xc143553dd0971c82, 0x415dd8ebb40e1fe0,
            0xc161ba2fd0a8a593, 0x41588db2f632700c, 0x4159595f4c588b60,
            0x4134b8fbde131210, 0x4155b915c0cb4294, 0xc162c52554566300,
            0x4151a17e187d1aa8, 0x4143b7996029dc68, 0x41553f05b70b6824,
            0x411e3dfc2a598ba0, 0x4152284e5ac4da5a, 0xc15a0f112acbf258,
            0x415feedbd2ed6038);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.x.f.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.x.f.v v16, v8, v0.t");
   //                                   0,               -2534012, 0, -9294207,
   //                                   0,                6645117, 0, 5694551, 0,
   //                                   4621816,                      0, 5569559,
   //                                   0,                4759865, 0, 8371055
-  VCMP_U64(12, v6, 0x0000000000000000, 0xffffffffffd95584, 0x0000000000000000,
+  VCMP_U64(12, v16, 0x0000000000000000, 0xffffffffffd95584, 0x0000000000000000,
            0xffffffffff722e81, 0x0000000000000000, 0x000000000065657d,
            0x0000000000000000, 0x000000000056e457, 0x0000000000000000,
            0x00000000004685f8, 0x0000000000000000, 0x000000000054fc17,
@@ -289,59 +289,59 @@ void TEST_CASE4(void) {
 
 // Simple random test with similar values
 void TEST_CASE5(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //                6996.000, -7512.000, -4792.000,   7240.000,   8336.000,
   //                6332.000, -277.750, -4074.000,   9352.000,   8832.000,
   //                -65.000,   5860.000,   6892.000,   2944.000,   9608.000,
   //                4608.000
-  VLOAD_16(v4, 0x6ed5, 0xef56, 0xecae, 0x6f12, 0x7012, 0x6e2f, 0xdc57, 0xebf5,
+  VLOAD_16(v8, 0x6ed5, 0xef56, 0xecae, 0x6f12, 0x7012, 0x6e2f, 0xdc57, 0xebf5,
            0x7091, 0x7050, 0xd410, 0x6db9, 0x6ebb, 0x69c0, 0x70b1, 0x6c80);
-  asm volatile("vfcvt.rtz.xu.f.v v6, v4");
+  asm volatile("vfcvt.rtz.xu.f.v v16, v8");
   //                    6996,          0,          0,       7240,       8336,
   //                    6332,          0,          0,       9352,       8832, 0,
   //                    5860,       6892,       2944,       9608,       4608
-  VCMP_U16(13, v6, 0x1b54, 0x0000, 0x0000, 0x1c48, 0x2090, 0x18bc, 0x0000,
+  VCMP_U16(13, v16, 0x1b54, 0x0000, 0x0000, 0x1c48, 0x2090, 0x18bc, 0x0000,
            0x0000, 0x2488, 0x2280, 0x0000, 0x16e4, 0x1aec, 0x0b80, 0x2588,
            0x1200);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //                85074.883, -2035.769,   67397.633, -57745.480,   82113.172,
   //                18415.770,   57859.465,   83291.773, -83693.375, 43321.199,
   //                94626.156, -53520.090,   9604.658, -5764.834,   94299.633,
   //                57572.980
-  VLOAD_32(v4, 0x47a62971, 0xc4fe789f, 0x4783a2d1, 0xc761917b, 0x47a06096,
+  VLOAD_32(v8, 0x47a62971, 0xc4fe789f, 0x4783a2d1, 0xc761917b, 0x47a06096,
            0x468fdf8a, 0x47620377, 0x47a2ade3, 0xc7a376b0, 0x47293933,
            0x47b8d114, 0xc7511017, 0x461612a2, 0xc5b426ac, 0x47b82dd1,
            0x4760e4fb);
-  asm volatile("vfcvt.rtz.xu.f.v v6, v4");
+  asm volatile("vfcvt.rtz.xu.f.v v16, v8");
   //                       85074,              0,          67397, 0, 82113,
   //                       18415,          57859,          83291, 0, 43321,
   //                       94626,              0,           9604, 0, 94299,
   //                       57572
-  VCMP_U32(14, v6, 0x00014c52, 0x00000000, 0x00010745, 0x00000000, 0x000140c1,
+  VCMP_U32(14, v16, 0x00014c52, 0x00000000, 0x00010745, 0x00000000, 0x000140c1,
            0x000047ef, 0x0000e203, 0x0001455b, 0x00000000, 0x0000a939,
            0x000171a2, 0x00000000, 0x00002584, 0x00000000, 0x0001705b,
            0x0000e0e4);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -5386285.220, -9081004.335, -9603879.062, -4621060.923,
   //              2017661.058,   1106405.978, -2095853.299,   1911589.313,
   //              4833261.528,   1291127.404, -9941577.120,   9259799.184,
   //              -8569693.727,   4926687.920, -7537625.130, -6328586.289
-  VLOAD_64(v4, 0xc1548c0b4e12be63, 0xc16152158ab92a41, 0xc1625164e1fd6af4,
+  VLOAD_64(v8, 0xc1548c0b4e12be63, 0xc16152158ab92a41, 0xc1625164e1fd6af4,
            0xc151a0c13b0c041c, 0x413ec97d0edd7a68, 0x4130e1e5fa5c8120,
            0xc13ffaed4c78fc7c, 0x413d2b2550357b50, 0x41526ffb61d23f42,
            0x4133b377675b6328, 0xc162f64923d5cce3, 0x4161a962e5e3a1e8,
            0xc160586bb74734b0, 0x4152cb37fae70f80, 0xc15cc0f6484f174c,
            0xc1582442928257b8);
-  asm volatile("vfcvt.rtz.xu.f.v v6, v4");
+  asm volatile("vfcvt.rtz.xu.f.v v16, v8");
   //                                   0,                      0, 0, 0, 2017661,
   //                                   1106405,                      0, 1911589,
   //                                   4833261,                1291127, 0,
   //                                   9259799,                      0, 4926687,
   //                                   0,                      0
-  VCMP_U64(15, v6, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+  VCMP_U64(15, v16, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
            0x0000000000000000, 0x00000000001ec97d, 0x000000000010e1e5,
            0x0000000000000000, 0x00000000001d2b25, 0x000000000049bfed,
            0x000000000013b377, 0x0000000000000000, 0x00000000008d4b17,
@@ -353,64 +353,64 @@ void TEST_CASE5(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE6(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //                6996.000, -7512.000, -4792.000,   7240.000,   8336.000,
   //                6332.000, -277.750, -4074.000,   9352.000,   8832.000,
   //                -65.000,   5860.000,   6892.000,   2944.000,   9608.000,
   //                4608.000
-  VLOAD_16(v4, 0x6ed5, 0xef56, 0xecae, 0x6f12, 0x7012, 0x6e2f, 0xdc57, 0xebf5,
+  VLOAD_16(v8, 0x6ed5, 0xef56, 0xecae, 0x6f12, 0x7012, 0x6e2f, 0xdc57, 0xebf5,
            0x7091, 0x7050, 0xd410, 0x6db9, 0x6ebb, 0x69c0, 0x70b1, 0x6c80);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.rtz.xu.f.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.rtz.xu.f.v v16, v8, v0.t");
   //                       0,          0,          0,       7240,          0,
   //                       6332,          0,          0,          0,       8832,
   //                       0,       5860,          0,       2944,          0,
   //                       4608
-  VCMP_U16(16, v6, 0x0000, 0x0000, 0x0000, 0x1c48, 0x0000, 0x18bc, 0x0000,
+  VCMP_U16(16, v16, 0x0000, 0x0000, 0x0000, 0x1c48, 0x0000, 0x18bc, 0x0000,
            0x0000, 0x0000, 0x2280, 0x0000, 0x16e4, 0x0000, 0x0b80, 0x0000,
            0x1200);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //                85074.883, -2035.769,   67397.633, -57745.480,   82113.172,
   //                18415.770,   57859.465,   83291.773, -83693.375, 43321.199,
   //                94626.156, -53520.090,   9604.658, -5764.834,   94299.633,
   //                57572.980
-  VLOAD_32(v4, 0x47a62971, 0xc4fe789f, 0x4783a2d1, 0xc761917b, 0x47a06096,
+  VLOAD_32(v8, 0x47a62971, 0xc4fe789f, 0x4783a2d1, 0xc761917b, 0x47a06096,
            0x468fdf8a, 0x47620377, 0x47a2ade3, 0xc7a376b0, 0x47293933,
            0x47b8d114, 0xc7511017, 0x461612a2, 0xc5b426ac, 0x47b82dd1,
            0x4760e4fb);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.rtz.xu.f.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.rtz.xu.f.v v16, v8, v0.t");
   //                           0,              0,              0, 0, 0, 18415,
   //                           0,          83291,              0, 43321, 0, 0,
   //                           0,              0,              0,          57572
-  VCMP_U32(17, v6, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+  VCMP_U32(17, v16, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
            0x000047ef, 0x00000000, 0x0001455b, 0x00000000, 0x0000a939,
            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
            0x0000e0e4);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -5386285.220, -9081004.335, -9603879.062, -4621060.923,
   //              2017661.058,   1106405.978, -2095853.299,   1911589.313,
   //              4833261.528,   1291127.404, -9941577.120,   9259799.184,
   //              -8569693.727,   4926687.920, -7537625.130, -6328586.289
-  VLOAD_64(v4, 0xc1548c0b4e12be63, 0xc16152158ab92a41, 0xc1625164e1fd6af4,
+  VLOAD_64(v8, 0xc1548c0b4e12be63, 0xc16152158ab92a41, 0xc1625164e1fd6af4,
            0xc151a0c13b0c041c, 0x413ec97d0edd7a68, 0x4130e1e5fa5c8120,
            0xc13ffaed4c78fc7c, 0x413d2b2550357b50, 0x41526ffb61d23f42,
            0x4133b377675b6328, 0xc162f64923d5cce3, 0x4161a962e5e3a1e8,
            0xc160586bb74734b0, 0x4152cb37fae70f80, 0xc15cc0f6484f174c,
            0xc1582442928257b8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.rtz.xu.f.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.rtz.xu.f.v v16, v8, v0.t");
   //                                   0,                      0, 0, 0, 0,
   //                                   1106405,                      0, 1911589,
   //                                   0,                1291127, 0, 9259799, 0,
   //                                   4926687,                      0, 0
-  VCMP_U64(18, v6, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+  VCMP_U64(18, v16, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
            0x0000000000000000, 0x0000000000000000, 0x000000000010e1e5,
            0x0000000000000000, 0x00000000001d2b25, 0x0000000000000000,
            0x000000000013b377, 0x0000000000000000, 0x00000000008d4b17,
@@ -425,61 +425,61 @@ void TEST_CASE6(void) {
 
 // Simple random test with similar values
 void TEST_CASE7(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //                5116.000,   4640.000,   5720.000,   1316.000,   8104.000,
   //                9952.000,   9400.000, -4120.000, -9368.000,   6076.000,
   //                1782.000, -5332.000, -4284.000, -2878.000, -2752.000,
   //                3714.000
-  VLOAD_16(v4, 0x6cff, 0x6c88, 0x6d96, 0x6524, 0x6fea, 0x70dc, 0x7097, 0xec06,
+  VLOAD_16(v8, 0x6cff, 0x6c88, 0x6d96, 0x6524, 0x6fea, 0x70dc, 0x7097, 0xec06,
            0xf093, 0x6def, 0x66f6, 0xed35, 0xec2f, 0xe99f, 0xe960, 0x6b41);
-  asm volatile("vfcvt.rtz.x.f.v v6, v4");
+  asm volatile("vfcvt.rtz.x.f.v v16, v8");
   //                    5116,       4640,       5720,       1316,       8104,
   //                    9952,       9400,      -4120,      -9368,       6076,
   //                    1782,      -5332,      -4284,      -2878,      -2752,
   //                    3714
-  VCMP_U16(19, v6, 0x13fc, 0x1220, 0x1658, 0x0524, 0x1fa8, 0x26e0, 0x24b8,
+  VCMP_U16(19, v16, 0x13fc, 0x1220, 0x1658, 0x0524, 0x1fa8, 0x26e0, 0x24b8,
            0xefe8, 0xdb68, 0x17bc, 0x06f6, 0xeb2c, 0xef44, 0xf4c2, 0xf540,
            0x0e82);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -31395.312,   38407.539,   39625.664, -19419.770, -77414.898,
   //              -96104.727, -8227.330, -45789.250, -74805.781,   78266.945,
   //              1635.832, -33150.762,   17428.920, -93694.898,   93592.562,
   //              -83328.680
-  VLOAD_32(v4, 0xc6f546a0, 0x4716078a, 0x471ac9aa, 0xc697b78a, 0xc7973373,
+  VLOAD_32(v8, 0xc6f546a0, 0x4716078a, 0x471ac9aa, 0xc697b78a, 0xc7973373,
            0xc7bbb45d, 0xc6008d52, 0xc732dd40, 0xc7921ae4, 0x4798dd79,
            0x44cc7aa0, 0xc7017ec3, 0x468829d7, 0xc7b6ff73, 0x47b6cc48,
            0xc7a2c057);
-  asm volatile("vfcvt.rtz.x.f.v v6, v4");
+  asm volatile("vfcvt.rtz.x.f.v v16, v8");
   //                      -31395,          38407,          39625, -19419,
   //                      -77414,         -96104,          -8227, -45789,
   //                      -74805,          78266,           1635, -33150, 17428,
   //                      -93694,          93592,         -83328
-  VCMP_U32(20, v6, 0xffff855d, 0x00009607, 0x00009ac9, 0xffffb425, 0xfffed19a,
+  VCMP_U32(20, v16, 0xffff855d, 0x00009607, 0x00009ac9, 0xffffb425, 0xfffed19a,
            0xfffe8898, 0xffffdfdd, 0xffff4d23, 0xfffedbcb, 0x000131ba,
            0x00000663, 0xffff7e82, 0x00004414, 0xfffe9202, 0x00016d98,
            0xfffeba80);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                1347922.217,   7326256.926,   2532328.150, -4365139.352,
   //                -3892733.643, -3401324.772, -2109243.969,   61221.157,
   //                -307581.498, -6001564.901, -1299579.664, -2048360.900,
   //                3486773.936, -5491246.977, -2222467.648,   1432204.815
-  VLOAD_64(v4, 0x413491523797bd28, 0x415bf28c3b410560, 0x414351f41339c8f8,
+  VLOAD_64(v8, 0x413491523797bd28, 0x415bf28c3b410560, 0x414351f41339c8f8,
            0xc150a6d4d6864763, 0xc14db2fed245a01c, 0xc149f33662d1f60e,
            0xc140179dfc15a4ac, 0x40ede4a503831a00, 0xc112c5f5fdac3c80,
            0xc156e4e739a40168, 0xc133d47ba9e7da00, 0xc13f4168e650cc0c,
            0x414a9a1af7c5dda0, 0xc154f28bbe844db6, 0xc140f4c1d2e7a21a,
            0x4135da8cd09570f8);
-  asm volatile("vfcvt.rtz.x.f.v v6, v4");
+  asm volatile("vfcvt.rtz.x.f.v v16, v8");
   //                             1347922,                7326256, 2532328,
   //                             -4365139,               -3892733, -3401324,
   //                             -2109243,                  61221, -307581,
   //                             -6001564,               -1299579, -2048360,
   //                             3486773,               -5491246, -2222467,
   //                             1432204
-  VCMP_U64(21, v6, 0x0000000000149152, 0x00000000006fca30, 0x000000000026a3e8,
+  VCMP_U64(21, v16, 0x0000000000149152, 0x00000000006fca30, 0x000000000026a3e8,
            0xffffffffffbd64ad, 0xffffffffffc49a03, 0xffffffffffcc1994,
            0xffffffffffdfd0c5, 0x000000000000ef25, 0xfffffffffffb4e83,
            0xffffffffffa46c64, 0xffffffffffec2b85, 0xffffffffffe0be98,
@@ -491,66 +491,66 @@ void TEST_CASE7(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE8(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //                5116.000,   4640.000,   5720.000,   1316.000,   8104.000,
   //                9952.000,   9400.000, -4120.000, -9368.000,   6076.000,
   //                1782.000, -5332.000, -4284.000, -2878.000, -2752.000,
   //                3714.000
-  VLOAD_16(v4, 0x6cff, 0x6c88, 0x6d96, 0x6524, 0x6fea, 0x70dc, 0x7097, 0xec06,
+  VLOAD_16(v8, 0x6cff, 0x6c88, 0x6d96, 0x6524, 0x6fea, 0x70dc, 0x7097, 0xec06,
            0xf093, 0x6def, 0x66f6, 0xed35, 0xec2f, 0xe99f, 0xe960, 0x6b41);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.rtz.x.f.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.rtz.x.f.v v16, v8, v0.t");
   //                       0,       4640,          0,       1316,          0,
   //                       9952,          0,      -4120,          0,       6076,
   //                       0,      -5332,          0,      -2878,          0,
   //                       3714
-  VCMP_U16(22, v6, 0x0000, 0x1220, 0x0000, 0x0524, 0x0000, 0x26e0, 0x0000,
+  VCMP_U16(22, v16, 0x0000, 0x1220, 0x0000, 0x0524, 0x0000, 0x26e0, 0x0000,
            0xefe8, 0x0000, 0x17bc, 0x0000, 0xeb2c, 0x0000, 0xf4c2, 0x0000,
            0x0e82);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -31395.312,   38407.539,   39625.664, -19419.770, -77414.898,
   //              -96104.727, -8227.330, -45789.250, -74805.781,   78266.945,
   //              1635.832, -33150.762,   17428.920, -93694.898,   93592.562,
   //              -83328.680
-  VLOAD_32(v4, 0xc6f546a0, 0x4716078a, 0x471ac9aa, 0xc697b78a, 0xc7973373,
+  VLOAD_32(v8, 0xc6f546a0, 0x4716078a, 0x471ac9aa, 0xc697b78a, 0xc7973373,
            0xc7bbb45d, 0xc6008d52, 0xc732dd40, 0xc7921ae4, 0x4798dd79,
            0x44cc7aa0, 0xc7017ec3, 0x468829d7, 0xc7b6ff73, 0x47b6cc48,
            0xc7a2c057);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.rtz.x.f.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.rtz.x.f.v v16, v8, v0.t");
   //                           0,          38407,              0, -19419, 0,
   //                           -96104,              0,         -45789, 0, 78266,
   //                           0,         -33150,              0, -93694, 0,
   //                           -83328
-  VCMP_U32(23, v6, 0x00000000, 0x00009607, 0x00000000, 0xffffb425, 0x00000000,
+  VCMP_U32(23, v16, 0x00000000, 0x00009607, 0x00000000, 0xffffb425, 0x00000000,
            0xfffe8898, 0x00000000, 0xffff4d23, 0x00000000, 0x000131ba,
            0x00000000, 0xffff7e82, 0x00000000, 0xfffe9202, 0x00000000,
            0xfffeba80);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                1347922.217,   7326256.926,   2532328.150, -4365139.352,
   //                -3892733.643, -3401324.772, -2109243.969,   61221.157,
   //                -307581.498, -6001564.901, -1299579.664, -2048360.900,
   //                3486773.936, -5491246.977, -2222467.648,   1432204.815
-  VLOAD_64(v4, 0x413491523797bd28, 0x415bf28c3b410560, 0x414351f41339c8f8,
+  VLOAD_64(v8, 0x413491523797bd28, 0x415bf28c3b410560, 0x414351f41339c8f8,
            0xc150a6d4d6864763, 0xc14db2fed245a01c, 0xc149f33662d1f60e,
            0xc140179dfc15a4ac, 0x40ede4a503831a00, 0xc112c5f5fdac3c80,
            0xc156e4e739a40168, 0xc133d47ba9e7da00, 0xc13f4168e650cc0c,
            0x414a9a1af7c5dda0, 0xc154f28bbe844db6, 0xc140f4c1d2e7a21a,
            0x4135da8cd09570f8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.rtz.x.f.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.rtz.x.f.v v16, v8, v0.t");
   //                                   0,                7326256, 0, -4365139,
   //                                   0,               -3401324, 0, 61221, 0,
   //                                   -6001564,                      0,
   //                                   -2048360,                      0,
   //                                   -5491246,                      0, 1432204
-  VCMP_U64(24, v6, 0x0000000000000000, 0x00000000006fca30, 0x0000000000000000,
+  VCMP_U64(24, v16, 0x0000000000000000, 0x00000000006fca30, 0x0000000000000000,
            0xffffffffffbd64ad, 0x0000000000000000, 0xffffffffffcc1994,
            0x0000000000000000, 0x000000000000ef25, 0x0000000000000000,
            0xffffffffffa46c64, 0x0000000000000000, 0xffffffffffe0be98,
@@ -564,56 +564,56 @@ void TEST_CASE8(void) {
 ////////////////
 
 void TEST_CASE9(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //                   55973,      61786,      64322,      55940,      55857,
   //                   3425,       1068,       4246,      57901,       7342,
   //                   8693,      60988,       9047,      63358,      58389,
   //                   8076
-  VLOAD_16(v4, 0xdaa5, 0xf15a, 0xfb42, 0xda84, 0xda31, 0x0d61, 0x042c, 0x1096,
+  VLOAD_16(v8, 0xdaa5, 0xf15a, 0xfb42, 0xda84, 0xda31, 0x0d61, 0x042c, 0x1096,
            0xe22d, 0x1cae, 0x21f5, 0xee3c, 0x2357, 0xf77e, 0xe415, 0x1f8c);
-  asm volatile("vfcvt.f.xu.v v6, v4");
+  asm volatile("vfcvt.f.xu.v v16, v8");
   //                55968.000,   61792.000,   64320.000,   55936.000, 55872.000,
   //                3424.000,   1068.000,   4248.000,   57888.000,   7344.000,
   //                8696.000,   60992.000,   9048.000,   63360.000,   58400.000,
   //                8076.000
-  VCMP_U16(25, v6, 0x7ad5, 0x7b8b, 0x7bda, 0x7ad4, 0x7ad2, 0x6ab0, 0x642c,
+  VCMP_U16(25, v16, 0x7ad5, 0x7b8b, 0x7bda, 0x7ad4, 0x7ad2, 0x6ab0, 0x642c,
            0x6c26, 0x7b11, 0x6f2c, 0x703f, 0x7b72, 0x706b, 0x7bbc, 0x7b21,
            0x6fe3);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //                       72473,     4294949057,          50975, 4294915723,
   //                       4294876584,     4294895088,          24967, 34761,
   //                       83805,          68361,          49397, 51562, 24877,
   //                       4294942241,     4294909502,          42562
-  VLOAD_32(v4, 0x00011b19, 0xffffb8c1, 0x0000c71f, 0xffff368b, 0xfffe9da8,
+  VLOAD_32(v8, 0x00011b19, 0xffffb8c1, 0x0000c71f, 0xffff368b, 0xfffe9da8,
            0xfffee5f0, 0x00006187, 0x000087c9, 0x0001475d, 0x00010b09,
            0x0000c0f5, 0x0000c96a, 0x0000612d, 0xffff9e21, 0xffff1e3e,
            0x0000a642);
-  asm volatile("vfcvt.f.xu.v v6, v4");
+  asm volatile("vfcvt.f.xu.v v16, v8");
   //                72473.000,   4294949120.000,   50975.000,   4294915840.000,
   //                4294876672.000,   4294895104.000,   24967.000,   34761.000,
   //                83805.000,   68361.000,   49397.000,   51562.000, 24877.000,
   //                4294942208.000,   4294909440.000,   42562.000
-  VCMP_U32(26, v6, 0x478d8c80, 0x4f7fffb9, 0x47471f00, 0x4f7fff37, 0x4f7ffe9e,
+  VCMP_U32(26, v16, 0x478d8c80, 0x4f7fffb9, 0x47471f00, 0x4f7fff37, 0x4f7ffe9e,
            0x4f7ffee6, 0x46c30e00, 0x4707c900, 0x47a3ae80, 0x47858480,
            0x4740f500, 0x47496a00, 0x46c25a00, 0x4f7fff9e, 0x4f7fff1e,
            0x47264200);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                 18446744073707704187,    18446744073702261660, 4325496,
   //                 3834488,    18446744073707063867,    18446744073706356425,
   //                 5215660,    18446744073707545423,                  69532,
   //                 18446744073707444829,                4236283, 3402850,
   //                 18446744073708706866,                 275183, 4230347,
   //                 18446744073704794800
-  VLOAD_64(v4, 0xffffffffffe3cf7b, 0xffffffffff90c39c, 0x0000000000420078,
+  VLOAD_64(v8, 0xffffffffffe3cf7b, 0xffffffffff90c39c, 0x0000000000420078,
            0x00000000003a8278, 0xffffffffffda0a3b, 0xffffffffffcf3ec9,
            0x00000000004f95ac, 0xffffffffffe1634f, 0x0000000000010f9c,
            0xffffffffffdfda5d, 0x000000000040a3fb, 0x000000000033ec62,
            0xfffffffffff31c32, 0x00000000000432ef, 0x0000000000408ccb,
            0xffffffffffb76ab0);
-  asm volatile("vfcvt.f.xu.v v6, v4");
+  asm volatile("vfcvt.f.xu.v v16, v8");
   //                18446744073707704320.000,   18446744073702260736.000,
   //                4325496.000,   3834488.000,   18446744073707063296.000,
   //                18446744073706356736.000,   5215660.000,
@@ -621,7 +621,7 @@ void TEST_CASE9(void) {
   //                18446744073707444224.000,   4236283.000,   3402850.000,
   //                18446744073708707840.000,   275183.000,   4230347.000,
   //                18446744073704794112.000
-  VCMP_U64(27, v6, 0x43effffffffffc7a, 0x43effffffffff218, 0x4150801e00000000,
+  VCMP_U64(27, v16, 0x43effffffffffc7a, 0x43effffffffff218, 0x4150801e00000000,
            0x414d413c00000000, 0x43effffffffffb41, 0x43effffffffff9e8,
            0x4153e56b00000000, 0x43effffffffffc2c, 0x40f0f9c000000000,
            0x43effffffffffbfb, 0x415028fec0000000, 0x4149f63100000000,
@@ -633,65 +633,65 @@ void TEST_CASE9(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE10(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //                   55973,      61786,      64322,      55940,      55857,
   //                   3425,       1068,       4246,      57901,       7342,
   //                   8693,      60988,       9047,      63358,      58389,
   //                   8076
-  VLOAD_16(v4, 0xdaa5, 0xf15a, 0xfb42, 0xda84, 0xda31, 0x0d61, 0x042c, 0x1096,
+  VLOAD_16(v8, 0xdaa5, 0xf15a, 0xfb42, 0xda84, 0xda31, 0x0d61, 0x042c, 0x1096,
            0xe22d, 0x1cae, 0x21f5, 0xee3c, 0x2357, 0xf77e, 0xe415, 0x1f8c);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.f.xu.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.f.xu.v v16, v8, v0.t");
   //                0.000,   61792.000,   0.000,   55936.000,   0.000, 3424.000,
   //                0.000,   4248.000,   0.000,   7344.000,   0.000, 60992.000,
   //                0.000,   63360.000,   0.000,   8076.000
-  VCMP_U16(28, v6, 0x0, 0x7b8b, 0x0, 0x7ad4, 0x0, 0x6ab0, 0x0, 0x6c26, 0x0,
+  VCMP_U16(28, v16, 0x0, 0x7b8b, 0x0, 0x7ad4, 0x0, 0x6ab0, 0x0, 0x6c26, 0x0,
            0x6f2c, 0x0, 0x7b72, 0x0, 0x7bbc, 0x0, 0x6fe3);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //                       72473,     4294949057,          50975, 4294915723,
   //                       4294876584,     4294895088,          24967, 34761,
   //                       83805,          68361,          49397, 51562, 24877,
   //                       4294942241,     4294909502,          42562
-  VLOAD_32(v4, 0x00011b19, 0xffffb8c1, 0x0000c71f, 0xffff368b, 0xfffe9da8,
+  VLOAD_32(v8, 0x00011b19, 0xffffb8c1, 0x0000c71f, 0xffff368b, 0xfffe9da8,
            0xfffee5f0, 0x00006187, 0x000087c9, 0x0001475d, 0x00010b09,
            0x0000c0f5, 0x0000c96a, 0x0000612d, 0xffff9e21, 0xffff1e3e,
            0x0000a642);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.f.xu.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.f.xu.v v16, v8, v0.t");
   //                0.000,   4294949120.000,   0.000,   4294915840.000,   0.000,
   //                4294895104.000,   0.000,   34761.000,   0.000,   68361.000,
   //                0.000,   51562.000,   0.000,   4294942208.000,   0.000,
   //                42562.000
-  VCMP_U32(29, v6, 0x0, 0x4f7fffb9, 0x0, 0x4f7fff37, 0x0, 0x4f7ffee6, 0x0,
+  VCMP_U32(29, v16, 0x0, 0x4f7fffb9, 0x0, 0x4f7fff37, 0x0, 0x4f7ffee6, 0x0,
            0x4707c900, 0x0, 0x47858480, 0x0, 0x47496a00, 0x0, 0x4f7fff9e, 0x0,
            0x47264200);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                 18446744073707704187,    18446744073702261660, 4325496,
   //                 3834488,    18446744073707063867,    18446744073706356425,
   //                 5215660,    18446744073707545423,                  69532,
   //                 18446744073707444829,                4236283, 3402850,
   //                 18446744073708706866,                 275183, 4230347,
   //                 18446744073704794800
-  VLOAD_64(v4, 0xffffffffffe3cf7b, 0xffffffffff90c39c, 0x0000000000420078,
+  VLOAD_64(v8, 0xffffffffffe3cf7b, 0xffffffffff90c39c, 0x0000000000420078,
            0x00000000003a8278, 0xffffffffffda0a3b, 0xffffffffffcf3ec9,
            0x00000000004f95ac, 0xffffffffffe1634f, 0x0000000000010f9c,
            0xffffffffffdfda5d, 0x000000000040a3fb, 0x000000000033ec62,
            0xfffffffffff31c32, 0x00000000000432ef, 0x0000000000408ccb,
            0xffffffffffb76ab0);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.f.xu.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.f.xu.v v16, v8, v0.t");
   //                0.000,   18446744073702260736.000,   0.000,   3834488.000,
   //                0.000,   18446744073706356736.000,   0.000,
   //                18446744073707544576.000,   0.000, 18446744073707444224.000,
   //                0.000,   3402850.000,   0.000,   275183.000,   0.000,
   //                18446744073704794112.000
-  VCMP_U64(30, v6, 0x0, 0x43effffffffff218, 0x0, 0x414d413c00000000, 0x0,
+  VCMP_U64(30, v16, 0x0, 0x43effffffffff218, 0x0, 0x414d413c00000000, 0x0,
            0x43effffffffff9e8, 0x0, 0x43effffffffffc2c, 0x0, 0x43effffffffffbfb,
            0x0, 0x4149f63100000000, 0x0, 0x4110cbbc00000000, 0x0,
            0x43effffffffff6ed);
@@ -703,61 +703,61 @@ void TEST_CASE10(void) {
 ///////////////
 
 void TEST_CASE11(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //                   -4779,        465,       9893,      -6763,      -4072,
   //                   1612,      -9552,       2426,        325,       7561,
   //                   -8581,      -1741,      -8518,      -4699,       3653,
   //                   9937
-  VLOAD_16(v4, 0xed55, 0x01d1, 0x26a5, 0xe595, 0xf018, 0x064c, 0xdab0, 0x097a,
+  VLOAD_16(v8, 0xed55, 0x01d1, 0x26a5, 0xe595, 0xf018, 0x064c, 0xdab0, 0x097a,
            0x0145, 0x1d89, 0xde7b, 0xf933, 0xdeba, 0xeda5, 0x0e45, 0x26d1);
-  asm volatile("vfcvt.f.x.v v6, v4");
+  asm volatile("vfcvt.f.x.v v16, v8");
   //              -4780.000,   465.000,   9896.000, -6764.000, -4072.000,
   //              1612.000, -9552.000,   2426.000,   325.000,   7560.000,
   //              -8584.000, -1741.000, -8520.000, -4700.000,   3652.000,
   //              9936.000
-  VCMP_U16(31, v6, 0xecab, 0x5f44, 0x70d5, 0xee9b, 0xebf4, 0x664c, 0xf0aa,
+  VCMP_U16(31, v16, 0xecab, 0x5f44, 0x70d5, 0xee9b, 0xebf4, 0x664c, 0xf0aa,
            0x68bd, 0x5d14, 0x6f62, 0xf031, 0xe6cd, 0xf029, 0xec97, 0x6b22,
            0x70da);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //                      -39422,          54262,          12833, -40266,
   //                      -64918,          28317,          89178, 54320, -99922,
   //                      -73005,          95070,         -24716, 60663, 59516,
   //                      14865,          26328
-  VLOAD_32(v4, 0xffff6602, 0x0000d3f6, 0x00003221, 0xffff62b6, 0xffff026a,
+  VLOAD_32(v8, 0xffff6602, 0x0000d3f6, 0x00003221, 0xffff62b6, 0xffff026a,
            0x00006e9d, 0x00015c5a, 0x0000d430, 0xfffe79ae, 0xfffee2d3,
            0x0001735e, 0xffff9f74, 0x0000ecf7, 0x0000e87c, 0x00003a11,
            0x000066d8);
-  asm volatile("vfcvt.f.x.v v6, v4");
+  asm volatile("vfcvt.f.x.v v16, v8");
   //              -39422.000,   54262.000,   12833.000, -40266.000, -64918.000,
   //              28317.000,   89178.000,   54320.000, -99922.000, -73005.000,
   //              95070.000, -24716.000,   60663.000,   59516.000,   14865.000,
   //              26328.000
-  VCMP_U32(32, v6, 0xc719fe00, 0x4753f600, 0x46488400, 0xc71d4a00, 0xc77d9600,
+  VCMP_U32(32, v16, 0xc719fe00, 0x4753f600, 0x46488400, 0xc71d4a00, 0xc77d9600,
            0x46dd3a00, 0x47ae2d00, 0x47543000, 0xc7c32900, 0xc78e9680,
            0x47b9af00, 0xc6c11800, 0x476cf700, 0x47687c00, 0x46684400,
            0x46cdb000);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                            -8860682,                8064547, -5636078,
   //                            -3712253,                8492493, 9839246,
   //                            -8271278,               -6234598, -4538479,
   //                            8807688,                5640899, 3839761,
   //                            -1394518,               -6118355, 1783927,
   //                            5819812
-  VLOAD_64(v4, 0xffffffffff78cbf6, 0x00000000007b0e23, 0xffffffffffaa0012,
+  VLOAD_64(v8, 0xffffffffff78cbf6, 0x00000000007b0e23, 0xffffffffffaa0012,
            0xffffffffffc75b03, 0x00000000008195cd, 0x000000000096228e,
            0xffffffffff81ca52, 0xffffffffffa0de1a, 0xffffffffffbabf91,
            0x0000000000866508, 0x00000000005612c3, 0x00000000003a9711,
            0xffffffffffeab8aa, 0xffffffffffa2a42d, 0x00000000001b3877,
            0x000000000058cda4);
-  asm volatile("vfcvt.f.x.v v6, v4");
+  asm volatile("vfcvt.f.x.v v16, v8");
   //              -8860682.000,   8064547.000, -5636078.000, -3712253.000,
   //              8492493.000,   9839246.000, -8271278.000, -6234598.000,
   //              -4538479.000,   8807688.000,   5640899.000,   3839761.000,
   //              -1394518.000, -6118355.000,   1783927.000,   5819812.000
-  VCMP_U64(33, v6, 0xc160e68140000000, 0x415ec388c0000000, 0xc1557ffb80000000,
+  VCMP_U64(33, v16, 0xc160e68140000000, 0x415ec388c0000000, 0xc1557ffb80000000,
            0xc14c527e80000000, 0x416032b9a0000000, 0x4162c451c0000000,
            0xc15f8d6b80000000, 0xc157c87980000000, 0xc151501bc0000000,
            0x4160cca100000000, 0x415584b0c0000000, 0x414d4b8880000000,
@@ -769,63 +769,63 @@ void TEST_CASE11(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE12(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //                   -4779,        465,       9893,      -6763,      -4072,
   //                   1612,      -9552,       2426,        325,       7561,
   //                   -8581,      -1741,      -8518,      -4699,       3653,
   //                   9937
-  VLOAD_16(v4, 0xed55, 0x01d1, 0x26a5, 0xe595, 0xf018, 0x064c, 0xdab0, 0x097a,
+  VLOAD_16(v8, 0xed55, 0x01d1, 0x26a5, 0xe595, 0xf018, 0x064c, 0xdab0, 0x097a,
            0x0145, 0x1d89, 0xde7b, 0xf933, 0xdeba, 0xeda5, 0x0e45, 0x26d1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.f.x.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.f.x.v v16, v8, v0.t");
   //                0.000,   465.000,   0.000, -6764.000,   0.000,   1612.000,
   //                0.000,   2426.000,   0.000,   7560.000,   0.000, -1741.000,
   //                0.000, -4700.000,   0.000,   9936.000
-  VCMP_U16(34, v6, 0x0, 0x5f44, 0x0, 0xee9b, 0x0, 0x664c, 0x0, 0x68bd, 0x0,
+  VCMP_U16(34, v16, 0x0, 0x5f44, 0x0, 0xee9b, 0x0, 0x664c, 0x0, 0x68bd, 0x0,
            0x6f62, 0x0, 0xe6cd, 0x0, 0xec97, 0x0, 0x70da);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //                      -39422,          54262,          12833, -40266,
   //                      -64918,          28317,          89178, 54320, -99922,
   //                      -73005,          95070,         -24716, 60663, 59516,
   //                      14865,          26328
-  VLOAD_32(v4, 0xffff6602, 0x0000d3f6, 0x00003221, 0xffff62b6, 0xffff026a,
+  VLOAD_32(v8, 0xffff6602, 0x0000d3f6, 0x00003221, 0xffff62b6, 0xffff026a,
            0x00006e9d, 0x00015c5a, 0x0000d430, 0xfffe79ae, 0xfffee2d3,
            0x0001735e, 0xffff9f74, 0x0000ecf7, 0x0000e87c, 0x00003a11,
            0x000066d8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.f.x.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.f.x.v v16, v8, v0.t");
   //                0.000,   54262.000,   0.000, -40266.000,   0.000, 28317.000,
   //                0.000,   54320.000,   0.000, -73005.000,   0.000,
   //                -24716.000,   0.000,   59516.000,   0.000,   26328.000
-  VCMP_U32(35, v6, 0x0, 0x4753f600, 0x0, 0xc71d4a00, 0x0, 0x46dd3a00, 0x0,
+  VCMP_U32(35, v16, 0x0, 0x4753f600, 0x0, 0xc71d4a00, 0x0, 0x46dd3a00, 0x0,
            0x47543000, 0x0, 0xc78e9680, 0x0, 0xc6c11800, 0x0, 0x47687c00, 0x0,
            0x46cdb000);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                            -8860682,                8064547, -5636078,
   //                            -3712253,                8492493, 9839246,
   //                            -8271278,               -6234598, -4538479,
   //                            8807688,                5640899, 3839761,
   //                            -1394518,               -6118355, 1783927,
   //                            5819812
-  VLOAD_64(v4, 0xffffffffff78cbf6, 0x00000000007b0e23, 0xffffffffffaa0012,
+  VLOAD_64(v8, 0xffffffffff78cbf6, 0x00000000007b0e23, 0xffffffffffaa0012,
            0xffffffffffc75b03, 0x00000000008195cd, 0x000000000096228e,
            0xffffffffff81ca52, 0xffffffffffa0de1a, 0xffffffffffbabf91,
            0x0000000000866508, 0x00000000005612c3, 0x00000000003a9711,
            0xffffffffffeab8aa, 0xffffffffffa2a42d, 0x00000000001b3877,
            0x000000000058cda4);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vfcvt.f.x.v v6, v4, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfcvt.f.x.v v16, v8, v0.t");
   //                0.000,   8064547.000,   0.000, -3712253.000,   0.000,
   //                9839246.000,   0.000, -6234598.000,   0.000,   8807688.000,
   //                0.000,   3839761.000,   0.000, -6118355.000,   0.000,
   //                5819812.000
-  VCMP_U64(36, v6, 0x0, 0x415ec388c0000000, 0x0, 0xc14c527e80000000, 0x0,
+  VCMP_U64(36, v16, 0x0, 0x415ec388c0000000, 0x0, 0xc14c527e80000000, 0x0,
            0x4162c451c0000000, 0x0, 0xc157c87980000000, 0x0, 0x4160cca100000000,
            0x0, 0x414d4b8880000000, 0x0, 0xc15756f4c0000000, 0x0,
            0x4156336900000000);
diff --git a/sw/riscvTests/isa/rv64uv/vfmacc.c b/sw/riscvTests/isa/rv64uv/vfmacc.c
index 795e55d9..1ceda34e 100644
--- a/sw/riscvTests/isa/rv64uv/vfmacc.c
+++ b/sw/riscvTests/isa/rv64uv/vfmacc.c
@@ -10,36 +10,36 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.6353, -0.2290,  0.6870, -0.1031,  0.5410,  0.4211, -0.4939,
   //              -0.8779, -0.3213, -0.6846,  0.9229,  0.0103, -0.5068,  0.8706,
   //              0.6309, -0.3054
-  VLOAD_16(v4, 0xb915, 0xb354, 0x397f, 0xae9a, 0x3854, 0x36bd, 0xb7e7, 0xbb06,
+  VLOAD_16(v16, 0xb915, 0xb354, 0x397f, 0xae9a, 0x3854, 0x36bd, 0xb7e7, 0xbb06,
            0xb524, 0xb97a, 0x3b62, 0x2142, 0xb80e, 0x3af7, 0x390c, 0xb4e3);
   //              -0.8042, -0.9463,  0.4431,  0.3757, -0.5259, -0.1290,  0.4697,
   //              0.0952, -0.9995,  0.8823, -0.6128, -0.5010, -0.9976,  0.0081,
   //              0.9746, -0.7734
-  VLOAD_16(v6, 0xba6f, 0xbb92, 0x3717, 0x3603, 0xb835, 0xb021, 0x3784, 0x2e17,
+  VLOAD_16(v24, 0xba6f, 0xbb92, 0x3717, 0x3603, 0xb835, 0xb021, 0x3784, 0x2e17,
            0xbbff, 0x3b0f, 0xb8e7, 0xb802, 0xbbfb, 0x2022, 0x3bcc, 0xba30);
   //               0.6509,  0.3452,  0.9360,  0.3616, -0.4258, -0.0945, -0.7295,
   //               -0.7734,  0.3411, -0.1519, -0.3557,  0.6060,  0.2598,
   //               -0.0171, -0.8042, -0.4419
-  VLOAD_16(v2, 0x3935, 0x3586, 0x3b7d, 0x35c9, 0xb6d0, 0xae0d, 0xb9d6, 0xba30,
+  VLOAD_16(v8, 0x3935, 0x3586, 0x3b7d, 0x35c9, 0xb6d0, 0xae0d, 0xb9d6, 0xba30,
            0x3575, 0xb0dc, 0xb5b1, 0x38d9, 0x3428, 0xa45e, 0xba6f, 0xb712);
-  asm volatile("vfmacc.vv v2, v4, v6");
+  asm volatile("vfmacc.vv v8, v16, v24");
   //               1.1621,  0.5620,  1.2402,  0.3228, -0.7100, -0.1489, -0.9614,
   //               -0.8569,  0.6621, -0.7559, -0.9209,  0.6006,  0.7651,
   //               -0.0100, -0.1895, -0.2057
-  VCMP_U16(1, v2, 0x3ca6, 0x387f, 0x3cf6, 0x352a, 0xb9af, 0xb0c4, 0xbbb1,
+  VCMP_U16(1, v8, 0x3ca6, 0x387f, 0x3cf6, 0x352a, 0xb9af, 0xb0c4, 0xbbb1,
            0xbadb, 0x394c, 0xba0c, 0xbb5f, 0x38ce, 0x3a1f, 0xa123, 0xb20f,
            0xb295);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.72754014,  0.34003398,  0.70107144, -0.41727209,
   //               -0.52331781, -0.11821542, -0.16069038,  0.30835113,
   //               -0.59407759, -0.53240144, -0.92390168,  0.33251825,
   //               -0.45979658,  0.32465541, -0.99342769, -0.16221718
-  VLOAD_32(v4, 0x3f3a4012, 0x3eae18ef, 0x3f33796b, 0xbed5a4b0, 0xbf05f828,
+  VLOAD_32(v16, 0x3f3a4012, 0x3eae18ef, 0x3f33796b, 0xbed5a4b0, 0xbf05f828,
            0xbdf21aed, 0xbe248c05, 0x3e9de033, 0xbf181578, 0xbf084b76,
            0xbf6c84d2, 0x3eaa3fd5, 0xbeeb6a75, 0x3ea6393c, 0xbf7e5147,
            0xbe261c43);
@@ -47,7 +47,7 @@ void TEST_CASE1(void) {
   //               0.93318671, -0.32301557,  0.41414812,  0.81797487,
   //               -0.21847244, -0.00211347, -0.72070456, -0.58624452,
   //               0.07381243, -0.16745377,  0.55389816, -0.23427610
-  VLOAD_32(v6, 0x3f7377f9, 0xbded11e6, 0x3e07f41b, 0x3e694fdb, 0x3f6ee553,
+  VLOAD_32(v24, 0x3f7377f9, 0xbded11e6, 0x3e07f41b, 0x3e694fdb, 0x3f6ee553,
            0xbea5624c, 0x3ed40b39, 0x3f5166cd, 0xbe5fb73d, 0xbb0a8224,
            0xbf388018, 0xbf16141f, 0x3d972af9, 0xbe2b7900, 0x3f0dcc45,
            0xbe6fe613);
@@ -55,29 +55,29 @@ void TEST_CASE1(void) {
   //              0.24971253,  0.97819000,  0.55116856, -0.97427863, 0.61764765,
   //              0.86367106,  0.48787504, -0.26353455, -0.22228357, 0.40454853,
   //              0.64000225, -0.51787829
-  VLOAD_32(v2, 0xbd98c591, 0xbb97273a, 0xbf79fed5, 0x3f71a618, 0x3e7fb4a4,
+  VLOAD_32(v8, 0xbd98c591, 0xbb97273a, 0xbf79fed5, 0x3f71a618, 0x3e7fb4a4,
            0x3f7a6aa9, 0x3f0d1962, 0xbf796a53, 0x3f1e1e28, 0x3f5d198c,
            0x3ef9cac2, 0xbe86ee00, 0xbe639e4e, 0x3ecf20fc, 0x3f23d730,
            0xbf0493ac);
-  asm volatile("vfmacc.vv v2, v4, v6");
+  asm volatile("vfmacc.vv v8, v16, v24");
   //               0.61733103, -0.04397407, -0.88346541,  0.84886783,
   //               -0.23864070,  1.01637542,  0.48461893, -0.72205520,
   //               0.74743724,  0.86479628,  1.15373516, -0.45847154,
   //               -0.25622228,  0.35018376,  0.08974451, -0.47987467
-  VCMP_U32(2, v2, 0x3f1e0968, 0xbd341e29, 0xbf622aca, 0x3f594f67, 0xbe745e3a,
+  VCMP_U32(2, v8, 0x3f1e0968, 0xbd341e29, 0xbf622aca, 0x3f594f67, 0xbe745e3a,
            0x3f821897, 0x3ef81ff9, 0xbf38d89b, 0x3f3f580c, 0x3f5d634a,
            0x3f93ad98, 0xbeeabcc8, 0xbe832f91, 0x3eb34b49, 0x3db7cbf5,
            0xbef5b222);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.8992497708533775,  0.5795977429472710, -0.9421852470430045,
   //              0.3407052467776674, -0.1137141395145149,  0.3284679540868891,
   //              0.9781857174570949,  0.6033619236526551, -0.1287683269222892,
   //              0.6555379481826638,  0.6785468173738887,  0.6923267883951645,
   //              0.2185923779321672, -0.1310544396012536, -0.7596952716763763,
   //              -0.4011231994121780,
-  VLOAD_64(v4, 0xbfecc6a774980626, 0x3fe28c1090d967fc, 0xbfee2661acda592c,
+  VLOAD_64(v16, 0xbfecc6a774980626, 0x3fe28c1090d967fc, 0xbfee2661acda592c,
            0x3fd5ce1d611f1590, 0xbfbd1c5eae4ec060, 0x3fd5059e742594fc,
            0x3fef4d4c223c8f84, 0x3fe34ebdaa37ac76, 0xbfc07b7b047228c0,
            0x3fe4fa2ab8176850, 0x3fe5b6a7d0ad9fa2, 0x3fe6278a8249a986,
@@ -89,7 +89,7 @@ void TEST_CASE1(void) {
   //               0.1775335284298603, -0.7021940272509897,  0.9279338928738479,
   //               -0.7358371767028979,  0.2529700403354449,
   //               -0.8333759771774525, -0.4016540133317048,
-  VLOAD_64(v6, 0x3fd36160c2769da4, 0x3fe00d350479c3ea, 0x3fc852de63fd6e08,
+  VLOAD_64(v24, 0x3fd36160c2769da4, 0x3fe00d350479c3ea, 0x3fc852de63fd6e08,
            0x3fd51548a8a19488, 0x3fe306781d37ea9a, 0xbfec06bc7e604fb8,
            0x3fd7ce88a1b60584, 0x3fed4f57e864d750, 0x3fb4a00b38c069f0,
            0x3fc6b96b2d465dc0, 0xbfe6785f9bcfaa42, 0x3fedb1a26b57c7d6,
@@ -101,20 +101,20 @@ void TEST_CASE1(void) {
   //              0.0322804237161178, -0.8345203693668675,  0.7175251091228996,
   //              -0.7419013213335950, -0.2977694001417877,  0.4556506623709609,
   //              -0.7832443836668095,
-  VLOAD_64(v2, 0xbfb0ffef54d0f220, 0xbfe5937e2c0e5202, 0x3fdba8604ddf0d80,
+  VLOAD_64(v8, 0xbfb0ffef54d0f220, 0xbfe5937e2c0e5202, 0x3fdba8604ddf0d80,
            0xbfc4d508600804d8, 0x3f93c690cdf47e40, 0xbfd6835fd0838044,
            0xbfdef17840e363cc, 0x3feaa6ceed574e1a, 0x3f9b1871c270c340,
            0x3fa0870f4852d0c0, 0xbfeab4640fc8d962, 0x3fe6f5f737b7bbe2,
            0xbfe7bda7d6ff9552, 0xbfd30ea762d6f1ec, 0x3fdd296165522d4c,
            0xbfe910568693fcea);
-  asm volatile("vfmacc.vv v2, v4, v6");
+  asm volatile("vfmacc.vv v8, v16, v24");
   //              -0.3387147047225807, -0.3835212035574087,  0.2531093914663254,
   //              -0.0505147363757267, -0.0482954147100367, -0.6394480093239447,
   //              -0.1196218202565150,  1.3855029309732363,  0.0160859479159849,
   //              0.1486603886766570, -1.3109918917369803,  1.3599586010192732,
   //              -0.9027497195599737, -0.3309222470138559,  1.0887624517613512,
   //              -0.6221316407824544,
-  VCMP_U64(3, v2, 0xbfd5ad8070dd4c48, 0xbfd88b9c84a68118, 0x3fd032f1bbaa2211,
+  VCMP_U64(3, v8, 0xbfd5ad8070dd4c48, 0xbfd88b9c84a68118, 0x3fd032f1bbaa2211,
            0xbfa9dd1149664d37, 0xbfa8ba2d3573e621, 0xbfe4765babf13c96,
            0xbfbe9f891de3c4d6, 0x3ff62b051f10acd5, 0x3f9078d5b0e5b2ba,
            0x3fc3074db9c9d78e, 0xbff4f9d2a2454dd5, 0x3ff5c263f334aac4,
@@ -126,62 +126,62 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked, the numbers are taken from
 // TEST_CASE1)
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xb915, 0xb354, 0x397f, 0xae9a, 0x3854, 0x36bd, 0xb7e7, 0xbb06,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xb915, 0xb354, 0x397f, 0xae9a, 0x3854, 0x36bd, 0xb7e7, 0xbb06,
            0xb524, 0xb97a, 0x3b62, 0x2142, 0xb80e, 0x3af7, 0x390c, 0xb4e3);
-  VLOAD_16(v6, 0xba6f, 0xbb92, 0x3717, 0x3603, 0xb835, 0xb021, 0x3784, 0x2e17,
+  VLOAD_16(v24, 0xba6f, 0xbb92, 0x3717, 0x3603, 0xb835, 0xb021, 0x3784, 0x2e17,
            0xbbff, 0x3b0f, 0xb8e7, 0xb802, 0xbbfb, 0x2022, 0x3bcc, 0xba30);
-  VLOAD_16(v2, 0x3935, 0x3586, 0x3b7d, 0x35c9, 0xb6d0, 0xae0d, 0xb9d6, 0xba30,
+  VLOAD_16(v8, 0x3935, 0x3586, 0x3b7d, 0x35c9, 0xb6d0, 0xae0d, 0xb9d6, 0xba30,
            0x3575, 0xb0dc, 0xb5b1, 0x38d9, 0x3428, 0xa45e, 0xba6f, 0xb712);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vfmacc.vv v2, v4, v6, v0.t");
-  VCMP_U16(4, v2, 0x3935, 0x387f, 0x3b7d, 0x352a, 0xb6d0, 0xb0c4, 0xb9d6,
+  asm volatile("vfmacc.vv v8, v16, v24, v0.t");
+  VCMP_U16(4, v8, 0x3935, 0x387f, 0x3b7d, 0x352a, 0xb6d0, 0xb0c4, 0xb9d6,
            0xbadb, 0x3575, 0xba0c, 0xb5b1, 0x38ce, 0x3428, 0xa123, 0xba6f,
            0xb295);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x3f3a4012, 0x3eae18ef, 0x3f33796b, 0xbed5a4b0, 0xbf05f828,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x3f3a4012, 0x3eae18ef, 0x3f33796b, 0xbed5a4b0, 0xbf05f828,
            0xbdf21aed, 0xbe248c05, 0x3e9de033, 0xbf181578, 0xbf084b76,
            0xbf6c84d2, 0x3eaa3fd5, 0xbeeb6a75, 0x3ea6393c, 0xbf7e5147,
            0xbe261c43);
-  VLOAD_32(v6, 0x3f7377f9, 0xbded11e6, 0x3e07f41b, 0x3e694fdb, 0x3f6ee553,
+  VLOAD_32(v24, 0x3f7377f9, 0xbded11e6, 0x3e07f41b, 0x3e694fdb, 0x3f6ee553,
            0xbea5624c, 0x3ed40b39, 0x3f5166cd, 0xbe5fb73d, 0xbb0a8224,
            0xbf388018, 0xbf16141f, 0x3d972af9, 0xbe2b7900, 0x3f0dcc45,
            0xbe6fe613);
-  VLOAD_32(v2, 0xbd98c591, 0xbb97273a, 0xbf79fed5, 0x3f71a618, 0x3e7fb4a4,
+  VLOAD_32(v8, 0xbd98c591, 0xbb97273a, 0xbf79fed5, 0x3f71a618, 0x3e7fb4a4,
            0x3f7a6aa9, 0x3f0d1962, 0xbf796a53, 0x3f1e1e28, 0x3f5d198c,
            0x3ef9cac2, 0xbe86ee00, 0xbe639e4e, 0x3ecf20fc, 0x3f23d730,
            0xbf0493ac);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vfmacc.vv v2, v4, v6, v0.t");
-  VCMP_U32(5, v2, 0xbd98c591, 0xbd341e29, 0xbf79fed5, 0x3f594f67, 0x3e7fb4a4,
+  asm volatile("vfmacc.vv v8, v16, v24, v0.t");
+  VCMP_U32(5, v8, 0xbd98c591, 0xbd341e29, 0xbf79fed5, 0x3f594f67, 0x3e7fb4a4,
            0x3f821897, 0x3f0d1962, 0xbf38d89b, 0x3f1e1e28, 0x3f5d634a,
            0x3ef9cac2, 0xbeeabcc8, 0xbe639e4e, 0x3eb34b49, 0x3f23d730,
            0xbef5b222);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0xbfecc6a774980626, 0x3fe28c1090d967fc, 0xbfee2661acda592c,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0xbfecc6a774980626, 0x3fe28c1090d967fc, 0xbfee2661acda592c,
            0x3fd5ce1d611f1590, 0xbfbd1c5eae4ec060, 0x3fd5059e742594fc,
            0x3fef4d4c223c8f84, 0x3fe34ebdaa37ac76, 0xbfc07b7b047228c0,
            0x3fe4fa2ab8176850, 0x3fe5b6a7d0ad9fa2, 0x3fe6278a8249a986,
            0x3fcbfad5c52fcfd8, 0xbfc0c664520a9f78, 0xbfe84f6c7558d3f0,
            0xbfd9ac00a3c919a8);
-  VLOAD_64(v6, 0x3fd36160c2769da4, 0x3fe00d350479c3ea, 0x3fc852de63fd6e08,
+  VLOAD_64(v24, 0x3fd36160c2769da4, 0x3fe00d350479c3ea, 0x3fc852de63fd6e08,
            0x3fd51548a8a19488, 0x3fe306781d37ea9a, 0xbfec06bc7e604fb8,
            0x3fd7ce88a1b60584, 0x3fed4f57e864d750, 0x3fb4a00b38c069f0,
            0x3fc6b96b2d465dc0, 0xbfe6785f9bcfaa42, 0x3fedb1a26b57c7d6,
            0xbfe78bfa6823d662, 0x3fd030a94086f244, 0xbfeaab0418e7f974,
            0xbfd9b4b308e446c8);
-  VLOAD_64(v2, 0xbfb0ffef54d0f220, 0xbfe5937e2c0e5202, 0x3fdba8604ddf0d80,
+  VLOAD_64(v8, 0xbfb0ffef54d0f220, 0xbfe5937e2c0e5202, 0x3fdba8604ddf0d80,
            0xbfc4d508600804d8, 0x3f93c690cdf47e40, 0xbfd6835fd0838044,
            0xbfdef17840e363cc, 0x3feaa6ceed574e1a, 0x3f9b1871c270c340,
            0x3fa0870f4852d0c0, 0xbfeab4640fc8d962, 0x3fe6f5f737b7bbe2,
            0xbfe7bda7d6ff9552, 0xbfd30ea762d6f1ec, 0x3fdd296165522d4c,
            0xbfe910568693fcea);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vfmacc.vv v2, v4, v6, v0.t");
-  VCMP_U64(6, v2, 0xbfb0ffef54d0f220, 0xbfd88b9c84a68118, 0x3fdba8604ddf0d80,
+  asm volatile("vfmacc.vv v8, v16, v24, v0.t");
+  VCMP_U64(6, v8, 0xbfb0ffef54d0f220, 0xbfd88b9c84a68118, 0x3fdba8604ddf0d80,
            0xbfa9dd1149664d37, 0x3f93c690cdf47e40, 0xbfe4765babf13c96,
            0xbfdef17840e363cc, 0x3ff62b051f10acd5, 0x3f9b1871c270c340,
            0x3fc3074db9c9d78e, 0xbfeab4640fc8d962, 0x3ff5c263f334aac4,
@@ -192,11 +192,11 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (with scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              0.7407, -0.1365,  0.0000, -0.8525, -0.0812,  0.9609, -0.3740,
   //              0.2800,  0.9692,  0.4045,  0.0205, -0.5503,  0.6499,  0.4470,
   //              -0.9360, -0.4426
-  VLOAD_16(v6, 0x39ed, 0xb05e, 0x0000, 0xbad2, 0xad33, 0x3bb0, 0xb5fc, 0x347b,
+  VLOAD_16(v24, 0x39ed, 0xb05e, 0x0000, 0xbad2, 0xad33, 0x3bb0, 0xb5fc, 0x347b,
            0x3bc1, 0x3679, 0x253e, 0xb867, 0x3933, 0x3727, 0xbb7d, 0xb715);
   float fscalar_16;
   //                             0.5757
@@ -204,22 +204,22 @@ void TEST_CASE3(void) {
   //             -0.1472, -0.8906,  0.2247,  0.6118, -0.0908, -0.6450, -0.5415,
   //             0.0505, -0.4595,  0.1157, -0.3494,  0.6670, -0.9658, -0.2944,
   //             -0.8096, -0.3364
-  VLOAD_16(v2, 0xb0b6, 0xbb20, 0x3331, 0x38e5, 0xadcf, 0xb929, 0xb855, 0x2a77,
+  VLOAD_16(v8, 0xb0b6, 0xbb20, 0x3331, 0x38e5, 0xadcf, 0xb929, 0xb855, 0x2a77,
            0xb75a, 0x2f68, 0xb597, 0x3956, 0xbbba, 0xb4b6, 0xba7a, 0xb562);
-  asm volatile("vfmacc.vf v2, %[A], v6" ::[A] "f"(fscalar_16));
+  asm volatile("vfmacc.vf v8, %[A], v24" ::[A] "f"(fscalar_16));
   //              0.2793, -0.9692,  0.2247,  0.1210, -0.1375, -0.0918, -0.7568,
   //              0.2118,  0.0986,  0.3486, -0.3376,  0.3501, -0.5918, -0.0371,
   //              -1.3486, -0.5913
-  VCMP_U16(7, v2, 0x3478, 0xbbc1, 0x3331, 0x2fbf, 0xb067, 0xade0, 0xba0e,
+  VCMP_U16(7, v8, 0x3478, 0xbbc1, 0x3331, 0x2fbf, 0xb067, 0xade0, 0xba0e,
            0x32c6, 0x2e4e, 0x3594, 0xb567, 0x359a, 0xb8bc, 0xa8bf, 0xbd65,
            0xb8bb);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.79164708, -0.13258822, -0.94492996, -0.93729085,
   //              0.80344391,  0.77393818,  0.31253836, -0.42539355,
   //              -0.20085664, -0.63946086,  0.24876182, -0.45639724,
   //              0.92842573,  0.39117134, -0.70563781,  0.13946204
-  VLOAD_32(v6, 0xbf4aa962, 0xbe07c535, 0xbf71e6ee, 0xbf6ff24b, 0x3f4dae80,
+  VLOAD_32(v24, 0xbf4aa962, 0xbe07c535, 0xbf71e6ee, 0xbf6ff24b, 0x3f4dae80,
            0x3f4620d0, 0x3ea00507, 0xbed9cd2f, 0xbe4dad5d, 0xbf23b3b5,
            0x3e7ebb6b, 0xbee9ace6, 0x3f6dad4f, 0x3ec8479c, 0xbf34a4ae,
            0x3e0ecf23);
@@ -230,29 +230,29 @@ void TEST_CASE3(void) {
   //              0.34759882,  0.65410614,  0.99296939, -0.31534156,
   //              -0.89647168,  0.47623411, -0.68185741,  0.77072626,
   //              0.19827089, -0.16254151,  0.81625229, -0.24369264
-  VLOAD_32(v2, 0xbee017a1, 0xbf3e0603, 0x3f1a339a, 0x3edf5b43, 0x3eb1f879,
+  VLOAD_32(v8, 0xbee017a1, 0xbf3e0603, 0x3f1a339a, 0x3edf5b43, 0x3eb1f879,
            0x3f277380, 0x3f7e333e, 0xbea17473, 0xbf657f2b, 0x3ef3d4f5,
            0xbf2e8e35, 0x3f454e51, 0x3e4b0786, 0xbe267148, 0x3f50f5e9,
            0xbe798a90);
-  asm volatile("vfmacc.vf v2, %[A], v6" ::[A] "f"(fscalar_32));
+  asm volatile("vfmacc.vf v8, %[A], v24" ::[A] "f"(fscalar_32));
   //              -1.21056581, -0.87172520, -0.32018578,
   //              -0.47883448,  1.13200164,  1.40970242,  1.29810071,
   //              -0.73065352, -1.09256816, -0.14807191, -0.43899110,
   //              0.32514536,  1.10469353,  0.21935931,  0.12733769, -0.10753576
-  VCMP_U32(8, v2, 0xbf9af3d2, 0xbf5f2962, 0xbea3ef65, 0xbef529cb, 0x3f90e56e,
+  VCMP_U32(8, v8, 0xbf9af3d2, 0xbf5f2962, 0xbea3ef65, 0xbef529cb, 0x3f90e56e,
            0x3fb47121, 0x3fa6282b, 0xbf3b0c1c, 0xbf8bd946, 0xbe17a02a,
            0xbee0c371, 0x3ea67974, 0x3f8d6699, 0x3e609fb9, 0x3e0264cf,
            0xbddc3bb6);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.1981785436218435,  0.2324321764718080,  0.3529425082887112,
   //              -0.4889737836823891,  0.1335009259637479, -0.7964186221277452,
   //              -0.2707335519445100,  0.8070543770008602, -0.1237072120160827,
   //              -0.2357903062216291, -0.0812498320849093,  0.8656662449573254,
   //              0.7178262144151533, -0.3106178959409680, -0.1410836751949509,
   //              0.6904294937898030
-  VLOAD_64(v6, 0xbfc95dea1dcff710, 0x3fcdc0566a3e04a0, 0x3fd6969c2c9df760,
+  VLOAD_64(v24, 0xbfc95dea1dcff710, 0x3fcdc0566a3e04a0, 0x3fd6969c2c9df760,
            0xbfdf4b58b2611a74, 0x3fc1168eef800078, 0xbfe97c42e7fed97a,
            0xbfd153b2d1e20588, 0x3fe9d363b369fec4, 0xbfbfab469de36f10,
            0xbfce2e6072f7c5c0, 0xbfb4ccc9fb9c3490, 0x3febb389b26af886,
@@ -267,20 +267,20 @@ void TEST_CASE3(void) {
   //              0.7665070398551490, -0.7817863527411446, -0.2155326059803253,
   //              -0.7807395886866346,  0.2528540140694266, -0.1740695080779533,
   //              0.7247829241803623
-  VLOAD_64(v2, 0xbfee2ffe0122d3b6, 0xbfb1d468c9a80310, 0xbfea2623e6043a6c,
+  VLOAD_64(v8, 0xbfee2ffe0122d3b6, 0xbfb1d468c9a80310, 0xbfea2623e6043a6c,
            0xbfee62d76bc21ae2, 0xbfe454d179c08866, 0x3fea1c44af53fb1a,
            0x3f9d95d7dd994d80, 0xbfe34777e1831e42, 0xbfeeaa7676c316f0,
            0x3fe88739c58a9cbe, 0xbfe90464d02f6f4c, 0xbfcb96928af41d88,
            0xbfe8fbd197034034, 0x3fd02ec29a45caf0, 0xbfc647e8de367aa0,
            0x3fe7316bf581b994);
-  asm volatile("vfmacc.vf v2, %[A], v6" ::[A] "f"(dscalar_64));
+  asm volatile("vfmacc.vf v8, %[A], v24" ::[A] "f"(dscalar_64));
   //              -1.1165434690834197,  0.1334713860074080, -0.5087250014486948,
   //              -1.3768719457941574, -0.5186894774163083,  0.1199732804009315,
   //              -0.2076977828175325,  0.1027976993173292, -1.0664141864137089,
   //              0.5604536790898100, -0.8527892757662274,  0.5409592190351925,
   //              -0.1534427913930433, -0.0185899752875187, -0.2973602653990804,
   //              1.3281381674327271
-  VCMP_U64(9, v2, 0xbff1dd5caf44692a, 0x3fc1159722ed4311, 0xbfe04779a77c2679,
+  VCMP_U64(9, v8, 0xbff1dd5caf44692a, 0x3fc1159722ed4311, 0xbfe04779a77c2679,
            0xbff607aae09f73e1, 0xbfe0991aacc90937, 0x3fbeb691a3b74133,
            0xbfca95d7485395ec, 0x3fba50f334ac0644, 0xbff11008526a327e,
            0x3fe1ef3c8dd3a2b9, 0xbfeb4a0cbc397482, 0x3fe14f89b5473a2f,
@@ -292,40 +292,40 @@ void TEST_CASE3(void) {
 // Simple random test with similar values (masked with scalar, values taken from
 // TEST_CASE3)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x39ed, 0xb05e, 0x0000, 0xbad2, 0xad33, 0x3bb0, 0xb5fc, 0x347b,
+  VSET(16, e16, m8);
+  VLOAD_16(v24, 0x39ed, 0xb05e, 0x0000, 0xbad2, 0xad33, 0x3bb0, 0xb5fc, 0x347b,
            0x3bc1, 0x3679, 0x253e, 0xb867, 0x3933, 0x3727, 0xbb7d, 0xb715);
   float fscalar_16;
   BOX_HALF_IN_FLOAT(fscalar_16, 0x389b);
-  VLOAD_16(v2, 0xb0b6, 0xbb20, 0x3331, 0x38e5, 0xadcf, 0xb929, 0xb855, 0x2a77,
+  VLOAD_16(v8, 0xb0b6, 0xbb20, 0x3331, 0x38e5, 0xadcf, 0xb929, 0xb855, 0x2a77,
            0xb75a, 0x2f68, 0xb597, 0x3956, 0xbbba, 0xb4b6, 0xba7a, 0xb562);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vfmacc.vf v2, %[A], v6, v0.t" ::[A] "f"(fscalar_16));
-  VCMP_U16(10, v2, 0xb0b6, 0xbbc1, 0x3331, 0x2fbf, 0xadcf, 0xade0, 0xb855,
+  asm volatile("vfmacc.vf v8, %[A], v24, v0.t" ::[A] "f"(fscalar_16));
+  VCMP_U16(10, v8, 0xb0b6, 0xbbc1, 0x3331, 0x2fbf, 0xadcf, 0xade0, 0xb855,
            0x32c6, 0xb75a, 0x3594, 0xb597, 0x359a, 0xbbba, 0xa8bf, 0xba7a,
            0xb8bb);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0xbf4aa962, 0xbe07c535, 0xbf71e6ee, 0xbf6ff24b, 0x3f4dae80,
+  VSET(16, e32, m8);
+  VLOAD_32(v24, 0xbf4aa962, 0xbe07c535, 0xbf71e6ee, 0xbf6ff24b, 0x3f4dae80,
            0x3f4620d0, 0x3ea00507, 0xbed9cd2f, 0xbe4dad5d, 0xbf23b3b5,
            0x3e7ebb6b, 0xbee9ace6, 0x3f6dad4f, 0x3ec8479c, 0xbf34a4ae,
            0x3e0ecf23);
   float fscalar_32;
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x3f79eed6);
-  VLOAD_32(v2, 0xbee017a1, 0xbf3e0603, 0x3f1a339a, 0x3edf5b43, 0x3eb1f879,
+  VLOAD_32(v8, 0xbee017a1, 0xbf3e0603, 0x3f1a339a, 0x3edf5b43, 0x3eb1f879,
            0x3f277380, 0x3f7e333e, 0xbea17473, 0xbf657f2b, 0x3ef3d4f5,
            0xbf2e8e35, 0x3f454e51, 0x3e4b0786, 0xbe267148, 0x3f50f5e9,
            0xbe798a90);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vfmacc.vf v2, %[A], v6, v0.t" ::[A] "f"(fscalar_32));
-  VCMP_U32(11, v2, 0xbee017a1, 0xbf5f2962, 0x3f1a339a, 0xbef529cb, 0x3eb1f879,
+  asm volatile("vfmacc.vf v8, %[A], v24, v0.t" ::[A] "f"(fscalar_32));
+  VCMP_U32(11, v8, 0xbee017a1, 0xbf5f2962, 0x3f1a339a, 0xbef529cb, 0x3eb1f879,
            0x3fb47121, 0x3f7e333e, 0xbf3b0c1c, 0xbf657f2b, 0xbe17a02a,
            0xbf2e8e35, 0x3ea67974, 0x3e4b0786, 0x3e609fb9, 0x3f50f5e9,
            0xbddc3bb6);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0xbfc95dea1dcff710, 0x3fcdc0566a3e04a0, 0x3fd6969c2c9df760,
+  VSET(16, e64, m8);
+  VLOAD_64(v24, 0xbfc95dea1dcff710, 0x3fcdc0566a3e04a0, 0x3fd6969c2c9df760,
            0xbfdf4b58b2611a74, 0x3fc1168eef800078, 0xbfe97c42e7fed97a,
            0xbfd153b2d1e20588, 0x3fe9d363b369fec4, 0xbfbfab469de36f10,
            0xbfce2e6072f7c5c0, 0xbfb4ccc9fb9c3490, 0x3febb389b26af886,
@@ -333,15 +333,15 @@ void TEST_CASE4(void) {
            0x3fe617ff9800ac5a);
   double dscalar_64;
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3febf6db7175e482);
-  VLOAD_64(v2, 0xbfee2ffe0122d3b6, 0xbfb1d468c9a80310, 0xbfea2623e6043a6c,
+  VLOAD_64(v8, 0xbfee2ffe0122d3b6, 0xbfb1d468c9a80310, 0xbfea2623e6043a6c,
            0xbfee62d76bc21ae2, 0xbfe454d179c08866, 0x3fea1c44af53fb1a,
            0x3f9d95d7dd994d80, 0xbfe34777e1831e42, 0xbfeeaa7676c316f0,
            0x3fe88739c58a9cbe, 0xbfe90464d02f6f4c, 0xbfcb96928af41d88,
            0xbfe8fbd197034034, 0x3fd02ec29a45caf0, 0xbfc647e8de367aa0,
            0x3fe7316bf581b994);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vfmacc.vf v2, %[A], v6, v0.t" ::[A] "f"(dscalar_64));
-  VCMP_U64(12, v2, 0xbfee2ffe0122d3b6, 0x3fc1159722ed4311, 0xbfea2623e6043a6c,
+  asm volatile("vfmacc.vf v8, %[A], v24, v0.t" ::[A] "f"(dscalar_64));
+  VCMP_U64(12, v8, 0xbfee2ffe0122d3b6, 0x3fc1159722ed4311, 0xbfea2623e6043a6c,
            0xbff607aae09f73e1, 0xbfe454d179c08866, 0x3fbeb691a3b74133,
            0x3f9d95d7dd994d80, 0x3fba50f334ac0644, 0xbfeeaa7676c316f0,
            0x3fe1ef3c8dd3a2b9, 0xbfe90464d02f6f4c, 0x3fe14f89b5473a2f,
diff --git a/sw/riscvTests/isa/rv64uv/vfmadd.c b/sw/riscvTests/isa/rv64uv/vfmadd.c
index e1737b22..3f83835e 100644
--- a/sw/riscvTests/isa/rv64uv/vfmadd.c
+++ b/sw/riscvTests/isa/rv64uv/vfmadd.c
@@ -10,36 +10,36 @@
 
 // Simple random test with similar values + 1 subnormal
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.3501, -0.3289, -0.8853, -0.4082, -0.4346, -0.2659,  0.9316,
   //               0.5444, -0.0538,  0.7686,  0.8203, -0.8623,  0.3059,  0.0372,
   //               0.5337, -0.5815
-  VLOAD_16(v4, 0x359a, 0xb543, 0xbb15, 0xb688, 0xb6f4, 0xb441, 0x3b74, 0x385b,
+  VLOAD_16(v16, 0x359a, 0xb543, 0xbb15, 0xb688, 0xb6f4, 0xb441, 0x3b74, 0x385b,
            0xaae4, 0x3a26, 0x3a90, 0xbae6, 0x34e5, 0x28c4, 0x3845, 0xb8a7);
   //              -0.8105,  0.5000, -0.8374, -0.8394,  0.3098,  0.1328, -0.2864,
   //              -0.4041, -0.1729,  0.0196,  0.2739,  0.8071, -0.1553,  0.2815,
   //              -0.9067, -0.2495
-  VLOAD_16(v6, 0xba7c, 0x3800, 0xbab3, 0xbab7, 0x34f5, 0x3040, 0xb495, 0xb677,
+  VLOAD_16(v24, 0xba7c, 0x3800, 0xbab3, 0xbab7, 0x34f5, 0x3040, 0xb495, 0xb677,
            0xb188, 0x2502, 0x3462, 0x3a75, 0xb0f8, 0x3481, 0xbb41, 0xb3fc);
   //              -0.6558, -0.1006,  0.4558, -0.0784,  0.1539,  0.6748,  0.3347,
   //              -0.3416,  0.0614,  0.2289, -0.0829,  0.3838, -0.6348,  0.0843,
   //              -0.6890, -0.2598
-  VLOAD_16(v2, 0xb93f, 0xae71, 0x374b, 0xad05, 0x30ed, 0x3966, 0x355b, 0xb577,
+  VLOAD_16(v8, 0xb93f, 0xae71, 0x374b, 0xad05, 0x30ed, 0x3966, 0x355b, 0xb577,
            0x2bdc, 0x3353, 0xad4f, 0x3624, 0xb914, 0x2d65, 0xb983, 0xb428);
-  asm volatile("vfmadd.vv v2, v4, v6");
+  asm volatile("vfmadd.vv v8, v16, v24");
   //              -1.0400,  0.5332, -1.2412, -0.8071,  0.2429, -0.0466,  0.0254,
   //              -0.5898, -0.1761,  0.1954,  0.2058,  0.4761, -0.3496,  0.2847,
   //              -1.2744, -0.0984
-  VCMP_U16(1, v2, 0xbc29, 0x3844, 0xbcf7, 0xba75, 0x33c6, 0xa9f7, 0x2684,
+  VCMP_U16(1, v8, 0xbc29, 0x3844, 0xbcf7, 0xba75, 0x33c6, 0xa9f7, 0x2684,
            0xb8b8, 0xb1a3, 0x3241, 0x3297, 0x379e, 0xb597, 0x348e, 0xbd19,
            0xae4d);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.20637949, -0.63321692,  0.40850523,  0.58702314,
   //              -0.25534528, -0.22053087,  0.96057665,  0.85530519,
   //              0.74252450, -0.87175107, -0.00987994, -0.52556008, 0.26113954,
   //              -0.71307814,  0.78942811,  0.48685852
-  VLOAD_32(v4, 0xbe535525, 0xbf221a81, 0x3ed12799, 0x3f164726, 0xbe82bc9e,
+  VLOAD_32(v16, 0xbe535525, 0xbf221a81, 0x3ed12799, 0x3f164726, 0xbe82bc9e,
            0xbe61d2d8, 0x3f75e85a, 0x3f5af548, 0x3f3e1616, 0xbf5f2b14,
            0xbc21df78, 0xbf068b1b, 0x3e85b415, 0xbf368c4a, 0x3f4a17f6,
            0x3ef94585);
@@ -47,7 +47,7 @@ void TEST_CASE1(void) {
   //              -0.96695948,  0.71368766,  0.23281342, -0.67807233,
   //              0.79363507,  0.62817359,  0.37205252,  0.27726358,
   //              -0.85021532, -0.16634122, -0.58148408,  0.06963744
-  VLOAD_32(v6, 0xbe20e41a, 0x3f54b4d4, 0x3f133971, 0x3f5a88f6, 0xbf778aa8,
+  VLOAD_32(v24, 0xbe20e41a, 0x3f54b4d4, 0x3f133971, 0x3f5a88f6, 0xbf778aa8,
            0x3f36b43c, 0x3e6e66a4, 0xbf2d9626, 0x3f4b2bab, 0x3f20cffc,
            0x3ebe7dab, 0x3e8df57e, 0xbf59a7b6, 0xbe2a555a, 0xbf14dc24,
            0x3d8e9e13);
@@ -55,29 +55,29 @@ void TEST_CASE1(void) {
   //              -0.84276563,  0.00681775,  0.30881208,  0.27571887,
   //              0.12349209,  0.29805747, -0.55497122, -0.52685922, 0.82809180,
   //              -0.83231467,  0.20959182,  0.15603130
-  VLOAD_32(v2, 0xbf216ffb, 0x3f139101, 0x3da7e970, 0xbd76f8fa, 0xbf57bf7d,
+  VLOAD_32(v8, 0xbf216ffb, 0x3f139101, 0x3da7e970, 0xbd76f8fa, 0xbf57bf7d,
            0x3bdf676d, 0x3e9e1c9e, 0x3e8d2b06, 0x3dfce96c, 0x3e989afd,
            0xbf0e1298, 0xbf06e03f, 0x3f53fdd3, 0xbf551293, 0x3e569f3d,
            0x3e1fc6ab);
-  asm volatile("vfmadd.vv v2, v4, v6");
+  asm volatile("vfmadd.vv v8, v16, v24");
   //              -0.02697416,  0.46587816,  0.60858786,  0.81825721,
   //              -0.75176322,  0.71218413,  0.52945113, -0.44224855,
   //              0.88533098,  0.36834168,  0.37753561,  0.55415976,
   //              -0.63396782,  0.42716417, -0.41602641,  0.14560261
-  VCMP_U32(2, v2, 0xbcdcf8e5, 0x3eee8795, 0x3f1bcc6a, 0x3f51794e, 0xbf40738e,
+  VCMP_U32(2, v8, 0xbcdcf8e5, 0x3eee8795, 0x3f1bcc6a, 0x3f51794e, 0xbf40738e,
            0x3f3651b3, 0x3f078a1b, 0xbee26e67, 0x3f62a50d, 0x3ebc9748,
            0x3ec14c59, 0x3f0ddd6a, 0xbf224bb7, 0x3edab544, 0xbed5016a,
            0x3e1518d9);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               0.0308264568094008,  0.5865382185158325,  0.4543411851187289,
   //               0.0036656924511687, -0.3103508259554966,  0.9658177901158624,
   //               -0.3381631341283657, -0.2003719333831677, 0.8989532087589025,
   //               -0.8054516243685412,  0.8701363884969631,
   //               -0.3585976675814562,  0.4150155349314333,
   //               -0.6908185611649824,  0.8412555125501906, -0.3357469205066645
-  VLOAD_64(v4, 0x3f9f90f87f644880, 0x3fe2c4ebcc4c25b4, 0x3fdd13ed0cd3e484,
+  VLOAD_64(v16, 0x3f9f90f87f644880, 0x3fe2c4ebcc4c25b4, 0x3fdd13ed0cd3e484,
            0x3f6e0783a63d2400, 0xbfd3dcc9b5f0fd10, 0x3feee7fab5ce29f4,
            0xbfd5a476fc72d40c, 0xbfc9a5c99a756020, 0x3fecc43985081eb2,
            0xbfe9c6427c2588e6, 0x3febd8284474eda0, 0xbfd6f343a1abca7c,
@@ -89,7 +89,7 @@ void TEST_CASE1(void) {
   //               -0.2540075520951832,  0.6661048539265222, 0.3013290199421905,
   //               -0.0367795249610035, -0.7178804756969177, 0.1577316726139908,
   //               -0.1242681642824526, -0.9006297759672148
-  VLOAD_64(v6, 0x3fe2d21c0f5cd922, 0xbfef9fc912e0ce28, 0xbfeb260b1d5f82be,
+  VLOAD_64(v24, 0x3fe2d21c0f5cd922, 0xbfef9fc912e0ce28, 0xbfeb260b1d5f82be,
            0xbfeefdd73b960c5a, 0xbfe594790988a396, 0x3fdbfc3f615edda8,
            0xbfeab01520204008, 0xbfc3723035a012c8, 0xbfd041a8e44be49c,
            0x3fe550bb206a47d8, 0x3fd348f9837f3238, 0xbfa2d4c411bd66e0,
@@ -101,20 +101,20 @@ void TEST_CASE1(void) {
   //              -0.3946645040604191,  0.6818539464440989,  0.9719861381061521,
   //              -0.8471643748461517,  0.8077493118513845,  0.2789872574353331,
   //              0.7073875082318823
-  VLOAD_64(v2, 0xbfeab3e8dee4061e, 0x3fe6a634071f1b28, 0xbfc81712d5195ee0,
+  VLOAD_64(v8, 0xbfeab3e8dee4061e, 0x3fe6a634071f1b28, 0xbfc81712d5195ee0,
            0xbfd19c3bdc149f5c, 0x3fcdee73f7748a88, 0xbfefcd75c2393d96,
            0xbfe11b1e209897fa, 0x3fb6b66250fca870, 0x3fd37d4be2d9c9a4,
            0xbfd9422ee8753844, 0x3fe5d1bf5e1407b4, 0x3fef1a82ac6a99b4,
            0xbfeb1bf876899dc0, 0x3fe9d91515b8951c, 0x3fd1daed5eabdf0c,
            0x3fe6a2eb20ae8e42);
-  asm volatile("vfmadd.vv v2, v4, v6");
+  asm volatile("vfmadd.vv v8, v16, v24");
   //               0.5624246503668447, -0.5731100645801621, -0.9339028680308291,
   //               -0.9694950747455855, -0.7469464057195535,
   //               -0.5225882703620045, -0.6532258740745487,
   //               -0.1696993409682697,  0.0197439149088051, 0.9839880198025914,
   //               0.8946349503834604, -0.3853314870073767, -1.0694668518985466,
   //               -0.4002765447811873,  0.1104314039662806, -1.1381329534609521
-  VCMP_U64(3, v2, 0x3fe1ff61faf9464f, 0xbfe256eaeb0c2af6, 0xbfede288447aa80f,
+  VCMP_U64(3, v8, 0x3fe1ff61faf9464f, 0xbfe256eaeb0c2af6, 0xbfede288447aa80f,
            0xbfef061a88f54aac, 0xbfe7e6fc260dc471, 0xbfe0b90b094f4be7,
            0xbfe4e739f2c1a370, 0xbfc5b8b53fce44b1, 0x3f9437bfb3503463,
            0x3fef7cd47196a75e, 0x3feca0d979b82d6d, 0xbfd8a94565b434f4,
@@ -126,34 +126,34 @@ void TEST_CASE1(void) {
 // Simple random test with similar values + 1 subnormal (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.3501, -0.3289, -0.8853, -0.4082, -0.4346, -0.2659,  0.9316,
   //               0.5444, -0.0538,  0.7686,  0.8203, -0.8623,  0.3059,  0.0372,
   //               0.5337, -0.5815
-  VLOAD_16(v4, 0x359a, 0xb543, 0xbb15, 0xb688, 0xb6f4, 0xb441, 0x3b74, 0x385b,
+  VLOAD_16(v16, 0x359a, 0xb543, 0xbb15, 0xb688, 0xb6f4, 0xb441, 0x3b74, 0x385b,
            0xaae4, 0x3a26, 0x3a90, 0xbae6, 0x34e5, 0x28c4, 0x3845, 0xb8a7);
   //              -0.8105,  0.5000, -0.8374, -0.8394,  0.3098,  0.1328, -0.2864,
   //              -0.4041, -0.1729,  0.0196,  0.2739,  0.8071, -0.1553,  0.2815,
   //              -0.9067, -0.2495
-  VLOAD_16(v6, 0xba7c, 0x3800, 0xbab3, 0xbab7, 0x34f5, 0x3040, 0xb495, 0xb677,
+  VLOAD_16(v24, 0xba7c, 0x3800, 0xbab3, 0xbab7, 0x34f5, 0x3040, 0xb495, 0xb677,
            0xb188, 0x2502, 0x3462, 0x3a75, 0xb0f8, 0x3481, 0xbb41, 0xb3fc);
   VLOAD_8(v0, 0xAA, 0xAA);
   //              -0.6558, -0.1006,  0.4558, -0.0784,  0.1539,  0.6748,  0.3347,
   //              -0.3416,  0.0614,  0.2289, -0.0829,  0.3838, -0.6348,  0.0843,
   //              -0.6890, -0.2598
-  VLOAD_16(v2, 0xb93f, 0xae71, 0x374b, 0xad05, 0x30ed, 0x3966, 0x355b, 0xb577,
+  VLOAD_16(v8, 0xb93f, 0xae71, 0x374b, 0xad05, 0x30ed, 0x3966, 0x355b, 0xb577,
            0x2bdc, 0x3353, 0xad4f, 0x3624, 0xb914, 0x2d65, 0xb983, 0xb428);
-  asm volatile("vfmadd.vv v2, v4, v6, v0.t");
-  VCMP_U16(4, v2, 0xb93f, 0x3844, 0x374b, 0xba75, 0x30ed, 0xa9f7, 0x355b,
+  asm volatile("vfmadd.vv v8, v16, v24, v0.t");
+  VCMP_U16(4, v8, 0xb93f, 0x3844, 0x374b, 0xba75, 0x30ed, 0xa9f7, 0x355b,
            0xb8b8, 0x2bdc, 0x3241, 0xad4f, 0x379e, 0xb914, 0x348e, 0xb983,
            0xae4d);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.20637949, -0.63321692,  0.40850523,  0.58702314,
   //              -0.25534528, -0.22053087,  0.96057665,  0.85530519,
   //              0.74252450, -0.87175107, -0.00987994, -0.52556008, 0.26113954,
   //              -0.71307814,  0.78942811,  0.48685852
-  VLOAD_32(v4, 0xbe535525, 0xbf221a81, 0x3ed12799, 0x3f164726, 0xbe82bc9e,
+  VLOAD_32(v16, 0xbe535525, 0xbf221a81, 0x3ed12799, 0x3f164726, 0xbe82bc9e,
            0xbe61d2d8, 0x3f75e85a, 0x3f5af548, 0x3f3e1616, 0xbf5f2b14,
            0xbc21df78, 0xbf068b1b, 0x3e85b415, 0xbf368c4a, 0x3f4a17f6,
            0x3ef94585);
@@ -161,7 +161,7 @@ void TEST_CASE2(void) {
   //              -0.96695948,  0.71368766,  0.23281342, -0.67807233,
   //              0.79363507,  0.62817359,  0.37205252,  0.27726358,
   //              -0.85021532, -0.16634122, -0.58148408,  0.06963744
-  VLOAD_32(v6, 0xbe20e41a, 0x3f54b4d4, 0x3f133971, 0x3f5a88f6, 0xbf778aa8,
+  VLOAD_32(v24, 0xbe20e41a, 0x3f54b4d4, 0x3f133971, 0x3f5a88f6, 0xbf778aa8,
            0x3f36b43c, 0x3e6e66a4, 0xbf2d9626, 0x3f4b2bab, 0x3f20cffc,
            0x3ebe7dab, 0x3e8df57e, 0xbf59a7b6, 0xbe2a555a, 0xbf14dc24,
            0x3d8e9e13);
@@ -170,25 +170,25 @@ void TEST_CASE2(void) {
   //              -0.84276563,  0.00681775,  0.30881208,  0.27571887,
   //              0.12349209,  0.29805747, -0.55497122, -0.52685922, 0.82809180,
   //              -0.83231467,  0.20959182,  0.15603130
-  VLOAD_32(v2, 0xbf216ffb, 0x3f139101, 0x3da7e970, 0xbd76f8fa, 0xbf57bf7d,
+  VLOAD_32(v8, 0xbf216ffb, 0x3f139101, 0x3da7e970, 0xbd76f8fa, 0xbf57bf7d,
            0x3bdf676d, 0x3e9e1c9e, 0x3e8d2b06, 0x3dfce96c, 0x3e989afd,
            0xbf0e1298, 0xbf06e03f, 0x3f53fdd3, 0xbf551293, 0x3e569f3d,
            0x3e1fc6ab);
-  asm volatile("vfmadd.vv v2, v4, v6, v0.t");
-  VCMP_U32(5, v2, 0xbf216ffb, 0x3eee8795, 0x3da7e970, 0x3f51794e, 0xbf57bf7d,
+  asm volatile("vfmadd.vv v8, v16, v24, v0.t");
+  VCMP_U32(5, v8, 0xbf216ffb, 0x3eee8795, 0x3da7e970, 0x3f51794e, 0xbf57bf7d,
            0x3f3651b3, 0x3e9e1c9e, 0xbee26e67, 0x3dfce96c, 0x3ebc9748,
            0xbf0e1298, 0x3f0ddd6a, 0x3f53fdd3, 0x3edab544, 0x3e569f3d,
            0x3e1518d9);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               0.0308264568094008,  0.5865382185158325,  0.4543411851187289,
   //               0.0036656924511687, -0.3103508259554966,  0.9658177901158624,
   //               -0.3381631341283657, -0.2003719333831677, 0.8989532087589025,
   //               -0.8054516243685412,  0.8701363884969631,
   //               -0.3585976675814562,  0.4150155349314333,
   //               -0.6908185611649824,  0.8412555125501906, -0.3357469205066645
-  VLOAD_64(v4, 0x3f9f90f87f644880, 0x3fe2c4ebcc4c25b4, 0x3fdd13ed0cd3e484,
+  VLOAD_64(v16, 0x3f9f90f87f644880, 0x3fe2c4ebcc4c25b4, 0x3fdd13ed0cd3e484,
            0x3f6e0783a63d2400, 0xbfd3dcc9b5f0fd10, 0x3feee7fab5ce29f4,
            0xbfd5a476fc72d40c, 0xbfc9a5c99a756020, 0x3fecc43985081eb2,
            0xbfe9c6427c2588e6, 0x3febd8284474eda0, 0xbfd6f343a1abca7c,
@@ -200,7 +200,7 @@ void TEST_CASE2(void) {
   //               -0.2540075520951832,  0.6661048539265222, 0.3013290199421905,
   //               -0.0367795249610035, -0.7178804756969177, 0.1577316726139908,
   //               -0.1242681642824526, -0.9006297759672148
-  VLOAD_64(v6, 0x3fe2d21c0f5cd922, 0xbfef9fc912e0ce28, 0xbfeb260b1d5f82be,
+  VLOAD_64(v24, 0x3fe2d21c0f5cd922, 0xbfef9fc912e0ce28, 0xbfeb260b1d5f82be,
            0xbfeefdd73b960c5a, 0xbfe594790988a396, 0x3fdbfc3f615edda8,
            0xbfeab01520204008, 0xbfc3723035a012c8, 0xbfd041a8e44be49c,
            0x3fe550bb206a47d8, 0x3fd348f9837f3238, 0xbfa2d4c411bd66e0,
@@ -213,20 +213,20 @@ void TEST_CASE2(void) {
   //              -0.3946645040604191,  0.6818539464440989,  0.9719861381061521,
   //              -0.8471643748461517,  0.8077493118513845,  0.2789872574353331,
   //              0.7073875082318823
-  VLOAD_64(v2, 0xbfeab3e8dee4061e, 0x3fe6a634071f1b28, 0xbfc81712d5195ee0,
+  VLOAD_64(v8, 0xbfeab3e8dee4061e, 0x3fe6a634071f1b28, 0xbfc81712d5195ee0,
            0xbfd19c3bdc149f5c, 0x3fcdee73f7748a88, 0xbfefcd75c2393d96,
            0xbfe11b1e209897fa, 0x3fb6b66250fca870, 0x3fd37d4be2d9c9a4,
            0xbfd9422ee8753844, 0x3fe5d1bf5e1407b4, 0x3fef1a82ac6a99b4,
            0xbfeb1bf876899dc0, 0x3fe9d91515b8951c, 0x3fd1daed5eabdf0c,
            0x3fe6a2eb20ae8e42);
-  asm volatile("vfmadd.vv v2, v4, v6, v0.t");
+  asm volatile("vfmadd.vv v8, v16, v24, v0.t");
   //               0.0000000000000000, -0.5731100645801621,  0.0000000000000000,
   //               -0.9694950747455855,  0.0000000000000000,
   //               -0.5225882703620045,  0.0000000000000000,
   //               -0.1696993409682697,  0.0000000000000000, 0.9839880198025914,
   //               0.0000000000000000, -0.3853314870073767,  0.0000000000000000,
   //               -0.4002765447811873,  0.0000000000000000, -1.1381329534609521
-  VCMP_U64(6, v2, 0xbfeab3e8dee4061e, 0xbfe256eaeb0c2af6, 0xbfc81712d5195ee0,
+  VCMP_U64(6, v8, 0xbfeab3e8dee4061e, 0xbfe256eaeb0c2af6, 0xbfc81712d5195ee0,
            0xbfef061a88f54aac, 0x3fcdee73f7748a88, 0xbfe0b90b094f4be7,
            0xbfe11b1e209897fa, 0xbfc5b8b53fce44b1, 0x3fd37d4be2d9c9a4,
            0x3fef7cd47196a75e, 0x3fe5d1bf5e1407b4, 0xbfd8a94565b434f4,
@@ -237,29 +237,29 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.6299
   BOX_HALF_IN_FLOAT(fscalar_16, 0x390a);
   //              -0.5352,  0.1115,  0.9541, -0.8857, -0.4143,  0.4045,  0.2949,
   //              -0.5479,  0.6733,  0.8965,  0.8882,  0.6294,  0.7568,  0.8735,
   //              -0.8569,  0.8271
-  VLOAD_16(v4, 0xb848, 0x2f23, 0x3ba2, 0xbb16, 0xb6a1, 0x3679, 0x34b8, 0xb862,
+  VLOAD_16(v16, 0xb848, 0x2f23, 0x3ba2, 0xbb16, 0xb6a1, 0x3679, 0x34b8, 0xb862,
            0x3963, 0x3b2c, 0x3b1b, 0x3909, 0x3a0e, 0x3afd, 0xbadb, 0x3a9e);
   //               0.2844,  0.1008,  0.3777,  0.9790, -0.8613,  0.4951,  0.4126,
   //               0.5518, -0.6680, -0.8340,  0.2094,  0.5884, -0.6509, -0.9360,
   //               -0.1609, -0.2527
-  VLOAD_16(v2, 0x348d, 0x2e74, 0x360b, 0x3bd5, 0xbae4, 0x37ec, 0x369a, 0x386a,
+  VLOAD_16(v8, 0x348d, 0x2e74, 0x360b, 0x3bd5, 0xbae4, 0x37ec, 0x369a, 0x386a,
            0xb958, 0xbaac, 0x32b3, 0x38b5, 0xb935, 0xbb7d, 0xb126, 0xb40b);
-  asm volatile("vfmadd.vf v2, %[A], v4" ::[A] "f"(fscalar_16));
+  asm volatile("vfmadd.vf v8, %[A], v16" ::[A] "f"(fscalar_16));
   //              -0.3560,  0.1750,  1.1924, -0.2690, -0.9570,  0.7163,  0.5547,
   //              -0.2002,  0.2527,  0.3711,  1.0195,  1.0000,  0.3469,  0.2842,
   //              -0.9580,  0.6680
-  VCMP_U16(7, v2, 0xb5b2, 0x319a, 0x3cc5, 0xb44e, 0xbba8, 0x39bb, 0x3870,
+  VCMP_U16(7, v8, 0xb5b2, 0x319a, 0x3cc5, 0xb44e, 0xbba8, 0x39bb, 0x3870,
            0xb269, 0x340b, 0x35f0, 0x3c15, 0x3c00, 0x358d, 0x348b, 0xbbab,
            0x3958);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                               0.80368215
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x3f4dbe1d);
@@ -267,7 +267,7 @@ void TEST_CASE3(void) {
   //               -0.69910282, -0.90573430,  0.86481184,  0.33341369,
   //               0.30657578, -0.90526944, -0.97891974, -0.50830764,
   //               0.79750061,  0.96885878,  0.48752418,  0.64305341
-  VLOAD_32(v4, 0x3e05db98, 0xbe4a2639, 0x3dbfe79e, 0x3ed22c6d, 0xbf32f867,
+  VLOAD_32(v16, 0x3e05db98, 0xbe4a2639, 0x3dbfe79e, 0x3ed22c6d, 0xbf32f867,
            0xbf67de34, 0x3f5d644f, 0x3eaab533, 0x3e9cf780, 0xbf67bfbd,
            0xbf7a9a7c, 0xbf022073, 0x3f4c2900, 0x3f780721, 0x3ef99cc5,
            0x3f249f26);
@@ -275,22 +275,22 @@ void TEST_CASE3(void) {
   //              -0.84296966,  0.50125730,  0.96147668,  0.65802389,
   //              0.19629262, -0.73197508, -0.06948850, -0.60436314,
   //              -0.80817568,  0.72047287, -0.78180677, -0.40237895
-  VLOAD_32(v2, 0xbf1c7638, 0x3f515a0a, 0xbeece360, 0xbe9e3276, 0xbf57ccdc,
+  VLOAD_32(v8, 0xbf1c7638, 0x3f515a0a, 0xbeece360, 0xbe9e3276, 0xbf57ccdc,
            0x3f005266, 0x3f762356, 0x3f287441, 0x3e4900ef, 0xbf3b62b8,
            0xbd8e4ffc, 0xbf1ab78b, 0xbf4ee49a, 0x3f3870e9, 0xbf48247d,
            0xbece049d);
-  asm volatile("vfmadd.vf v2, %[A], v4" ::[A] "f"(fscalar_32));
+  asm volatile("vfmadd.vf v8, %[A], v16" ::[A] "f"(fscalar_32));
   //              -0.36047307,  0.45982391, -0.27813792,  0.16217449,
   //              -1.37658250, -0.50288272,  1.63753343,  0.86225569,
   //              0.46433264, -1.49354482, -1.03476644, -0.99402350, 0.14798427,
   //              1.54788995, -0.14079997,  0.31966865
-  VCMP_U32(8, v2, 0xbeb88fed, 0x3eeb6e09, 0xbe8e6818, 0x3e261112, 0xbfb033db,
+  VCMP_U32(8, v8, 0xbeb88fed, 0x3eeb6e09, 0xbe8e6818, 0x3e261112, 0xbfb033db,
            0xbf00bced, 0x3fd19ab2, 0x3f5cbccb, 0x3eedbd02, 0xbfbf2c79,
            0xbf84733a, 0xbf7e7853, 0x3e17892e, 0x3fc62142, 0xbe102ddd,
            0x3ea3ab9c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.5717861827636179
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fe24c128968c808);
@@ -301,7 +301,7 @@ void TEST_CASE3(void) {
   //               -0.6941474840922310,  0.4809970389518419,
   //               -0.4671263490725479,  0.5176516826232249,
   //               -0.9714116214357187,  0.0212574845134876
-  VLOAD_64(v4, 0xbfb90ff83cc58160, 0xbfe9d0157c220eae, 0x3fb9a21bd6239ad0,
+  VLOAD_64(v16, 0xbfb90ff83cc58160, 0xbfe9d0157c220eae, 0x3fb9a21bd6239ad0,
            0x3fe3c985e1ec6d14, 0xbfe6b113bcd49f88, 0x3fde2a4914f71f28,
            0xbfedf64fbb356b82, 0x3fe581cf0bb1e7c4, 0xbfc5905a8722a398,
            0xbf952cb38782ee00, 0xbfe63674c8d8dba6, 0x3fdec8a7cdf1580c,
@@ -314,20 +314,20 @@ void TEST_CASE3(void) {
   //               -0.8379133193505066, -0.6497652150347000,
   //               -0.4444119628309799, -0.8810041425660891, 0.4421772814931029,
   //               0.0606105644967410
-  VLOAD_64(v2, 0xbfeb84f2357b2242, 0xbfeb8d061ebc48de, 0xbfe20e9f1cee50cc,
+  VLOAD_64(v8, 0xbfeb84f2357b2242, 0xbfeb8d061ebc48de, 0xbfe20e9f1cee50cc,
            0x3fecaacc26c2f0d0, 0x3fd76ecbc40b5864, 0x3fba0eeb244baff0,
            0x3fcd6d36a4399740, 0xbfdfd005f440f21c, 0xbfe2c1342d3e9986,
            0xbfe50f78d644befe, 0xbfead02f97efc88a, 0xbfe4cae06b94e0d2,
            0xbfdc713edf93dac0, 0xbfec312f997ec7ac, 0x3fdc4ca1f0c30314,
            0x3faf0859109c77c0);
-  asm volatile("vfmadd.vf v2, %[A], v4" ::[A] "f"(dscalar_64));
+  asm volatile("vfmadd.vf v8, %[A], v16" ::[A] "f"(dscalar_64));
   //              -0.5896239092143964, -1.2989386647705283, -0.2225204504323405,
   //              1.1305842246079476, -0.4997635227612305,  0.5295330954311120,
   //              -0.8048662854791286,  0.3878770491466992, -0.5035828135241305,
   //              -0.3969929346554276, -1.1732547424504496,  0.1094702669545694,
   //              -0.7212349688741608,  0.0139056869464266, -0.7185807615459836,
   //              0.0559137678222272
-  VCMP_U64(9, v2, 0xbfe2de32f5e07f06, 0xbff4c873e8cb3071, 0xbfcc7b8cd4a627de,
+  VCMP_U64(9, v8, 0xbfe2de32f5e07f06, 0xbff4c873e8cb3071, 0xbfcc7b8cd4a627de,
            0x3ff216df7be108d1, 0xbfdffc20247f9130, 0x3fe0f1ef63e0d73b,
            0xbfe9c176f0b925be, 0x3fd8d2fa423d0f48, 0xbfe01d59b45d3de9,
            0xbfd968550dc5a3de, 0xbff2c5a6c3cb39b0, 0x3fbc063e50744ab8,
@@ -338,27 +338,27 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.6299
   BOX_HALF_IN_FLOAT(fscalar_16, 0x390a);
   //               -0.5352,  0.1115,  0.9541, -0.8857, -0.4143,  0.4045, 0.2949,
   //               -0.5479,  0.6733,  0.8965,  0.8882,  0.6294,  0.7568, 0.8735,
   //               -0.8569,  0.8271
-  VLOAD_16(v4, 0xb848, 0x2f23, 0x3ba2, 0xbb16, 0xb6a1, 0x3679, 0x34b8, 0xb862,
+  VLOAD_16(v16, 0xb848, 0x2f23, 0x3ba2, 0xbb16, 0xb6a1, 0x3679, 0x34b8, 0xb862,
            0x3963, 0x3b2c, 0x3b1b, 0x3909, 0x3a0e, 0x3afd, 0xbadb, 0x3a9e);
   VLOAD_8(v0, 0xAA, 0xAA);
   //                0.2844,  0.1008,  0.3777,  0.9790, -0.8613,  0.4951, 0.4126,
   //                0.5518, -0.6680, -0.8340,  0.2094,  0.5884, -0.6509,
   //                -0.9360, -0.1609, -0.2527
-  VLOAD_16(v2, 0x348d, 0x2e74, 0x360b, 0x3bd5, 0xbae4, 0x37ec, 0x369a, 0x386a,
+  VLOAD_16(v8, 0x348d, 0x2e74, 0x360b, 0x3bd5, 0xbae4, 0x37ec, 0x369a, 0x386a,
            0xb958, 0xbaac, 0x32b3, 0x38b5, 0xb935, 0xbb7d, 0xb126, 0xb40b);
-  asm volatile("vfmadd.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
-  VCMP_U16(10, v2, 0x348d, 0x319a, 0x360b, 0xb44e, 0xbae4, 0x39bb, 0x369a,
+  asm volatile("vfmadd.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_16));
+  VCMP_U16(10, v8, 0x348d, 0x319a, 0x360b, 0xb44e, 0xbae4, 0x39bb, 0x369a,
            0xb269, 0xb958, 0x35f0, 0x32b3, 0x3c00, 0xb935, 0x348b, 0xb126,
            0x3958);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                               0.80368215
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x3f4dbe1d);
@@ -366,7 +366,7 @@ void TEST_CASE4(void) {
   //                -0.69910282, -0.90573430,  0.86481184,  0.33341369,
   //                0.30657578, -0.90526944, -0.97891974, -0.50830764,
   //                0.79750061,  0.96885878,  0.48752418,  0.64305341
-  VLOAD_32(v4, 0x3e05db98, 0xbe4a2639, 0x3dbfe79e, 0x3ed22c6d, 0xbf32f867,
+  VLOAD_32(v16, 0x3e05db98, 0xbe4a2639, 0x3dbfe79e, 0x3ed22c6d, 0xbf32f867,
            0xbf67de34, 0x3f5d644f, 0x3eaab533, 0x3e9cf780, 0xbf67bfbd,
            0xbf7a9a7c, 0xbf022073, 0x3f4c2900, 0x3f780721, 0x3ef99cc5,
            0x3f249f26);
@@ -375,18 +375,18 @@ void TEST_CASE4(void) {
   //               -0.84296966,  0.50125730,  0.96147668,  0.65802389,
   //               0.19629262, -0.73197508, -0.06948850, -0.60436314,
   //               -0.80817568,  0.72047287, -0.78180677, -0.40237895
-  VLOAD_32(v2, 0xbf1c7638, 0x3f515a0a, 0xbeece360, 0xbe9e3276, 0xbf57ccdc,
+  VLOAD_32(v8, 0xbf1c7638, 0x3f515a0a, 0xbeece360, 0xbe9e3276, 0xbf57ccdc,
            0x3f005266, 0x3f762356, 0x3f287441, 0x3e4900ef, 0xbf3b62b8,
            0xbd8e4ffc, 0xbf1ab78b, 0xbf4ee49a, 0x3f3870e9, 0xbf48247d,
            0xbece049d);
-  asm volatile("vfmadd.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
-  VCMP_U32(11, v2, 0xbf1c7638, 0x3eeb6e09, 0xbeece360, 0x3e261112, 0xbf57ccdc,
+  asm volatile("vfmadd.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_32));
+  VCMP_U32(11, v8, 0xbf1c7638, 0x3eeb6e09, 0xbeece360, 0x3e261112, 0xbf57ccdc,
            0xbf00bced, 0x3f762356, 0x3f5cbccb, 0x3e4900ef, 0xbfbf2c79,
            0xbd8e4ffc, 0xbf7e7853, 0xbf4ee49a, 0x3fc62142, 0xbf48247d,
            0x3ea3ab9c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.5717861827636179
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fe24c128968c808);
@@ -398,7 +398,7 @@ void TEST_CASE4(void) {
   //                -0.6941474840922310,  0.4809970389518419,
   //                -0.4671263490725479,  0.5176516826232249,
   //                -0.9714116214357187,  0.0212574845134876
-  VLOAD_64(v4, 0xbfb90ff83cc58160, 0xbfe9d0157c220eae, 0x3fb9a21bd6239ad0,
+  VLOAD_64(v16, 0xbfb90ff83cc58160, 0xbfe9d0157c220eae, 0x3fb9a21bd6239ad0,
            0x3fe3c985e1ec6d14, 0xbfe6b113bcd49f88, 0x3fde2a4914f71f28,
            0xbfedf64fbb356b82, 0x3fe581cf0bb1e7c4, 0xbfc5905a8722a398,
            0xbf952cb38782ee00, 0xbfe63674c8d8dba6, 0x3fdec8a7cdf1580c,
@@ -412,14 +412,14 @@ void TEST_CASE4(void) {
   //                -0.6581386742527398, -0.8379133193505066,
   //                -0.6497652150347000, -0.4444119628309799,
   //                -0.8810041425660891,  0.4421772814931029, 0.0606105644967410
-  VLOAD_64(v2, 0xbfeb84f2357b2242, 0xbfeb8d061ebc48de, 0xbfe20e9f1cee50cc,
+  VLOAD_64(v8, 0xbfeb84f2357b2242, 0xbfeb8d061ebc48de, 0xbfe20e9f1cee50cc,
            0x3fecaacc26c2f0d0, 0x3fd76ecbc40b5864, 0x3fba0eeb244baff0,
            0x3fcd6d36a4399740, 0xbfdfd005f440f21c, 0xbfe2c1342d3e9986,
            0xbfe50f78d644befe, 0xbfead02f97efc88a, 0xbfe4cae06b94e0d2,
            0xbfdc713edf93dac0, 0xbfec312f997ec7ac, 0x3fdc4ca1f0c30314,
            0x3faf0859109c77c0);
-  asm volatile("vfmadd.vf v2, %[A], v4, v0.t" ::[A] "f"(dscalar_64));
-  VCMP_U64(12, v2, 0xbfeb84f2357b2242, 0xbff4c873e8cb3071, 0xbfe20e9f1cee50cc,
+  asm volatile("vfmadd.vf v8, %[A], v16, v0.t" ::[A] "f"(dscalar_64));
+  VCMP_U64(12, v8, 0xbfeb84f2357b2242, 0xbff4c873e8cb3071, 0xbfe20e9f1cee50cc,
            0x3ff216df7be108d1, 0x3fd76ecbc40b5864, 0x3fe0f1ef63e0d73b,
            0x3fcd6d36a4399740, 0x3fd8d2fa423d0f48, 0xbfe2c1342d3e9986,
            0xbfd968550dc5a3de, 0xbfead02f97efc88a, 0x3fbc063e50744ab8,
diff --git a/sw/riscvTests/isa/rv64uv/vfmax.c b/sw/riscvTests/isa/rv64uv/vfmax.c
index a65c16d8..e4faf6b1 100644
--- a/sw/riscvTests/isa/rv64uv/vfmax.c
+++ b/sw/riscvTests/isa/rv64uv/vfmax.c
@@ -10,31 +10,31 @@
 
 // Simple random test with similar values + 1 subnormal
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.0445, -0.4812,  0.5732,  0.0634,  0.2072, -0.6416,  0.7759,
   //               -0.0042,  0.6138,  0.7847, -0.5337,  0.3455,  0.0304, 0.7920,
   //               0.8179, -0.5659
-  VLOAD_16(v4, 0x29b3, 0xb7b3, 0x3896, 0x2c0f, 0x32a1, 0xb922, 0x3a35, 0x9c4d,
+  VLOAD_16(v16, 0x29b3, 0xb7b3, 0x3896, 0x2c0f, 0x32a1, 0xb922, 0x3a35, 0x9c4d,
            0x38e9, 0x3a47, 0xb845, 0x3587, 0x27ca, 0x3a56, 0x3a8b, 0xb887);
   //               0.6426, -0.4099, -0.1183,  0.2915,  0.5972, -0.1932, -0.0265,
   //               -0.5913, -0.8560,  0.5029, -0.8975, -0.7373,  0.3701, 0.9546,
   //               -0.2671, -0.6855
-  VLOAD_16(v6, 0x3924, 0xb68f, 0xaf93, 0x34aa, 0x38c7, 0xb22f, 0xa6c7, 0xb8bb,
+  VLOAD_16(v24, 0x3924, 0xb68f, 0xaf93, 0x34aa, 0x38c7, 0xb22f, 0xa6c7, 0xb8bb,
            0xbad9, 0x3806, 0xbb2e, 0xb9e6, 0x35ec, 0x3ba3, 0xb446, 0xb97c);
-  asm volatile("vfmax.vv v2, v4, v6");
+  asm volatile("vfmax.vv v8, v16, v24");
   //               0.6426, -0.4099,  0.5732,  0.2915,  0.5972, -0.1932,  0.7759,
   //               -0.0042,  0.6138,  0.7847, -0.5337,  0.3455,  0.3701, 0.9546,
   //               0.8179, -0.5659
-  VCMP_U16(1, v2, 0x3924, 0xb68f, 0x3896, 0x34aa, 0x38c7, 0xb22f, 0x3a35,
+  VCMP_U16(1, v8, 0x3924, 0xb68f, 0x3896, 0x34aa, 0x38c7, 0xb22f, 0x3a35,
            0x9c4d, 0x38e9, 0x3a47, 0xb845, 0x3587, 0x35ec, 0x3ba3, 0x3a8b,
            0xb887);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.19589283,  0.64597517, -0.09556163,  0.96582597,
   //              0.93413597,  0.78331935, -0.18831402, -0.29520443, 0.09486515,
   //              0.96548969,  0.74523991,  0.81442171,  0.25644442,
   //              -0.92091519,  0.25139943, -0.77403748
-  VLOAD_32(v4, 0xbe489821, 0x3f255ea1, 0xbdc3b5d1, 0x3f77405f, 0x3f6f2389,
+  VLOAD_32(v16, 0xbe489821, 0x3f255ea1, 0xbdc3b5d1, 0x3f77405f, 0x3f6f2389,
            0x3f48879e, 0xbe40d564, 0xbe972509, 0x3dc248a9, 0x3f772a55,
            0x3f3ec80b, 0x3f507df1, 0x3e834caf, 0xbf6bc119, 0x3e80b76d,
            0xbf462752);
@@ -42,29 +42,29 @@ void TEST_CASE1(void) {
   //              0.15872470, -0.17028977, -0.99863762, -0.02739566,
   //              -0.08060763,  0.73060948,  0.62843031,  0.68798363,
   //              -0.35207590,  0.01353026,  0.25345275, -0.93635505
-  VLOAD_32(v6, 0xbf16d6e0, 0x3f318640, 0x3f25eebb, 0xbc0e6e1c, 0x3e2288ba,
+  VLOAD_32(v24, 0xbf16d6e0, 0x3f318640, 0x3f25eebb, 0xbc0e6e1c, 0x3e2288ba,
            0xbe2e6071, 0xbf7fa6b7, 0xbce06cdd, 0xbda5159d, 0x3f3b0939,
            0x3f20e0cf, 0x3f301fb2, 0xbeb4434b, 0x3c5dae02, 0x3e81c48f,
            0xbf6fb4f7);
-  asm volatile("vfmax.vv v2, v4, v6");
+  asm volatile("vfmax.vv v8, v16, v24");
   //              -0.19589283,  0.69345474,  0.64817399,  0.96582597,
   //              0.93413597,  0.78331935, -0.18831402, -0.02739566, 0.09486515,
   //              0.96548969,  0.74523991,  0.81442171,  0.25644442, 0.01353026,
   //              0.25345275, -0.77403748
-  VCMP_U32(2, v2, 0xbe489821, 0x3f318640, 0x3f25eebb, 0x3f77405f, 0x3f6f2389,
+  VCMP_U32(2, v8, 0xbe489821, 0x3f318640, 0x3f25eebb, 0x3f77405f, 0x3f6f2389,
            0x3f48879e, 0xbe40d564, 0xbce06cdd, 0x3dc248a9, 0x3f772a55,
            0x3f3ec80b, 0x3f507df1, 0x3e834caf, 0x3c5dae02, 0x3e81c48f,
            0xbf462752);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.4061329687298849, -0.2985478109200665,  0.0070087316277823,
   //              -0.2169778494878496, -0.8530745559533048, -0.1247477743553222,
   //              0.5680045000966327,  0.9515829310663801, -0.9797693611753244,
   //              0.0055288881366042,  0.3717566019240965,  0.0982171502328268,
   //              -0.1563664923399100,  0.9555697921812856,  0.4810293698835877,
   //              -0.1835757691555060
-  VLOAD_64(v4, 0xbfd9fe1522a16c7c, 0xbfd31b68470c6bc4, 0x3f7cb530120b5400,
+  VLOAD_64(v16, 0xbfd9fe1522a16c7c, 0xbfd31b68470c6bc4, 0x3f7cb530120b5400,
            0xbfcbc5ee1fc0dc58, 0xbfeb4c6302dbd036, 0xbfbfef785b1ada80,
            0x3fe22d17c5fcaaf0, 0x3fee735e0c0b94e4, 0xbfef5a45467bddd8,
            0x3f76a5759bade800, 0x3fd7cadc33d5826c, 0x3fb924c2582803f0,
@@ -76,20 +76,20 @@ void TEST_CASE1(void) {
   //              -0.5415645292681506,  0.0094485111801912, -0.2151605186231076,
   //              -0.0785069829906857,  0.6345480854408712,  0.4658290296396683,
   //              -0.5143497066150833
-  VLOAD_64(v6, 0xbfe17a53f1e9e958, 0xbfdc5ce6e7f43e14, 0xbfe7ddf3ea78a228,
+  VLOAD_64(v24, 0xbfe17a53f1e9e958, 0xbfdc5ce6e7f43e14, 0xbfe7ddf3ea78a228,
            0xbfeb8eca710827f8, 0x3fe0ec9e8632f518, 0x3fdef4edc443ec94,
            0xbfe3046a59846530, 0x3fe0eb6249006ebc, 0x3fd3cc0765615f4c,
            0xbfe1547f22bc2bc2, 0x3f8359bdb41e5580, 0xbfcb8a613f7035f0,
            0xbfb419089c73df20, 0x3fe44e37c956a792, 0x3fddd0248ff51b48,
            0xbfe0758d8413ceaa);
-  asm volatile("vfmax.vv v2, v4, v6");
+  asm volatile("vfmax.vv v8, v16, v24");
   //              -0.4061329687298849, -0.2985478109200665,  0.0070087316277823,
   //              -0.2169778494878496,  0.5288841839862100,  0.4836992661145783,
   //              0.5680045000966327,  0.9515829310663801,  0.3093279352228719,
   //              0.0055288881366042,  0.3717566019240965,  0.0982171502328268,
   //              -0.0785069829906857,  0.9555697921812856,  0.4810293698835877,
   //              -0.1835757691555060
-  VCMP_U64(3, v2, 0xbfd9fe1522a16c7c, 0xbfd31b68470c6bc4, 0x3f7cb530120b5400,
+  VCMP_U64(3, v8, 0xbfd9fe1522a16c7c, 0xbfd31b68470c6bc4, 0x3f7cb530120b5400,
            0xbfcbc5ee1fc0dc58, 0x3fe0ec9e8632f518, 0x3fdef4edc443ec94,
            0x3fe22d17c5fcaaf0, 0x3fee735e0c0b94e4, 0x3fd3cc0765615f4c,
            0x3f76a5759bade800, 0x3fd7cadc33d5826c, 0x3fb924c2582803f0,
@@ -101,32 +101,32 @@ void TEST_CASE1(void) {
 // Simple random test with similar values + 1 subnormal (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.0445, -0.4812,  0.5732,  0.0634,  0.2072, -0.6416,  0.7759,
   //               -0.0042,  0.6138,  0.7847, -0.5337,  0.3455,  0.0304, 0.7920,
   //               0.8179, -0.5659
-  VLOAD_16(v4, 0x29b3, 0xb7b3, 0x3896, 0x2c0f, 0x32a1, 0xb922, 0x3a35, 0x9c4d,
+  VLOAD_16(v16, 0x29b3, 0xb7b3, 0x3896, 0x2c0f, 0x32a1, 0xb922, 0x3a35, 0x9c4d,
            0x38e9, 0x3a47, 0xb845, 0x3587, 0x27ca, 0x3a56, 0x3a8b, 0xb887);
   //               0.6426, -0.4099, -0.1183,  0.2915,  0.5972, -0.1932, -0.0265,
   //               -0.5913, -0.8560,  0.5029, -0.8975, -0.7373,  0.3701, 0.9546,
   //               -0.2671, -0.6855
-  VLOAD_16(v6, 0x3924, 0xb68f, 0xaf93, 0x34aa, 0x38c7, 0xb22f, 0xa6c7, 0xb8bb,
+  VLOAD_16(v24, 0x3924, 0xb68f, 0xaf93, 0x34aa, 0x38c7, 0xb22f, 0xa6c7, 0xb8bb,
            0xbad9, 0x3806, 0xbb2e, 0xb9e6, 0x35ec, 0x3ba3, 0xb446, 0xb97c);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmax.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfmax.vv v8, v16, v24, v0.t");
   //               0.0000, -0.4099,  0.0000,  0.2915,  0.0000, -0.1932,  0.0000,
   //               -0.0042,  0.0000,  0.7847,  0.0000,  0.3455,  0.0000, 0.9546,
   //               0.0000, -0.5659
-  VCMP_U16(4, v2, 0x0, 0xb68f, 0x0, 0x34aa, 0x0, 0xb22f, 0x0, 0x9c4d, 0x0,
+  VCMP_U16(4, v8, 0x0, 0xb68f, 0x0, 0x34aa, 0x0, 0xb22f, 0x0, 0x9c4d, 0x0,
            0x3a47, 0x0, 0x3587, 0x0, 0x3ba3, 0x0, 0xb887);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.19589283,  0.64597517, -0.09556163,  0.96582597,
   //              0.93413597,  0.78331935, -0.18831402, -0.29520443, 0.09486515,
   //              0.96548969,  0.74523991,  0.81442171,  0.25644442,
   //              -0.92091519,  0.25139943, -0.77403748
-  VLOAD_32(v4, 0xbe489821, 0x3f255ea1, 0xbdc3b5d1, 0x3f77405f, 0x3f6f2389,
+  VLOAD_32(v16, 0xbe489821, 0x3f255ea1, 0xbdc3b5d1, 0x3f77405f, 0x3f6f2389,
            0x3f48879e, 0xbe40d564, 0xbe972509, 0x3dc248a9, 0x3f772a55,
            0x3f3ec80b, 0x3f507df1, 0x3e834caf, 0xbf6bc119, 0x3e80b76d,
            0xbf462752);
@@ -134,30 +134,30 @@ void TEST_CASE2(void) {
   //              0.15872470, -0.17028977, -0.99863762, -0.02739566,
   //              -0.08060763,  0.73060948,  0.62843031,  0.68798363,
   //              -0.35207590,  0.01353026,  0.25345275, -0.93635505
-  VLOAD_32(v6, 0xbf16d6e0, 0x3f318640, 0x3f25eebb, 0xbc0e6e1c, 0x3e2288ba,
+  VLOAD_32(v24, 0xbf16d6e0, 0x3f318640, 0x3f25eebb, 0xbc0e6e1c, 0x3e2288ba,
            0xbe2e6071, 0xbf7fa6b7, 0xbce06cdd, 0xbda5159d, 0x3f3b0939,
            0x3f20e0cf, 0x3f301fb2, 0xbeb4434b, 0x3c5dae02, 0x3e81c48f,
            0xbf6fb4f7);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmax.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfmax.vv v8, v16, v24, v0.t");
   //               0.00000000,  0.69345474,  0.00000000,  0.96582597,
   //               0.00000000,  0.78331935,  0.00000000, -0.02739566,
   //               0.00000000,  0.96548969,  0.00000000,  0.81442171,
   //               0.00000000,  0.01353026,  0.00000000, -0.77403748
-  VCMP_U32(5, v2, 0x0, 0x3f318640, 0x0, 0x3f77405f, 0x0, 0x3f48879e, 0x0,
+  VCMP_U32(5, v8, 0x0, 0x3f318640, 0x0, 0x3f77405f, 0x0, 0x3f48879e, 0x0,
            0xbce06cdd, 0x0, 0x3f772a55, 0x0, 0x3f507df1, 0x0, 0x3c5dae02, 0x0,
            0xbf462752);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.4061329687298849, -0.2985478109200665,  0.0070087316277823,
   //              -0.2169778494878496, -0.8530745559533048, -0.1247477743553222,
   //              0.5680045000966327,  0.9515829310663801, -0.9797693611753244,
   //              0.0055288881366042,  0.3717566019240965,  0.0982171502328268,
   //              -0.1563664923399100,  0.9555697921812856,  0.4810293698835877,
   //              -0.1835757691555060
-  VLOAD_64(v4, 0xbfd9fe1522a16c7c, 0xbfd31b68470c6bc4, 0x3f7cb530120b5400,
+  VLOAD_64(v16, 0xbfd9fe1522a16c7c, 0xbfd31b68470c6bc4, 0x3f7cb530120b5400,
            0xbfcbc5ee1fc0dc58, 0xbfeb4c6302dbd036, 0xbfbfef785b1ada80,
            0x3fe22d17c5fcaaf0, 0x3fee735e0c0b94e4, 0xbfef5a45467bddd8,
            0x3f76a5759bade800, 0x3fd7cadc33d5826c, 0x3fb924c2582803f0,
@@ -169,22 +169,22 @@ void TEST_CASE2(void) {
   //              -0.5415645292681506,  0.0094485111801912, -0.2151605186231076,
   //              -0.0785069829906857,  0.6345480854408712,  0.4658290296396683,
   //              -0.5143497066150833
-  VLOAD_64(v6, 0xbfe17a53f1e9e958, 0xbfdc5ce6e7f43e14, 0xbfe7ddf3ea78a228,
+  VLOAD_64(v24, 0xbfe17a53f1e9e958, 0xbfdc5ce6e7f43e14, 0xbfe7ddf3ea78a228,
            0xbfeb8eca710827f8, 0x3fe0ec9e8632f518, 0x3fdef4edc443ec94,
            0xbfe3046a59846530, 0x3fe0eb6249006ebc, 0x3fd3cc0765615f4c,
            0xbfe1547f22bc2bc2, 0x3f8359bdb41e5580, 0xbfcb8a613f7035f0,
            0xbfb419089c73df20, 0x3fe44e37c956a792, 0x3fddd0248ff51b48,
            0xbfe0758d8413ceaa);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmax.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfmax.vv v8, v16, v24, v0.t");
   //               0.0000000000000000, -0.2985478109200665,  0.0000000000000000,
   //               -0.2169778494878496,  0.0000000000000000, 0.4836992661145783,
   //               0.0000000000000000,  0.9515829310663801,  0.0000000000000000,
   //               0.0055288881366042,  0.0000000000000000,  0.0982171502328268,
   //               0.0000000000000000,  0.9555697921812856,  0.0000000000000000,
   //               -0.1835757691555060
-  VCMP_U64(6, v2, 0x0, 0xbfd31b68470c6bc4, 0x0, 0xbfcbc5ee1fc0dc58, 0x0,
+  VCMP_U64(6, v8, 0x0, 0xbfd31b68470c6bc4, 0x0, 0xbfcbc5ee1fc0dc58, 0x0,
            0x3fdef4edc443ec94, 0x0, 0x3fee735e0c0b94e4, 0x0, 0x3f76a5759bade800,
            0x0, 0x3fb924c2582803f0, 0x0, 0x3fee940719ceda38, 0x0,
            0xbfc77f692a6e3368);
@@ -193,24 +193,24 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.0368
   BOX_HALF_IN_FLOAT(fscalar_16, 0x28b5);
   //              -0.5518,  0.6772,  0.2756,  0.4421,  0.2081,  0.6250,  0.4136,
   //              0.8203, -0.3535, -0.1597, -0.5244,  0.8696,  0.1744,  0.0793,
   //              -0.2445, -0.4031
-  VLOAD_16(v4, 0xb86a, 0x396b, 0x3469, 0x3713, 0x32a9, 0x3900, 0x369e, 0x3a90,
+  VLOAD_16(v16, 0xb86a, 0x396b, 0x3469, 0x3713, 0x32a9, 0x3900, 0x369e, 0x3a90,
            0xb5a8, 0xb11c, 0xb832, 0x3af5, 0x3195, 0x2d14, 0xb3d3, 0xb673);
-  asm volatile("vfmax.vf v2, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfmax.vf v8, v16, %[A]" ::[A] "f"(fscalar_16));
   //               0.0368,  0.6772,  0.2756,  0.4421,  0.2081,  0.6250,  0.4136,
   //               0.8203,  0.0368,  0.0368,  0.0368,  0.8696,  0.1744,  0.0793,
   //               0.0368,  0.0368
-  VCMP_U16(7, v2, 0x28b5, 0x396b, 0x3469, 0x3713, 0x32a9, 0x3900, 0x369e,
+  VCMP_U16(7, v8, 0x28b5, 0x396b, 0x3469, 0x3713, 0x32a9, 0x3900, 0x369e,
            0x3a90, 0x28b5, 0x28b5, 0x28b5, 0x3af5, 0x3195, 0x2d14, 0x28b5,
            0x28b5);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.94383347
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbf719f12);
@@ -218,22 +218,22 @@ void TEST_CASE3(void) {
   //               0.11194360, -0.33637357,  0.83680850,  0.95792335,
   //               0.41251704,  0.27496886, -0.06774041, -0.19357064,
   //               -0.48802575, -0.53921199,  0.32722279,  0.28428423
-  VLOAD_32(v4, 0x3f047029, 0x3ea002ba, 0x3ef27a17, 0x3e0cafaf, 0x3de542b0,
+  VLOAD_32(v16, 0x3f047029, 0x3ea002ba, 0x3ef27a17, 0x3e0cafaf, 0x3de542b0,
            0xbeac3928, 0x3f563915, 0x3f753a77, 0x3ed3356f, 0x3e8cc8b8,
            0xbd8abb7c, 0xbe463762, 0xbef9de83, 0xbf0a09cc, 0x3ea789bf,
            0x3e918db4);
-  asm volatile("vfmax.vf v2, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfmax.vf v8, v16, %[A]" ::[A] "f"(fscalar_32));
   //               0.51733643,  0.31252080,  0.47358772,  0.13738893,
   //               0.11194360, -0.33637357,  0.83680850,  0.95792335,
   //               0.41251704,  0.27496886, -0.06774041, -0.19357064,
   //               -0.48802575, -0.53921199,  0.32722279,  0.28428423
-  VCMP_U32(8, v2, 0x3f047029, 0x3ea002ba, 0x3ef27a17, 0x3e0cafaf, 0x3de542b0,
+  VCMP_U32(8, v8, 0x3f047029, 0x3ea002ba, 0x3ef27a17, 0x3e0cafaf, 0x3de542b0,
            0xbeac3928, 0x3f563915, 0x3f753a77, 0x3ed3356f, 0x3e8cc8b8,
            0xbd8abb7c, 0xbe463762, 0xbef9de83, 0xbf0a09cc, 0x3ea789bf,
            0x3e918db4);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                               -0.8274885128397702
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfea7ac9308eccb6);
@@ -245,20 +245,20 @@ void TEST_CASE3(void) {
   //                0.1886883982201846,  0.9268486384654282,
   //                -0.9639662652720637, -0.2101071651393955,
   //                0.0859470276611187, -0.7001184217853196
-  VLOAD_64(v4, 0x3feed2b8221dbd8e, 0x3fdde613942dab28, 0xbfc6640da5eaf690,
+  VLOAD_64(v16, 0x3feed2b8221dbd8e, 0x3fdde613942dab28, 0xbfc6640da5eaf690,
            0xbfb807daf023fbb0, 0x3fd601252797bdcc, 0x3fd2ce29819fd630,
            0xbfd716dac57e4298, 0x3fe5e4a85818c992, 0xbfe6455756bf47f8,
            0x3fde2865724428b0, 0x3fc826f101bec2b8, 0x3feda8be79d1a2f4,
            0xbfeed8cfc7f94e06, 0xbfcae4caa576e8a8, 0x3fb6009fd8fe2f80,
            0xbfe6675ebf9ca482);
-  asm volatile("vfmax.vf v2, v4, %[A]" ::[A] "f"(dscalar_64));
+  asm volatile("vfmax.vf v8, v16, %[A]" ::[A] "f"(dscalar_64));
   //               0.9632225672084347,  0.4671677538923853, -0.1749283847947720,
   //               -0.0938698612480795,  0.3438198935172891, 0.2938331380713377,
   //               -0.3607699326176230,  0.6841623039857032,
   //               -0.6959644979744999,  0.4712155929452235, 0.1886883982201846,
   //               0.9268486384654282, -0.8274885128397702, -0.2101071651393955,
   //               0.0859470276611187, -0.7001184217853196
-  VCMP_U64(9, v2, 0x3feed2b8221dbd8e, 0x3fdde613942dab28, 0xbfc6640da5eaf690,
+  VCMP_U64(9, v8, 0x3feed2b8221dbd8e, 0x3fdde613942dab28, 0xbfc6640da5eaf690,
            0xbfb807daf023fbb0, 0x3fd601252797bdcc, 0x3fd2ce29819fd630,
            0xbfd716dac57e4298, 0x3fe5e4a85818c992, 0xbfe6455756bf47f8,
            0x3fde2865724428b0, 0x3fc826f101bec2b8, 0x3feda8be79d1a2f4,
@@ -269,25 +269,25 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.0368
   BOX_HALF_IN_FLOAT(fscalar_16, 0x28b5);
   //               -0.5518,  0.6772,  0.2756,  0.4421,  0.2081,  0.6250, 0.4136,
   //               0.8203, -0.3535, -0.1597, -0.5244,  0.8696,  0.1744,  0.0793,
   //               -0.2445, -0.4031
-  VLOAD_16(v4, 0xb86a, 0x396b, 0x3469, 0x3713, 0x32a9, 0x3900, 0x369e, 0x3a90,
+  VLOAD_16(v16, 0xb86a, 0x396b, 0x3469, 0x3713, 0x32a9, 0x3900, 0x369e, 0x3a90,
            0xb5a8, 0xb11c, 0xb832, 0x3af5, 0x3195, 0x2d14, 0xb3d3, 0xb673);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmax.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v8);
+  asm volatile("vfmax.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.0000,  0.6772,  0.0000,  0.4421,  0.0000,  0.6250, 0.0000,
   //                0.8203,  0.0000,  0.0368,  0.0000,  0.8696,  0.0000, 0.0793,
   //                0.0000,  0.0368
-  VCMP_U16(10, v2, 0x0, 0x396b, 0x0, 0x3713, 0x0, 0x3900, 0x0, 0x3a90, 0x0,
+  VCMP_U16(10, v8, 0x0, 0x396b, 0x0, 0x3713, 0x0, 0x3900, 0x0, 0x3a90, 0x0,
            0x28b5, 0x0, 0x3af5, 0x0, 0x2d14, 0x0, 0x28b5);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.94383347
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbf719f12);
@@ -295,23 +295,23 @@ void TEST_CASE4(void) {
   //                0.11194360, -0.33637357,  0.83680850,  0.95792335,
   //                0.41251704,  0.27496886, -0.06774041, -0.19357064,
   //                -0.48802575, -0.53921199,  0.32722279,  0.28428423
-  VLOAD_32(v4, 0x3f047029, 0x3ea002ba, 0x3ef27a17, 0x3e0cafaf, 0x3de542b0,
+  VLOAD_32(v16, 0x3f047029, 0x3ea002ba, 0x3ef27a17, 0x3e0cafaf, 0x3de542b0,
            0xbeac3928, 0x3f563915, 0x3f753a77, 0x3ed3356f, 0x3e8cc8b8,
            0xbd8abb7c, 0xbe463762, 0xbef9de83, 0xbf0a09cc, 0x3ea789bf,
            0x3e918db4);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmax.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v8);
+  asm volatile("vfmax.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.00000000,  0.31252080,  0.00000000,  0.13738893,
   //                0.00000000, -0.33637357,  0.00000000,  0.95792335,
   //                0.00000000,  0.27496886,  0.00000000, -0.19357064,
   //                0.00000000, -0.53921199,  0.00000000,  0.28428423
-  VCMP_U32(11, v2, 0x0, 0x3ea002ba, 0x0, 0x3e0cafaf, 0x0, 0xbeac3928, 0x0,
+  VCMP_U32(11, v8, 0x0, 0x3ea002ba, 0x0, 0x3e0cafaf, 0x0, 0xbeac3928, 0x0,
            0x3f753a77, 0x0, 0x3e8cc8b8, 0x0, 0xbe463762, 0x0, 0xbf0a09cc, 0x0,
            0x3e918db4);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                               -0.8274885128397702
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfea7ac9308eccb6);
@@ -323,15 +323,15 @@ void TEST_CASE4(void) {
   //                 0.1886883982201846,  0.9268486384654282,
   //                 -0.9639662652720637, -0.2101071651393955,
   //                 0.0859470276611187, -0.7001184217853196
-  VLOAD_64(v4, 0x3feed2b8221dbd8e, 0x3fdde613942dab28, 0xbfc6640da5eaf690,
+  VLOAD_64(v16, 0x3feed2b8221dbd8e, 0x3fdde613942dab28, 0xbfc6640da5eaf690,
            0xbfb807daf023fbb0, 0x3fd601252797bdcc, 0x3fd2ce29819fd630,
            0xbfd716dac57e4298, 0x3fe5e4a85818c992, 0xbfe6455756bf47f8,
            0x3fde2865724428b0, 0x3fc826f101bec2b8, 0x3feda8be79d1a2f4,
            0xbfeed8cfc7f94e06, 0xbfcae4caa576e8a8, 0x3fb6009fd8fe2f80,
            0xbfe6675ebf9ca482);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmax.vf v2, v4, %[A], v0.t" ::[A] "f"(dscalar_64));
+  VCLEAR(v8);
+  asm volatile("vfmax.vf v8, v16, %[A], v0.t" ::[A] "f"(dscalar_64));
   //                0.0000000000000000,  0.4671677538923853, 0.0000000000000000,
   //                -0.0938698612480795,  0.0000000000000000,
   //                0.2938331380713377,  0.0000000000000000, 0.6841623039857032,
@@ -339,7 +339,7 @@ void TEST_CASE4(void) {
   //                0.9268486384654282,  0.0000000000000000,
   //                -0.2101071651393955,  0.0000000000000000,
   //                -0.7001184217853196
-  VCMP_U64(12, v2, 0x0, 0x3fdde613942dab28, 0x0, 0xbfb807daf023fbb0, 0x0,
+  VCMP_U64(12, v8, 0x0, 0x3fdde613942dab28, 0x0, 0xbfb807daf023fbb0, 0x0,
            0x3fd2ce29819fd630, 0x0, 0x3fe5e4a85818c992, 0x0, 0x3fde2865724428b0,
            0x0, 0x3feda8be79d1a2f4, 0x0, 0xbfcae4caa576e8a8, 0x0,
            0xbfe6675ebf9ca482);
diff --git a/sw/riscvTests/isa/rv64uv/vfmin.c b/sw/riscvTests/isa/rv64uv/vfmin.c
index b21e6768..9841b175 100644
--- a/sw/riscvTests/isa/rv64uv/vfmin.c
+++ b/sw/riscvTests/isa/rv64uv/vfmin.c
@@ -10,31 +10,31 @@
 
 // Simple random test with similar values + 1 subnormal
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.9390,  0.9619,  0.9121,  0.6265,  0.1193, -0.4492, -0.3562,
   //               0.2365, -0.9897,  0.8638, -0.0379, -0.6201,  0.1809,  0.9824,
   //               -0.9922, -0.6851
-  VLOAD_16(v4, 0x3b83, 0x3bb2, 0x3b4c, 0x3903, 0x2fa2, 0xb730, 0xb5b3, 0x3391,
+  VLOAD_16(v16, 0x3b83, 0x3bb2, 0x3b4c, 0x3903, 0x2fa2, 0xb730, 0xb5b3, 0x3391,
            0xbbeb, 0x3ae9, 0xa8da, 0xb8f6, 0x31ca, 0x3bdc, 0xbbf0, 0xb97b);
   //               0.9795, -0.1069,  0.7070, -0.7305,  0.0516, -0.1321,  0.3828,
   //               0.0230, -0.9424, -0.8652, -0.3865, -0.1719, -0.7021,  0.1664,
   //               0.7026, -0.8535
-  VLOAD_16(v6, 0x3bd6, 0xaed8, 0x39a8, 0xb9d8, 0x2a9a, 0xb03a, 0x3620, 0x25e2,
+  VLOAD_16(v24, 0x3bd6, 0xaed8, 0x39a8, 0xb9d8, 0x2a9a, 0xb03a, 0x3620, 0x25e2,
            0xbb8a, 0xbaec, 0xb62f, 0xb180, 0xb99e, 0x3153, 0x399f, 0xbad4);
-  asm volatile("vfmin.vv v2, v4, v6");
+  asm volatile("vfmin.vv v8, v16, v24");
   //               0.9390, -0.1069,  0.7070, -0.7305,  0.0516, -0.4492, -0.3562,
   //               0.0230, -0.9897, -0.8652, -0.3865, -0.6201, -0.7021,  0.1664,
   //               -0.9922, -0.8535
-  VCMP_U16(1, v2, 0x3b83, 0xaed8, 0x39a8, 0xb9d8, 0x2a9a, 0xb730, 0xb5b3,
+  VCMP_U16(1, v8, 0x3b83, 0xaed8, 0x39a8, 0xb9d8, 0x2a9a, 0xb730, 0xb5b3,
            0x25e2, 0xbbeb, 0xbaec, 0xb62f, 0xb8f6, 0xb99e, 0x3153, 0xbbf0,
            0xbad4);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.33477312, -0.14129849, -0.94871885,  0.83600986,
   //               -0.28163233, -0.47814348,  0.77408481, -0.54823470,
   //               -0.72419900,  0.27495387, -0.76835793,  0.71516198,
   //               0.32305571, -0.76598656, -0.36499983, -0.52954155
-  VLOAD_32(v4, 0x3eab6762, 0xbe10b08d, 0xbf72df3d, 0x3f5604be, 0xbe90321d,
+  VLOAD_32(v16, 0x3eab6762, 0xbe10b08d, 0xbf72df3d, 0x3f5604be, 0xbe90321d,
            0xbef4cf39, 0x3f462a6c, 0xbf0c591c, 0xbf39651b, 0x3e8cc6c1,
            0xbf44b31b, 0x3f3714db, 0x3ea5678f, 0xbf4417b2, 0xbebae142,
            0xbf079009);
@@ -42,29 +42,29 @@ void TEST_CASE1(void) {
   //               0.74085194, -0.99458516, -0.73125440, -0.46319291,
   //               -0.76140571, -0.82557100,  0.15205561,  0.39971715,
   //               -0.32876521, -0.53106725,  0.84727478,  0.21940185
-  VLOAD_32(v6, 0x3f5f314f, 0x3eccd36f, 0x3ecd67c7, 0x3f7946a1, 0x3f3da879,
+  VLOAD_32(v24, 0x3f5f314f, 0x3eccd36f, 0x3ecd67c7, 0x3f7946a1, 0x3f3da879,
            0xbf7e9d22, 0xbf3b337d, 0xbeed279f, 0xbf42eb7c, 0xbf53589f,
            0x3e1bb477, 0x3ecca7ba, 0xbea853ea, 0xbf07f406, 0x3f58e700,
            0x3e60aae1);
-  asm volatile("vfmin.vv v2, v4, v6");
+  asm volatile("vfmin.vv v8, v16, v24");
   //               0.33477312, -0.14129849, -0.94871885,  0.83600986,
   //               -0.28163233, -0.99458516, -0.73125440, -0.54823470,
   //               -0.76140571, -0.82557100, -0.76835793,  0.39971715,
   //               -0.32876521, -0.76598656, -0.36499983, -0.52954155
-  VCMP_U32(2, v2, 0x3eab6762, 0xbe10b08d, 0xbf72df3d, 0x3f5604be, 0xbe90321d,
+  VCMP_U32(2, v8, 0x3eab6762, 0xbe10b08d, 0xbf72df3d, 0x3f5604be, 0xbe90321d,
            0xbf7e9d22, 0xbf3b337d, 0xbf0c591c, 0xbf42eb7c, 0xbf53589f,
            0xbf44b31b, 0x3ecca7ba, 0xbea853ea, 0xbf4417b2, 0xbebae142,
            0xbf079009);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               0.9387726994461698,  0.8517969615002949, -0.8864275043807637,
   //               0.3621349692771021,  0.5392486258321831, -0.1288714247798126,
   //               -0.9149173505741688, -0.9378576380992047,
   //               -0.2263428385339852,  0.1016628884386184, 0.4783549203499486,
   //               0.5394596797016060,  0.7861587828590215,  0.0194772848204161,
   //               -0.9126826319328591,  0.3997583898469530
-  VLOAD_64(v4, 0x3fee0a6d0b4ff74a, 0x3feb41ebb38f3ae2, 0xbfec5d9d36b2e38c,
+  VLOAD_64(v16, 0x3fee0a6d0b4ff74a, 0x3feb41ebb38f3ae2, 0xbfec5d9d36b2e38c,
            0x3fd72d3826721e9c, 0x3fe14186558b96e0, 0xbfc07edbdd68bb68,
            0xbfed4700c06849e8, 0xbfee02ee057e1390, 0xbfccf8cd5897f8a0,
            0x3fba06943d0f8e20, 0x3fde9d5df4b22860, 0x3fe14340f23a8770,
@@ -76,20 +76,20 @@ void TEST_CASE1(void) {
   //               0.1176441554686278,  0.4929731878752270,  0.0942028280153233,
   //               0.9496420237972776, -0.4549651855719854, -0.9663401540020158,
   //               0.4114236885680320
-  VLOAD_64(v6, 0x3fdec58fccbc12a4, 0x3fe719be53c35314, 0xbfee413924cc77e4,
+  VLOAD_64(v24, 0x3fdec58fccbc12a4, 0x3fe719be53c35314, 0xbfee413924cc77e4,
            0x3fe7790b32975e1a, 0x3fef5cd4d43cbc4e, 0xbfe5fecd00a37bfa,
            0xbfe6b0de55ba0314, 0x3fe900abee2f95f8, 0x3fe5caf19e1f4324,
            0x3fbe1ded684da4d0, 0x3fdf8cdf69eea758, 0x3fb81dad31843b10,
            0x3fee6377ab63bade, 0xbfdd1e264c366a78, 0xbfeeec422fc80224,
            0x3fda54c405ccc2c0);
-  asm volatile("vfmin.vv v2, v4, v6");
+  asm volatile("vfmin.vv v8, v16, v24");
   //               0.4808082103120717,  0.7218925128932789, -0.9454618185734458,
   //               0.3621349692771021,  0.5392486258321831, -0.6873536121819364,
   //               -0.9149173505741688, -0.9378576380992047,
   //               -0.2263428385339852,  0.1016628884386184, 0.4783549203499486,
   //               0.0942028280153233,  0.7861587828590215, -0.4549651855719854,
   //               -0.9663401540020158,  0.3997583898469530
-  VCMP_U64(3, v2, 0x3fdec58fccbc12a4, 0x3fe719be53c35314, 0xbfee413924cc77e4,
+  VCMP_U64(3, v8, 0x3fdec58fccbc12a4, 0x3fe719be53c35314, 0xbfee413924cc77e4,
            0x3fd72d3826721e9c, 0x3fe14186558b96e0, 0xbfe5fecd00a37bfa,
            0xbfed4700c06849e8, 0xbfee02ee057e1390, 0xbfccf8cd5897f8a0,
            0x3fba06943d0f8e20, 0x3fde9d5df4b22860, 0x3fb81dad31843b10,
@@ -101,32 +101,32 @@ void TEST_CASE1(void) {
 // Simple random test with similar values + 1 subnormal (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.9390,  0.9619,  0.9121,  0.6265,  0.1193, -0.4492, -0.3562,
   //               0.2365, -0.9897,  0.8638, -0.0379, -0.6201,  0.1809,  0.9824,
   //               -0.9922, -0.6851
-  VLOAD_16(v4, 0x3b83, 0x3bb2, 0x3b4c, 0x3903, 0x2fa2, 0xb730, 0xb5b3, 0x3391,
+  VLOAD_16(v16, 0x3b83, 0x3bb2, 0x3b4c, 0x3903, 0x2fa2, 0xb730, 0xb5b3, 0x3391,
            0xbbeb, 0x3ae9, 0xa8da, 0xb8f6, 0x31ca, 0x3bdc, 0xbbf0, 0xb97b);
   //               0.9795, -0.1069,  0.7070, -0.7305,  0.0516, -0.1321,  0.3828,
   //               0.0230, -0.9424, -0.8652, -0.3865, -0.1719, -0.7021,  0.1664,
   //               0.7026, -0.8535
-  VLOAD_16(v6, 0x3bd6, 0xaed8, 0x39a8, 0xb9d8, 0x2a9a, 0xb03a, 0x3620, 0x25e2,
+  VLOAD_16(v24, 0x3bd6, 0xaed8, 0x39a8, 0xb9d8, 0x2a9a, 0xb03a, 0x3620, 0x25e2,
            0xbb8a, 0xbaec, 0xb62f, 0xb180, 0xb99e, 0x3153, 0x399f, 0xbad4);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmin.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfmin.vv v8, v16, v24, v0.t");
   //               0.0000, -0.1069,  0.0000, -0.7305,  0.0000, -0.4492,  0.0000,
   //               0.0230,  0.0000, -0.8652,  0.0000, -0.6201,  0.0000,  0.1664,
   //               0.0000, -0.8535
-  VCMP_U16(4, v2, 0x0, 0xaed8, 0x0, 0xb9d8, 0x0, 0xb730, 0x0, 0x25e2, 0x0,
+  VCMP_U16(4, v8, 0x0, 0xaed8, 0x0, 0xb9d8, 0x0, 0xb730, 0x0, 0x25e2, 0x0,
            0xbaec, 0x0, 0xb8f6, 0x0, 0x3153, 0x0, 0xbad4);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.33477312, -0.14129849, -0.94871885,  0.83600986,
   //               -0.28163233, -0.47814348,  0.77408481, -0.54823470,
   //               -0.72419900,  0.27495387, -0.76835793,  0.71516198,
   //               0.32305571, -0.76598656, -0.36499983, -0.52954155
-  VLOAD_32(v4, 0x3eab6762, 0xbe10b08d, 0xbf72df3d, 0x3f5604be, 0xbe90321d,
+  VLOAD_32(v16, 0x3eab6762, 0xbe10b08d, 0xbf72df3d, 0x3f5604be, 0xbe90321d,
            0xbef4cf39, 0x3f462a6c, 0xbf0c591c, 0xbf39651b, 0x3e8cc6c1,
            0xbf44b31b, 0x3f3714db, 0x3ea5678f, 0xbf4417b2, 0xbebae142,
            0xbf079009);
@@ -134,30 +134,30 @@ void TEST_CASE2(void) {
   //               0.74085194, -0.99458516, -0.73125440, -0.46319291,
   //               -0.76140571, -0.82557100,  0.15205561,  0.39971715,
   //               -0.32876521, -0.53106725,  0.84727478,  0.21940185
-  VLOAD_32(v6, 0x3f5f314f, 0x3eccd36f, 0x3ecd67c7, 0x3f7946a1, 0x3f3da879,
+  VLOAD_32(v24, 0x3f5f314f, 0x3eccd36f, 0x3ecd67c7, 0x3f7946a1, 0x3f3da879,
            0xbf7e9d22, 0xbf3b337d, 0xbeed279f, 0xbf42eb7c, 0xbf53589f,
            0x3e1bb477, 0x3ecca7ba, 0xbea853ea, 0xbf07f406, 0x3f58e700,
            0x3e60aae1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmin.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfmin.vv v8, v16, v24, v0.t");
   //               0.00000000, -0.14129849,  0.00000000,  0.83600986,
   //               0.00000000, -0.99458516,  0.00000000, -0.54823470,
   //               0.00000000, -0.82557100,  0.00000000,  0.39971715,
   //               0.00000000, -0.76598656,  0.00000000, -0.52954155
-  VCMP_U32(5, v2, 0x0, 0xbe10b08d, 0x0, 0x3f5604be, 0x0, 0xbf7e9d22, 0x0,
+  VCMP_U32(5, v8, 0x0, 0xbe10b08d, 0x0, 0x3f5604be, 0x0, 0xbf7e9d22, 0x0,
            0xbf0c591c, 0x0, 0xbf53589f, 0x0, 0x3ecca7ba, 0x0, 0xbf4417b2, 0x0,
            0xbf079009);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               0.9387726994461698,  0.8517969615002949, -0.8864275043807637,
   //               0.3621349692771021,  0.5392486258321831, -0.1288714247798126,
   //               -0.9149173505741688, -0.9378576380992047,
   //               -0.2263428385339852,  0.1016628884386184, 0.4783549203499486,
   //               0.5394596797016060,  0.7861587828590215,  0.0194772848204161,
   //               -0.9126826319328591,  0.3997583898469530
-  VLOAD_64(v4, 0x3fee0a6d0b4ff74a, 0x3feb41ebb38f3ae2, 0xbfec5d9d36b2e38c,
+  VLOAD_64(v16, 0x3fee0a6d0b4ff74a, 0x3feb41ebb38f3ae2, 0xbfec5d9d36b2e38c,
            0x3fd72d3826721e9c, 0x3fe14186558b96e0, 0xbfc07edbdd68bb68,
            0xbfed4700c06849e8, 0xbfee02ee057e1390, 0xbfccf8cd5897f8a0,
            0x3fba06943d0f8e20, 0x3fde9d5df4b22860, 0x3fe14340f23a8770,
@@ -169,22 +169,22 @@ void TEST_CASE2(void) {
   //               0.1176441554686278,  0.4929731878752270,  0.0942028280153233,
   //               0.9496420237972776, -0.4549651855719854, -0.9663401540020158,
   //               0.4114236885680320
-  VLOAD_64(v6, 0x3fdec58fccbc12a4, 0x3fe719be53c35314, 0xbfee413924cc77e4,
+  VLOAD_64(v24, 0x3fdec58fccbc12a4, 0x3fe719be53c35314, 0xbfee413924cc77e4,
            0x3fe7790b32975e1a, 0x3fef5cd4d43cbc4e, 0xbfe5fecd00a37bfa,
            0xbfe6b0de55ba0314, 0x3fe900abee2f95f8, 0x3fe5caf19e1f4324,
            0x3fbe1ded684da4d0, 0x3fdf8cdf69eea758, 0x3fb81dad31843b10,
            0x3fee6377ab63bade, 0xbfdd1e264c366a78, 0xbfeeec422fc80224,
            0x3fda54c405ccc2c0);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmin.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfmin.vv v8, v16, v24, v0.t");
   //               0.0000000000000000,  0.7218925128932789,  0.0000000000000000,
   //               0.3621349692771021,  0.0000000000000000, -0.6873536121819364,
   //               0.0000000000000000, -0.9378576380992047,  0.0000000000000000,
   //               0.1016628884386184,  0.0000000000000000,  0.0942028280153233,
   //               0.0000000000000000, -0.4549651855719854,  0.0000000000000000,
   //               0.3997583898469530
-  VCMP_U64(6, v2, 0x0, 0x3fe719be53c35314, 0x0, 0x3fd72d3826721e9c, 0x0,
+  VCMP_U64(6, v8, 0x0, 0x3fe719be53c35314, 0x0, 0x3fd72d3826721e9c, 0x0,
            0xbfe5fecd00a37bfa, 0x0, 0xbfee02ee057e1390, 0x0, 0x3fba06943d0f8e20,
            0x0, 0x3fb81dad31843b10, 0x0, 0xbfdd1e264c366a78, 0x0,
            0x3fd995a436ac6f1c);
@@ -193,24 +193,24 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.4434
   BOX_HALF_IN_FLOAT(fscalar_16, 0x3718);
   //              -0.2537,  0.5449,  0.2070, -0.5752, -0.3008,  0.0165, -0.8447,
   //              0.6279,  0.6802,  0.7300,  0.7720, -0.8525,  0.5264, -0.5249,
   //              -0.9839,  0.4875
-  VLOAD_16(v4, 0xb40f, 0x385c, 0x32a0, 0xb89a, 0xb4d0, 0x2437, 0xbac2, 0x3906,
+  VLOAD_16(v16, 0xb40f, 0x385c, 0x32a0, 0xb89a, 0xb4d0, 0x2437, 0xbac2, 0x3906,
            0x3971, 0x39d7, 0x3a2d, 0xbad2, 0x3836, 0xb833, 0xbbdf, 0x37cd);
-  asm volatile("vfmin.vf v2, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfmin.vf v8, v16, %[A]" ::[A] "f"(fscalar_16));
   //              -0.2537,  0.4434,  0.2070, -0.5752, -0.3008,  0.0165, -0.8447,
   //              0.4434,  0.4434,  0.4434,  0.4434, -0.8525,  0.4434, -0.5249,
   //              -0.9839,  0.4434
-  VCMP_U16(7, v2, 0xb40f, 0x3718, 0x32a0, 0xb89a, 0xb4d0, 0x2437, 0xbac2,
+  VCMP_U16(7, v8, 0xb40f, 0x3718, 0x32a0, 0xb89a, 0xb4d0, 0x2437, 0xbac2,
            0x3718, 0x3718, 0x3718, 0x3718, 0xbad2, 0x3718, 0xb833, 0xbbdf,
            0x3718);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                               0.59499639
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x3f1851af);
@@ -218,22 +218,22 @@ void TEST_CASE3(void) {
   //              0.22003150, -0.67564118, -0.90376341,  0.16465612,
   //              -0.15494362, -0.01763406,  0.97777683, -0.91671157,
   //              0.81712914, -0.10151604,  0.03442690, -0.14597759
-  VLOAD_32(v4, 0xbf71440f, 0xbf068d77, 0xbf39686c, 0xbf2da1c2, 0x3e614ff0,
+  VLOAD_32(v16, 0xbf71440f, 0xbf068d77, 0xbf39686c, 0xbf2da1c2, 0x3e614ff0,
            0xbf2cf6d2, 0xbf675d0a, 0x3e289b9d, 0xbe1ea98a, 0xbc90754e,
            0x3f7a4f95, 0xbf6aad9c, 0x3f512f60, 0xbdcfe7a4, 0x3d0d0338,
            0xbe157b26);
-  asm volatile("vfmin.vf v2, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfmin.vf v8, v16, %[A]" ::[A] "f"(fscalar_32));
   //              -0.94244474, -0.52559608, -0.72424960, -0.67824948,
   //              0.22003150, -0.67564118, -0.90376341,  0.16465612,
   //              -0.15494362, -0.01763406,  0.59499639, -0.91671157,
   //              0.59499639, -0.10151604,  0.03442690, -0.14597759
-  VCMP_U32(8, v2, 0xbf71440f, 0xbf068d77, 0xbf39686c, 0xbf2da1c2, 0x3e614ff0,
+  VCMP_U32(8, v8, 0xbf71440f, 0xbf068d77, 0xbf39686c, 0xbf2da1c2, 0x3e614ff0,
            0xbf2cf6d2, 0xbf675d0a, 0x3e289b9d, 0xbe1ea98a, 0xbc90754e,
            0x3f1851af, 0xbf6aad9c, 0x3f1851af, 0xbdcfe7a4, 0x3d0d0338,
            0xbe157b26);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.8631130564395617
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3feb9e9f45c51298);
@@ -243,20 +243,20 @@ void TEST_CASE3(void) {
   //               -0.7695072044924456, -0.6726760621514143,
   //               -0.9995830020822822,  0.2485224245452053, 0.7025040357726613,
   //               -0.6452676560401207,  0.5090044889036880,  0.0801949752856408
-  VLOAD_64(v4, 0xbf94dc2c93a00800, 0x3fdedfbff74290e0, 0x3fe1a720de3f34c0,
+  VLOAD_64(v16, 0xbf94dc2c93a00800, 0x3fdedfbff74290e0, 0x3fe1a720de3f34c0,
            0xbfb96a9acd667320, 0x3fe7c36063b54b1e, 0x3fd3b68465cb4b28,
            0xbfe59c154d684914, 0xbfd52e7fee0af3fc, 0xbfe89fcd92aa9b24,
            0xbfe5868ff2f7c1a4, 0xbfeffc957df296c0, 0x3fcfcf9532df44b8,
            0x3fe67ae9be5e7376, 0xbfe4a6085afb7c12, 0x3fe049c3c82b791e,
            0x3fb487a86c27c560);
-  asm volatile("vfmin.vf v2, v4, %[A]" ::[A] "f"(dscalar_64));
+  asm volatile("vfmin.vf v8, v16, %[A]" ::[A] "f"(dscalar_64));
   //              -0.0203711476424431,  0.4824066080711997,  0.5516514149436702,
   //              -0.0992829085793798,  0.7425996730256406,  0.3080149644930992,
   //              -0.6753031265127754, -0.3309631180416657, -0.7695072044924456,
   //              -0.6726760621514143, -0.9995830020822822,  0.2485224245452053,
   //              0.7025040357726613, -0.6452676560401207,  0.5090044889036880,
   //              0.0801949752856408
-  VCMP_U64(9, v2, 0xbf94dc2c93a00800, 0x3fdedfbff74290e0, 0x3fe1a720de3f34c0,
+  VCMP_U64(9, v8, 0xbf94dc2c93a00800, 0x3fdedfbff74290e0, 0x3fe1a720de3f34c0,
            0xbfb96a9acd667320, 0x3fe7c36063b54b1e, 0x3fd3b68465cb4b28,
            0xbfe59c154d684914, 0xbfd52e7fee0af3fc, 0xbfe89fcd92aa9b24,
            0xbfe5868ff2f7c1a4, 0xbfeffc957df296c0, 0x3fcfcf9532df44b8,
@@ -267,25 +267,25 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.4434
   BOX_HALF_IN_FLOAT(fscalar_16, 0x3718);
   //               -0.2537,  0.5449,  0.2070, -0.5752, -0.3008,  0.0165,
   //               -0.8447,  0.6279,  0.6802,  0.7300,  0.7720, -0.8525, 0.5264,
   //               -0.5249, -0.9839,  0.4875
-  VLOAD_16(v4, 0xb40f, 0x385c, 0x32a0, 0xb89a, 0xb4d0, 0x2437, 0xbac2, 0x3906,
+  VLOAD_16(v16, 0xb40f, 0x385c, 0x32a0, 0xb89a, 0xb4d0, 0x2437, 0xbac2, 0x3906,
            0x3971, 0x39d7, 0x3a2d, 0xbad2, 0x3836, 0xb833, 0xbbdf, 0x37cd);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmin.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v8);
+  asm volatile("vfmin.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.0000,  0.4434,  0.0000, -0.5752,  0.0000,  0.0165, 0.0000,
   //                0.4434,  0.0000,  0.4434,  0.0000, -0.8525,  0.0000,
   //                -0.5249,  0.0000,  0.4434
-  VCMP_U16(10, v2, 0x0, 0x3718, 0x0, 0xb89a, 0x0, 0x2437, 0x0, 0x3718, 0x0,
+  VCMP_U16(10, v8, 0x0, 0x3718, 0x0, 0xb89a, 0x0, 0x2437, 0x0, 0x3718, 0x0,
            0x3718, 0x0, 0xbad2, 0x0, 0xb833, 0x0, 0x3718);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                               0.59499639
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x3f1851af);
@@ -293,23 +293,23 @@ void TEST_CASE4(void) {
   //               0.22003150, -0.67564118, -0.90376341,  0.16465612,
   //               -0.15494362, -0.01763406,  0.97777683, -0.91671157,
   //               0.81712914, -0.10151604,  0.03442690, -0.14597759
-  VLOAD_32(v4, 0xbf71440f, 0xbf068d77, 0xbf39686c, 0xbf2da1c2, 0x3e614ff0,
+  VLOAD_32(v16, 0xbf71440f, 0xbf068d77, 0xbf39686c, 0xbf2da1c2, 0x3e614ff0,
            0xbf2cf6d2, 0xbf675d0a, 0x3e289b9d, 0xbe1ea98a, 0xbc90754e,
            0x3f7a4f95, 0xbf6aad9c, 0x3f512f60, 0xbdcfe7a4, 0x3d0d0338,
            0xbe157b26);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmin.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v8);
+  asm volatile("vfmin.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.00000000, -0.52559608,  0.00000000, -0.67824948,
   //                0.00000000, -0.67564118,  0.00000000,  0.16465612,
   //                0.00000000, -0.01763406,  0.00000000, -0.91671157,
   //                0.00000000, -0.10151604,  0.00000000, -0.14597759
-  VCMP_U32(11, v2, 0x0, 0xbf068d77, 0x0, 0xbf2da1c2, 0x0, 0xbf2cf6d2, 0x0,
+  VCMP_U32(11, v8, 0x0, 0xbf068d77, 0x0, 0xbf2da1c2, 0x0, 0xbf2cf6d2, 0x0,
            0x3e289b9d, 0x0, 0xbc90754e, 0x0, 0xbf6aad9c, 0x0, 0xbdcfe7a4, 0x0,
            0xbe157b26);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.8631130564395617
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3feb9e9f45c51298);
@@ -320,15 +320,15 @@ void TEST_CASE4(void) {
   //                -0.6726760621514143, -0.9995830020822822,
   //                0.2485224245452053,  0.7025040357726613,
   //                -0.6452676560401207,  0.5090044889036880, 0.0801949752856408
-  VLOAD_64(v4, 0xbf94dc2c93a00800, 0x3fdedfbff74290e0, 0x3fe1a720de3f34c0,
+  VLOAD_64(v16, 0xbf94dc2c93a00800, 0x3fdedfbff74290e0, 0x3fe1a720de3f34c0,
            0xbfb96a9acd667320, 0x3fe7c36063b54b1e, 0x3fd3b68465cb4b28,
            0xbfe59c154d684914, 0xbfd52e7fee0af3fc, 0xbfe89fcd92aa9b24,
            0xbfe5868ff2f7c1a4, 0xbfeffc957df296c0, 0x3fcfcf9532df44b8,
            0x3fe67ae9be5e7376, 0xbfe4a6085afb7c12, 0x3fe049c3c82b791e,
            0x3fb487a86c27c560);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmin.vf v2, v4, %[A], v0.t" ::[A] "f"(dscalar_64));
+  VCLEAR(v8);
+  asm volatile("vfmin.vf v8, v16, %[A], v0.t" ::[A] "f"(dscalar_64));
   //                0.0000000000000000,  0.4824066080711997, 0.0000000000000000,
   //                -0.0992829085793798,  0.0000000000000000,
   //                0.3080149644930992,  0.0000000000000000,
@@ -336,7 +336,7 @@ void TEST_CASE4(void) {
   //                -0.6726760621514143,  0.0000000000000000,
   //                0.2485224245452053,  0.0000000000000000,
   //                -0.6452676560401207,  0.0000000000000000, 0.0801949752856408
-  VCMP_U64(12, v2, 0x0, 0x3fdedfbff74290e0, 0x0, 0xbfb96a9acd667320, 0x0,
+  VCMP_U64(12, v8, 0x0, 0x3fdedfbff74290e0, 0x0, 0xbfb96a9acd667320, 0x0,
            0x3fd3b68465cb4b28, 0x0, 0xbfd52e7fee0af3fc, 0x0, 0xbfe5868ff2f7c1a4,
            0x0, 0x3fcfcf9532df44b8, 0x0, 0xbfe4a6085afb7c12, 0x0,
            0x3fb487a86c27c560);
diff --git a/sw/riscvTests/isa/rv64uv/vfmsac.c b/sw/riscvTests/isa/rv64uv/vfmsac.c
index 8fe1053d..e342f37b 100644
--- a/sw/riscvTests/isa/rv64uv/vfmsac.c
+++ b/sw/riscvTests/isa/rv64uv/vfmsac.c
@@ -10,36 +10,36 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.9175,  0.0740, -0.0362,  0.2961,  0.6226, -0.8032,  0.7749,
   //               0.8188,  0.2019,  0.4885,  0.5669, -0.1743,  0.4404,  0.0618,
   //               0.8252, -0.5947
-  VLOAD_16(v4, 0x3b57, 0x2cbc, 0xa8a3, 0x34bd, 0x38fb, 0xba6d, 0x3a33, 0x3a8d,
+  VLOAD_16(v16, 0x3b57, 0x2cbc, 0xa8a3, 0x34bd, 0x38fb, 0xba6d, 0x3a33, 0x3a8d,
            0x3276, 0x37d1, 0x3889, 0xb194, 0x370c, 0x2bea, 0x3a9a, 0xb8c2);
   //               0.2812, -0.6733,  0.3289,  0.9609, -0.6841,  0.5488, -0.1401,
   //               0.5591,  0.2759, -0.6973,  0.1418,  0.2389, -0.3308,  0.8867,
   //               0.8936,  0.3611
-  VLOAD_16(v6, 0x3480, 0xb963, 0x3543, 0x3bb0, 0xb979, 0x3864, 0xb07c, 0x3879,
+  VLOAD_16(v24, 0x3480, 0xb963, 0x3543, 0x3bb0, 0xb979, 0x3864, 0xb07c, 0x3879,
            0x346a, 0xb994, 0x308a, 0x33a5, 0xb54b, 0x3b18, 0x3b26, 0x35c7);
   //               0.4780, -0.1810,  0.2800,  0.7529,  0.6484, -0.9526,
   //               0.5947,  1.0000, -0.1874,  0.2949, -0.4280,  0.6934,  0.5444,
   //               0.8823, -0.8911,  0.7603
-  VLOAD_16(v2, 0x37a6, 0xb1cb, 0x347b, 0x3a06, 0x3930, 0xbb9f, 0x38c2, 0x3c00,
+  VLOAD_16(v8, 0x37a6, 0xb1cb, 0x347b, 0x3a06, 0x3930, 0xbb9f, 0x38c2, 0x3c00,
            0xb1ff, 0x34b8, 0xb6d9, 0x398c, 0x385b, 0x3b0f, 0xbb21, 0x3a15);
-  asm volatile("vfmsac.vv v2, v4, v6");
+  asm volatile("vfmsac.vv v8, v16, v24");
   //              -0.2200,  0.1312, -0.2920, -0.4683, -1.0742,  0.5117, -0.7031,
   //              -0.5420,  0.2430, -0.6357,  0.5083, -0.7349, -0.6904, -0.8276,
   //              1.6289, -0.9751
-  VCMP_U16(1, v2, 0xb30a, 0x3033, 0xb4ac, 0xb77e, 0xbc4c, 0x3818, 0xb9a0,
+  VCMP_U16(1, v8, 0xb30a, 0x3033, 0xb4ac, 0xb77e, 0xbc4c, 0x3818, 0xb9a0,
            0xb856, 0x33c7, 0xb916, 0x3811, 0xb9e1, 0xb985, 0xba9f, 0x3e84,
            0xbbcd);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.90310860,  0.30282700,  0.54854167, -0.38732994,
   //              0.92121714,  0.99595129, -0.10263380,  0.83759040,
   //              -0.23468767,  0.03914077, -0.46234205,  0.38326120,
   //              0.36417511, -0.50103557,  0.36991179,  0.44718841
-  VLOAD_32(v4, 0xbf673220, 0x3e9b0c24, 0x3f0c6d3a, 0xbec6501c, 0x3f6bd4e3,
+  VLOAD_32(v16, 0xbf673220, 0x3e9b0c24, 0x3f0c6d3a, 0xbec6501c, 0x3f6bd4e3,
            0x3f7ef6aa, 0xbdd231ab, 0x3f566c53, 0xbe7051f7, 0x3d205212,
            0xbeecb819, 0x3ec43ad0, 0x3eba7529, 0xbf0043de, 0x3ebd6514,
            0x3ee4f5e1);
@@ -47,7 +47,7 @@ void TEST_CASE1(void) {
   //               -0.30795863,  0.57084304,  0.51653886, -0.97366458,
   //               0.49300706,  0.62932760,  0.45846274, -0.73850167,
   //               -0.42686453, -0.31419462, -0.47245970, -0.87721694
-  VLOAD_32(v6, 0x3f5992e8, 0xbd3a1866, 0xbf3ef767, 0xbe9d1e99, 0xbe9dacc1,
+  VLOAD_32(v24, 0x3f5992e8, 0xbd3a1866, 0xbf3ef767, 0xbe9d1e99, 0xbe9dacc1,
            0x3f1222c5, 0x3f043be4, 0xbf794215, 0x3efc6b6c, 0x3f211b9d,
            0x3eeabba1, 0xbf3d0e72, 0xbeda8dfd, 0xbea0de1e, 0xbef1e63d,
            0xbf60914a);
@@ -55,29 +55,29 @@ void TEST_CASE1(void) {
   //              0.12284227, -0.04006640, -0.93113720, -0.93526161,
   //              -0.27461481,  0.64110506,  0.61687475, -0.43741968,
   //              0.70502371,  0.37014356, -0.98105848,  0.77993429
-  VLOAD_32(v2, 0xbf44a48d, 0x3f5f2230, 0xbf2df961, 0xbf7c6055, 0x3dfb94bb,
+  VLOAD_32(v8, 0xbf44a48d, 0x3f5f2230, 0xbf2df961, 0xbf7c6055, 0x3dfb94bb,
            0xbd241caa, 0xbf6e5f02, 0xbf6f6d4e, 0xbe8c9a50, 0x3f241f76,
            0x3f1deb81, 0xbedff579, 0x3f347c6f, 0x3ebd8375, 0xbf7b26a6,
            0x3f47a9c6);
-  asm volatile("vfmsac.vv v2, v4, v6");
+  asm volatile("vfmsac.vv v8, v16, v24");
   //               0.00058579, -0.88537389,  0.27039492,  1.10470641,
   //               -0.40653905,  0.60859829,  0.87812287,  0.11972952,
   //               0.15891212, -0.61647266, -0.82884133,  0.15438065,
   //               -0.86047715, -0.21272089,  0.80629003, -1.17221546
-  VCMP_U32(2, v2, 0x3a198f11, 0xbf62a7dd, 0x3e8a7134, 0x3f8d6705, 0xbed025e3,
+  VCMP_U32(2, v8, 0x3a198f11, 0xbf62a7dd, 0x3e8a7134, 0x3f8d6705, 0xbed025e3,
            0x3f1bcd19, 0x3f60cca9, 0x3df534be, 0x3e22b9dd, 0xbf1dd127,
            0xbf542ef3, 0x3e1e15f6, 0xbf5c483b, 0xbe59d381, 0x3f4e6907,
            0xbf960b29);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               0.0971325394189311,  0.6403859199401045,  0.3478142243141771,
   //               -0.4702414117546168,  0.8862438155310881, 0.6157878617136987,
   //               -0.9954501284062294, -0.2761157935600853,
   //               -0.7189549700888722, -0.2302799669824283, 0.0093666993515229,
   //               0.9188774299961215, -0.4297410504980956,  0.2729294776457381,
   //               -0.1419575372981836, -0.8472908703054822
-  VLOAD_64(v4, 0x3fb8ddad982e8680, 0x3fe47e0a9cdec59e, 0x3fd6429697a0d4f8,
+  VLOAD_64(v16, 0x3fb8ddad982e8680, 0x3fe47e0a9cdec59e, 0x3fd6429697a0d4f8,
            0xbfde186f6f2d8030, 0x3fec5c1bfd7f9ffe, 0x3fe3b488beeab100,
            0xbfefdaba3a49b85e, 0xbfd1abe193cffa54, 0xbfe701adda7a81f6,
            0xbfcd79d05f8e86d0, 0x3f832ed91b170d00, 0x3fed6771a3dbb538,
@@ -89,7 +89,7 @@ void TEST_CASE1(void) {
   //              0.6584804564152213,  0.6542532086910551, -0.2215058802905889,
   //              0.3203723346938081,  0.0696368102348055,  0.8882580549203218,
   //              0.7725843936650791
-  VLOAD_64(v6, 0xbfceef27f9efdac8, 0xbfd1854f968baf44, 0x3fe3786e1cd2fff2,
+  VLOAD_64(v24, 0xbfceef27f9efdac8, 0xbfd1854f968baf44, 0x3fe3786e1cd2fff2,
            0xbfd99a7e695862ec, 0x3fe3271f9ab3593a, 0xbfee97117f34eb4c,
            0x3fe008fcb4283a76, 0x3fe27915a4d94fb2, 0xbfdd20c1bc974608,
            0x3fe512459b2b7912, 0x3fe4efa46cd43256, 0xbfcc5a4dffdc2170,
@@ -101,13 +101,13 @@ void TEST_CASE1(void) {
   //              -0.6132901056934972,  0.1207753636997857,  0.4420874266235846,
   //              0.8256868703569773,  0.0642541522901756, -0.3012484644971416,
   //              0.7323810741358745
-  VLOAD_64(v2, 0xbfecbecd32eadc10, 0x3fe1dd69cb65674e, 0xbfd98675ea3b69b0,
+  VLOAD_64(v8, 0xbfecbecd32eadc10, 0x3fe1dd69cb65674e, 0xbfd98675ea3b69b0,
            0x3f9b6ebebe00e300, 0x3fea5fb000835cf4, 0x3fd22bc772ca399c,
            0xbfde9956d534a0f8, 0xbfbfbf79a29f1810, 0x3fdd5a42d93f2348,
            0xbfe3a012925d3f1c, 0x3fbeeb225d40ca30, 0x3fdc4b290fd48cd4,
            0x3fea6c06df1d6f14, 0x3fb072f5cab7f020, 0xbfd347a7a3bf1174,
            0x3fe76faa6f33ef10);
-  asm volatile("vfmsac.vv v2, v4, v6");
+  asm volatile("vfmsac.vv v8, v16, v24");
   //               0.8748168483008159, -0.7335910925744179,  0.6104597169258920,
   //               0.1613325712615846, -0.2937408044039052, -0.8725789038271781,
   //               -0.0207080522817558, -0.0353809253176660,
@@ -115,7 +115,7 @@ void TEST_CASE1(void) {
   //               -0.1146471705942074, -0.6456241806340295,
   //               -0.9633640140188219, -0.0452482140478748, 0.1751535385353780,
   //               -1.3869847774287927
-  VCMP_U64(3, v2, 0x3febfe7fe72e2334, 0xbfe7799406e7cf1f, 0x3fe388e2d0f71ba3,
+  VCMP_U64(3, v8, 0x3febfe7fe72e2334, 0xbfe7799406e7cf1f, 0x3fe388e2d0f71ba3,
            0x3fc4a68bb2ac8e62, 0xbfd2cca63b1a97a5, 0xbfebec2a97e3c096,
            0xbf95347ddd418906, 0xbfa21d72da487f01, 0xbfc0d260a75ceb46,
            0x3fdd8bc273f9289e, 0xbfbd59845847f323, 0xbfe4a8f40aaa8efa,
@@ -127,37 +127,37 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.9175,  0.0740, -0.0362,  0.2961,  0.6226, -0.8032,  0.7749,
   //               0.8188,  0.2019,  0.4885,  0.5669, -0.1743,  0.4404,  0.0618,
   //               0.8252, -0.5947
-  VLOAD_16(v4, 0x3b57, 0x2cbc, 0xa8a3, 0x34bd, 0x38fb, 0xba6d, 0x3a33, 0x3a8d,
+  VLOAD_16(v16, 0x3b57, 0x2cbc, 0xa8a3, 0x34bd, 0x38fb, 0xba6d, 0x3a33, 0x3a8d,
            0x3276, 0x37d1, 0x3889, 0xb194, 0x370c, 0x2bea, 0x3a9a, 0xb8c2);
   //               0.2812, -0.6733,  0.3289,  0.9609, -0.6841,  0.5488, -0.1401,
   //               0.5591,  0.2759, -0.6973,  0.1418,  0.2389, -0.3308,  0.8867,
   //               0.8936,  0.3611
-  VLOAD_16(v6, 0x3480, 0xb963, 0x3543, 0x3bb0, 0xb979, 0x3864, 0xb07c, 0x3879,
+  VLOAD_16(v24, 0x3480, 0xb963, 0x3543, 0x3bb0, 0xb979, 0x3864, 0xb07c, 0x3879,
            0x346a, 0xb994, 0x308a, 0x33a5, 0xb54b, 0x3b18, 0x3b26, 0x35c7);
   VLOAD_8(v0, 0xAA, 0xAA);
   //               0.4780, -0.1810,  0.2800,  0.7529,  0.6484, -0.9526,
   //               0.5947,  1.0000, -0.1874,  0.2949, -0.4280,  0.6934,  0.5444,
   //               0.8823, -0.8911,  0.7603
-  VLOAD_16(v2, 0x37a6, 0xb1cb, 0x347b, 0x3a06, 0x3930, 0xbb9f, 0x38c2, 0x3c00,
+  VLOAD_16(v8, 0x37a6, 0xb1cb, 0x347b, 0x3a06, 0x3930, 0xbb9f, 0x38c2, 0x3c00,
            0xb1ff, 0x34b8, 0xb6d9, 0x398c, 0x385b, 0x3b0f, 0xbb21, 0x3a15);
-  asm volatile("vfmsac.vv v2, v4, v6, v0.t");
+  asm volatile("vfmsac.vv v8, v16, v24, v0.t");
   //               0.4780,  0.1312,  0.2800, -0.4683,  0.6484,  0.5117,  0.5947,
   //               -0.5420, -0.1874, -0.6357, -0.4280, -0.7349,  0.5444,
   //               -0.8276, -0.8911, -0.9751
-  VCMP_U16(4, v2, 0x37a6, 0x3033, 0x347b, 0xb77e, 0x3930, 0x3818, 0x38c2,
+  VCMP_U16(4, v8, 0x37a6, 0x3033, 0x347b, 0xb77e, 0x3930, 0x3818, 0x38c2,
            0xb856, 0xb1ff, 0xb916, 0xb6d9, 0xb9e1, 0x385b, 0xba9f, 0xbb21,
            0xbbcd);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.90310860,  0.30282700,  0.54854167, -0.38732994,
   //              0.92121714,  0.99595129, -0.10263380,  0.83759040,
   //              -0.23468767,  0.03914077, -0.46234205,  0.38326120,
   //              0.36417511, -0.50103557,  0.36991179,  0.44718841
-  VLOAD_32(v4, 0xbf673220, 0x3e9b0c24, 0x3f0c6d3a, 0xbec6501c, 0x3f6bd4e3,
+  VLOAD_32(v16, 0xbf673220, 0x3e9b0c24, 0x3f0c6d3a, 0xbec6501c, 0x3f6bd4e3,
            0x3f7ef6aa, 0xbdd231ab, 0x3f566c53, 0xbe7051f7, 0x3d205212,
            0xbeecb819, 0x3ec43ad0, 0x3eba7529, 0xbf0043de, 0x3ebd6514,
            0x3ee4f5e1);
@@ -165,7 +165,7 @@ void TEST_CASE2(void) {
   //               -0.30795863,  0.57084304,  0.51653886, -0.97366458,
   //               0.49300706,  0.62932760,  0.45846274, -0.73850167,
   //               -0.42686453, -0.31419462, -0.47245970, -0.87721694
-  VLOAD_32(v6, 0x3f5992e8, 0xbd3a1866, 0xbf3ef767, 0xbe9d1e99, 0xbe9dacc1,
+  VLOAD_32(v24, 0x3f5992e8, 0xbd3a1866, 0xbf3ef767, 0xbe9d1e99, 0xbe9dacc1,
            0x3f1222c5, 0x3f043be4, 0xbf794215, 0x3efc6b6c, 0x3f211b9d,
            0x3eeabba1, 0xbf3d0e72, 0xbeda8dfd, 0xbea0de1e, 0xbef1e63d,
            0xbf60914a);
@@ -174,29 +174,29 @@ void TEST_CASE2(void) {
   //              0.12284227, -0.04006640, -0.93113720, -0.93526161,
   //              -0.27461481,  0.64110506,  0.61687475, -0.43741968,
   //              0.70502371,  0.37014356, -0.98105848,  0.77993429
-  VLOAD_32(v2, 0xbf44a48d, 0x3f5f2230, 0xbf2df961, 0xbf7c6055, 0x3dfb94bb,
+  VLOAD_32(v8, 0xbf44a48d, 0x3f5f2230, 0xbf2df961, 0xbf7c6055, 0x3dfb94bb,
            0xbd241caa, 0xbf6e5f02, 0xbf6f6d4e, 0xbe8c9a50, 0x3f241f76,
            0x3f1deb81, 0xbedff579, 0x3f347c6f, 0x3ebd8375, 0xbf7b26a6,
            0x3f47a9c6);
-  asm volatile("vfmsac.vv v2, v4, v6, v0.t");
+  asm volatile("vfmsac.vv v8, v16, v24, v0.t");
   //              -0.76813585, -0.88537389, -0.67958647,  1.10470641,
   //              0.12284227,  0.60859829, -0.93113720,  0.11972952,
   //              -0.27461481, -0.61647266,  0.61687475,  0.15438065,
   //              0.70502371, -0.21272089, -0.98105848, -1.17221546
-  VCMP_U32(5, v2, 0xbf44a48d, 0xbf62a7dd, 0xbf2df961, 0x3f8d6705, 0x3dfb94bb,
+  VCMP_U32(5, v8, 0xbf44a48d, 0xbf62a7dd, 0xbf2df961, 0x3f8d6705, 0x3dfb94bb,
            0x3f1bcd19, 0xbf6e5f02, 0x3df534be, 0xbe8c9a50, 0xbf1dd127,
            0x3f1deb81, 0x3e1e15f6, 0x3f347c6f, 0xbe59d381, 0xbf7b26a6,
            0xbf960b29);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               0.0971325394189311,  0.6403859199401045,  0.3478142243141771,
   //               -0.4702414117546168,  0.8862438155310881, 0.6157878617136987,
   //               -0.9954501284062294, -0.2761157935600853,
   //               -0.7189549700888722, -0.2302799669824283, 0.0093666993515229,
   //               0.9188774299961215, -0.4297410504980956,  0.2729294776457381,
   //               -0.1419575372981836, -0.8472908703054822
-  VLOAD_64(v4, 0x3fb8ddad982e8680, 0x3fe47e0a9cdec59e, 0x3fd6429697a0d4f8,
+  VLOAD_64(v16, 0x3fb8ddad982e8680, 0x3fe47e0a9cdec59e, 0x3fd6429697a0d4f8,
            0xbfde186f6f2d8030, 0x3fec5c1bfd7f9ffe, 0x3fe3b488beeab100,
            0xbfefdaba3a49b85e, 0xbfd1abe193cffa54, 0xbfe701adda7a81f6,
            0xbfcd79d05f8e86d0, 0x3f832ed91b170d00, 0x3fed6771a3dbb538,
@@ -208,7 +208,7 @@ void TEST_CASE2(void) {
   //              0.6584804564152213,  0.6542532086910551, -0.2215058802905889,
   //              0.3203723346938081,  0.0696368102348055,  0.8882580549203218,
   //              0.7725843936650791
-  VLOAD_64(v6, 0xbfceef27f9efdac8, 0xbfd1854f968baf44, 0x3fe3786e1cd2fff2,
+  VLOAD_64(v24, 0xbfceef27f9efdac8, 0xbfd1854f968baf44, 0x3fe3786e1cd2fff2,
            0xbfd99a7e695862ec, 0x3fe3271f9ab3593a, 0xbfee97117f34eb4c,
            0x3fe008fcb4283a76, 0x3fe27915a4d94fb2, 0xbfdd20c1bc974608,
            0x3fe512459b2b7912, 0x3fe4efa46cd43256, 0xbfcc5a4dffdc2170,
@@ -221,20 +221,20 @@ void TEST_CASE2(void) {
   //              -0.6132901056934972,  0.1207753636997857,  0.4420874266235846,
   //              0.8256868703569773,  0.0642541522901756, -0.3012484644971416,
   //              0.7323810741358745
-  VLOAD_64(v2, 0xbfecbecd32eadc10, 0x3fe1dd69cb65674e, 0xbfd98675ea3b69b0,
+  VLOAD_64(v8, 0xbfecbecd32eadc10, 0x3fe1dd69cb65674e, 0xbfd98675ea3b69b0,
            0x3f9b6ebebe00e300, 0x3fea5fb000835cf4, 0x3fd22bc772ca399c,
            0xbfde9956d534a0f8, 0xbfbfbf79a29f1810, 0x3fdd5a42d93f2348,
            0xbfe3a012925d3f1c, 0x3fbeeb225d40ca30, 0x3fdc4b290fd48cd4,
            0x3fea6c06df1d6f14, 0x3fb072f5cab7f020, 0xbfd347a7a3bf1174,
            0x3fe76faa6f33ef10);
-  asm volatile("vfmsac.vv v2, v4, v6, v0.t");
+  asm volatile("vfmsac.vv v8, v16, v24, v0.t");
   //              -0.8982912058335177, -0.7335910925744179, -0.3988318240568800,
   //              0.1613325712615846,  0.8241806039831361, -0.8725789038271781,
   //              -0.4781090814672235, -0.0353809253176660,  0.4586341020154134,
   //              0.4616552479316257,  0.1207753636997857, -0.6456241806340295,
   //              0.8256868703569773, -0.0452482140478748, -0.3012484644971416,
   //              -1.3869847774287927
-  VCMP_U64(6, v2, 0xbfecbecd32eadc10, 0xbfe7799406e7cf1f, 0xbfd98675ea3b69b0,
+  VCMP_U64(6, v8, 0xbfecbecd32eadc10, 0xbfe7799406e7cf1f, 0xbfd98675ea3b69b0,
            0x3fc4a68bb2ac8e62, 0x3fea5fb000835cf4, 0xbfebec2a97e3c096,
            0xbfde9956d534a0f8, 0xbfa21d72da487f01, 0x3fdd5a42d93f2348,
            0x3fdd8bc273f9289e, 0x3fbeeb225d40ca30, 0xbfe4a8f40aaa8efa,
@@ -245,29 +245,29 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.3911
   BOX_HALF_IN_FLOAT(fscalar_16, 0x3642);
   //               0.3203, -0.8521,  0.0744,  0.9370,  0.2056,  0.2866, -0.8379,
   //               -0.2668, -0.0878, -0.5703,  0.1272, -0.6606, -0.6919, 0.9189,
   //               0.6245,  0.9932
-  VLOAD_16(v4, 0x3520, 0xbad1, 0x2cc3, 0x3b7f, 0x3294, 0x3496, 0xbab4, 0xb445,
+  VLOAD_16(v16, 0x3520, 0xbad1, 0x2cc3, 0x3b7f, 0x3294, 0x3496, 0xbab4, 0xb445,
            0xad9f, 0xb890, 0x3012, 0xb949, 0xb989, 0x3b5a, 0x38ff, 0x3bf2);
   //               0.8706,  0.4900, -0.9497,  0.4727, -0.7168,  0.0167, -0.3606,
   //               -0.1565, -0.5142,  0.8271, -0.4783,  0.6318,  0.0842,
   //               -0.6646,  0.1454, -0.3020
-  VLOAD_16(v2, 0x3af7, 0x37d7, 0xbb99, 0x3790, 0xb9bc, 0x2445, 0xb5c5, 0xb102,
+  VLOAD_16(v8, 0x3af7, 0x37d7, 0xbb99, 0x3790, 0xb9bc, 0x2445, 0xb5c5, 0xb102,
            0xb81d, 0x3a9e, 0xb7a7, 0x390e, 0x2d63, 0xb951, 0x30a7, 0xb4d5);
-  asm volatile("vfmsac.vf v2, %[A], v4" ::[A] "f"(fscalar_16));
+  asm volatile("vfmsac.vf v8, %[A], v16" ::[A] "f"(fscalar_16));
   //              -0.7451, -0.8232,  0.9790, -0.1062,  0.7974,  0.0955,  0.0330,
   //              0.0521,  0.4797, -1.0498,  0.5278, -0.8901, -0.3547,  1.0234,
   //              0.0989,  0.6904
-  VCMP_U16(7, v2, 0xb9f6, 0xba96, 0x3bd5, 0xaecc, 0x3a61, 0x2e1b, 0x2836,
+  VCMP_U16(7, v8, 0xb9f6, 0xba96, 0x3bd5, 0xaecc, 0x3a61, 0x2e1b, 0x2836,
            0x2aac, 0x37ad, 0xbc33, 0x3839, 0xbb1f, 0xb5ad, 0x3c19, 0x2e54,
            0x3986);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.39704049
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbecb48e4);
@@ -275,7 +275,7 @@ void TEST_CASE3(void) {
   //               -0.41457745, -0.69918746,  0.38535324,  0.83301985,
   //               0.79336989, -0.03326649, -0.85931808,  0.92554229,
   //               -0.77742523,  0.47821125, -0.53653014, -0.32442030
-  VLOAD_32(v4, 0x3ee07b86, 0x3e0ca367, 0x3e1fc1b7, 0x3efab4b6, 0xbed4437f,
+  VLOAD_32(v16, 0x3ee07b86, 0x3e0ca367, 0x3e1fc1b7, 0x3efab4b6, 0xbed4437f,
            0xbf32fdf3, 0x3ec54d05, 0x3f5540ca, 0x3f4b1a4a, 0xbd084272,
            0xbf5bfc45, 0x3f6cf057, 0xbf470557, 0x3ef4d81b, 0xbf095a0a,
            0xbea61a6b);
@@ -283,22 +283,22 @@ void TEST_CASE3(void) {
   //              0.34779423,  0.22721651,  0.47497734, -0.58483958,
   //              -0.24916913,  0.13750601, -0.99799657,  0.66137350,
   //              0.58565408,  0.68887448, -0.74538875,  0.99311894
-  VLOAD_32(v2, 0xbf3b2f7d, 0x3f5f929c, 0xbe272c0c, 0xbe9b02e0, 0x3eb21216,
+  VLOAD_32(v8, 0xbf3b2f7d, 0x3f5f929c, 0xbe272c0c, 0xbe9b02e0, 0x3eb21216,
            0x3e68ab72, 0x3ef3303b, 0xbf15b80c, 0xbe7f2631, 0x3e0cce60,
            0xbf7f7cb4, 0x3f294fc6, 0x3f15ed6d, 0x3f305a14, 0xbf3ed1cc,
            0x3f7e3d0b);
-  asm volatile("vfmsac.vf v2, %[A], v4" ::[A] "f"(fscalar_32));
+  asm volatile("vfmsac.vf v8, %[A], v16" ::[A] "f"(fscalar_32));
   //               0.55711401, -0.92786121,  0.10131072,  0.10834149,
   //               -0.18319020,  0.05038923, -0.62797821,  0.25409698,
   //               -0.06583084, -0.12429786,  1.33918071, -1.02885127,
   //               -0.27698478, -0.87874371,  0.95841295, -0.86431098
-  VCMP_U32(8, v2, 0x3f0e9f06, 0xbf6d8850, 0x3dcf7bff, 0x3ddde223, 0xbe3b9636,
+  VCMP_U32(8, v8, 0x3f0e9f06, 0xbf6d8850, 0x3dcf7bff, 0x3ddde223, 0xbe3b9636,
            0x3d4e64ec, 0xbf20c32e, 0x3e821900, 0xbd86d252, 0xbdfe8fe1,
            0x3fab6a45, 0xbf83b166, 0xbe8dd0f3, 0xbf60f559, 0x3f755a8d,
            0xbf5d437b);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.0070730785066928
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3f7cf8a90de48000);
@@ -308,7 +308,7 @@ void TEST_CASE3(void) {
   //               0.4892172254017777,  0.9508074316559227, -0.9022151172016701,
   //               -0.7929839752648156,  0.5513143449560454, 0.4823446191982377,
   //               -0.7486658065787619
-  VLOAD_64(v4, 0xbfd6abf15f87c3c4, 0x3fe2c1dfc88b26c8, 0x3fe248735bfda932,
+  VLOAD_64(v16, 0xbfd6abf15f87c3c4, 0x3fe2c1dfc88b26c8, 0x3fe248735bfda932,
            0x3fd22fdebc43a768, 0x3fd9be624bf72ff4, 0xbfef5ff39c079aea,
            0xbfef0d621514ca4c, 0x3fcd4b43685929d8, 0x3fc71fca543f2eb8,
            0x3fdf4f55c3ef6448, 0x3fee6d03b4f830b0, 0xbfecdef23ccad0bc,
@@ -321,20 +321,20 @@ void TEST_CASE3(void) {
   //               -0.2107692441818434,  0.1746722346734710,
   //               -0.5298547863982788,  0.2397543330794352,
   //               -0.8347981409736787, -0.6198539479673024
-  VLOAD_64(v2, 0xbfe8551415c9d6cc, 0xbfa92b9053839560, 0xbfd7c617af2cedf8,
+  VLOAD_64(v8, 0xbfe8551415c9d6cc, 0xbfa92b9053839560, 0xbfd7c617af2cedf8,
            0xbfe38202ae18c034, 0xbfd20a241ae21e00, 0x3fd693c8d73a46c0,
            0x3fbe1efc293b2500, 0xbfca3b9e173fd0c8, 0xbfe62a8ed24449ee,
            0x3fe74332cc30c46e, 0xbfcafa7c9161bf78, 0x3fc65ba8e7b88cc0,
            0xbfe0f4920666b5a4, 0x3fceb0451dd34270, 0xbfeab6aa9747cb24,
            0xbfe3d5d7f25a1d14);
-  asm volatile("vfmsac.vf v2, %[A], v4" ::[A] "f"(dscalar_64));
+  asm volatile("vfmsac.vf v8, %[A], v16" ::[A] "f"(dscalar_64));
   //               0.7578799543094064,  0.0533064903276678,  0.3755067691720115,
   //               0.6116303877234964,  0.2847140709489031, -0.3597049427834890,
   //               -0.1245238936163020,  0.2065631231810536, 0.6939728614971534,
   //               -0.7234926612877562,  0.2174943797906927,
   //               -0.1810536730273635,  0.5242459484866814,
   //               -0.2358548434356951,  0.8382098023325486,  0.6145585759420944
-  VCMP_U64(9, v2, 0x3fe8408d7641b126, 0x3fab4afd013e6639, 0x3fd8084d8b414e68,
+  VCMP_U64(9, v8, 0x3fe8408d7641b126, 0x3fab4afd013e6639, 0x3fd8084d8b414e68,
            0x3fe39279e4106415, 0x3fd238c15ddbf0a4, 0xbfd70567e15dbc9b,
            0xbfbfe0cc42a710ce, 0x3fca70a9114fa5b7, 0x3fe63506930e2352,
            0xbfe726da14e40fb7, 0x3fcbd6db1821e5e6, 0xbfc72cc44a3c91ef,
@@ -345,30 +345,30 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.3911
   BOX_HALF_IN_FLOAT(fscalar_16, 0x3642);
   //                0.3203, -0.8521,  0.0744,  0.9370,  0.2056,  0.2866,
   //                -0.8379, -0.2668, -0.0878, -0.5703,  0.1272, -0.6606,
   //                -0.6919,  0.9189,  0.6245,  0.9932
-  VLOAD_16(v4, 0x3520, 0xbad1, 0x2cc3, 0x3b7f, 0x3294, 0x3496, 0xbab4, 0xb445,
+  VLOAD_16(v16, 0x3520, 0xbad1, 0x2cc3, 0x3b7f, 0x3294, 0x3496, 0xbab4, 0xb445,
            0xad9f, 0xb890, 0x3012, 0xb949, 0xb989, 0x3b5a, 0x38ff, 0x3bf2);
   VLOAD_8(v0, 0xAA, 0xAA);
   //                0.8706,  0.4900, -0.9497,  0.4727, -0.7168,  0.0167,
   //                -0.3606, -0.1565, -0.5142,  0.8271, -0.4783,  0.6318,
   //                0.0842, -0.6646,  0.1454, -0.3020
-  VLOAD_16(v2, 0x3af7, 0x37d7, 0xbb99, 0x3790, 0xb9bc, 0x2445, 0xb5c5, 0xb102,
+  VLOAD_16(v8, 0x3af7, 0x37d7, 0xbb99, 0x3790, 0xb9bc, 0x2445, 0xb5c5, 0xb102,
            0xb81d, 0x3a9e, 0xb7a7, 0x390e, 0x2d63, 0xb951, 0x30a7, 0xb4d5);
-  asm volatile("vfmsac.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
+  asm volatile("vfmsac.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_16));
   //                0.8706, -0.8232, -0.9497, -0.1062, -0.7168,  0.0955,
   //                -0.3606,  0.0521, -0.5142, -1.0498, -0.4783, -0.8901,
   //                0.0842,  1.0234,  0.1454,  0.6904
-  VCMP_U16(10, v2, 0x3af7, 0xba96, 0xbb99, 0xaecc, 0xb9bc, 0x2e1b, 0xb5c5,
+  VCMP_U16(10, v8, 0x3af7, 0xba96, 0xbb99, 0xaecc, 0xb9bc, 0x2e1b, 0xb5c5,
            0x2aac, 0xb81d, 0xbc33, 0xb7a7, 0xbb1f, 0x2d63, 0x3c19, 0x30a7,
            0x3986);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.39704049
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbecb48e4);
@@ -376,7 +376,7 @@ void TEST_CASE4(void) {
   //                -0.41457745, -0.69918746,  0.38535324,  0.83301985,
   //                0.79336989, -0.03326649, -0.85931808,  0.92554229,
   //                -0.77742523,  0.47821125, -0.53653014, -0.32442030
-  VLOAD_32(v4, 0x3ee07b86, 0x3e0ca367, 0x3e1fc1b7, 0x3efab4b6, 0xbed4437f,
+  VLOAD_32(v16, 0x3ee07b86, 0x3e0ca367, 0x3e1fc1b7, 0x3efab4b6, 0xbed4437f,
            0xbf32fdf3, 0x3ec54d05, 0x3f5540ca, 0x3f4b1a4a, 0xbd084272,
            0xbf5bfc45, 0x3f6cf057, 0xbf470557, 0x3ef4d81b, 0xbf095a0a,
            0xbea61a6b);
@@ -385,22 +385,22 @@ void TEST_CASE4(void) {
   //               0.34779423,  0.22721651,  0.47497734, -0.58483958,
   //               -0.24916913,  0.13750601, -0.99799657,  0.66137350,
   //               0.58565408,  0.68887448, -0.74538875,  0.99311894
-  VLOAD_32(v2, 0xbf3b2f7d, 0x3f5f929c, 0xbe272c0c, 0xbe9b02e0, 0x3eb21216,
+  VLOAD_32(v8, 0xbf3b2f7d, 0x3f5f929c, 0xbe272c0c, 0xbe9b02e0, 0x3eb21216,
            0x3e68ab72, 0x3ef3303b, 0xbf15b80c, 0xbe7f2631, 0x3e0cce60,
            0xbf7f7cb4, 0x3f294fc6, 0x3f15ed6d, 0x3f305a14, 0xbf3ed1cc,
            0x3f7e3d0b);
-  asm volatile("vfmsac.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
+  asm volatile("vfmsac.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_32));
   //               -0.73119336, -0.92786121, -0.16325396,  0.10834149,
   //               0.34779423,  0.05038923,  0.47497734,  0.25409698,
   //               -0.24916913, -0.12429786, -0.99799657, -1.02885127,
   //               0.58565408, -0.87874371, -0.74538875, -0.86431098
-  VCMP_U32(11, v2, 0xbf3b2f7d, 0xbf6d8850, 0xbe272c0c, 0x3ddde223, 0x3eb21216,
+  VCMP_U32(11, v8, 0xbf3b2f7d, 0xbf6d8850, 0xbe272c0c, 0x3ddde223, 0x3eb21216,
            0x3d4e64ec, 0x3ef3303b, 0x3e821900, 0xbe7f2631, 0xbdfe8fe1,
            0xbf7f7cb4, 0xbf83b166, 0x3f15ed6d, 0xbf60f559, 0xbf3ed1cc,
            0xbf5d437b);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.0070730785066928
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3f7cf8a90de48000);
@@ -411,7 +411,7 @@ void TEST_CASE4(void) {
   //                0.9508074316559227, -0.9022151172016701,
   //                -0.7929839752648156,  0.5513143449560454,
   //                0.4823446191982377, -0.7486658065787619
-  VLOAD_64(v4, 0xbfd6abf15f87c3c4, 0x3fe2c1dfc88b26c8, 0x3fe248735bfda932,
+  VLOAD_64(v16, 0xbfd6abf15f87c3c4, 0x3fe2c1dfc88b26c8, 0x3fe248735bfda932,
            0x3fd22fdebc43a768, 0x3fd9be624bf72ff4, 0xbfef5ff39c079aea,
            0xbfef0d621514ca4c, 0x3fcd4b43685929d8, 0x3fc71fca543f2eb8,
            0x3fdf4f55c3ef6448, 0x3fee6d03b4f830b0, 0xbfecdef23ccad0bc,
@@ -426,13 +426,13 @@ void TEST_CASE4(void) {
   //                -0.2107692441818434,  0.1746722346734710,
   //                -0.5298547863982788,  0.2397543330794352,
   //                -0.8347981409736787, -0.6198539479673024
-  VLOAD_64(v2, 0xbfe8551415c9d6cc, 0xbfa92b9053839560, 0xbfd7c617af2cedf8,
+  VLOAD_64(v8, 0xbfe8551415c9d6cc, 0xbfa92b9053839560, 0xbfd7c617af2cedf8,
            0xbfe38202ae18c034, 0xbfd20a241ae21e00, 0x3fd693c8d73a46c0,
            0x3fbe1efc293b2500, 0xbfca3b9e173fd0c8, 0xbfe62a8ed24449ee,
            0x3fe74332cc30c46e, 0xbfcafa7c9161bf78, 0x3fc65ba8e7b88cc0,
            0xbfe0f4920666b5a4, 0x3fceb0451dd34270, 0xbfeab6aa9747cb24,
            0xbfe3d5d7f25a1d14);
-  asm volatile("vfmsac.vf v2, %[A], v4, v0.t" ::[A] "f"(dscalar_64));
+  asm volatile("vfmsac.vf v8, %[A], v16, v0.t" ::[A] "f"(dscalar_64));
   //               -0.7603855538897846,  0.0533064903276678,
   //               -0.3714656077097227,  0.6116303877234964,
   //               -0.2818689596683441, -0.3597049427834890, 0.1176602936422064,
@@ -440,7 +440,7 @@ void TEST_CASE4(void) {
   //               -0.2107692441818434, -0.1810536730273635,
   //               -0.5298547863982788, -0.2358548434356951,
   //               -0.8347981409736787,  0.6145585759420944
-  VCMP_U64(12, v2, 0xbfe8551415c9d6cc, 0x3fab4afd013e6639, 0xbfd7c617af2cedf8,
+  VCMP_U64(12, v8, 0xbfe8551415c9d6cc, 0x3fab4afd013e6639, 0xbfd7c617af2cedf8,
            0x3fe39279e4106415, 0xbfd20a241ae21e00, 0xbfd70567e15dbc9b,
            0x3fbe1efc293b2500, 0x3fca70a9114fa5b7, 0xbfe62a8ed24449ee,
            0xbfe726da14e40fb7, 0xbfcafa7c9161bf78, 0xbfc72cc44a3c91ef,
diff --git a/sw/riscvTests/isa/rv64uv/vfmsub.c b/sw/riscvTests/isa/rv64uv/vfmsub.c
index 56cf0814..012e726e 100644
--- a/sw/riscvTests/isa/rv64uv/vfmsub.c
+++ b/sw/riscvTests/isa/rv64uv/vfmsub.c
@@ -10,36 +10,36 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.6821,  0.7749,  0.0299,  0.0299, -0.5410, -0.1865,  0.1885,
   //               0.0228, -0.5410,  0.1902, -0.9160, -0.3511, -0.9287, -0.9961,
   //               -0.6509, -0.3940
-  VLOAD_16(v4, 0x3975, 0x3a33, 0x27a5, 0x27a5, 0xb854, 0xb1f8, 0x3208, 0x25d8,
+  VLOAD_16(v16, 0x3975, 0x3a33, 0x27a5, 0x27a5, 0xb854, 0xb1f8, 0x3208, 0x25d8,
            0xb854, 0x3216, 0xbb54, 0xb59e, 0xbb6e, 0xbbf8, 0xb935, 0xb64e);
   //              -0.9048,  0.1698,  0.2411,  0.2411, -0.6147,  0.9580,  0.5117,
   //              0.8330, -0.6147,  0.5591,  0.7031, -0.1556,  0.2397,  0.8154,
   //              0.1646,  0.2693
-  VLOAD_16(v6, 0xbb3d, 0x316f, 0x33b7, 0x33b7, 0xb8eb, 0x3baa, 0x3818, 0x3aaa,
+  VLOAD_16(v24, 0xbb3d, 0x316f, 0x33b7, 0x33b7, 0xb8eb, 0x3baa, 0x3818, 0x3aaa,
            0xb8eb, 0x3879, 0x39a0, 0xb0fb, 0x33ac, 0x3a86, 0x3144, 0x344f);
   //              -0.2292,  0.7578, -0.7427, -0.7427,  0.1119,  0.2939, -0.2983,
   //              -0.3608,  0.1119, -0.5562, -0.0629, -0.1968, -0.8638, -0.2700,
   //              -0.7690,  0.4216
-  VLOAD_16(v2, 0xb356, 0x3a10, 0xb9f1, 0xb9f1, 0x2f29, 0x34b4, 0xb4c6, 0xb5c6,
+  VLOAD_16(v8, 0xb356, 0x3a10, 0xb9f1, 0xb9f1, 0x2f29, 0x34b4, 0xb4c6, 0xb5c6,
            0x2f29, 0xb873, 0xac06, 0xb24c, 0xbae9, 0xb452, 0xba27, 0x36bf);
-  asm volatile("vfmsub.vv v2, v4, v6");
+  asm volatile("vfmsub.vv v8, v16, v24");
   //               0.7485,  0.4175, -0.2632, -0.2632,  0.5542, -1.0127, -0.5679,
   //               -0.8413,  0.5542, -0.6650, -0.6455,  0.2247,  0.5625,
   //               -0.5464,  0.3359, -0.4355
-  VCMP_U16(1, v2, 0x39fd, 0x36ae, 0xb436, 0xb436, 0x386f, 0xbc0d, 0xb88b,
+  VCMP_U16(1, v8, 0x39fd, 0x36ae, 0xb436, 0xb436, 0x386f, 0xbc0d, 0xb88b,
            0xbabb, 0x386f, 0xb952, 0xb92a, 0x3331, 0x3880, 0xb85f, 0x3560,
            0xb6f8);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.74553698, -0.16736358, -0.11869104, -0.85860848,
   //              -0.66138542, -0.68386567, -0.45389724, -0.12761629,
   //              -0.95652348,  0.71083277,  0.24187960,  0.01609672,
   //              -0.58867335, -0.55222940, -0.67417240, -0.06725668
-  VLOAD_32(v4, 0xbf3edb83, 0xbe2b615c, 0xbdf3144a, 0xbf5bcdc4, 0xbf29508e,
+  VLOAD_32(v16, 0xbf3edb83, 0xbe2b615c, 0xbdf3144a, 0xbf5bcdc4, 0xbf29508e,
            0xbf2f11d2, 0xbee86538, 0xbe02add8, 0xbf74deb9, 0x3f35f923,
            0x3e77af49, 0x3c83dd45, 0xbf16b34c, 0xbf0d5ee8, 0xbf2c9690,
            0xbd89bddf);
@@ -47,7 +47,7 @@ void TEST_CASE1(void) {
   //              0.49659184, -0.09389434,  0.05757815, -0.13087828,
   //              -0.73042232, -0.79662275, -0.96801740,  0.03017101,
   //              0.70759267, -0.35606241,  0.18037270, -0.35372722
-  VLOAD_32(v6, 0xbe333510, 0xbf50bc3a, 0xbea39d6f, 0x3e6916cc, 0x3efe4149,
+  VLOAD_32(v24, 0xbe333510, 0xbf50bc3a, 0xbea39d6f, 0x3e6916cc, 0x3efe4149,
            0xbdc04bad, 0x3d6bd711, 0xbe0604f5, 0xbf3afcf5, 0xbf4bef78,
            0xbf77cffd, 0x3cf72932, 0x3f3524cb, 0xbeb64dd0, 0x3e38b39f,
            0xbeb51bbc);
@@ -55,29 +55,29 @@ void TEST_CASE1(void) {
   //               0.90907055,  0.07037155,  0.07339484,  0.17415307,
   //               -0.61978233, -0.04939311,  0.56138068, -0.51601994,
   //               -0.80625385, -0.31227911,  0.91474551,  0.78424871
-  VLOAD_32(v2, 0x3f6dc3b9, 0x3e3e2fab, 0xbed7cb1e, 0xbf4afb22, 0x3f68b8d9,
+  VLOAD_32(v8, 0x3f6dc3b9, 0x3e3e2fab, 0xbed7cb1e, 0xbf4afb22, 0x3f68b8d9,
            0x3d901ef6, 0x3d965009, 0x3e32552f, 0xbf1eaa0e, 0xbd4a506e,
            0x3f0fb6a5, 0xbf0419e2, 0xbf4e66a7, 0xbe9fe30c, 0x3f6a2cc3,
            0x3f48c486);
-  asm volatile("vfmsub.vv v2, v4, v6");
+  asm volatile("vfmsub.vv v8, v16, v24");
   //              -0.51742357,  0.78428787,  0.36958539,  0.45315993,
   //              -1.09783781,  0.04576965, -0.09089187,
   //              0.10865352,  1.32325864,  0.76151252,  1.10380387,
   //              -0.03847724, -0.23297250,  0.52851212, -0.79706889, 0.30098125
-  VCMP_U32(2, v2, 0xbf0475df, 0x3f48c717, 0x3ebd3a4c, 0x3ee80493, 0xbf8c85f3,
+  VCMP_U32(2, v8, 0xbf0475df, 0x3f48c717, 0x3ebd3a4c, 0x3ee80493, 0xbf8c85f3,
            0x3d3b78f5, 0xbdba2584, 0x3dde85bc, 0x3fa9608a, 0x3f42f27c,
            0x3f8d4973, 0xbd1d9a4f, 0xbe6e9058, 0x3f074c92, 0xbf4c0cb5,
            0x3e9a1a37);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               0.3304351537536074, -0.7528197595818080, -0.7530937950641439,
   //               -0.7994160811423281,  0.0797802827518117,
   //               -0.6361377214985149,  0.1748070414096887, 0.8251843575618585,
   //               0.0699629848559165, -0.8195631240215655, -0.4843919596862658,
   //               -0.9206444585342115,  0.9791118581337512, 0.5143481050333210,
   //               0.5856279779979670, -0.5536419150604011
-  VLOAD_64(v4, 0x3fd525d97cb482ac, 0xbfe8171976e5f762, 0xbfe819582893df6e,
+  VLOAD_64(v16, 0x3fd525d97cb482ac, 0xbfe8171976e5f762, 0xbfe819582893df6e,
            0xbfe994d1088ce396, 0x3fb46c7b0948dfc0, 0xbfe45b3d7eb2d188,
            0x3fc66013befb8968, 0x3fea67e9069cc438, 0x3fb1e9181be2ff10,
            0xbfea39dc71d5c454, 0xbfdf00472253102c, 0xbfed75eb5e14bcf6,
@@ -90,7 +90,7 @@ void TEST_CASE1(void) {
   //               -0.2492371358416354,  0.4131695659117063,
   //               -0.9085600854772706, -0.3952216110937696, 0.0817663443229741,
   //               0.1439804529607418
-  VLOAD_64(v6, 0x3fda997577954be0, 0xbfe8faec3ae9f10e, 0xbfec3ef992a7ed86,
+  VLOAD_64(v24, 0x3fda997577954be0, 0xbfe8faec3ae9f10e, 0xbfec3ef992a7ed86,
            0x3fdec970c7c16d8c, 0x3fede18e86a8f206, 0xbfe135863f697cd2,
            0xbfc25c6af06e7710, 0x3fbeb257d63cc310, 0xbfd0a5eaf1337874,
            0xbfc734de337f3100, 0xbfcfe700a1b1bb78, 0x3fda715ec352c558,
@@ -102,20 +102,20 @@ void TEST_CASE1(void) {
   //              0.1628442001087833,  0.2337303194688813,  0.1926350000139823,
   //              -0.6653994610877216, -0.6745212179353777,  0.8748797125997727,
   //              -0.7324641634418565
-  VLOAD_64(v2, 0xbfcbfa50c7635df8, 0xbfeeade562a749c2, 0x3fbf27194abf66e0,
+  VLOAD_64(v8, 0xbfcbfa50c7635df8, 0xbfeeade562a749c2, 0x3fbf27194abf66e0,
            0x3fe87ddfd38d1514, 0xbfe2f86de1af9792, 0x3fed319f612fa6f6,
            0x3fc4157886016dd8, 0x3fd06d5afcf59780, 0xbfed29db86ef2934,
            0x3fc4d81428e7be98, 0x3fcdeae00719eac8, 0x3fc8a84380900070,
            0xbfe54af3cf84bab0, 0xbfe595ad856fb278, 0x3febff03bd3198ce,
            0xbfe77058af6f3156);
-  asm volatile("vfmsub.vv v2, v4, v6");
+  asm volatile("vfmsub.vv v8, v16, v24");
   //              -0.4878417526056305,  1.5023792602532113,  0.7910431172705017,
   //              -1.0928904581998689, -0.9810795946017860, -0.0425694375227023,
   //              0.1708735055334605,  0.0918950033157782,  0.1963653801662987,
   //              0.0478398011349183,  0.1360200483560070, -0.5905179111943168,
   //              0.2570595827304748,  0.0482829008439404,  0.4305876927582732,
   //              0.2615424092003222
-  VCMP_U64(3, v2, 0xbfdf38cc9d4420dd, 0x3ff809bed5cf9e94, 0x3fe95039a7cce2e7,
+  VCMP_U64(3, v8, 0xbfdf38cc9d4420dd, 0x3ff809bed5cf9e94, 0x3fe95039a7cce2e7,
            0xbff17c7ab4814324, 0xbfef650108b2cdb1, 0xbfa5cba94bf030ac,
            0x3fc5df2edb027178, 0x3fb7866e51e83656, 0x3fc9228032f0c004,
            0x3fa87e755aa4ab1c, 0x3fc1691adda50ab1, 0xbfe2e585d18904b2,
@@ -127,37 +127,37 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.6821,  0.7749,  0.0299,  0.0299, -0.5410, -0.1865,  0.1885,
   //               0.0228,  0.7217,  0.1902, -0.9160, -0.3511, -0.9287, -0.9961,
   //               -0.6509, -0.3940
-  VLOAD_16(v4, 0x3975, 0x3a33, 0x27a5, 0x27a5, 0xb854, 0xb1f8, 0x3208, 0x25d8,
+  VLOAD_16(v16, 0x3975, 0x3a33, 0x27a5, 0x27a5, 0xb854, 0xb1f8, 0x3208, 0x25d8,
            0x39c6, 0x3216, 0xbb54, 0xb59e, 0xbb6e, 0xbbf8, 0xb935, 0xb64e);
   //              -0.9048,  0.1698,  0.2411,  0.2411, -0.6147,  0.9580,  0.5117,
   //              0.8330, -0.8584,  0.5591,  0.7031, -0.1556,  0.2397,  0.8154,
   //              0.1646,  0.2693
-  VLOAD_16(v6, 0xbb3d, 0x316f, 0x33b7, 0x33b7, 0xb8eb, 0x3baa, 0x3818, 0x3aaa,
+  VLOAD_16(v24, 0xbb3d, 0x316f, 0x33b7, 0x33b7, 0xb8eb, 0x3baa, 0x3818, 0x3aaa,
            0xbade, 0x3879, 0x39a0, 0xb0fb, 0x33ac, 0x3a86, 0x3144, 0x344f);
   VLOAD_8(v0, 0xAA, 0xAA);
   //              -0.2292,  0.7578, -0.7427, -0.7427,  0.1119,  0.2939, -0.2983,
   //              -0.3608,  0.3169, -0.5562, -0.0629, -0.1968, -0.8638, -0.2700,
   //              -0.7690,  0.4216
-  VLOAD_16(v2, 0xb356, 0x3a10, 0xb9f1, 0xb9f1, 0x2f29, 0x34b4, 0xb4c6, 0xb5c6,
+  VLOAD_16(v8, 0xb356, 0x3a10, 0xb9f1, 0xb9f1, 0x2f29, 0x34b4, 0xb4c6, 0xb5c6,
            0x3512, 0xb873, 0xac06, 0xb24c, 0xbae9, 0xb452, 0xba27, 0x36bf);
-  asm volatile("vfmsub.vv v2, v4, v6, v0.t");
+  asm volatile("vfmsub.vv v8, v16, v24, v0.t");
   //              -0.2292,  0.4175, -0.7427, -0.2632,  0.1119, -1.0127, -0.2983,
   //              -0.8413,  0.3169, -0.6650, -0.0629,  0.2247, -0.8638, -0.5464,
   //              -0.7690, -0.4355
-  VCMP_U16(4, v2, 0xb356, 0x36ae, 0xb9f1, 0xb436, 0x2f29, 0xbc0d, 0xb4c6,
+  VCMP_U16(4, v8, 0xb356, 0x36ae, 0xb9f1, 0xb436, 0x2f29, 0xbc0d, 0xb4c6,
            0xbabb, 0x3512, 0xb952, 0xac06, 0x3331, 0xbae9, 0xb85f, 0xba27,
            0xb6f8);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.74553698, -0.16736358, -0.11869104, -0.85860848,
   //              -0.66138542, -0.68386567, -0.45389724, -0.12761629,
   //              -0.95652348,  0.71083277,  0.24187960,  0.01609672,
   //              -0.58867335, -0.55222940, -0.67417240, -0.06725668
-  VLOAD_32(v4, 0xbf3edb83, 0xbe2b615c, 0xbdf3144a, 0xbf5bcdc4, 0xbf29508e,
+  VLOAD_32(v16, 0xbf3edb83, 0xbe2b615c, 0xbdf3144a, 0xbf5bcdc4, 0xbf29508e,
            0xbf2f11d2, 0xbee86538, 0xbe02add8, 0xbf74deb9, 0x3f35f923,
            0x3e77af49, 0x3c83dd45, 0xbf16b34c, 0xbf0d5ee8, 0xbf2c9690,
            0xbd89bddf);
@@ -165,7 +165,7 @@ void TEST_CASE2(void) {
   //              0.49659184, -0.09389434,  0.05757815, -0.13087828,
   //              -0.73042232, -0.79662275, -0.96801740,  0.03017101,
   //              0.70759267, -0.35606241,  0.18037270, -0.35372722
-  VLOAD_32(v6, 0xbe333510, 0xbf50bc3a, 0xbea39d6f, 0x3e6916cc, 0x3efe4149,
+  VLOAD_32(v24, 0xbe333510, 0xbf50bc3a, 0xbea39d6f, 0x3e6916cc, 0x3efe4149,
            0xbdc04bad, 0x3d6bd711, 0xbe0604f5, 0xbf3afcf5, 0xbf4bef78,
            0xbf77cffd, 0x3cf72932, 0x3f3524cb, 0xbeb64dd0, 0x3e38b39f,
            0xbeb51bbc);
@@ -174,29 +174,29 @@ void TEST_CASE2(void) {
   //               0.90907055,  0.07037155,  0.07339484,  0.17415307,
   //               -0.61978233, -0.04939311,  0.56138068, -0.51601994,
   //               -0.80625385, -0.31227911,  0.91474551,  0.78424871
-  VLOAD_32(v2, 0x3f6dc3b9, 0x3e3e2fab, 0xbed7cb1e, 0xbf4afb22, 0x3f68b8d9,
+  VLOAD_32(v8, 0x3f6dc3b9, 0x3e3e2fab, 0xbed7cb1e, 0xbf4afb22, 0x3f68b8d9,
            0x3d901ef6, 0x3d965009, 0x3e32552f, 0xbf1eaa0e, 0xbd4a506e,
            0x3f0fb6a5, 0xbf0419e2, 0xbf4e66a7, 0xbe9fe30c, 0x3f6a2cc3,
            0x3f48c486);
-  asm volatile("vfmsub.vv v2, v4, v6, v0.t");
+  asm volatile("vfmsub.vv v8, v16, v24, v0.t");
   //               0.92876774,  0.78428787, -0.42147154,  0.45315993,
   //               0.90907055,  0.04576965,  0.07339484,  0.10865352,
   //               -0.61978233,  0.76151252,  0.56138068, -0.03847724,
   //               -0.80625385,  0.52851212,  0.91474551,  0.30098125
-  VCMP_U32(5, v2, 0x3f6dc3b9, 0x3f48c717, 0xbed7cb1e, 0x3ee80493, 0x3f68b8d9,
+  VCMP_U32(5, v8, 0x3f6dc3b9, 0x3f48c717, 0xbed7cb1e, 0x3ee80493, 0x3f68b8d9,
            0x3d3b78f5, 0x3d965009, 0x3dde85bc, 0xbf1eaa0e, 0x3f42f27c,
            0x3f0fb6a5, 0xbd1d9a4f, 0xbf4e66a7, 0x3f074c92, 0x3f6a2cc3,
            0x3e9a1a37);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               0.3304351537536074, -0.7528197595818080, -0.7530937950641439,
   //               -0.7994160811423281,  0.0797802827518117,
   //               -0.6361377214985149,  0.1748070414096887, 0.8251843575618585,
   //               0.0699629848559165, -0.8195631240215655, -0.4843919596862658,
   //               -0.9206444585342115,  0.9791118581337512, 0.5143481050333210,
   //               0.5856279779979670, -0.5536419150604011
-  VLOAD_64(v4, 0x3fd525d97cb482ac, 0xbfe8171976e5f762, 0xbfe819582893df6e,
+  VLOAD_64(v16, 0x3fd525d97cb482ac, 0xbfe8171976e5f762, 0xbfe819582893df6e,
            0xbfe994d1088ce396, 0x3fb46c7b0948dfc0, 0xbfe45b3d7eb2d188,
            0x3fc66013befb8968, 0x3fea67e9069cc438, 0x3fb1e9181be2ff10,
            0xbfea39dc71d5c454, 0xbfdf00472253102c, 0xbfed75eb5e14bcf6,
@@ -209,7 +209,7 @@ void TEST_CASE2(void) {
   //               -0.2492371358416354,  0.4131695659117063,
   //               -0.9085600854772706, -0.3952216110937696, 0.0817663443229741,
   //               0.1439804529607418
-  VLOAD_64(v6, 0x3fda997577954be0, 0xbfe8faec3ae9f10e, 0xbfec3ef992a7ed86,
+  VLOAD_64(v24, 0x3fda997577954be0, 0xbfe8faec3ae9f10e, 0xbfec3ef992a7ed86,
            0x3fdec970c7c16d8c, 0x3fede18e86a8f206, 0xbfe135863f697cd2,
            0xbfc25c6af06e7710, 0x3fbeb257d63cc310, 0xbfd0a5eaf1337874,
            0xbfc734de337f3100, 0xbfcfe700a1b1bb78, 0x3fda715ec352c558,
@@ -222,20 +222,20 @@ void TEST_CASE2(void) {
   //              0.1628442001087833,  0.2337303194688813,  0.1926350000139823,
   //              -0.6653994610877216, -0.6745212179353777,  0.8748797125997727,
   //              -0.7324641634418565
-  VLOAD_64(v2, 0xbfcbfa50c7635df8, 0xbfeeade562a749c2, 0x3fbf27194abf66e0,
+  VLOAD_64(v8, 0xbfcbfa50c7635df8, 0xbfeeade562a749c2, 0x3fbf27194abf66e0,
            0x3fe87ddfd38d1514, 0xbfe2f86de1af9792, 0x3fed319f612fa6f6,
            0x3fc4157886016dd8, 0x3fd06d5afcf59780, 0xbfed29db86ef2934,
            0x3fc4d81428e7be98, 0x3fcdeae00719eac8, 0x3fc8a84380900070,
            0xbfe54af3cf84bab0, 0xbfe595ad856fb278, 0x3febff03bd3198ce,
            0xbfe77058af6f3156);
-  asm volatile("vfmsub.vv v2, v4, v6, v0.t");
+  asm volatile("vfmsub.vv v8, v16, v24, v0.t");
   //              -0.2185765241217579,  1.5023792602532113,  0.1216903502931035,
   //              -1.0928904581998689, -0.5928258331230032, -0.0425694375227023,
   //              0.1569052366565831,  0.0918950033157782, -0.9113595614847214,
   //              0.0478398011349183,  0.2337303194688813, -0.5905179111943168,
   //              -0.6653994610877216,  0.0482829008439404,  0.8748797125997727,
   //              0.2615424092003222
-  VCMP_U64(6, v2, 0xbfcbfa50c7635df8, 0x3ff809bed5cf9e94, 0x3fbf27194abf66e0,
+  VCMP_U64(6, v8, 0xbfcbfa50c7635df8, 0x3ff809bed5cf9e94, 0x3fbf27194abf66e0,
            0xbff17c7ab4814324, 0xbfe2f86de1af9792, 0xbfa5cba94bf030ac,
            0x3fc4157886016dd8, 0x3fb7866e51e83656, 0xbfed29db86ef2934,
            0x3fa87e755aa4ab1c, 0x3fcdeae00719eac8, 0xbfe2e585d18904b2,
@@ -246,29 +246,29 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.1489
   BOX_HALF_IN_FLOAT(fscalar_16, 0x30c4);
   //               0.8530, -0.3298, -0.1814, -0.2385,  0.9946,  0.6553,  0.8711,
   //               -0.6377,  0.4224, -0.1814,  0.7026,  0.2852,  0.0553, 0.7349,
   //               -0.8105,  0.0033
-  VLOAD_16(v4, 0x3ad3, 0xb547, 0xb1ce, 0xb3a2, 0x3bf5, 0x393e, 0x3af8, 0xb91a,
+  VLOAD_16(v16, 0x3ad3, 0xb547, 0xb1ce, 0xb3a2, 0x3bf5, 0x393e, 0x3af8, 0xb91a,
            0x36c2, 0xb1ce, 0x399f, 0x3490, 0x2b15, 0x39e1, 0xba7c, 0x1abd);
   //              -0.2338, -0.2512,  0.0069,  0.0613, -0.1733,  0.8560, -0.2766,
   //              -0.0028, -0.1803,  0.0069,  0.7856, -0.0243, -0.1974,  0.6416,
   //              0.7109,  0.0817
-  VLOAD_16(v2, 0xb37b, 0xb405, 0x1f06, 0x2bd8, 0xb18c, 0x3ad9, 0xb46d, 0x99d2,
+  VLOAD_16(v8, 0xb37b, 0xb405, 0x1f06, 0x2bd8, 0xb18c, 0x3ad9, 0xb46d, 0x99d2,
            0xb1c5, 0x1f06, 0x3a49, 0xa639, 0xb251, 0x3922, 0x39b0, 0x2d3a);
-  asm volatile("vfmsub.vf v2, %[A], v4" ::[A] "f"(fscalar_16));
+  asm volatile("vfmsub.vf v8, %[A], v16" ::[A] "f"(fscalar_16));
   //              -0.8877,  0.2925,  0.1824,  0.2477, -1.0205, -0.5278, -0.9121,
   //              0.6372, -0.4492,  0.1824, -0.5854, -0.2888, -0.0847, -0.6392,
   //              0.9165,  0.0089
-  VCMP_U16(7, v2, 0xbb1a, 0x34ae, 0x31d6, 0x33ed, 0xbc15, 0xb839, 0xbb4c,
+  VCMP_U16(7, v8, 0xbb1a, 0x34ae, 0x31d6, 0x33ed, 0xbc15, 0xb839, 0xbb4c,
            0x3919, 0xb730, 0x31d6, 0xb8af, 0xb49f, 0xad6c, 0xb91d, 0x3b55,
            0x208b);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.12857932
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbe03aa4c);
@@ -276,7 +276,7 @@ void TEST_CASE3(void) {
   //               -0.28880060,  0.46233574, -0.51105869, -0.11776974,
   //               -0.39969075,  0.51141965,  0.88750082, -0.22310242,
   //               0.60111052,  0.58466393, -0.14306845, -0.01826003
-  VLOAD_32(v4, 0x3e9efadd, 0xbe0dc2e3, 0x3e6faaea, 0xbe9c641e, 0xbe93ddac,
+  VLOAD_32(v16, 0x3e9efadd, 0xbe0dc2e3, 0x3e6faaea, 0xbe9c641e, 0xbe93ddac,
            0x3eecb745, 0xbf02d4be, 0xbdf13143, 0xbecca444, 0x3f02ec66,
            0x3f633341, 0xbe6474f6, 0x3f19e261, 0x3f15ac89, 0xbe128089,
            0xbc95960e);
@@ -284,22 +284,22 @@ void TEST_CASE3(void) {
   //              -0.50454420,  0.30827177, -0.25503114,  0.07736996,
   //              0.20596179, -0.42633566,  0.89622146,  0.03779412, 0.50878429,
   //              0.67896879, -0.17667305,  0.06984760
-  VLOAD_32(v2, 0xbf049506, 0x3f45f5fd, 0xbf6263ee, 0x3ed13af8, 0xbf0129cf,
+  VLOAD_32(v8, 0xbf049506, 0x3f45f5fd, 0xbf6263ee, 0x3ed13af8, 0xbf0129cf,
            0x3e9dd5cc, 0xbe829371, 0x3d9e7424, 0x3e52e7a6, 0xbeda48ab,
            0x3f656ec5, 0x3d1ace01, 0x3f023fb0, 0x3f2dd0e6, 0xbe34e9c8,
            0x3d8f0c42);
-  asm volatile("vfmsub.vf v2, %[A], v4" ::[A] "f"(fscalar_32));
+  asm volatile("vfmsub.vf v8, %[A], v16" ::[A] "f"(fscalar_32));
   //              -0.24391660,  0.03901032, -0.12034293,  0.25290701,
   //              0.35367453, -0.50197309,  0.54385042,  0.10782156, 0.37320831,
   //              -0.45660171, -1.00273633,  0.21824288, -0.66652966,
   //              -0.67196524,  0.16578496,  0.00927907
-  VCMP_U32(8, v2, 0xbe79c546, 0x3d1fc94a, 0xbdf6765b, 0x3e817d07, 0x3eb514d5,
+  VCMP_U32(8, v8, 0xbe79c546, 0x3d1fc94a, 0xbdf6765b, 0x3e817d07, 0x3eb514d5,
            0xbf00814f, 0x3f0b39c8, 0x3ddcd18d, 0x3ebf1529, 0xbee9c7b3,
            0xbf8059aa, 0x3e5f7b10, 0xbf2aa1b0, 0xbf2c05eb, 0x3e29c388,
            0x3c18073f);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                               -0.6953502965951812
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfe6404f43e47c8c);
@@ -309,7 +309,7 @@ void TEST_CASE3(void) {
   //               -0.4464070291333477,  0.5599998966835931,
   //               -0.3406088963725078,  0.4908382567748615,
   //               -0.5194254665571632,  0.0909287222245825,  0.5893410930389467
-  VLOAD_64(v4, 0xbfec64e92b21453c, 0x3fd90b76663c74f4, 0x3fec9ccf06e3d51a,
+  VLOAD_64(v16, 0xbfec64e92b21453c, 0x3fd90b76663c74f4, 0x3fec9ccf06e3d51a,
            0x3fd0d574d8567864, 0xbfe9e8cae6c6325c, 0x3fe4a36b411b6206,
            0x3fead4815153e1da, 0xbfefdc02add2c126, 0xbfec990204389c42,
            0xbfdc91eec9b5438c, 0x3fe1eb84e7409f04, 0xbfd5cc8941a96178,
@@ -321,20 +321,20 @@ void TEST_CASE3(void) {
   //               0.3780444269462682, -0.6731508364205383,  0.1263808806166760,
   //               0.8571806635726140,  0.5149747658358419,  0.3530123248386567,
   //               -0.3756405874818076, -0.4529815298587780
-  VLOAD_64(v2, 0xbfdc153dde8f3078, 0xbfcf0c99c409ad98, 0xbfec824d0777279c,
+  VLOAD_64(v8, 0xbfdc153dde8f3078, 0xbfcf0c99c409ad98, 0xbfec824d0777279c,
            0xbfe97a21412fca1a, 0x3fa21bf19e277c80, 0x3fd32781ab407ee0,
            0xbfdacb94deb0b06c, 0xbfe159aae0fd4b9a, 0x3fd831e1408ad588,
            0xbfe58a739f7670b4, 0x3fc02d3faa8b4d88, 0x3feb6e062499dac6,
            0x3fe07aac5c30f764, 0x3fd697c1019115dc, 0xbfd80a7ed19236bc,
            0xbfdcfda63e1bdf38);
-  asm volatile("vfmsub.vf v2, %[A], v4" ::[A] "f"(dscalar_64));
+  asm volatile("vfmsub.vf v8, %[A], v16" ::[A] "f"(dscalar_64));
   //               1.1924354834767115, -0.2226520744998102, -0.2746500252428773,
   //               0.2905806577161405,  0.7850729097860438, -0.8530574119257405,
   //               -0.5473143461852141,  1.3726227142641205, 0.6308044149460488,
   //               0.9144826628916634, -0.6478788795043589, -0.2554319322783636,
   //               -0.8489261129378481,  0.2739582417788488, 0.1702730716940806,
   //               -0.2743602518995064
-  VCMP_U64(9, v2, 0x3ff314373ac1f573, 0xbfcc7fdcf92e7eaa, 0xbfd193ddb310e0ff,
+  VCMP_U64(9, v8, 0x3ff314373ac1f573, 0xbfcc7fdcf92e7eaa, 0xbfd193ddb310e0ff,
            0x3fd298df9d6f6c70, 0x3fe91f5139103634, 0xbfeb4c3f0eba9b49,
            0xbfe18399602fe862, 0x3ff5f6433c382dac, 0x3fe42f8cbd8bb3c3,
            0x3fed4371253c1e34, 0xbfe4bb6c7ce7b0ea, 0xbfd058ff2cdf5691,
@@ -345,30 +345,30 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.1489
   BOX_HALF_IN_FLOAT(fscalar_16, 0x30c4);
   //                0.8530, -0.3298, -0.1814, -0.2385,  0.9946,  0.6553, 0.8711,
   //                -0.6377,  0.4224, -0.1814,  0.7026,  0.2852,  0.0553,
   //                0.7349, -0.8105,  0.0033
-  VLOAD_16(v4, 0x3ad3, 0xb547, 0xb1ce, 0xb3a2, 0x3bf5, 0x393e, 0x3af8, 0xb91a,
+  VLOAD_16(v16, 0x3ad3, 0xb547, 0xb1ce, 0xb3a2, 0x3bf5, 0x393e, 0x3af8, 0xb91a,
            0x36c2, 0xb1ce, 0x399f, 0x3490, 0x2b15, 0x39e1, 0xba7c, 0x1abd);
   VLOAD_8(v0, 0xAA, 0xAA);
   //               -0.2338, -0.2512,  0.0069,  0.0613, -0.1733,  0.8560,
   //               -0.2766, -0.0028, -0.1803,  0.0069,  0.7856, -0.0243,
   //               -0.1974,  0.6416,  0.7109,  0.0817
-  VLOAD_16(v2, 0xb37b, 0xb405, 0x1f06, 0x2bd8, 0xb18c, 0x3ad9, 0xb46d, 0x99d2,
+  VLOAD_16(v8, 0xb37b, 0xb405, 0x1f06, 0x2bd8, 0xb18c, 0x3ad9, 0xb46d, 0x99d2,
            0xb1c5, 0x1f06, 0x3a49, 0xa639, 0xb251, 0x3922, 0x39b0, 0x2d3a);
-  asm volatile("vfmsub.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
+  asm volatile("vfmsub.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_16));
   //               -0.2338,  0.2925,  0.0069,  0.2477, -0.1733, -0.5278,
   //               -0.2766,  0.6372, -0.1803,  0.1824,  0.7856, -0.2888,
   //               -0.1974, -0.6392,  0.7109,  0.0089
-  VCMP_U16(10, v2, 0xb37b, 0x34ae, 0x1f06, 0x33ed, 0xb18c, 0xb839, 0xb46d,
+  VCMP_U16(10, v8, 0xb37b, 0x34ae, 0x1f06, 0x33ed, 0xb18c, 0xb839, 0xb46d,
            0x3919, 0xb1c5, 0x31d6, 0x3a49, 0xb49f, 0xb251, 0xb91d, 0x39b0,
            0x208b);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.12857932
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbe03aa4c);
@@ -376,7 +376,7 @@ void TEST_CASE4(void) {
   //                -0.28880060,  0.46233574, -0.51105869, -0.11776974,
   //                -0.39969075,  0.51141965,  0.88750082, -0.22310242,
   //                0.60111052,  0.58466393, -0.14306845, -0.01826003
-  VLOAD_32(v4, 0x3e9efadd, 0xbe0dc2e3, 0x3e6faaea, 0xbe9c641e, 0xbe93ddac,
+  VLOAD_32(v16, 0x3e9efadd, 0xbe0dc2e3, 0x3e6faaea, 0xbe9c641e, 0xbe93ddac,
            0x3eecb745, 0xbf02d4be, 0xbdf13143, 0xbecca444, 0x3f02ec66,
            0x3f633341, 0xbe6474f6, 0x3f19e261, 0x3f15ac89, 0xbe128089,
            0xbc95960e);
@@ -385,22 +385,22 @@ void TEST_CASE4(void) {
   //               -0.50454420,  0.30827177, -0.25503114,  0.07736996,
   //               0.20596179, -0.42633566,  0.89622146,  0.03779412,
   //               0.50878429,  0.67896879, -0.17667305,  0.06984760
-  VLOAD_32(v2, 0xbf049506, 0x3f45f5fd, 0xbf6263ee, 0x3ed13af8, 0xbf0129cf,
+  VLOAD_32(v8, 0xbf049506, 0x3f45f5fd, 0xbf6263ee, 0x3ed13af8, 0xbf0129cf,
            0x3e9dd5cc, 0xbe829371, 0x3d9e7424, 0x3e52e7a6, 0xbeda48ab,
            0x3f656ec5, 0x3d1ace01, 0x3f023fb0, 0x3f2dd0e6, 0xbe34e9c8,
            0x3d8f0c42);
-  asm volatile("vfmsub.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
+  asm volatile("vfmsub.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_32));
   //               -0.51789892,  0.03901032, -0.88433731,  0.25290701,
   //               -0.50454420, -0.50197309, -0.25503114,  0.10782156,
   //               0.20596179, -0.45660171,  0.89622146,  0.21824288,
   //               0.50878429, -0.67196524, -0.17667305,  0.00927907
-  VCMP_U32(11, v2, 0xbf049506, 0x3d1fc94a, 0xbf6263ee, 0x3e817d07, 0xbf0129cf,
+  VCMP_U32(11, v8, 0xbf049506, 0x3d1fc94a, 0xbf6263ee, 0x3e817d07, 0xbf0129cf,
            0xbf00814f, 0xbe829371, 0x3ddcd18d, 0x3e52e7a6, 0xbee9c7b3,
            0x3f656ec5, 0x3e5f7b10, 0x3f023fb0, 0xbf2c05eb, 0xbe34e9c8,
            0x3c18073f);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                               -0.6953502965951812
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfe6404f43e47c8c);
@@ -411,7 +411,7 @@ void TEST_CASE4(void) {
   //                -0.8936777193492917, -0.4464070291333477,
   //                0.5599998966835931, -0.3406088963725078, 0.4908382567748615,
   //                -0.5194254665571632,  0.0909287222245825, 0.5893410930389467
-  VLOAD_64(v4, 0xbfec64e92b21453c, 0x3fd90b76663c74f4, 0x3fec9ccf06e3d51a,
+  VLOAD_64(v16, 0xbfec64e92b21453c, 0x3fd90b76663c74f4, 0x3fec9ccf06e3d51a,
            0x3fd0d574d8567864, 0xbfe9e8cae6c6325c, 0x3fe4a36b411b6206,
            0x3fead4815153e1da, 0xbfefdc02add2c126, 0xbfec990204389c42,
            0xbfdc91eec9b5438c, 0x3fe1eb84e7409f04, 0xbfd5cc8941a96178,
@@ -425,13 +425,13 @@ void TEST_CASE4(void) {
   //                0.3780444269462682, -0.6731508364205383, 0.1263808806166760,
   //                0.8571806635726140,  0.5149747658358419, 0.3530123248386567,
   //                -0.3756405874818076, -0.4529815298587780
-  VLOAD_64(v2, 0xbfdc153dde8f3078, 0xbfcf0c99c409ad98, 0xbfec824d0777279c,
+  VLOAD_64(v8, 0xbfdc153dde8f3078, 0xbfcf0c99c409ad98, 0xbfec824d0777279c,
            0xbfe97a21412fca1a, 0x3fa21bf19e277c80, 0x3fd32781ab407ee0,
            0xbfdacb94deb0b06c, 0xbfe159aae0fd4b9a, 0x3fd831e1408ad588,
            0xbfe58a739f7670b4, 0x3fc02d3faa8b4d88, 0x3feb6e062499dac6,
            0x3fe07aac5c30f764, 0x3fd697c1019115dc, 0xbfd80a7ed19236bc,
            0xbfdcfda63e1bdf38);
-  asm volatile("vfmsub.vf v2, %[A], v4, v0.t" ::[A] "f"(dscalar_64));
+  asm volatile("vfmsub.vf v8, %[A], v16, v0.t" ::[A] "f"(dscalar_64));
   //               -0.4387964890891065, -0.2226520744998102,
   //               -0.8909058709916624,  0.2905806577161405, 0.0353694444236163,
   //               -0.8530574119257405,
@@ -439,7 +439,7 @@ void TEST_CASE4(void) {
   //               0.9144826628916634,  0.1263808806166760, -0.2554319322783636,
   //               0.5149747658358419,  0.2739582417788488, -0.3756405874818076,
   //               -0.2743602518995064
-  VCMP_U64(12, v2, 0xbfdc153dde8f3078, 0xbfcc7fdcf92e7eaa, 0xbfec824d0777279c,
+  VCMP_U64(12, v8, 0xbfdc153dde8f3078, 0xbfcc7fdcf92e7eaa, 0xbfec824d0777279c,
            0x3fd298df9d6f6c70, 0x3fa21bf19e277c80, 0xbfeb4c3f0eba9b49,
            0xbfdacb94deb0b06c, 0x3ff5f6433c382dac, 0x3fd831e1408ad588,
            0x3fed4371253c1e34, 0x3fc02d3faa8b4d88, 0xbfd058ff2cdf5691,
diff --git a/sw/riscvTests/isa/rv64uv/vfmul.c b/sw/riscvTests/isa/rv64uv/vfmul.c
index 62335603..d24c1989 100644
--- a/sw/riscvTests/isa/rv64uv/vfmul.c
+++ b/sw/riscvTests/isa/rv64uv/vfmul.c
@@ -10,31 +10,31 @@
 
 // Simple random test with similar values + 1 subnormal
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.5522,  0.0462, -0.4255,  0.4131,  0.4658,  0.3931, -0.4868,
   //              0.5503,  0.3516, -0.3025, -0.2155,  0.9307,  0.9775,  0.8394,
   //              0.7446,  0.3909
-  VLOAD_16(v4, 0xb86b, 0x29e9, 0xb6cf, 0x369c, 0x3774, 0x364a, 0xb7ca, 0x3867,
+  VLOAD_16(v16, 0xb86b, 0x29e9, 0xb6cf, 0x369c, 0x3774, 0x364a, 0xb7ca, 0x3867,
            0x35a0, 0xb4d7, 0xb2e5, 0x3b72, 0x3bd2, 0x3ab7, 0x39f5, 0x3641);
   //               0.8247,  0.4902,  0.5796, -0.9561, -0.7676,  0.1672, -0.1094,
   //               -0.9395,  0.4885, -0.2739,  0.8691, -0.3394, -0.8032,
   //               -0.4922,  0.4456,  0.2050
-  VLOAD_16(v6, 0x3a99, 0x37d8, 0x38a3, 0xbba6, 0xba24, 0x315a, 0xaf01, 0xbb84,
+  VLOAD_16(v24, 0x3a99, 0x37d8, 0x38a3, 0xbba6, 0xba24, 0x315a, 0xaf01, 0xbb84,
            0x37d1, 0xb462, 0x3af4, 0xb56e, 0xba6d, 0xb7e0, 0x3721, 0x328f);
-  asm volatile("vfmul.vv v2, v4, v6");
+  asm volatile("vfmul.vv v8, v16, v24");
   //              -0.4553,  0.0226, -0.2466, -0.3950, -0.3577,  0.0657,  0.0533,
   //              -0.5171,  0.1718,  0.0829, -0.1873, -0.3159, -0.7852, -0.4131,
   //              0.3318,  0.0801
-  VCMP_U16(1, v2, 0xb749, 0x25cb, 0xb3e4, 0xb652, 0xb5b9, 0x2c35, 0x2ad2,
+  VCMP_U16(1, v8, 0xb749, 0x25cb, 0xb3e4, 0xb652, 0xb5b9, 0x2c35, 0x2ad2,
            0xb823, 0x317f, 0x2d4e, 0xb1fe, 0xb50e, 0xba48, 0xb69c, 0x354f,
            0x2d21);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.48805356,  0.30350628, -0.10483003,  0.61108905,
   //               -0.09161828,  0.83353645, -0.55006021, -0.78635991,
   //               0.49253011, -0.03583150, -0.77662903,  0.57397723,
   //               -0.54674339,  0.86299890,  0.65402901, -0.16832402
-  VLOAD_32(v4, 0x3ef9e228, 0x3e9b652d, 0xbdd6b121, 0x3f1c7055, 0xbdbba25d,
+  VLOAD_32(v16, 0x3ef9e228, 0x3e9b652d, 0xbdd6b121, 0x3f1c7055, 0xbdbba25d,
            0x3f5562a5, 0xbf0cd0bf, 0xbf494ee2, 0x3efc2ce8, 0xbd12c40e,
            0xbf46d129, 0x3f12f02c, 0xbf0bf760, 0x3f5ced7f, 0x3f276e72,
            0xbe2c5d22);
@@ -42,29 +42,29 @@ void TEST_CASE1(void) {
   //               -0.99424285,  0.31885657,  0.18092929, -0.68290263,
   //               0.45391774, -0.45151946, -0.08929581,  0.80524033,
   //               0.81978256, -0.28325567, -0.53026456, -0.21847765
-  VLOAD_32(v6, 0x3f5f15cf, 0xbea7b67f, 0x3f445e7a, 0xbf0b50f0, 0xbf7e86b3,
+  VLOAD_32(v24, 0x3f5f15cf, 0xbea7b67f, 0x3f445e7a, 0xbf0b50f0, 0xbf7e86b3,
            0x3ea3412b, 0x3e394587, 0xbf2ed2b5, 0x3ee867e8, 0xbee72d8f,
            0xbdb6e0b9, 0x3f4e243b, 0x3f51dd45, 0xbe9106e3, 0xbf07bf6b,
            0xbe5fb89b);
-  asm volatile("vfmul.vv v2, v4, v6");
+  asm volatile("vfmul.vv v8, v16, v24");
   //               0.42530280, -0.09941780, -0.08041162, -0.33255696,
   //               0.09109081,  0.26577857, -0.09952200,  0.53700727,
   //               0.22356816,  0.01617862,  0.06934972,  0.46218961,
   //               -0.44821069, -0.24444933, -0.34680840,  0.03677504
-  VCMP_U32(2, v2, 0x3ed9c14a, 0xbdcb9b8f, 0xbda4aed9, 0xbeaa44e8, 0x3dba8dd2,
+  VCMP_U32(2, v8, 0x3ed9c14a, 0xbdcb9b8f, 0xbda4aed9, 0xbeaa44e8, 0x3dba8dd2,
            0x3e881421, 0xbdcbd231, 0x3f09794f, 0x3e64ef0d, 0x3c848907,
            0x3d8e073a, 0x3eeca41e, 0xbee57bdf, 0xbe7a50ed, 0xbeb190df,
            0x3d16a16c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.7493892241714462,  0.7026559207451004,  0.6475697152132245,
   //              0.0771197585157644, -0.2238692303359540,  0.8998213782649329,
   //              -0.9446193329247832,  0.8596730101791072, -0.0254417293392082,
   //              0.1965035124326171, -0.4709662077579637, -0.2875069600640039,
   //              -0.4671574223295827,  0.3105385724706418,  0.1703390668980564,
   //              0.1487690137320270
-  VLOAD_64(v4, 0xbfe7faff1c39514c, 0x3fe67c2844fe1c76, 0x3fe4b8e41f971110,
+  VLOAD_64(v16, 0xbfe7faff1c39514c, 0x3fe67c2844fe1c76, 0x3fe4b8e41f971110,
            0x3fb3be1ed8b35c30, 0xbfcca7bf376fd290, 0x3feccb5633fc770c,
            0xbfee3a5252c299d8, 0x3feb8270f8ff23f8, 0xbf9a0d658ddcc1c0,
            0x3fc92706efb93e80, 0xbfde244f72f5dcb4, 0xbfd2668397b639c0,
@@ -76,20 +76,20 @@ void TEST_CASE1(void) {
   //               0.6297663200296084,  0.3637508978200528,  0.6003193921430929,
   //               -0.9089688764960682,  0.1595578103621622, 0.2113473996516566,
   //               -0.4586515678904381
-  VLOAD_64(v6, 0x3fe62f4b848d2362, 0xbfd1334ac4aee374, 0x3fd02f3bdcc85930,
+  VLOAD_64(v24, 0x3fe62f4b848d2362, 0xbfd1334ac4aee374, 0x3fd02f3bdcc85930,
            0x3fe751b7e126b540, 0xbfe22f283c572a1e, 0x3f82dddde857f980,
            0xbfe06c8ede5db9be, 0xbf923ab26578ce40, 0x3fb4ea36e2cf6110,
            0x3fe4270bb294c832, 0x3fd747b1d881c6e4, 0x3fe335d1038d1808,
            0xbfed1645e5b43d3e, 0x3fc46c63eca9d670, 0x3fcb0d6e7ccc9be0,
            0xbfdd5a8c1b164ebc);
-  asm volatile("vfmul.vv v2, v4, v6");
+  asm volatile("vfmul.vv v8, v16, v24");
   //              -0.5195315511948315, -0.1888427270075288,  0.1637593235041994,
   //              0.0561991250128884,  0.1272151431765869,  0.0082893703931556,
   //              0.4848274962501199, -0.0153039296644220, -0.0020785594718451,
   //              0.1237512938975817, -0.1713143809148648, -0.1725960035025313,
   //              0.4246315573217200,  0.0495488546564072,  0.0360007188479938,
   //              -0.0682331414017083
-  VCMP_U64(3, v2, 0xbfe0a000a1b3e706, 0xbfc82bff9c4ada77, 0x3fc4f610c56ecca8,
+  VCMP_U64(3, v8, 0xbfe0a000a1b3e706, 0xbfc82bff9c4ada77, 0x3fc4f610c56ecca8,
            0x3facc621b7fd0401, 0x3fc04895f7bfec49, 0x3f80fa0475f1bbe1,
            0x3fdf0769e826220a, 0xbf8f57aaab459580, 0xbf61070e1e8a29ae,
            0x3fbfae2a3020b759, 0xbfc5eda12fae9203, 0xbfc617a0373b59a7,
@@ -101,32 +101,32 @@ void TEST_CASE1(void) {
 // Simple random test with similar values + 1 subnormal (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.5522,  0.0462, -0.4255,  0.4131,  0.4658,  0.3931, -0.4868,
   //              0.5503,  0.3516, -0.3025, -0.2155,  0.9307,  0.9775,  0.8394,
   //              0.7446,  0.3909
-  VLOAD_16(v4, 0xb86b, 0x29e9, 0xb6cf, 0x369c, 0x3774, 0x364a, 0xb7ca, 0x3867,
+  VLOAD_16(v16, 0xb86b, 0x29e9, 0xb6cf, 0x369c, 0x3774, 0x364a, 0xb7ca, 0x3867,
            0x35a0, 0xb4d7, 0xb2e5, 0x3b72, 0x3bd2, 0x3ab7, 0x39f5, 0x3641);
   //               0.8247,  0.4902,  0.5796, -0.9561, -0.7676,  0.1672, -0.1094,
   //               -0.9395,  0.4885, -0.2739,  0.8691, -0.3394, -0.8032,
   //               -0.4922,  0.4456,  0.2050
-  VLOAD_16(v6, 0x3a99, 0x37d8, 0x38a3, 0xbba6, 0xba24, 0x315a, 0xaf01, 0xbb84,
+  VLOAD_16(v24, 0x3a99, 0x37d8, 0x38a3, 0xbba6, 0xba24, 0x315a, 0xaf01, 0xbb84,
            0x37d1, 0xb462, 0x3af4, 0xb56e, 0xba6d, 0xb7e0, 0x3721, 0x328f);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmul.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfmul.vv v8, v16, v24, v0.t");
   //               0.0000,  0.0226,  0.0000, -0.3950,  0.0000,  0.0657,  0.0000,
   //               -0.5171,  0.0000,  0.0829,  0.0000, -0.3159,  0.0000,
   //               -0.4131,  0.0000,  0.0801
-  VCMP_U16(4, v2, 0x0, 0x25cb, 0x0, 0xb652, 0x0, 0x2c35, 0x0, 0xb823, 0x0,
+  VCMP_U16(4, v8, 0x0, 0x25cb, 0x0, 0xb652, 0x0, 0x2c35, 0x0, 0xb823, 0x0,
            0x2d4e, 0x0, 0xb50e, 0x0, 0xb69c, 0x0, 0x2d21);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.48805356,  0.30350628, -0.10483003,  0.61108905,
   //               -0.09161828,  0.83353645, -0.55006021, -0.78635991,
   //               0.49253011, -0.03583150, -0.77662903,  0.57397723,
   //               -0.54674339,  0.86299890,  0.65402901, -0.16832402
-  VLOAD_32(v4, 0x3ef9e228, 0x3e9b652d, 0xbdd6b121, 0x3f1c7055, 0xbdbba25d,
+  VLOAD_32(v16, 0x3ef9e228, 0x3e9b652d, 0xbdd6b121, 0x3f1c7055, 0xbdbba25d,
            0x3f5562a5, 0xbf0cd0bf, 0xbf494ee2, 0x3efc2ce8, 0xbd12c40e,
            0xbf46d129, 0x3f12f02c, 0xbf0bf760, 0x3f5ced7f, 0x3f276e72,
            0xbe2c5d22);
@@ -134,30 +134,30 @@ void TEST_CASE2(void) {
   //               -0.99424285,  0.31885657,  0.18092929, -0.68290263,
   //               0.45391774, -0.45151946, -0.08929581,  0.80524033,
   //               0.81978256, -0.28325567, -0.53026456, -0.21847765
-  VLOAD_32(v6, 0x3f5f15cf, 0xbea7b67f, 0x3f445e7a, 0xbf0b50f0, 0xbf7e86b3,
+  VLOAD_32(v24, 0x3f5f15cf, 0xbea7b67f, 0x3f445e7a, 0xbf0b50f0, 0xbf7e86b3,
            0x3ea3412b, 0x3e394587, 0xbf2ed2b5, 0x3ee867e8, 0xbee72d8f,
            0xbdb6e0b9, 0x3f4e243b, 0x3f51dd45, 0xbe9106e3, 0xbf07bf6b,
            0xbe5fb89b);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmul.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfmul.vv v8, v16, v24, v0.t");
   //               0.00000000, -0.09941780,  0.00000000, -0.33255696,
   //               0.00000000,  0.26577857,  0.00000000,  0.53700727,
   //               0.00000000,  0.01617862,  0.00000000,  0.46218961,
   //               0.00000000, -0.24444933,  0.00000000,  0.03677504
-  VCMP_U32(5, v2, 0x0, 0xbdcb9b8f, 0x0, 0xbeaa44e8, 0x0, 0x3e881421, 0x0,
+  VCMP_U32(5, v8, 0x0, 0xbdcb9b8f, 0x0, 0xbeaa44e8, 0x0, 0x3e881421, 0x0,
            0x3f09794f, 0x0, 0x3c848907, 0x0, 0x3eeca41e, 0x0, 0xbe7a50ed, 0x0,
            0x3d16a16c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.7493892241714462,  0.7026559207451004,  0.6475697152132245,
   //              0.0771197585157644, -0.2238692303359540,  0.8998213782649329,
   //              -0.9446193329247832,  0.8596730101791072, -0.0254417293392082,
   //              0.1965035124326171, -0.4709662077579637, -0.2875069600640039,
   //              -0.4671574223295827,  0.3105385724706418,  0.1703390668980564,
   //              0.1487690137320270
-  VLOAD_64(v4, 0xbfe7faff1c39514c, 0x3fe67c2844fe1c76, 0x3fe4b8e41f971110,
+  VLOAD_64(v16, 0xbfe7faff1c39514c, 0x3fe67c2844fe1c76, 0x3fe4b8e41f971110,
            0x3fb3be1ed8b35c30, 0xbfcca7bf376fd290, 0x3feccb5633fc770c,
            0xbfee3a5252c299d8, 0x3feb8270f8ff23f8, 0xbf9a0d658ddcc1c0,
            0x3fc92706efb93e80, 0xbfde244f72f5dcb4, 0xbfd2668397b639c0,
@@ -169,22 +169,22 @@ void TEST_CASE2(void) {
   //               0.6297663200296084,  0.3637508978200528,  0.6003193921430929,
   //               -0.9089688764960682,  0.1595578103621622, 0.2113473996516566,
   //               -0.4586515678904381
-  VLOAD_64(v6, 0x3fe62f4b848d2362, 0xbfd1334ac4aee374, 0x3fd02f3bdcc85930,
+  VLOAD_64(v24, 0x3fe62f4b848d2362, 0xbfd1334ac4aee374, 0x3fd02f3bdcc85930,
            0x3fe751b7e126b540, 0xbfe22f283c572a1e, 0x3f82dddde857f980,
            0xbfe06c8ede5db9be, 0xbf923ab26578ce40, 0x3fb4ea36e2cf6110,
            0x3fe4270bb294c832, 0x3fd747b1d881c6e4, 0x3fe335d1038d1808,
            0xbfed1645e5b43d3e, 0x3fc46c63eca9d670, 0x3fcb0d6e7ccc9be0,
            0xbfdd5a8c1b164ebc);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmul.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfmul.vv v8, v16, v24, v0.t");
   //               0.0000000000000000, -0.1888427270075288,  0.0000000000000000,
   //               0.0561991250128884,  0.0000000000000000,  0.0082893703931556,
   //               0.0000000000000000, -0.0153039296644220,  0.0000000000000000,
   //               0.1237512938975817,  0.0000000000000000, -0.1725960035025313,
   //               0.0000000000000000,  0.0495488546564072,  0.0000000000000000,
   //               -0.0682331414017083
-  VCMP_U64(6, v2, 0x0, 0xbfc82bff9c4ada77, 0x0, 0x3facc621b7fd0401, 0x0,
+  VCMP_U64(6, v8, 0x0, 0xbfc82bff9c4ada77, 0x0, 0x3facc621b7fd0401, 0x0,
            0x3f80fa0475f1bbe1, 0x0, 0xbf8f57aaab459580, 0x0, 0x3fbfae2a3020b759,
            0x0, 0xbfc617a0373b59a7, 0x0, 0x3fa95e77ac9b67ce, 0x0,
            0xbfb177ba26d2dcbe);
@@ -193,47 +193,47 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.8423,  0.9531,  0.3889, -0.3704, -0.9731, -0.4636, -0.4797,
   //              -0.5903,  0.2959,  0.4685, -0.3660,  0.3167, -0.9766,  0.0052,
   //              -0.6489, -0.0474
-  VLOAD_16(v4, 0xbabd, 0x3ba0, 0x3639, 0xb5ed, 0xbbc9, 0xb76b, 0xb7ad, 0xb8b9,
+  VLOAD_16(v16, 0xbabd, 0x3ba0, 0x3639, 0xb5ed, 0xbbc9, 0xb76b, 0xb7ad, 0xb8b9,
            0x34bc, 0x377f, 0xb5db, 0x3511, 0xbbd0, 0x1d48, 0xb931, 0xaa11);
   float fscalar_16;
   //                              0.2971
   BOX_HALF_IN_FLOAT(fscalar_16, 0x34c1);
-  asm volatile("vfmul.vf v2, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfmul.vf v8, v16, %[A]" ::[A] "f"(fscalar_16));
   //              -0.2502,  0.2832,  0.1155, -0.1100, -0.2891, -0.1377, -0.1426,
   //              -0.1754,  0.0879,  0.1392, -0.1088,  0.0941, -0.2900,  0.0015,
   //              -0.1927, -0.0141
-  VCMP_U16(7, v2, 0xb401, 0x3488, 0x2f65, 0xaf0b, 0xb4a0, 0xb068, 0xb090,
+  VCMP_U16(7, v8, 0xb401, 0x3488, 0x2f65, 0xaf0b, 0xb4a0, 0xb068, 0xb090,
            0xb19d, 0x2da0, 0x3074, 0xaef6, 0x2e05, 0xb4a4, 0x1647, 0xb22b,
            0xa336);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.11454447, -0.46133029,  0.06972761,  0.20429718,
   //              -0.97134608, -0.95719630, -0.11250938,  0.48455358,
   //              0.59656250,  0.46462929,  0.13447689, -0.32035729, 0.75118428,
   //              0.90634471,  0.73552424, -0.53555632
-  VLOAD_32(v4, 0xbdea964b, 0xbeec337c, 0x3d8ecd5a, 0x3e513348, 0xbf78aa23,
+  VLOAD_32(v16, 0xbdea964b, 0xbeec337c, 0x3d8ecd5a, 0x3e513348, 0xbf78aa23,
            0xbf750ad1, 0xbde66b52, 0x3ef81768, 0x3f18b852, 0x3eede3e4,
            0x3e09b44f, 0xbea405df, 0x3f404d9d, 0x3f680635, 0x3f3c4b51,
            0xbf091a38);
   float fscalar_32;
   //                               0.94017404
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x3f70af3f);
-  asm volatile("vfmul.vf v2, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfmul.vf v8, v16, %[A]" ::[A] "f"(fscalar_32));
   //              -0.10769174, -0.43373078,  0.06555609,  0.19207491,
   //              -0.91323435, -0.89993113, -0.10577840,  0.45556471,
   //              0.56087255,  0.43683240,  0.12643167, -0.30119160, 0.70624399,
   //              0.85212177,  0.69152081, -0.50351614
-  VCMP_U32(8, v2, 0xbddc8d7d, 0xbede11f6, 0x3d864246, 0x3e44af49, 0xbf69c9ba,
+  VCMP_U32(8, v8, 0xbddc8d7d, 0xbede11f6, 0x3d864246, 0x3e44af49, 0xbf69c9ba,
            0xbf6661e3, 0xbdd8a259, 0x3ee93fc7, 0x3f0f9558, 0x3edfa87f,
            0x3e01774e, 0xbe9a35c9, 0x3f34cc68, 0x3f5a24a7, 0x3f310782,
            0xbf00e66f);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               -0.3344965024132001, -0.2497404698970234, 0.3402338726452623,
   //               -0.5885400342262450, -0.7135559920290824, 0.1114442794173345,
   //               -0.9541638058007114,  0.1021679621951177,
@@ -241,7 +241,7 @@ void TEST_CASE3(void) {
   //               -0.2701320849999789,  0.3582375365191053,
   //               -0.6137661452178358,  0.6195430637830983, 0.2731869234335833,
   //               -0.4075196944877124
-  VLOAD_64(v4, 0xbfd56864049f6dd8, 0xbfcff77ee7590278, 0x3fd5c6644b002e60,
+  VLOAD_64(v16, 0xbfd56864049f6dd8, 0xbfcff77ee7590278, 0x3fd5c6644b002e60,
            0xbfe2d551e8ec6e20, 0xbfe6d573603426e0, 0x3fbc879cbf6c7a10,
            0xbfee8882889e1c44, 0x3fba27adf853b5f0, 0xbfc177db63eceed0,
            0xbfedec94daa41aac, 0xbfd149d815ab3680, 0x3fd6ed5d21e3257c,
@@ -250,14 +250,14 @@ void TEST_CASE3(void) {
   double dscalar_64;
   //                               -0.7970907277742201
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfe981c469f7860e);
-  asm volatile("vfmul.vf v2, v4, %[A]" ::[A] "f"(dscalar_64));
+  asm volatile("vfmul.vf v8, v16, %[A]" ::[A] "f"(dscalar_64));
   //               0.2666240605464688,  0.1990658129048941, -0.2711972651602534,
   //               0.4691198042056620,  0.5687688649941168, -0.0888312017870367,
   //               0.7605551223815086, -0.0814371353413154,  0.1087791670362886,
   //               0.7453831118261137,  0.2153197802278006, -0.2855478187000574,
   //               0.4892273033748624, -0.4938320315983399, -0.2177547636180751,
   //               0.3248301698615385
-  VCMP_U64(9, v2, 0x3fd1105e5d17ec76, 0x3fc97afd1216ce6e, 0xbfd15b4bc6282ffc,
+  VCMP_U64(9, v8, 0x3fd1105e5d17ec76, 0x3fc97afd1216ce6e, 0xbfd15b4bc6282ffc,
            0x3fde060f123e080e, 0x3fe2335ac3443fa9, 0xbfb6bda4428a29bb,
            0x3fe85677b22de228, 0xbfb4d91068f88b49, 0x3fbbd8f394e82fe7,
            0x3fe7da2daf091575, 0x3fcb8f993b2151e0, 0xbfd2466a5bb0b251,
@@ -268,30 +268,30 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               -0.8423,  0.9531,  0.3889, -0.3704, -0.9731, -0.4636,
   //               -0.4797, -0.5903,  0.2959,  0.4685, -0.3660,  0.3167,
   //               -0.9766,  0.0052, -0.6489, -0.0474
-  VLOAD_16(v4, 0xbabd, 0x3ba0, 0x3639, 0xb5ed, 0xbbc9, 0xb76b, 0xb7ad, 0xb8b9,
+  VLOAD_16(v16, 0xbabd, 0x3ba0, 0x3639, 0xb5ed, 0xbbc9, 0xb76b, 0xb7ad, 0xb8b9,
            0x34bc, 0x377f, 0xb5db, 0x3511, 0xbbd0, 0x1d48, 0xb931, 0xaa11);
   float fscalar_16;
   //                              0.2971
   BOX_HALF_IN_FLOAT(fscalar_16, 0x34c1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmul.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v8);
+  asm volatile("vfmul.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.0000,  0.2832,  0.0000, -0.1100,  0.0000, -0.1377, 0.0000,
   //                -0.1754,  0.0000,  0.1392,  0.0000,  0.0941,  0.0000,
   //                0.0015,  0.0000, -0.0141
-  VCMP_U16(10, v2, 0x0, 0x3488, 0x0, 0xaf0b, 0x0, 0xb068, 0x0, 0xb19d, 0x0,
+  VCMP_U16(10, v8, 0x0, 0x3488, 0x0, 0xaf0b, 0x0, 0xb068, 0x0, 0xb19d, 0x0,
            0x3074, 0x0, 0x2e05, 0x0, 0x1647, 0x0, 0xa336);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               -0.11454447, -0.46133029,  0.06972761,  0.20429718,
   //               -0.97134608, -0.95719630, -0.11250938,  0.48455358,
   //               0.59656250,  0.46462929,  0.13447689, -0.32035729,
   //               0.75118428,  0.90634471,  0.73552424, -0.53555632
-  VLOAD_32(v4, 0xbdea964b, 0xbeec337c, 0x3d8ecd5a, 0x3e513348, 0xbf78aa23,
+  VLOAD_32(v16, 0xbdea964b, 0xbeec337c, 0x3d8ecd5a, 0x3e513348, 0xbf78aa23,
            0xbf750ad1, 0xbde66b52, 0x3ef81768, 0x3f18b852, 0x3eede3e4,
            0x3e09b44f, 0xbea405df, 0x3f404d9d, 0x3f680635, 0x3f3c4b51,
            0xbf091a38);
@@ -299,18 +299,18 @@ void TEST_CASE4(void) {
   //                               0.94017404
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x3f70af3f);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmul.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v8);
+  asm volatile("vfmul.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.00000000, -0.43373078,  0.00000000,  0.19207491,
   //                0.00000000, -0.89993113,  0.00000000,  0.45556471,
   //                0.00000000,  0.43683240,  0.00000000, -0.30119160,
   //                0.00000000,  0.85212177,  0.00000000, -0.50351614
-  VCMP_U32(11, v2, 0x0, 0xbede11f6, 0x0, 0x3e44af49, 0x0, 0xbf6661e3, 0x0,
+  VCMP_U32(11, v8, 0x0, 0xbede11f6, 0x0, 0x3e44af49, 0x0, 0xbf6661e3, 0x0,
            0x3ee93fc7, 0x0, 0x3edfa87f, 0x0, 0xbe9a35c9, 0x0, 0x3f5a24a7, 0x0,
            0xbf00e66f);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                -0.3344965024132001, -0.2497404698970234,
   //                0.3402338726452623, -0.5885400342262450,
   //                -0.7135559920290824,  0.1114442794173345,
@@ -319,7 +319,7 @@ void TEST_CASE4(void) {
   //                -0.2701320849999789,  0.3582375365191053,
   //                -0.6137661452178358,  0.6195430637830983,
   //                0.2731869234335833, -0.4075196944877124
-  VLOAD_64(v4, 0xbfd56864049f6dd8, 0xbfcff77ee7590278, 0x3fd5c6644b002e60,
+  VLOAD_64(v16, 0xbfd56864049f6dd8, 0xbfcff77ee7590278, 0x3fd5c6644b002e60,
            0xbfe2d551e8ec6e20, 0xbfe6d573603426e0, 0x3fbc879cbf6c7a10,
            0xbfee8882889e1c44, 0x3fba27adf853b5f0, 0xbfc177db63eceed0,
            0xbfedec94daa41aac, 0xbfd149d815ab3680, 0x3fd6ed5d21e3257c,
@@ -329,8 +329,8 @@ void TEST_CASE4(void) {
   //                               -0.7970907277742201
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfe981c469f7860e);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfmul.vf v2, v4, %[A], v0.t" ::[A] "f"(dscalar_64));
+  VCLEAR(v8);
+  asm volatile("vfmul.vf v8, v16, %[A], v0.t" ::[A] "f"(dscalar_64));
   //                0.0000000000000000,  0.1990658129048941, 0.0000000000000000,
   //                0.4691198042056620,  0.0000000000000000,
   //                -0.0888312017870367,  0.0000000000000000,
@@ -338,7 +338,7 @@ void TEST_CASE4(void) {
   //                0.7453831118261137,  0.0000000000000000,
   //                -0.2855478187000574,  0.0000000000000000,
   //                -0.4938320315983399,  0.0000000000000000, 0.3248301698615385
-  VCMP_U64(12, v2, 0x0, 0x3fc97afd1216ce6e, 0x0, 0x3fde060f123e080e, 0x0,
+  VCMP_U64(12, v8, 0x0, 0x3fc97afd1216ce6e, 0x0, 0x3fde060f123e080e, 0x0,
            0xbfb6bda4428a29bb, 0x0, 0xbfb4d91068f88b49, 0x0, 0x3fe7da2daf091575,
            0x0, 0xbfd2466a5bb0b251, 0x0, 0xbfdf9af1aa5ba7aa, 0x0,
            0x3fd4ca047b13cdbf);
diff --git a/sw/riscvTests/isa/rv64uv/vfmv.c b/sw/riscvTests/isa/rv64uv/vfmv.c
index 3f12dec3..03ae30ef 100644
--- a/sw/riscvTests/isa/rv64uv/vfmv.c
+++ b/sw/riscvTests/isa/rv64uv/vfmv.c
@@ -10,48 +10,48 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                            -0.9380
   BOX_HALF_IN_FLOAT(fscalar_16, 0xbb81);
-  VCLEAR(v2);
-  asm volatile("vfmv.v.f v2, %[A]" ::[A] "f"(fscalar_16));
+  VCLEAR(v8);
+  asm volatile("vfmv.v.f v8, %[A]" ::[A] "f"(fscalar_16));
   //              -0.9380, -0.9380, -0.9380, -0.9380, -0.9380, -0.9380, -0.9380,
   //              -0.9380, -0.9380, -0.9380, -0.9380, -0.9380, -0.9380, -0.9380,
   //              -0.9380, -0.9380
-  VCMP_U16(1, v2, 0xbb81, 0xbb81, 0xbb81, 0xbb81, 0xbb81, 0xbb81, 0xbb81,
+  VCMP_U16(1, v8, 0xbb81, 0xbb81, 0xbb81, 0xbb81, 0xbb81, 0xbb81, 0xbb81,
            0xbb81, 0xbb81, 0xbb81, 0xbb81, 0xbb81, 0xbb81, 0xbb81, 0xbb81,
            0xbb81);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                             -0.96056187
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbf75e762);
-  VCLEAR(v2);
-  asm volatile("vfmv.v.f v2, %[A]" ::[A] "f"(fscalar_32));
+  VCLEAR(v8);
+  asm volatile("vfmv.v.f v8, %[A]" ::[A] "f"(fscalar_32));
   //               -0.96056187, -0.96056187, -0.96056187, -0.96056187,
   //               -0.96056187, -0.96056187, -0.96056187, -0.96056187,
   //               -0.96056187, -0.96056187, -0.96056187, -0.96056187,
   //               -0.96056187, -0.96056187, -0.96056187, -0.96056187
-  VCMP_U32(2, v2, 0xbf75e762, 0xbf75e762, 0xbf75e762, 0xbf75e762, 0xbf75e762,
+  VCMP_U32(2, v8, 0xbf75e762, 0xbf75e762, 0xbf75e762, 0xbf75e762, 0xbf75e762,
            0xbf75e762, 0xbf75e762, 0xbf75e762, 0xbf75e762, 0xbf75e762,
            0xbf75e762, 0xbf75e762, 0xbf75e762, 0xbf75e762, 0xbf75e762,
            0xbf75e762);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                               0.9108707261227378
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fed25da5d7296fe);
-  VCLEAR(v2);
-  asm volatile("vfmv.v.f v2, %[A]" ::[A] "f"(dscalar_64));
+  VCLEAR(v8);
+  asm volatile("vfmv.v.f v8, %[A]" ::[A] "f"(dscalar_64));
   //                0.9108707261227378,  0.9108707261227378, 0.9108707261227378,
   //                0.9108707261227378,  0.9108707261227378, 0.9108707261227378,
   //                0.9108707261227378,  0.9108707261227378, 0.9108707261227378,
   //                0.9108707261227378,  0.9108707261227378, 0.9108707261227378,
   //                0.9108707261227378,  0.9108707261227378, 0.9108707261227378,
   //                0.9108707261227378
-  VCMP_U64(3, v2, 0x3fed25da5d7296fe, 0x3fed25da5d7296fe, 0x3fed25da5d7296fe,
+  VCMP_U64(3, v8, 0x3fed25da5d7296fe, 0x3fed25da5d7296fe, 0x3fed25da5d7296fe,
            0x3fed25da5d7296fe, 0x3fed25da5d7296fe, 0x3fed25da5d7296fe,
            0x3fed25da5d7296fe, 0x3fed25da5d7296fe, 0x3fed25da5d7296fe,
            0x3fed25da5d7296fe, 0x3fed25da5d7296fe, 0x3fed25da5d7296fe,
diff --git a/sw/riscvTests/isa/rv64uv/vfncvt.c b/sw/riscvTests/isa/rv64uv/vfncvt.c
index 40cd48b5..1e7f7874 100644
--- a/sw/riscvTests/isa/rv64uv/vfncvt.c
+++ b/sw/riscvTests/isa/rv64uv/vfncvt.c
@@ -19,11 +19,11 @@ void TEST_CASE1(void) {
   //                -6826.076,  -6976.746,   2675.899,   9587.624, -3671.810,
   //                3611.960, -9086.531, -5333.617, -3284.205,   5676.141,
   //                -8293.472
-  VLOAD_32(v4, 0x460f36ad, 0x45ab810c, 0x479c8d06, 0xc59cf316, 0x45dfd8be,
+  VLOAD_32(v16, 0x460f36ad, 0x45ab810c, 0x479c8d06, 0xc59cf316, 0x45dfd8be,
            0xc5d5509c, 0xc5da05f8, 0x45273e62, 0x4615ce7f, 0xc5657cf5,
            0x4561bf5b, 0xc60dfa20, 0xc5a6acf0, 0xc54d4347, 0x45b16120,
            0xc60195e3);
-  asm volatile("vfncvt.xu.f.w v8, v4");
+  asm volatile("vfncvt.xu.f.w v8, v16");
   //                    9166,       5488,      65535,          0,       7163, 0,
   //                    0,       2676,       9588,          0,       3612, 0, 0,
   //                    0,       5676,          0
@@ -37,13 +37,13 @@ void TEST_CASE1(void) {
   //              -5056868.769,   4282070.604,   458667.918,   8393053.957,
   //              -4485003.775, -5016427.098, -9086965.507, -6796529.257,
   //              -7756776.890, -1173384.460,   4850684.145,   8658279.578
-  VLOAD_64(v4, 0xc14ac53f4813ac38, 0x41399b7a6ae9e42f, 0xc128660783332e44,
+  VLOAD_64(v16, 0xc14ac53f4813ac38, 0x41399b7a6ae9e42f, 0xc128660783332e44,
            0x413a0e9c6ddfa609, 0xc1534a59313a407b, 0x415055b5a6a655de,
            0x411bfeafabb28b3f, 0x4160022bbe9fc5e9, 0xc1511be2f1a1ac8b,
            0xc15322dac64b7c31, 0xc16154feb0372db3, 0xc159ed3c506ab6eb,
            0xc15d96fa38fb0400, 0xc131e78875bc4ace, 0x415280ff09493a97,
            0x416083acf280b61e);
-  asm volatile("vfncvt.xu.f.w v8, v4");
+  asm volatile("vfncvt.xu.f.w v8, v16");
   //                           0,        1678202,              0, 1707676, 0,
   //                           4282071,         458668,        8393054, 0, 0, 0,
   //                           0,              0,              0, 4850684,
@@ -63,13 +63,13 @@ void TEST_CASE2(void) {
   //                    7163.093, -6826.076, -6976.746,   2675.899,   9587.624,
   //                    -3671.810,   3611.960, -9086.531, -5333.617, -3284.205,
   //                    5676.141, -8293.472
-  VLOAD_32(v4, 0x460f36ad, 0x45ab810c, 0xc4ce09ad, 0xc59cf316, 0x45dfd8be,
+  VLOAD_32(v16, 0x460f36ad, 0x45ab810c, 0xc4ce09ad, 0xc59cf316, 0x45dfd8be,
            0xc5d5509c, 0xc5da05f8, 0x45273e62, 0x4615ce7f, 0xc5657cf5,
            0x4561bf5b, 0xc60dfa20, 0xc5a6acf0, 0xc54d4347, 0x45b16120,
            0xc60195e3);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.xu.f.w v8, v4, v0.t");
+  asm volatile("vfncvt.xu.f.w v8, v16, v0.t");
   //                       0,       5488,          0,          0,          0, 0,
   //                       0,       2676,          0,          0,          0, 0,
   //                       0,          0,          0,          0
@@ -85,7 +85,7 @@ void TEST_CASE2(void) {
   //                        -5016427.098, -9086965.507, -6796529.257,
   //                        -7756776.890, -1173384.460,   4850684.145,
   //                        8658279.578
-  VLOAD_64(v4, 0xc14ac53f4813ac38, 0x41399b7a6ae9e42f, 0xc128660783332e44,
+  VLOAD_64(v16, 0xc14ac53f4813ac38, 0x41399b7a6ae9e42f, 0xc128660783332e44,
            0x413a0e9c6ddfa609, 0xc1534a59313a407b, 0x415055b5a6a655de,
            0x411bfeafabb28b3f, 0x4160022bbe9fc5e9, 0xc1511be2f1a1ac8b,
            0xc15322dac64b7c31, 0xc16154feb0372db3, 0xc159ed3c506ab6eb,
@@ -93,7 +93,7 @@ void TEST_CASE2(void) {
            0x416083acf280b61e);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.xu.f.w v8, v4, v0.t");
+  asm volatile("vfncvt.xu.f.w v8, v16, v0.t");
   //                           0,        1678202,              0, 1707676, 0,
   //                           4282071,              0,        8393054, 0, 0, 0,
   //                           0,              0,              0, 0, 8658280
@@ -115,11 +115,11 @@ void TEST_CASE3(void) {
   //              9676.333,   6963.966,   3589.870, -4334.772, -3261.309,
   //              -2340.480,   6085.075,   4043.322,   2827.902,   4389.497,
   //              -5196.684
-  VLOAD_32(v4, 0xc5f40072, 0x461195a2, 0x44d2bc86, 0x4578798a, 0xc5bad0dd,
+  VLOAD_32(v16, 0xc5f40072, 0x461195a2, 0x44d2bc86, 0x4578798a, 0xc5bad0dd,
            0x46173155, 0x45d99fbb, 0x45605ded, 0xc587762e, 0xc54bd4f0,
            0xc51247af, 0x45be2899, 0x457cb528, 0x4530be6f, 0x45892bfa,
            0xc5a26578);
-  asm volatile("vfncvt.x.f.w v8, v4");
+  asm volatile("vfncvt.x.f.w v8, v16");
   //                   -7808,       9317,       1686,       3976,      -5978,
   //                   9676,       6964,       3590,      -4335,      -3261,
   //                   -2340,       6085,       4043,       2828,       4389,
@@ -134,13 +134,13 @@ void TEST_CASE3(void) {
   //                -9624608.750, -6974543.165,   5868078.422, -5387798.170,
   //                3847378.080,   1368753.124,   4380497.931, -8044304.268,
   //                1687738.849,   3753399.509, -3684410.483, -7416477.444
-  VLOAD_64(v4, 0x415477e8714aea69, 0xc15cda91b6eefd56, 0x415ebb605a479cd5,
+  VLOAD_64(v16, 0x415477e8714aea69, 0xc15cda91b6eefd56, 0x415ebb605a479cd5,
            0xc142d4e5a0a1f367, 0xc1625b841802ee1d, 0xc15a9b13ca8c7bb6,
            0x4156628b9afacdc9, 0xc1548d858ae6df86, 0x414d5a690a2dbb5e,
            0x4134e2b11fa8e994, 0x4150b5d47b9c3df2, 0xc15eafc4112995f5,
            0x4139c0bad971859a, 0x414ca2dbc1288a12, 0xc14c1c1d3dcd1b39,
            0xc15c4aa75c6c5635);
-  asm volatile("vfncvt.x.f.w v8, v4");
+  asm volatile("vfncvt.x.f.w v8, v16");
   //                     5365666,       -7563847,        8056193, -2468299,
   //                     -9624609,       -6974543,        5868078, -5387798,
   //                     3847378,        1368753,        4380498, -8044304,
@@ -160,13 +160,13 @@ void TEST_CASE4(void) {
   //              9676.333,   6963.966,   3589.870, -4334.772, -3261.309,
   //              -2340.480,   6085.075,   4043.322,   2827.902,   4389.497,
   //              -5196.684
-  VLOAD_32(v4, 0xc5f40072, 0x461195a2, 0x44d2bc86, 0x4578798a, 0xc5bad0dd,
+  VLOAD_32(v16, 0xc5f40072, 0x461195a2, 0x44d2bc86, 0x4578798a, 0xc5bad0dd,
            0x46173155, 0x45d99fbb, 0x45605ded, 0xc587762e, 0xc54bd4f0,
            0xc51247af, 0x45be2899, 0x457cb528, 0x4530be6f, 0x45892bfa,
            0xc5a26578);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.x.f.w v8, v4, v0.t");
+  asm volatile("vfncvt.x.f.w v8, v16, v0.t");
   //                       0,       9317,          0,       3976,          0,
   //                       9676,          0,       3590,          0,      -3261,
   //                       0,       6085,          0,       2828,          0,
@@ -181,7 +181,7 @@ void TEST_CASE4(void) {
   //                -9624608.750, -6974543.165,   5868078.422, -5387798.170,
   //                3847378.080,   1368753.124,   4380497.931, -8044304.268,
   //                1687738.849,   3753399.509, -3684410.483, -7416477.444
-  VLOAD_64(v4, 0x415477e8714aea69, 0xc15cda91b6eefd56, 0x415ebb605a479cd5,
+  VLOAD_64(v16, 0x415477e8714aea69, 0xc15cda91b6eefd56, 0x415ebb605a479cd5,
            0xc142d4e5a0a1f367, 0xc1625b841802ee1d, 0xc15a9b13ca8c7bb6,
            0x4156628b9afacdc9, 0xc1548d858ae6df86, 0x414d5a690a2dbb5e,
            0x4134e2b11fa8e994, 0x4150b5d47b9c3df2, 0xc15eafc4112995f5,
@@ -189,7 +189,7 @@ void TEST_CASE4(void) {
            0xc15c4aa75c6c5635);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.x.f.w v8, v4, v0.t");
+  asm volatile("vfncvt.x.f.w v8, v16, v0.t");
   //                           0,       -7563847,              0, -2468299, 0,
   //                           -6974543,              0,       -5387798, 0,
   //                           1368753,              0,       -8044304, 0,
@@ -212,11 +212,11 @@ void TEST_CASE5(void) {
   //              6670.171, -4079.234, -1773.082,   254.350,   53.058,
   //              -9041.926, -8137.022,   1522.146,   198.516, -920.430,
   //              2857.583
-  VLOAD_32(v4, 0xc6185902, 0xc5885de3, 0xc51299d6, 0x45daa07e, 0xc5de5808,
+  VLOAD_32(v16, 0xc6185902, 0xc5885de3, 0xc51299d6, 0x45daa07e, 0xc5de5808,
            0x45d0715e, 0xc57ef3bf, 0xc4dda29c, 0x437e5998, 0x42543afb,
            0xc60d47b4, 0xc5fe482e, 0x44be44af, 0x43468433, 0xc4661b8b,
            0x45329953);
-  asm volatile("vfncvt.rtz.xu.f.w v8, v4");
+  asm volatile("vfncvt.rtz.xu.f.w v8, v16");
   //                       0,          0,          0,       6996,          0,
   //                       6670,          0,          0,        254,         53,
   //                       0,          0,       1522,        198,          0,
@@ -231,13 +231,13 @@ void TEST_CASE5(void) {
   //              5750957.328, -7243911.338, -8202847.045,   5348152.868,
   //              9957770.965,   8018962.598, -8478197.842, -9780786.953,
   //              184470.081,   250336.923, -6517203.475, -7691903.192
-  VLOAD_64(v4, 0xc16007d978438b7f, 0x414bad2ac51eade4, 0xc150aa777763eeda,
+  VLOAD_64(v16, 0xc16007d978438b7f, 0x414bad2ac51eade4, 0xc150aa777763eeda,
            0xc146008fcfc2093b, 0x4155f02b54fbd105, 0xc15ba221d5a4f5c3,
            0xc15f4a97c2e2daa6, 0x415466ce378e9269, 0x4162fe315edeecec,
            0x415e9704a64d845e, 0xc1602bbebaf40bb8, 0xc162a7c65e8002a9,
            0x410684b0a4ee482d, 0x410e8f07623ffd06, 0xc158dc74de617fbc,
            0xc15d579fcc41ba16);
-  asm volatile("vfncvt.rtz.xu.f.w v8, v4");
+  asm volatile("vfncvt.rtz.xu.f.w v8, v16");
   //                           0,        3627605,              0, 0, 5750957, 0,
   //                           0,        5348152,        9957770, 8018962, 0, 0,
   //                           184470,         250336,              0, 0
@@ -256,13 +256,13 @@ void TEST_CASE6(void) {
   //              6670.171, -4079.234, -1773.082,   254.350,   53.058,
   //              -9041.926, -8137.022,   1522.146,   198.516, -920.430,
   //              2857.583
-  VLOAD_32(v4, 0xc6185902, 0xc5885de3, 0xc51299d6, 0x45daa07e, 0xc5de5808,
+  VLOAD_32(v16, 0xc6185902, 0xc5885de3, 0xc51299d6, 0x45daa07e, 0xc5de5808,
            0x45d0715e, 0xc57ef3bf, 0xc4dda29c, 0x437e5998, 0x42543afb,
            0xc60d47b4, 0xc5fe482e, 0x44be44af, 0x43468433, 0xc4661b8b,
            0x45329953);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.rtz.xu.f.w v8, v4, v0.t");
+  asm volatile("vfncvt.rtz.xu.f.w v8, v16, v0.t");
   //                       0,          0,          0,       6996,          0,
   //                       6670,          0,          0,          0,         53,
   //                       0,          0,          0,        198,          0,
@@ -277,7 +277,7 @@ void TEST_CASE6(void) {
   //              5750957.328, -7243911.338, -8202847.045,   5348152.868,
   //              9957770.965,   8018962.598, -8478197.842, -9780786.953,
   //              184470.081,   250336.923, -6517203.475, -7691903.192
-  VLOAD_64(v4, 0xc16007d978438b7f, 0x414bad2ac51eade4, 0xc150aa777763eeda,
+  VLOAD_64(v16, 0xc16007d978438b7f, 0x414bad2ac51eade4, 0xc150aa777763eeda,
            0xc146008fcfc2093b, 0x4155f02b54fbd105, 0xc15ba221d5a4f5c3,
            0xc15f4a97c2e2daa6, 0x415466ce378e9269, 0x4162fe315edeecec,
            0x415e9704a64d845e, 0xc1602bbebaf40bb8, 0xc162a7c65e8002a9,
@@ -285,7 +285,7 @@ void TEST_CASE6(void) {
            0xc15d579fcc41ba16);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.rtz.xu.f.w v8, v4, v0.t");
+  asm volatile("vfncvt.rtz.xu.f.w v8, v16, v0.t");
   //                           0,        3627605,              0, 0, 0, 0, 0,
   //                           5348152,              0,        8018962, 0, 0, 0,
   //                           250336,              0,              0
@@ -307,11 +307,11 @@ void TEST_CASE7(void) {
   //                -5717.140, -3327.545,   1286.004,   1797.767,   3842.966,
   //                -2148.369, -7283.256,   8783.331, -7958.880, -6728.271,
   //                4727.792
-  VLOAD_32(v4, 0x461221ac, 0xc5b2bbac, 0x45904e86, 0xc53c4026, 0xc560d104,
+  VLOAD_32(v16, 0x461221ac, 0xc5b2bbac, 0x45904e86, 0xc53c4026, 0xc560d104,
            0xc5b2a91e, 0xc54ff8b9, 0x44a0c01e, 0x44e0b88c, 0x45702f76,
            0xc50645e9, 0xc5e39a0c, 0x46093d53, 0xc5f8b70a, 0xc5d2422c,
            0x4593be56);
-  asm volatile("vfncvt.rtz.x.f.w v8, v4");
+  asm volatile("vfncvt.rtz.x.f.w v8, v16");
   //                    9352,      -5719,       4617,      -3012,      -3597,
   //                    -5717,      -3327,       1286,       1797,       3842,
   //                    -2148,      -7283,       8783,      -7958,      -6728,
@@ -326,13 +326,13 @@ void TEST_CASE7(void) {
   //                9551708.952, -336377.787, -2352111.643,   4412162.570,
   //                7087155.475,   338850.875,   2765611.498,   2723631.912,
   //                -3252079.308,   1096915.326,   5492109.280, -7265880.245
-  VLOAD_64(v4, 0x4137db9a42b839bd, 0xc13e596598118127, 0x4158c7d738d1eec8,
+  VLOAD_64(v16, 0x4137db9a42b839bd, 0xc13e596598118127, 0x4158c7d738d1eec8,
            0x4153484eb13573ed, 0x416237eb9e79d2a8, 0xc11487e725f1ce50,
            0xc141f1f7d2451c3d, 0x4150d4c0a47be906, 0x415b090cde6b0575,
            0x4114ae8b8081532d, 0x41451995bfc3bc74, 0x4144c797f4b307dd,
            0xc148cfb7a76dea0f, 0x4130bcd353667e5d, 0x4154f36351f3a3c5,
            0xc15bb7960fb007a5);
-  asm volatile("vfncvt.rtz.x.f.w v8, v4");
+  asm volatile("vfncvt.rtz.x.f.w v8, v16");
   //                     1563546,       -1988965,        6496092, 5054778,
   //                     9551708,        -336377,       -2352111, 4412162,
   //                     7087155,         338850,        2765611, 2723631,
@@ -352,13 +352,13 @@ void TEST_CASE8(void) {
   //                -5717.140, -3327.545,   1286.004,   1797.767,   3842.966,
   //                -2148.369, -7283.256,   8783.331, -7958.880, -6728.271,
   //                4727.792
-  VLOAD_32(v4, 0x461221ac, 0xc5b2bbac, 0x45904e86, 0xc53c4026, 0xc560d104,
+  VLOAD_32(v16, 0x461221ac, 0xc5b2bbac, 0x45904e86, 0xc53c4026, 0xc560d104,
            0xc5b2a91e, 0xc54ff8b9, 0x44a0c01e, 0x44e0b88c, 0x45702f76,
            0xc50645e9, 0xc5e39a0c, 0x46093d53, 0xc5f8b70a, 0xc5d2422c,
            0x4593be56);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.rtz.x.f.w v8, v4, v0.t");
+  asm volatile("vfncvt.rtz.x.f.w v8, v16, v0.t");
   //                       0,      -5719,          0,      -3012,          0,
   //                       -5717,          0,       1286,          0, 3842, 0,
   //                       -7283,          0,      -7958,          0,       4727
@@ -372,7 +372,7 @@ void TEST_CASE8(void) {
   //                9551708.952, -336377.787, -2352111.643,   4412162.570,
   //                7087155.475,   338850.875,   2765611.498,   2723631.912,
   //                -3252079.308,   1096915.326,   5492109.280, -7265880.245
-  VLOAD_64(v4, 0x4137db9a42b839bd, 0xc13e596598118127, 0x4158c7d738d1eec8,
+  VLOAD_64(v16, 0x4137db9a42b839bd, 0xc13e596598118127, 0x4158c7d738d1eec8,
            0x4153484eb13573ed, 0x416237eb9e79d2a8, 0xc11487e725f1ce50,
            0xc141f1f7d2451c3d, 0x4150d4c0a47be906, 0x415b090cde6b0575,
            0x4114ae8b8081532d, 0x41451995bfc3bc74, 0x4144c797f4b307dd,
@@ -380,7 +380,7 @@ void TEST_CASE8(void) {
            0xc15bb7960fb007a5);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.rtz.x.f.w v8, v4, v0.t");
+  asm volatile("vfncvt.rtz.x.f.w v8, v16, v0.t");
   //                           0,       -1988965,              0, 5054778, 0,
   //                           -336377,              0,        4412162, 0,
   //                           338850,              0,        2723631, 0,
@@ -403,11 +403,11 @@ void TEST_CASE9(void) {
   //                 1637,       3984,    4294964217,       9553,    4294962615,
   //                 4294962166,       9867,    4294958580,    4294966752, 5172,
   //                 7478
-  VLOAD_32(v4, 0xfffff3d2, 0x000016dd, 0xffffedce, 0xffffeba2, 0x000011e9,
+  VLOAD_32(v16, 0xfffff3d2, 0x000016dd, 0xffffedce, 0xffffeba2, 0x000011e9,
            0x00000665, 0x00000f90, 0xfffff3f9, 0x00002551, 0xffffedb7,
            0xffffebf6, 0x0000268b, 0xffffddf4, 0xfffffde0, 0x00001434,
            0x00001d36);
-  asm volatile("vfncvt.f.xu.w v8, v4");
+  asm volatile("vfncvt.f.xu.w v8, v16");
   //                     inf,   5852.000,   inf,   inf,   4584.000,   1637.000,
   //                     3984.000,   inf,   9552.000,   inf,   inf,   9864.000,
   //                     inf,   inf,   5172.000,   7480.000
@@ -423,13 +423,13 @@ void TEST_CASE9(void) {
   //                 18446744073705977615,    18446744073704792883,
   //                 18446744073704699584,        8685460, 18446744073709143843,
   //                 18446744073703142874,        3905530, 18446744073704152149
-  VLOAD_64(v4, 0xffffffffffb80822, 0xfffffffffff960b9, 0xffffffffffc84e30,
+  VLOAD_64(v16, 0xffffffffffb80822, 0xfffffffffff960b9, 0xffffffffffc84e30,
            0x00000000001fd673, 0xffffffffff69013c, 0x00000000000e3ba3,
            0x000000000003e709, 0x000000000030090f, 0xffffffffffc9770f,
            0xffffffffffb76333, 0xffffffffffb5f6c0, 0x0000000000848794,
            0xfffffffffff9c723, 0xffffffffff9e35da, 0x00000000003b97fa,
            0xffffffffffad9c55);
-  asm volatile("vfncvt.f.xu.w v8, v4");
+  asm volatile("vfncvt.f.xu.w v8, v16");
   //                18446744073709551616.000,   18446744073709551616.000,
   //                18446744073709551616.000,   2086515.000,
   //                18446744073709551616.000,   932771.000,   255753.000,
@@ -453,13 +453,13 @@ void TEST_CASE10(void) {
   //                 1637,       3984,    4294964217,       9553,    4294962615,
   //                 4294962166,       9867,    4294958580,    4294966752, 5172,
   //                 7478
-  VLOAD_32(v4, 0xfffff3d2, 0x000016dd, 0xffffedce, 0xffffeba2, 0x000011e9,
+  VLOAD_32(v16, 0xfffff3d2, 0x000016dd, 0xffffedce, 0xffffeba2, 0x000011e9,
            0x00000665, 0x00000f90, 0xfffff3f9, 0x00002551, 0xffffedb7,
            0xffffebf6, 0x0000268b, 0xffffddf4, 0xfffffde0, 0x00001434,
            0x00001d36);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.f.xu.w v8, v4, v0.t");
+  asm volatile("vfncvt.f.xu.w v8, v16, v0.t");
   //                0.000,   5852.000,   0.000,   inf,   0.000,   1637.000,
   //                0.000,   inf,   0.000,   inf,   0.000,   9864.000,   0.000,
   //                inf,   0.000,   7480.000
@@ -474,7 +474,7 @@ void TEST_CASE10(void) {
   //                 18446744073705977615,    18446744073704792883,
   //                 18446744073704699584,        8685460, 18446744073709143843,
   //                 18446744073703142874,        3905530, 18446744073704152149
-  VLOAD_64(v4, 0xffffffffffb80822, 0xfffffffffff960b9, 0xffffffffffc84e30,
+  VLOAD_64(v16, 0xffffffffffb80822, 0xfffffffffff960b9, 0xffffffffffc84e30,
            0x00000000001fd673, 0xffffffffff69013c, 0x00000000000e3ba3,
            0x000000000003e709, 0x000000000030090f, 0xffffffffffc9770f,
            0xffffffffffb76333, 0xffffffffffb5f6c0, 0x0000000000848794,
@@ -482,7 +482,7 @@ void TEST_CASE10(void) {
            0xffffffffffad9c55);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.f.xu.w v8, v4, v0.t");
+  asm volatile("vfncvt.f.xu.w v8, v16, v0.t");
   //                0.000,   18446744073709551616.000,   0.000,   2086515.000,
   //                0.000,   932771.000,   0.000,   3148047.000,   0.000,
   //                18446744073709551616.000,   0.000,   8685460.000,   0.000,
@@ -504,11 +504,11 @@ void TEST_CASE11(void) {
   //                       3851,       5592,      -3692,      -2747,       -748,
   //                       -2621,      -9352,       4018,       3174, -6975,
   //                       -4466
-  VLOAD_32(v4, 0xffffe779, 0x00000e85, 0x0000233e, 0xffffdd23, 0xffffea66,
+  VLOAD_32(v16, 0xffffe779, 0x00000e85, 0x0000233e, 0xffffdd23, 0xffffea66,
            0x00000f0b, 0x000015d8, 0xfffff194, 0xfffff545, 0xfffffd14,
            0xfffff5c3, 0xffffdb78, 0x00000fb2, 0x00000c66, 0xffffe4c1,
            0xffffee8e);
-  asm volatile("vfncvt.f.x.w v8, v4");
+  asm volatile("vfncvt.f.x.w v8, v16");
   //                -6280.000,   3716.000,   9024.000,  -8928.000,  -5528.000,
   //                3852.000,   5592.000, -3692.000, -2748.000, -748.000,
   //                -2620.000, -9352.000,   4018.000,   3174.000, -6976.000,
@@ -525,13 +525,13 @@ void TEST_CASE11(void) {
   //                              4475248,       -2937762,        3310433,
   //                              9151745,       -2201488,       -1506850,
   //                              1593161
-  VLOAD_64(v4, 0x00000000000b8d6b, 0xffffffffff7117cd, 0x00000000002e090d,
+  VLOAD_64(v16, 0x00000000000b8d6b, 0xffffffffff7117cd, 0x00000000002e090d,
            0xffffffffff72714f, 0xffffffffff8094ea, 0xfffffffffff61394,
            0xffffffffffe4e9c8, 0x00000000004717ac, 0x000000000002445d,
            0x0000000000444970, 0xffffffffffd32c5e, 0x0000000000328361,
            0x00000000008ba501, 0xffffffffffde6870, 0xffffffffffe901de,
            0x0000000000184f49);
-  asm volatile("vfncvt.f.x.w v8, v4");
+  asm volatile("vfncvt.f.x.w v8, v16");
   //                   757099.000, -9365555.000,   3016973.000, -9277105.000,
   //                   -8350486.000, -650348.000, -1775160.000,   4659116.000,
   //                   148573.000,   4475248.000, -2937762.000,   3310433.000,
@@ -551,13 +551,13 @@ void TEST_CASE12(void) {
   //                   3851,       5592,      -3692,      -2747,       -748,
   //                   -2621,      -9352,       4018,       3174,      -6975,
   //                   -4466
-  VLOAD_32(v4, 0xffffe779, 0x00000e85, 0x0000233e, 0xffffdd23, 0xffffea66,
+  VLOAD_32(v16, 0xffffe779, 0x00000e85, 0x0000233e, 0xffffdd23, 0xffffea66,
            0x00000f0b, 0x000015d8, 0xfffff194, 0xfffff545, 0xfffffd14,
            0xfffff5c3, 0xffffdb78, 0x00000fb2, 0x00000c66, 0xffffe4c1,
            0xffffee8e);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.f.x.w v8, v4, v0.t");
+  asm volatile("vfncvt.f.x.w v8, v16, v0.t");
   //                0.000,   3716.000,   0.000, -8928.000,   0.000,   3852.000,
   //                0.000, -3692.000,   0.000, -748.000,   0.000, -9352.000,
   //                0.000,   3174.000,   0.000, -4464.000
@@ -570,7 +570,7 @@ void TEST_CASE12(void) {
   //                      -8350486,        -650348,       -1775160, 4659116,
   //                      148573,        4475248,       -2937762, 3310433,
   //                      9151745,       -2201488,       -1506850, 1593161
-  VLOAD_64(v4, 0x00000000000b8d6b, 0xffffffffff7117cd, 0x00000000002e090d,
+  VLOAD_64(v16, 0x00000000000b8d6b, 0xffffffffff7117cd, 0x00000000002e090d,
            0xffffffffff72714f, 0xffffffffff8094ea, 0xfffffffffff61394,
            0xffffffffffe4e9c8, 0x00000000004717ac, 0x000000000002445d,
            0x0000000000444970, 0xffffffffffd32c5e, 0x0000000000328361,
@@ -578,7 +578,7 @@ void TEST_CASE12(void) {
            0x0000000000184f49);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.f.x.w v8, v4, v0.t");
+  asm volatile("vfncvt.f.x.w v8, v16, v0.t");
   //                0.000, -9365555.000,   0.000, -9277105.000,   0.000,
   //                -650348.000,   0.000,   4659116.000,   0.000,   4475248.000,
   //                0.000,   3310433.000,   0.000, -2201488.000,   0.000,
@@ -599,11 +599,11 @@ void TEST_CASE13(void) {
   //              908.994, -6788.630, -5789.335, 8054.104, 3947.551, 9596.856,
   //              2474.506, 3094.286, 7684.992, -6850.149, -54.922, 7737.443,
   //              4171.873, 5266.611, 9163.839, 5679.187
-  VLOAD_32(v4, 0x44633fa3, 0xc5d4250b, 0xc5b4eaaf, 0x45fbb0d4, 0x4576b8d0,
+  VLOAD_32(v16, 0x44633fa3, 0xc5d4250b, 0xc5b4eaaf, 0x45fbb0d4, 0x4576b8d0,
            0x4615f36d, 0x451aa818, 0x45416494, 0x45f027ef, 0xc5d61131,
            0xc25bb026, 0x45f1cb8c, 0x45825efb, 0x45a494e4, 0x460f2f5b,
            0x45b1797f);
-  asm volatile("vfncvt.f.f.w v8, v4");
+  asm volatile("vfncvt.f.f.w v8, v16");
   //              909.000, -6788.000, -5788.000, 8056.000, 3948.000, 9600.000,
   //              2474.000, 3094.000, 7684.000, -6852.000, -54.938, 7736.000,
   //              4172.000, 5268.000, 9160.000, 5680.000
@@ -617,13 +617,13 @@ void TEST_CASE13(void) {
   //              7538298.328, -8731739.480, 537176.622, -3884944.157,
   //              7612336.042, -2270131.404, -4976406.726, -5260237.163,
   //              -4947737.810, 3583352.355, 7648790.331, -9360989.228
-  VLOAD_64(v4, 0x4102babe20435c2f, 0xc15dbd4abd4015a9, 0xc15960e30c871450,
+  VLOAD_64(v16, 0x4102babe20435c2f, 0xc15dbd4abd4015a9, 0xc15960e30c871450,
            0x41300472c1efbd9f, 0x415cc19e94ffb79b, 0xc160a78b6f5bcd25,
            0x412064b13e931aa9, 0xc14da3c81425b914, 0x415d09ec02a8cc93,
            0xc14151d9b3c1ecaf, 0xc152fbc5ae718384, 0xc15410f34a6ddb48,
            0xc152dfc673d9ba53, 0x414b56bc2d765fad, 0x415d2d85952e8398,
            0xc161dacba74d791e);
-  asm volatile("vfncvt.f.f.w v8, v4");
+  asm volatile("vfncvt.f.f.w v8, v16");
   //              153431.766, -7796011.000, -6652812.000, 1049714.750,
   //              7538298.500, -8731739.000, 537176.625, -3884944.250,
   //              7612336.000, -2270131.500, -4976406.500, -5260237.000,
@@ -642,13 +642,13 @@ void TEST_CASE14(void) {
   //              908.994, -6788.630, -5789.335, 8054.104, 3947.551, 9596.856,
   //              2474.506, 3094.286, 7684.992, -6850.149, -54.922, 7737.443,
   //              4171.873, 5266.611, 9163.839, 5679.187
-  VLOAD_32(v4, 0x44633fa3, 0xc5d4250b, 0xc5b4eaaf, 0x45fbb0d4, 0x4576b8d0,
+  VLOAD_32(v16, 0x44633fa3, 0xc5d4250b, 0xc5b4eaaf, 0x45fbb0d4, 0x4576b8d0,
            0x4615f36d, 0x451aa818, 0x45416494, 0x45f027ef, 0xc5d61131,
            0xc25bb026, 0x45f1cb8c, 0x45825efb, 0x45a494e4, 0x460f2f5b,
            0x45b1797f);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.f.f.w v8, v4, v0.t");
+  asm volatile("vfncvt.f.f.w v8, v16, v0.t");
   //              0.000, -6788.000, 0.000, 8056.000, 0.000, 9600.000, 0.000,
   //              3094.000, 0.000, -6852.000, 0.000, 7736.000, 0.000, 5268.000,
   //              0.000, 5680.000
@@ -661,7 +661,7 @@ void TEST_CASE14(void) {
   //              7538298.328, -8731739.480, 537176.622, -3884944.157,
   //              7612336.042, -2270131.404, -4976406.726, -5260237.163,
   //              -4947737.810, 3583352.355, 7648790.331, -9360989.228
-  VLOAD_64(v4, 0x4102babe20435c2f, 0xc15dbd4abd4015a9, 0xc15960e30c871450,
+  VLOAD_64(v16, 0x4102babe20435c2f, 0xc15dbd4abd4015a9, 0xc15960e30c871450,
            0x41300472c1efbd9f, 0x415cc19e94ffb79b, 0xc160a78b6f5bcd25,
            0x412064b13e931aa9, 0xc14da3c81425b914, 0x415d09ec02a8cc93,
            0xc14151d9b3c1ecaf, 0xc152fbc5ae718384, 0xc15410f34a6ddb48,
@@ -669,7 +669,7 @@ void TEST_CASE14(void) {
            0xc161dacba74d791e);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.f.f.w v8, v4, v0.t");
+  asm volatile("vfncvt.f.f.w v8, v16, v0.t");
   //              0.000, -7796011.000, 0.000, 1049714.750, 0.000, -8731739.000,
   //              0.000, -3884944.250, 0.000, -2270131.500, 0.000, -5260237.000,
   //              0.000, 3583352.250, 0.000, -9360989.000
@@ -690,11 +690,11 @@ void TEST_CASE15(void) {
   //                     9596.856, 2474.506, 3094.286, 7684.992, -6850.149,
   //                     -54.922, 7737.443, 4171.873, 5266.611, 9163.839,
   //                     5679.187
-  VLOAD_32(v4, 0x44633fa3, 0xc5d4250b, 0xc5b4eaaf, 0x45fbb0d4, 0x4576b8d0,
+  VLOAD_32(v16, 0x44633fa3, 0xc5d4250b, 0xc5b4eaaf, 0x45fbb0d4, 0x4576b8d0,
            0x4615f36d, 0x451aa818, 0x45416494, 0x45f027ef, 0xc5d61131,
            0xc25bb026, 0x45f1cb8c, 0x45825efb, 0x45a494e4, 0x460f2f5b,
            0x45b1797f);
-  asm volatile("vfncvt.rod.f.f.w v8, v4");
+  asm volatile("vfncvt.rod.f.f.w v8, v16");
   //                  909.000, -6788.000, -5788.000, 8056.000, 3948.000,
   //                  9600.000, 2474.000, 3094.000, 7684.000, -6852.000,
   //                  -54.938, 7736.000, 4172.000, 5268.000, 9160.000, 5680.000
@@ -709,13 +709,13 @@ void TEST_CASE15(void) {
   //                       -3884944.157, 7612336.042, -2270131.404,
   //                       -4976406.726, -5260237.163, -4947737.810,
   //                       3583352.355, 7648790.331, -9360989.228
-  VLOAD_64(v4, 0x4102babe20435c2f, 0xc15dbd4abd4015a9, 0xc15960e30c871450,
+  VLOAD_64(v16, 0x4102babe20435c2f, 0xc15dbd4abd4015a9, 0xc15960e30c871450,
            0x41300472c1efbd9f, 0x415cc19e94ffb79b, 0xc160a78b6f5bcd25,
            0x412064b13e931aa9, 0xc14da3c81425b914, 0x415d09ec02a8cc93,
            0xc14151d9b3c1ecaf, 0xc152fbc5ae718384, 0xc15410f34a6ddb48,
            0xc152dfc673d9ba53, 0x414b56bc2d765fad, 0x415d2d85952e8398,
            0xc161dacba74d791e);
-  asm volatile("vfncvt.rod.f.f.w v8, v4");
+  asm volatile("vfncvt.rod.f.f.w v8, v16");
   //                       153431.766,       -7796010.500,   -6652812.500,
   //                       1049714.875,    7538298.500,   -8731739.000,
   //                       537176.5625,   -3884944.250,    7612336.500,
@@ -736,13 +736,13 @@ void TEST_CASE16(void) {
   //              908.994, -6788.630, -5789.335, 8054.104, 3947.551, 9596.856,
   //              2474.506, 3094.286, 7684.992, -6850.149, -54.922, 7737.443,
   //              4171.873, 5266.611, 9163.839, 5679.187
-  VLOAD_32(v4, 0x44633fa3, 0xc5d4250b, 0xc5b4eaaf, 0x45fbb0d4, 0x4576b8d0,
+  VLOAD_32(v16, 0x44633fa3, 0xc5d4250b, 0xc5b4eaaf, 0x45fbb0d4, 0x4576b8d0,
            0x4615f36d, 0x451aa818, 0x45416494, 0x45f027ef, 0xc5d61131,
            0xc25bb026, 0x45f1cb8c, 0x45825efb, 0x45a494e4, 0x460f2f5b,
            0x45b1797f);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.rod.f.f.w v8, v4, v0.t");
+  asm volatile("vfncvt.rod.f.f.w v8, v16, v0.t");
   //              0.000, -6788.000, 0.000, 8056.000, 0.000, 9600.000, 0.000,
   //              3094.000, 0.000, -6852.000, 0.000, 7736.000, 0.000, 5268.000,
   //              0.000, 5680.000
@@ -755,7 +755,7 @@ void TEST_CASE16(void) {
   //              7538298.328, -8731739.480, 537176.622, -3884944.157,
   //              7612336.042, -2270131.404, -4976406.726, -5260237.163,
   //              -4947737.810, 3583352.355, 7648790.331, -9360989.228
-  VLOAD_64(v4, 0x4102babe20435c2f, 0xc15dbd4abd4015a9, 0xc15960e30c871450,
+  VLOAD_64(v16, 0x4102babe20435c2f, 0xc15dbd4abd4015a9, 0xc15960e30c871450,
            0x41300472c1efbd9f, 0x415cc19e94ffb79b, 0xc160a78b6f5bcd25,
            0x412064b13e931aa9, 0xc14da3c81425b914, 0x415d09ec02a8cc93,
            0xc14151d9b3c1ecaf, 0xc152fbc5ae718384, 0xc15410f34a6ddb48,
@@ -763,7 +763,7 @@ void TEST_CASE16(void) {
            0xc161dacba74d791e);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vfncvt.rod.f.f.w v8, v4, v0.t");
+  asm volatile("vfncvt.rod.f.f.w v8, v16, v0.t");
   //              0.000, -7796011.000, 0.000, 1049714.750, 0.000, -8731739.000,
   //              0.000, -3884944.250, 0.000, -2270131.500, 0.000, -5260237.000,
   //              0.000, 3583352.250, 0.000, -9360989.000
diff --git a/sw/riscvTests/isa/rv64uv/vfnmacc.c b/sw/riscvTests/isa/rv64uv/vfnmacc.c
index b8a3d3f8..9d0e0b94 100644
--- a/sw/riscvTests/isa/rv64uv/vfnmacc.c
+++ b/sw/riscvTests/isa/rv64uv/vfnmacc.c
@@ -10,36 +10,36 @@
 
 // Simple random test with similar values + 1 subnormal
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.6377, -0.2332,  0.9458, -0.2612, -0.6772,  0.4543,  0.1002,
   //              0.7764,  0.7979, -0.8599,  0.7837, -0.2461,  0.4221,  0.2251,
   //              0.7739,  0.1461
-  VLOAD_16(v4, 0xb91a, 0xb376, 0x3b91, 0xb42e, 0xb96b, 0x3745, 0x2e69, 0x3a36,
+  VLOAD_16(v16, 0xb91a, 0xb376, 0x3b91, 0xb42e, 0xb96b, 0x3745, 0x2e69, 0x3a36,
            0x3a62, 0xbae1, 0x3a45, 0xb3e0, 0x36c1, 0x3334, 0x3a31, 0x30ad);
   //               0.9551, -0.6787,  0.5605, -0.7305, -0.7197, -0.1581,  0.7271,
   //               0.6113,  0.2971, -0.8062,  0.9668, -0.5278,  0.3972, -0.1084,
   //               -0.3015,  0.9556
-  VLOAD_16(v6, 0x3ba4, 0xb96e, 0x387c, 0xb9d8, 0xb9c2, 0xb10f, 0x39d1, 0x38e4,
+  VLOAD_16(v24, 0x3ba4, 0xb96e, 0x387c, 0xb9d8, 0xb9c2, 0xb10f, 0x39d1, 0x38e4,
            0x34c1, 0xba73, 0x3bbc, 0xb839, 0x365b, 0xaef0, 0xb4d3, 0x3ba5);
   //               0.7402,  0.0935,  0.1455, -0.2771,  0.3347,  0.7964,  0.6543,
   //               -0.7534,  0.2476,  0.0338,  0.9980,  0.3284,  0.2239,
   //               -0.4551,  0.6694, -0.8550
-  VLOAD_16(v2, 0x39ec, 0x2dfc, 0x30a8, 0xb46f, 0x355b, 0x3a5f, 0x393c, 0xba07,
+  VLOAD_16(v8, 0x39ec, 0x2dfc, 0x30a8, 0xb46f, 0x355b, 0x3a5f, 0x393c, 0xba07,
            0x33ec, 0x2853, 0x3bfc, 0x3541, 0x332a, 0xb748, 0x395b, 0xbad7);
-  asm volatile("vfnmacc.vv v2, v4, v6");
+  asm volatile("vfnmacc.vv v8, v16, v24");
   //              -0.1313, -0.2517, -0.6758,  0.0863, -0.8223, -0.7246, -0.7271,
   //              0.2788, -0.4846, -0.7271, -1.7559, -0.4583, -0.3916,  0.4795,
   //              -0.4360,  0.7153
-  VCMP_U16(1, v2, 0xb033, 0xb407, 0xb968, 0x2d86, 0xba94, 0xb9cc, 0xb9d1,
+  VCMP_U16(1, v8, 0xb033, 0xb407, 0xb968, 0x2d86, 0xba94, 0xb9cc, 0xb9d1,
            0x3476, 0xb7c1, 0xb9d1, 0xbf06, 0xb755, 0xb644, 0x37ac, 0xb6fa,
            0x39b9);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.17374928, -0.36242354, -0.18093164,  0.94970566,
   //              -0.45790458, -0.17780401, -0.51985794, -0.04832974,
   //              0.13252106,  0.77533042,  0.42536697, -0.72199643,
   //              -0.25088808,  0.28798762,  0.66300607, -0.63549894
-  VLOAD_32(v4, 0xbe31eb55, 0xbeb98f94, 0xbe394625, 0x3f731fe9, 0xbeea7278,
+  VLOAD_32(v16, 0xbe31eb55, 0xbeb98f94, 0xbe394625, 0x3f731fe9, 0xbeea7278,
            0xbe361241, 0xbf051569, 0xbd45f569, 0x3e07b39a, 0x3f467c0e,
            0x3ed9c9b3, 0xbf38d4c2, 0xbe807467, 0x3e93731d, 0x3f29bac4,
            0xbf22b00f);
@@ -47,7 +47,7 @@ void TEST_CASE1(void) {
   //              0.19637996, -0.88467985,  0.73412597, -0.98048240, 0.25438991,
   //              -0.02058743, -0.00876777,  0.21936898, -0.71130067,
   //              -0.29675287, -0.96093589,  0.24695934
-  VLOAD_32(v6, 0xbf1cc7ee, 0x3f36e29b, 0xbe2014df, 0x3ddf9905, 0x3e4917d4,
+  VLOAD_32(v24, 0xbf1cc7ee, 0x3f36e29b, 0xbe2014df, 0x3ddf9905, 0x3e4917d4,
            0xbf627a61, 0x3f3befae, 0xbf7b00e5, 0x3e823f65, 0xbca8a6f9,
            0xbc0fa6af, 0x3e60a243, 0xbf3617cd, 0xbe97effe, 0xbf75ffe5,
            0x3e7ce2e9);
@@ -55,29 +55,29 @@ void TEST_CASE1(void) {
   //               0.45613721, -0.90825689,  0.21235447,  0.35766414,
   //               0.08650716, -0.98431164,  0.21029140, -0.92919809,
   //               0.46440944,  0.70648551, -0.80876821, -0.19595607
-  VLOAD_32(v2, 0x3f46a83c, 0x3cd04eb8, 0xbf22dcea, 0x3defb680, 0x3ee98ad1,
+  VLOAD_32(v8, 0x3f46a83c, 0x3cd04eb8, 0xbf22dcea, 0x3defb680, 0x3ee98ad1,
            0xbf688386, 0x3e597373, 0x3eb71fc1, 0x3db12aaa, 0xbf7bfbd9,
            0x3e5756a1, 0xbf6ddfed, 0x3eedc713, 0x3f34dc3c, 0xbf4f0b6f,
            0xbe48a8b5);
-  asm volatile("vfnmacc.vv v2, v4, v6");
+  asm volatile("vfnmacc.vv v8, v16, v24");
   //              -0.88241309,  0.23348548,  0.60789841, -0.22073483,
   //              -0.36621392,  0.75095725,  0.16928674, -0.40505061,
   //              -0.12021918,  1.00027370, -0.20656188,  1.08758175,
   //              -0.64286631, -0.62102437,  1.44587445,  0.35289848
-  VCMP_U32(2, v2, 0xbf61e5d3, 0x3e6f16d2, 0x3f1b9f3b, 0xbe62084f, 0xbebb8064,
+  VCMP_U32(2, v8, 0xbf61e5d3, 0x3e6f16d2, 0x3f1b9f3b, 0xbe62084f, 0xbebb8064,
            0x3f403ebc, 0x3e2d5982, 0xbecf62cb, 0xbdf63579, 0x3f8008f8,
            0xbe5384f5, 0x3f8b35e1, 0xbf2492e3, 0xbf1efb74, 0x3fb9126b,
            0x3eb4af1c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.3252450595073633,  0.4758165631309326, -0.1595578232245429,
   //              -0.5062008461482019, -0.8497827573746595, -0.1941654045426651,
   //              0.5653121187716577, -0.9852357785633095, -0.4238236947700038,
   //              0.5852522737985073,  0.4009389814391957, -0.8725649196362917,
   //              -0.5946782335830663,  0.4175703122760628, -0.6355596052793091,
   //              -0.3469340725892474
-  VLOAD_64(v4, 0xbfd4d0d0a77142c0, 0x3fde73c75062b7e8, 0xbfc46c6408490198,
+  VLOAD_64(v16, 0xbfd4d0d0a77142c0, 0x3fde73c75062b7e8, 0xbfc46c6408490198,
            0xbfe032cc1ded3ff0, 0xbfeb316b9bf41faa, 0xbfc8da6977433ee0,
            0x3fe2170970c503fe, 0xbfef870d2ef8e992, 0xbfdb1fed6b13a6c0,
            0x3fe2ba62f9fbf9aa, 0x3fd9a8fbf93e43f0, 0xbfebec0d442f3114,
@@ -90,7 +90,7 @@ void TEST_CASE1(void) {
   //               -0.5209348837668262,  0.1676058792979986,
   //               -0.3611782231841894,  0.5839305722445856,
   //               -0.5690013462620132, -0.7273345685963009
-  VLOAD_64(v6, 0x3fece11b83abb9b8, 0x3fc666d29fd34b08, 0x3fe0197c6cafd8c4,
+  VLOAD_64(v24, 0x3fece11b83abb9b8, 0x3fc666d29fd34b08, 0x3fe0197c6cafd8c4,
            0xbfcd7b88c1b4daf0, 0xbfd8d61841f43c54, 0xbfee36420fbd9482,
            0xbfef195a7bef10b4, 0x3fe57beccc59d47e, 0xbfb7593394338500,
            0xbfe11c8c0e185e4a, 0xbfe0ab7fa223f876, 0x3fc5741c0519e298,
@@ -102,20 +102,20 @@ void TEST_CASE1(void) {
   //              -0.7128277097157256, -0.8385947434294139,  0.8834902787005550,
   //              0.5936682304042178,  0.1532178226844403, -0.5096194622607613,
   //              -0.8578075287458693
-  VLOAD_64(v2, 0xbfb3b16484d96110, 0xbfeb07fadbff7462, 0xbfc87ec5fcb06230,
+  VLOAD_64(v8, 0xbfb3b16484d96110, 0xbfeb07fadbff7462, 0xbfc87ec5fcb06230,
            0x3fe885d78705c2d4, 0x3fca59411dac8758, 0xbf99c23b11679a80,
            0x3fe0e17f24429b70, 0xbfe8542d9e4907ce, 0x3fe4cb329a1542de,
            0xbfe6cf7c0e9d2c04, 0xbfead5c4a4b40f1a, 0x3fec458d67ab4a36,
            0x3fe2ff5484485472, 0x3fc39ca440cc0820, 0xbfe04ecd797a151a,
            0xbfeb7328c6473c1e);
-  asm volatile("vfnmacc.vv v2, v4, v6");
+  asm volatile("vfnmacc.vv v8, v16, v24");
   //               0.3704523636601942,  0.7614500740339213,  0.2716441267930978,
   //               -0.8829326116147059, -0.5356217329860959,
   //               -0.1581610880357251, 0.0218692556270895,  1.4217408543890222,
   //               -0.6884591815896014,  1.0257824393236514,  1.0474578451230310,
   //               -0.7372432681003268, -0.8084530581760619,
   //               -0.3970498940841519,  0.1479851912270807,  0.6054703847278113
-  VCMP_U64(3, v2, 0x3fd7b57dd4a95f28, 0x3fe85dcc8bb06629, 0x3fd1629e0c2e846c,
+  VCMP_U64(3, v8, 0x3fd7b57dd4a95f28, 0x3fe85dcc8bb06629, 0x3fd1629e0c2e846c,
            0xbfec40fbe46ea001, 0xbfe123d0304677d2, 0xbfc43e9f5e4e7ddd,
            0x3f9664e4e6d32991, 0x3ff6bf73568fcea3, 0xbfe607db8cb1dd4b,
            0x3ff0699ad8db4c8b, 0x3ff0c263284bdf71, 0xbfe7977f31b5fc6d,
@@ -127,37 +127,37 @@ void TEST_CASE1(void) {
 // Simple random test with similar values + 1 subnormal (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.6377, -0.2332,  0.9458, -0.2612, -0.6772,  0.4543,  0.1002,
   //              0.7764,  0.7979, -0.8599,  0.7837, -0.2461,  0.4221,  0.2251,
   //              0.7739,  0.1461
-  VLOAD_16(v4, 0xb91a, 0xb376, 0x3b91, 0xb42e, 0xb96b, 0x3745, 0x2e69, 0x3a36,
+  VLOAD_16(v16, 0xb91a, 0xb376, 0x3b91, 0xb42e, 0xb96b, 0x3745, 0x2e69, 0x3a36,
            0x3a62, 0xbae1, 0x3a45, 0xb3e0, 0x36c1, 0x3334, 0x3a31, 0x30ad);
   //               0.9551, -0.6787,  0.5605, -0.7305, -0.7197, -0.1581,  0.7271,
   //               0.6113,  0.2971, -0.8062,  0.9668, -0.5278,  0.3972, -0.1084,
   //               -0.3015,  0.9556
-  VLOAD_16(v6, 0x3ba4, 0xb96e, 0x387c, 0xb9d8, 0xb9c2, 0xb10f, 0x39d1, 0x38e4,
+  VLOAD_16(v24, 0x3ba4, 0xb96e, 0x387c, 0xb9d8, 0xb9c2, 0xb10f, 0x39d1, 0x38e4,
            0x34c1, 0xba73, 0x3bbc, 0xb839, 0x365b, 0xaef0, 0xb4d3, 0x3ba5);
   VLOAD_8(v0, 0xAA, 0xAA);
   //               0.7402,  0.0935,  0.1455, -0.2771,  0.3347,  0.7964,  0.6543,
   //               -0.7534,  0.2476,  0.0338,  0.9980,  0.3284,  0.2239,
   //               -0.4551,  0.6694, -0.8550
-  VLOAD_16(v2, 0x39ec, 0x2dfc, 0x30a8, 0xb46f, 0x355b, 0x3a5f, 0x393c, 0xba07,
+  VLOAD_16(v8, 0x39ec, 0x2dfc, 0x30a8, 0xb46f, 0x355b, 0x3a5f, 0x393c, 0xba07,
            0x33ec, 0x2853, 0x3bfc, 0x3541, 0x332a, 0xb748, 0x395b, 0xbad7);
-  asm volatile("vfnmacc.vv v2, v4, v6, v0.t");
+  asm volatile("vfnmacc.vv v8, v16, v24, v0.t");
   //               0.0000, -0.2517,  0.0000,  0.0863,  0.0000, -0.7246,  0.0000,
   //               0.2788,  0.0000, -0.7271,  0.0000, -0.4583,  0.0000,  0.4795,
   //               0.0000,  0.7153
-  VCMP_U16(4, v2, 0x39ec, 0xb407, 0x30a8, 0x2d86, 0x355b, 0xb9cc, 0x393c,
+  VCMP_U16(4, v8, 0x39ec, 0xb407, 0x30a8, 0x2d86, 0x355b, 0xb9cc, 0x393c,
            0x3476, 0x33ec, 0xb9d1, 0x3bfc, 0xb755, 0x332a, 0x37ac, 0x395b,
            0x39b9);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.17374928, -0.36242354, -0.18093164,  0.94970566,
   //              -0.45790458, -0.17780401, -0.51985794, -0.04832974,
   //              0.13252106,  0.77533042,  0.42536697, -0.72199643,
   //              -0.25088808,  0.28798762,  0.66300607, -0.63549894
-  VLOAD_32(v4, 0xbe31eb55, 0xbeb98f94, 0xbe394625, 0x3f731fe9, 0xbeea7278,
+  VLOAD_32(v16, 0xbe31eb55, 0xbeb98f94, 0xbe394625, 0x3f731fe9, 0xbeea7278,
            0xbe361241, 0xbf051569, 0xbd45f569, 0x3e07b39a, 0x3f467c0e,
            0x3ed9c9b3, 0xbf38d4c2, 0xbe807467, 0x3e93731d, 0x3f29bac4,
            0xbf22b00f);
@@ -165,7 +165,7 @@ void TEST_CASE2(void) {
   //              0.19637996, -0.88467985,  0.73412597, -0.98048240, 0.25438991,
   //              -0.02058743, -0.00876777,  0.21936898, -0.71130067,
   //              -0.29675287, -0.96093589,  0.24695934
-  VLOAD_32(v6, 0xbf1cc7ee, 0x3f36e29b, 0xbe2014df, 0x3ddf9905, 0x3e4917d4,
+  VLOAD_32(v24, 0xbf1cc7ee, 0x3f36e29b, 0xbe2014df, 0x3ddf9905, 0x3e4917d4,
            0xbf627a61, 0x3f3befae, 0xbf7b00e5, 0x3e823f65, 0xbca8a6f9,
            0xbc0fa6af, 0x3e60a243, 0xbf3617cd, 0xbe97effe, 0xbf75ffe5,
            0x3e7ce2e9);
@@ -174,29 +174,29 @@ void TEST_CASE2(void) {
   //               0.45613721, -0.90825689,  0.21235447,  0.35766414,
   //               0.08650716, -0.98431164,  0.21029140, -0.92919809,
   //               0.46440944,  0.70648551, -0.80876821, -0.19595607
-  VLOAD_32(v2, 0x3f46a83c, 0x3cd04eb8, 0xbf22dcea, 0x3defb680, 0x3ee98ad1,
+  VLOAD_32(v8, 0x3f46a83c, 0x3cd04eb8, 0xbf22dcea, 0x3defb680, 0x3ee98ad1,
            0xbf688386, 0x3e597373, 0x3eb71fc1, 0x3db12aaa, 0xbf7bfbd9,
            0x3e5756a1, 0xbf6ddfed, 0x3eedc713, 0x3f34dc3c, 0xbf4f0b6f,
            0xbe48a8b5);
-  asm volatile("vfnmacc.vv v2, v4, v6, v0.t");
+  asm volatile("vfnmacc.vv v8, v16, v24, v0.t");
   //               0.00000000,  0.23348548,  0.00000000, -0.22073483,
   //               0.00000000,  0.75095725,  0.00000000, -0.40505061,
   //               0.00000000,  1.00027370,  0.00000000,  1.08758175,
   //               0.00000000, -0.62102437,  0.00000000,  0.35289848
-  VCMP_U32(5, v2, 0x3f46a83c, 0x3e6f16d2, 0xbf22dcea, 0xbe62084f, 0x3ee98ad1,
+  VCMP_U32(5, v8, 0x3f46a83c, 0x3e6f16d2, 0xbf22dcea, 0xbe62084f, 0x3ee98ad1,
            0x3f403ebc, 0x3e597373, 0xbecf62cb, 0x3db12aaa, 0x3f8008f8,
            0x3e5756a1, 0x3f8b35e1, 0x3eedc713, 0xbf1efb74, 0xbf4f0b6f,
            0x3eb4af1c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.3252450595073633,  0.4758165631309326, -0.1595578232245429,
   //              -0.5062008461482019, -0.8497827573746595, -0.1941654045426651,
   //              0.5653121187716577, -0.9852357785633095, -0.4238236947700038,
   //              0.5852522737985073,  0.4009389814391957, -0.8725649196362917,
   //              -0.5946782335830663,  0.4175703122760628, -0.6355596052793091,
   //              -0.3469340725892474
-  VLOAD_64(v4, 0xbfd4d0d0a77142c0, 0x3fde73c75062b7e8, 0xbfc46c6408490198,
+  VLOAD_64(v16, 0xbfd4d0d0a77142c0, 0x3fde73c75062b7e8, 0xbfc46c6408490198,
            0xbfe032cc1ded3ff0, 0xbfeb316b9bf41faa, 0xbfc8da6977433ee0,
            0x3fe2170970c503fe, 0xbfef870d2ef8e992, 0xbfdb1fed6b13a6c0,
            0x3fe2ba62f9fbf9aa, 0x3fd9a8fbf93e43f0, 0xbfebec0d442f3114,
@@ -209,7 +209,7 @@ void TEST_CASE2(void) {
   //               -0.5209348837668262,  0.1676058792979986,
   //               -0.3611782231841894,  0.5839305722445856,
   //               -0.5690013462620132, -0.7273345685963009
-  VLOAD_64(v6, 0x3fece11b83abb9b8, 0x3fc666d29fd34b08, 0x3fe0197c6cafd8c4,
+  VLOAD_64(v24, 0x3fece11b83abb9b8, 0x3fc666d29fd34b08, 0x3fe0197c6cafd8c4,
            0xbfcd7b88c1b4daf0, 0xbfd8d61841f43c54, 0xbfee36420fbd9482,
            0xbfef195a7bef10b4, 0x3fe57beccc59d47e, 0xbfb7593394338500,
            0xbfe11c8c0e185e4a, 0xbfe0ab7fa223f876, 0x3fc5741c0519e298,
@@ -222,20 +222,20 @@ void TEST_CASE2(void) {
   //              -0.7128277097157256, -0.8385947434294139,  0.8834902787005550,
   //              0.5936682304042178,  0.1532178226844403, -0.5096194622607613,
   //              -0.8578075287458693
-  VLOAD_64(v2, 0xbfb3b16484d96110, 0xbfeb07fadbff7462, 0xbfc87ec5fcb06230,
+  VLOAD_64(v8, 0xbfb3b16484d96110, 0xbfeb07fadbff7462, 0xbfc87ec5fcb06230,
            0x3fe885d78705c2d4, 0x3fca59411dac8758, 0xbf99c23b11679a80,
            0x3fe0e17f24429b70, 0xbfe8542d9e4907ce, 0x3fe4cb329a1542de,
            0xbfe6cf7c0e9d2c04, 0xbfead5c4a4b40f1a, 0x3fec458d67ab4a36,
            0x3fe2ff5484485472, 0x3fc39ca440cc0820, 0xbfe04ecd797a151a,
            0xbfeb7328c6473c1e);
-  asm volatile("vfnmacc.vv v2, v4, v6, v0.t");
+  asm volatile("vfnmacc.vv v8, v16, v24, v0.t");
   //               0.0000000000000000,  0.7614500740339213,  0.0000000000000000,
   //               -0.8829326116147059,  0.0000000000000000,
   //               -0.1581610880357251, 0.0000000000000000,  1.4217408543890222,
   //               0.0000000000000000,  1.0257824393236514,  0.0000000000000000,
   //               -0.7372432681003268,  0.0000000000000000,
   //               -0.3970498940841519,  0.0000000000000000,  0.6054703847278113
-  VCMP_U64(6, v2, 0xbfb3b16484d96110, 0x3fe85dcc8bb06629, 0xbfc87ec5fcb06230,
+  VCMP_U64(6, v8, 0xbfb3b16484d96110, 0x3fe85dcc8bb06629, 0xbfc87ec5fcb06230,
            0xbfec40fbe46ea001, 0x3fca59411dac8758, 0xbfc43e9f5e4e7ddd,
            0x3fe0e17f24429b70, 0x3ff6bf73568fcea3, 0x3fe4cb329a1542de,
            0x3ff0699ad8db4c8b, 0xbfead5c4a4b40f1a, 0xbfe7977f31b5fc6d,
@@ -246,29 +246,29 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.1300
   BOX_HALF_IN_FLOAT(fscalar_16, 0x3029);
   //              -0.2844,  0.4070, -0.1837, -0.2321, -0.5283, -0.6104, -0.7183,
   //              -0.1191,  0.7998,  0.1169,  0.1169, -0.9214, -0.4360, -0.6250,
   //              -0.5386,  0.6543
-  VLOAD_16(v4, 0xb48d, 0x3683, 0xb1e1, 0xb36d, 0xb83a, 0xb8e2, 0xb9bf, 0xaf9f,
+  VLOAD_16(v16, 0xb48d, 0x3683, 0xb1e1, 0xb36d, 0xb83a, 0xb8e2, 0xb9bf, 0xaf9f,
            0x3a66, 0x2f7c, 0x2f7c, 0xbb5f, 0xb6fa, 0xb900, 0xb84f, 0x393c);
   //               0.9268, -0.3337, -0.3225, -0.8306, -0.1857, -0.6831,  0.0557,
   //               0.5586,  0.2352,  0.6294,  0.6294, -0.8877, -0.2426,  0.5488,
   //               0.4001,  0.1772
-  VLOAD_16(v2, 0x3b6a, 0xb557, 0xb529, 0xbaa5, 0xb1f1, 0xb977, 0x2b21, 0x3878,
+  VLOAD_16(v8, 0x3b6a, 0xb557, 0xb529, 0xbaa5, 0xb1f1, 0xb977, 0x2b21, 0x3878,
            0x3387, 0x3909, 0x3909, 0xbb1a, 0xb3c3, 0x3864, 0x3667, 0x31ac);
-  asm volatile("vfnmacc.vf v2, %[A], v4" ::[A] "f"(fscalar_16));
+  asm volatile("vfnmacc.vf v8, %[A], v16" ::[A] "f"(fscalar_16));
   //              -0.8896,  0.2808,  0.3464,  0.8608,  0.2544,  0.7627,  0.0377,
   //              -0.5430, -0.3394, -0.6445, -0.6445,  1.0078,  0.2993, -0.4675,
   //              -0.3301, -0.2622
-  VCMP_U16(7, v2, 0xbb1e, 0x347e, 0x358b, 0x3ae3, 0x3412, 0x3a1a, 0x28d3,
+  VCMP_U16(7, v8, 0xbb1e, 0x347e, 0x358b, 0x3ae3, 0x3412, 0x3a1a, 0x28d3,
            0xb858, 0xb56d, 0xb928, 0xb928, 0x3c08, 0x34ca, 0xb77b, 0xb548,
            0xb432);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.26917368
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbe89d122);
@@ -276,7 +276,7 @@ void TEST_CASE3(void) {
   //              -0.49064314, -0.74352056, -0.17169137,  0.26071417,
   //              0.71857828,  0.07920383, -0.43244356, -0.58339220, 0.80679923,
   //              0.23900302,  0.73513943, -0.80685192
-  VLOAD_32(v4, 0xbe8e0f00, 0xbf5cf35c, 0xbe2b7bf9, 0xbf2fce80, 0xbefb3594,
+  VLOAD_32(v16, 0xbe8e0f00, 0xbf5cf35c, 0xbe2b7bf9, 0xbf2fce80, 0xbefb3594,
            0xbf3e575d, 0xbe2fcfdd, 0x3e857c54, 0x3f37f4bf, 0x3da2359e,
            0xbedd693e, 0xbf155931, 0x3f4e8a65, 0x3e74bd35, 0x3f3c3219,
            0xbf4e8dd9);
@@ -284,22 +284,22 @@ void TEST_CASE3(void) {
   //               0.63772237, -0.87242430, -0.44194883, -0.41286576,
   //               -0.57735479,  0.61664599,  0.94073379, -0.89744234,
   //               -0.70681161,  0.23247144,  0.06774496, -0.38581881
-  VLOAD_32(v2, 0x3e0a5676, 0xbe955998, 0x3f4e10c4, 0xbf22e93c, 0x3f2341c6,
+  VLOAD_32(v8, 0x3e0a5676, 0xbe955998, 0x3f4e10c4, 0xbf22e93c, 0x3f2341c6,
            0xbf5f5733, 0xbee2471e, 0xbed36324, 0xbf13cd86, 0x3f1ddc83,
            0x3f70d3ee, 0xbf65bec8, 0xbf34f19b, 0x3e6e0cfe, 0x3d8abdde,
            0xbec58a0b);
-  asm volatile("vfnmacc.vf v2, %[A], v4" ::[A] "f"(fscalar_32));
+  asm volatile("vfnmacc.vf v8, %[A], v16" ::[A] "f"(fscalar_32));
   //              -0.20977989,  0.05937849, -0.85002053,  0.45151776,
   //              -0.76979059,  0.67228812,  0.39573404,  0.48304313,
   //              0.77077717, -0.59532642, -1.05713618,  0.74040854, 0.92398071,
   //              -0.16813812,  0.13013524,  0.16863550
-  VCMP_U32(8, v2, 0xbe56d08a, 0x3d7336de, 0xbf599af2, 0x3ee72d57, 0xbf4510ff,
+  VCMP_U32(8, v8, 0xbe56d08a, 0x3d7336de, 0xbf599af2, 0x3ee72d57, 0xbf4510ff,
            0x3f2c1b13, 0x3eca9da7, 0x3ef7516f, 0x3f4551a7, 0xbf186750,
            0xbf87503d, 0x3f3d8b6a, 0x3f6c8a00, 0xbe2c2c66, 0x3e05422c,
            0x3e2caec9);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.1021836258281641
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fba28b4c31e60e0);
@@ -309,7 +309,7 @@ void TEST_CASE3(void) {
   //                0.9355143976513562, -0.4219868517017851, 0.8950700270161456,
   //                0.6727820676214205, -0.8833440526985297, 0.0357808590148252,
   //                -0.3802125831332157,  0.9831607630398518
-  VLOAD_64(v4, 0x3fd4f4406b993a2c, 0x3fed9d97ae0b1cd6, 0x3feefcd01012c05e,
+  VLOAD_64(v16, 0x3fd4f4406b993a2c, 0x3fed9d97ae0b1cd6, 0x3feefcd01012c05e,
            0xbfe5b09210bc082e, 0x3feef1596c459614, 0x3fe9af1e3ee3adfa,
            0xbfe7a4ec2374d0e2, 0x3fe7c8a2209c110c, 0x3fedefbbe3db30dc,
            0xbfdb01d523d9acc0, 0x3feca469e5b540fa, 0x3fe5876e42389dca,
@@ -322,20 +322,20 @@ void TEST_CASE3(void) {
   //                -0.3443302881655670,  0.3680926220616383,
   //                -0.2344410843781140,  0.3553553454507421,
   //                0.0951222110617760, -0.8329780449088213
-  VLOAD_64(v2, 0x3fc56654e2cbd888, 0x3fe40bb445915f4a, 0x3fc4514877d696a0,
+  VLOAD_64(v8, 0x3fc56654e2cbd888, 0x3fe40bb445915f4a, 0x3fc4514877d696a0,
            0xbfd56df357d00344, 0x3fde371a20d41408, 0x3fd26b70e63cabf0,
            0x3fe044a59c60fcd4, 0x3fee3905d92cc95e, 0xbfd1f50bba2f6e40,
            0xbfe719aff62247a4, 0xbfd60981e7ac601c, 0x3fd78ed45b69d4fc,
            0xbfce022a5b1f1348, 0x3fd6be2458cadcb0, 0x3fb859ede1a22f80,
            0xbfeaa7c192a56bc8);
-  asm volatile("vfnmacc.vf v2, %[A], v4" ::[A] "f"(dscalar_64));
+  asm volatile("vfnmacc.vf v8, %[A], v16" ::[A] "f"(dscalar_64));
   //              -0.2006411422994659, -0.7209983883869466, -0.2576811937222847,
   //              0.4040963223414386, -0.5709208038927434, -0.3698229881701340,
   //              -0.4328780954683192, -1.0204078946581041,  0.1849871561177042,
   //              0.7650058093340112,  0.2528687874349445, -0.4368399331233641,
   //              0.3247043825365946, -0.3590115633601233, -0.0562707107317317,
   //              0.7325151133694248
-  VCMP_U64(9, v2, 0xbfc9ae9be43442c9, 0xbfe7126b3652e68a, 0xbfd07dd942f53687,
+  VCMP_U64(9, v8, 0xbfc9ae9be43442c9, 0xbfe7126b3652e68a, 0xbfd07dd942f53687,
            0x3fd9dcb6d238fb8a, 0xbfe244fbb4aa695e, 0xbfd7ab2e09dffb6d,
            0xbfdbb44653cc3c92, 0xbff053973a823036, 0x3fc7ada8bcda50a5,
            0x3fe87aed768addeb, 0x3fd02f00910d95b4, 0xbfdbf52f7a9681dc,
@@ -346,30 +346,30 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.1300
   BOX_HALF_IN_FLOAT(fscalar_16, 0x3029);
   //               -0.2844,  0.4070, -0.1837, -0.2321, -0.5283, -0.6104,
   //               -0.7183, -0.1191,  0.7998,  0.1169,  0.2551, -0.9214,
   //               -0.4360, -0.6250, -0.5386,  0.6543
-  VLOAD_16(v4, 0xb48d, 0x3683, 0xb1e1, 0xb36d, 0xb83a, 0xb8e2, 0xb9bf, 0xaf9f,
+  VLOAD_16(v16, 0xb48d, 0x3683, 0xb1e1, 0xb36d, 0xb83a, 0xb8e2, 0xb9bf, 0xaf9f,
            0x3a66, 0x2f7c, 0x3415, 0xbb5f, 0xb6fa, 0xb900, 0xb84f, 0x393c);
   VLOAD_8(v0, 0xAA, 0xAA);
   //                0.9268, -0.3337, -0.3225, -0.8306, -0.1857, -0.6831, 0.0557,
   //                0.5586,  0.2352,  0.6294, -0.0325, -0.8877, -0.2426, 0.5488,
   //                0.4001,  0.1772
-  VLOAD_16(v2, 0x3b6a, 0xb557, 0xb529, 0xbaa5, 0xb1f1, 0xb977, 0x2b21, 0x3878,
+  VLOAD_16(v8, 0x3b6a, 0xb557, 0xb529, 0xbaa5, 0xb1f1, 0xb977, 0x2b21, 0x3878,
            0x3387, 0x3909, 0xa828, 0xbb1a, 0xb3c3, 0x3864, 0x3667, 0x31ac);
-  asm volatile("vfnmacc.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
+  asm volatile("vfnmacc.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_16));
   //                0.0000,  0.2808,  0.0000,  0.8608,  0.0000,  0.7627, 0.0000,
   //                -0.5430,  0.0000, -0.6445,  0.0000,  1.0078,  0.0000,
   //                -0.4675,  0.0000, -0.2622
-  VCMP_U16(10, v2, 0x3b6a, 0x347e, 0xb529, 0x3ae3, 0xb1f1, 0x3a1a, 0x2b21,
+  VCMP_U16(10, v8, 0x3b6a, 0x347e, 0xb529, 0x3ae3, 0xb1f1, 0x3a1a, 0x2b21,
            0xb858, 0x3387, 0xb928, 0xa828, 0x3c08, 0xb3c3, 0xb77b, 0x3667,
            0xb432);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.26917368
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbe89d122);
@@ -377,7 +377,7 @@ void TEST_CASE4(void) {
   //               -0.49064314, -0.74352056, -0.17169137,  0.26071417,
   //               0.71857828,  0.07920383, -0.43244356, -0.58339220,
   //               0.80679923,  0.23900302,  0.73513943, -0.80685192
-  VLOAD_32(v4, 0xbe8e0f00, 0xbf5cf35c, 0xbe2b7bf9, 0xbf2fce80, 0xbefb3594,
+  VLOAD_32(v16, 0xbe8e0f00, 0xbf5cf35c, 0xbe2b7bf9, 0xbf2fce80, 0xbefb3594,
            0xbf3e575d, 0xbe2fcfdd, 0x3e857c54, 0x3f37f4bf, 0x3da2359e,
            0xbedd693e, 0xbf155931, 0x3f4e8a65, 0x3e74bd35, 0x3f3c3219,
            0xbf4e8dd9);
@@ -386,22 +386,22 @@ void TEST_CASE4(void) {
   //                0.63772237, -0.87242430, -0.44194883, -0.41286576,
   //                -0.57735479,  0.61664599,  0.94073379, -0.89744234,
   //                -0.70681161,  0.23247144,  0.06774496, -0.38581881
-  VLOAD_32(v2, 0x3e0a5676, 0xbe955998, 0x3f4e10c4, 0xbf22e93c, 0x3f2341c6,
+  VLOAD_32(v8, 0x3e0a5676, 0xbe955998, 0x3f4e10c4, 0xbf22e93c, 0x3f2341c6,
            0xbf5f5733, 0xbee2471e, 0xbed36324, 0xbf13cd86, 0x3f1ddc83,
            0x3f70d3ee, 0xbf65bec8, 0xbf34f19b, 0x3e6e0cfe, 0x3d8abdde,
            0xbec58a0b);
-  asm volatile("vfnmacc.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
+  asm volatile("vfnmacc.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_32));
   //                0.00000000,  0.05937849,  0.00000000,  0.45151776,
   //                0.00000000,  0.67228812,  0.00000000,  0.48304313,
   //                0.00000000, -0.59532642,  0.00000000,  0.74040854,
   //                0.00000000, -0.16813812,  0.00000000,  0.16863550
-  VCMP_U32(11, v2, 0x3e0a5676, 0x3d7336de, 0x3f4e10c4, 0x3ee72d57, 0x3f2341c6,
+  VCMP_U32(11, v8, 0x3e0a5676, 0x3d7336de, 0x3f4e10c4, 0x3ee72d57, 0x3f2341c6,
            0x3f2c1b13, 0xbee2471e, 0x3ef7516f, 0xbf13cd86, 0xbf186750,
            0x3f70d3ee, 0x3f3d8b6a, 0xbf34f19b, 0xbe2c2c66, 0x3d8abdde,
            0x3e2caec9);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.1021836258281641
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fba28b4c31e60e0);
@@ -413,7 +413,7 @@ void TEST_CASE4(void) {
   //                 0.8950700270161456,  0.6727820676214205,
   //                 -0.8833440526985297,  0.0357808590148252,
   //                 -0.3802125831332157,  0.9831607630398518
-  VLOAD_64(v4, 0x3fd4f4406b993a2c, 0x3fed9d97ae0b1cd6, 0x3feefcd01012c05e,
+  VLOAD_64(v16, 0x3fd4f4406b993a2c, 0x3fed9d97ae0b1cd6, 0x3feefcd01012c05e,
            0xbfe5b09210bc082e, 0x3feef1596c459614, 0x3fe9af1e3ee3adfa,
            0xbfe7a4ec2374d0e2, 0x3fe7c8a2209c110c, 0x3fedefbbe3db30dc,
            0xbfdb01d523d9acc0, 0x3feca469e5b540fa, 0x3fe5876e42389dca,
@@ -428,13 +428,13 @@ void TEST_CASE4(void) {
   //                 -0.3443302881655670,  0.3680926220616383,
   //                 -0.2344410843781140,  0.3553553454507421,
   //                 0.0951222110617760, -0.8329780449088213
-  VLOAD_64(v2, 0x3fc56654e2cbd888, 0x3fe40bb445915f4a, 0x3fc4514877d696a0,
+  VLOAD_64(v8, 0x3fc56654e2cbd888, 0x3fe40bb445915f4a, 0x3fc4514877d696a0,
            0xbfd56df357d00344, 0x3fde371a20d41408, 0x3fd26b70e63cabf0,
            0x3fe044a59c60fcd4, 0x3fee3905d92cc95e, 0xbfd1f50bba2f6e40,
            0xbfe719aff62247a4, 0xbfd60981e7ac601c, 0x3fd78ed45b69d4fc,
            0xbfce022a5b1f1348, 0x3fd6be2458cadcb0, 0x3fb859ede1a22f80,
            0xbfeaa7c192a56bc8);
-  asm volatile("vfnmacc.vf v2, %[A], v4, v0.t" ::[A] "f"(dscalar_64));
+  asm volatile("vfnmacc.vf v8, %[A], v16, v0.t" ::[A] "f"(dscalar_64));
   //                -0.2006411422994659, -0.7209983883869466,
   //                -0.2576811937222847,  0.4040963223414386,
   //                -0.5709208038927434, -0.3698229881701340,
@@ -442,7 +442,7 @@ void TEST_CASE4(void) {
   //                0.1849871561177042,  0.7650058093340112, 0.2528687874349445,
   //                -0.4368399331233641,  0.3247043825365946,
   //                -0.3590115633601233, -0.0562707107317317, 0.7325151133694248
-  VCMP_U64(12, v2, 0x3fc56654e2cbd888, 0xbfe7126b3652e68a, 0x3fc4514877d696a0,
+  VCMP_U64(12, v8, 0x3fc56654e2cbd888, 0xbfe7126b3652e68a, 0x3fc4514877d696a0,
            0x3fd9dcb6d238fb8a, 0x3fde371a20d41408, 0xbfd7ab2e09dffb6d,
            0x3fe044a59c60fcd4, 0xbff053973a823036, 0xbfd1f50bba2f6e40,
            0x3fe87aed768addeb, 0xbfd60981e7ac601c, 0xbfdbf52f7a9681dc,
diff --git a/sw/riscvTests/isa/rv64uv/vfnmadd.c b/sw/riscvTests/isa/rv64uv/vfnmadd.c
index 8203324b..9bc23a86 100644
--- a/sw/riscvTests/isa/rv64uv/vfnmadd.c
+++ b/sw/riscvTests/isa/rv64uv/vfnmadd.c
@@ -10,36 +10,36 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.7461,  0.0514, -0.3071, -0.4934, -0.5220, -0.7983,  0.4907,
   //              -0.9028,  0.1752,  0.0676,  0.1040,  0.4526,  0.3525, -0.2686,
   //              0.3540, -0.0847
-  VLOAD_16(v4, 0xb9f8, 0x2a94, 0xb4ea, 0xb7e5, 0xb82d, 0xba63, 0x37da, 0xbb39,
+  VLOAD_16(v16, 0xb9f8, 0x2a94, 0xb4ea, 0xb7e5, 0xb82d, 0xba63, 0x37da, 0xbb39,
            0x319b, 0x2c54, 0x2ea8, 0x373e, 0x35a4, 0xb44c, 0x35aa, 0xad6c);
   //               0.1573, -0.7700,  0.0804, -0.9438,  0.0790,  0.7998, -0.2854,
   //               0.1963, -0.0687, -0.2123,  0.3625, -0.0002,  0.7168, -0.4033,
   //               0.2812, -0.3159
-  VLOAD_16(v6, 0x3109, 0xba29, 0x2d25, 0xbb8d, 0x2d0e, 0x3a66, 0xb491, 0x3248,
+  VLOAD_16(v24, 0x3109, 0xba29, 0x2d25, 0xbb8d, 0x2d0e, 0x3a66, 0xb491, 0x3248,
            0xac65, 0xb2cb, 0x35cd, 0x897c, 0x39bc, 0xb674, 0x3480, 0xb50e);
   //               0.0337,  0.2034, -0.1886,  0.8242,  0.3225,  0.0331,  0.0698,
   //               0.6777, -0.2539, -0.5825, -0.4319, -0.6323,  0.0674, -0.2903,
   //               -0.8145,  0.1893
-  VLOAD_16(v2, 0x284f, 0x3282, 0xb209, 0x3a98, 0x3529, 0x283b, 0x2c77, 0x396c,
+  VLOAD_16(v8, 0x284f, 0x3282, 0xb209, 0x3a98, 0x3529, 0x283b, 0x2c77, 0x396c,
            0xb410, 0xb8a9, 0xb6e9, 0xb90f, 0x2c50, 0xb4a5, 0xba84, 0x320f);
-  asm volatile("vfnmadd.vv v2, v4, v6");
+  asm volatile("vfnmadd.vv v8, v16, v24");
   //              -0.1322,  0.7598, -0.1383,  1.3506,  0.0894, -0.7734,  0.2512,
   //              0.4155,  0.1132,  0.2517, -0.3176,  0.2864, -0.7407,  0.3254,
   //              0.0071,  0.3320
-  VCMP_U16(1, v2, 0xb03b, 0x3a14, 0xb06d, 0x3d67, 0x2db8, 0xba30, 0x3405,
+  VCMP_U16(1, v8, 0xb03b, 0x3a14, 0xb06d, 0x3d67, 0x2db8, 0xba30, 0x3405,
            0x36a6, 0x2f3e, 0x3407, 0xb515, 0x3495, 0xb9ed, 0x3535, 0x1f3d,
            0x3550);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.36820358,  0.10496315, -0.32905263, -0.92334682,
   //              0.43153936,  0.92736709, -0.59600371,  0.75117606, 0.84123290,
   //              0.33028743, -0.43412161,  0.95273590,  0.06816643,
   //              -0.88978988,  0.18573478,  0.61926919
-  VLOAD_32(v4, 0xbebc852e, 0x3dd6f6ec, 0xbea87996, 0xbf6c6075, 0x3edcf2ba,
+  VLOAD_32(v16, 0xbebc852e, 0x3dd6f6ec, 0xbea87996, 0xbf6c6075, 0x3edcf2ba,
            0x3f6d67ee, 0xbf1893b3, 0x3f404d13, 0x3f575b0a, 0x3ea91b6f,
            0xbede4530, 0x3f73e680, 0x3d8b9ad8, 0xbf63c945, 0x3e3e3142,
            0x3f1e886d);
@@ -47,7 +47,7 @@ void TEST_CASE1(void) {
   //               -0.67489260,  0.23259214, -0.14038530,  0.09741956,
   //               -0.23567833,  0.75417399, -0.90357685, -0.87489468,
   //               0.54726779, -0.06705534, -0.15476358, -0.96940458
-  VLOAD_32(v6, 0x3f30dac8, 0xbea068b4, 0xbf0c4ffb, 0x3e801918, 0xbf2cc5c3,
+  VLOAD_32(v24, 0x3f30dac8, 0xbea068b4, 0xbf0c4ffb, 0x3e801918, 0xbf2cc5c3,
            0x3e6e2ca2, 0xbe0fc12a, 0x3dc783e8, 0xbe7155a9, 0x3f41118c,
            0xbf6750d0, 0xbf5ff919, 0x3f0c19be, 0xbd895450, 0xbe1e7a58,
            0xbf782ae6);
@@ -55,29 +55,29 @@ void TEST_CASE1(void) {
   //               0.63562357, -0.45508829, -0.22051410,  0.42499006,
   //               -0.59229839, -0.50074077, -0.80474108, -0.20762257,
   //               0.15367362,  0.98349953, -0.15871963, -0.07445616
-  VLOAD_32(v2, 0x3d187c0a, 0x3f4ed687, 0x3f0a0c76, 0xbf020eee, 0x3f22b83a,
+  VLOAD_32(v8, 0x3d187c0a, 0x3f4ed687, 0x3f0a0c76, 0xbf020eee, 0x3f22b83a,
            0xbee90155, 0xbe61ce73, 0x3ed9984c, 0xbf17a0de, 0xbf00308c,
            0xbf4e0383, 0xbe549b03, 0x3e1d5c9e, 0x3f7bc6a0, 0xbe228766,
            0xbd987c79);
-  asm volatile("vfnmadd.vv v2, v4, v6");
+  asm volatile("vfnmadd.vv v8, v16, v24");
   //              -0.67713100,  0.22849269,  0.72553790, -0.71928883,
   //              0.40059602,  0.18944177,  0.00895807, -0.41666192, 0.73393923,
   //              -0.58878565,  0.55422139,  1.07270420, -0.55774319,
   //              0.94216329,  0.18424334,  1.01551294
-  VCMP_U32(2, v2, 0xbf2d5875, 0x3e69f9fd, 0x3f39bcda, 0xbf382350, 0x3ecd1aec,
+  VCMP_U32(2, v8, 0xbf2d5875, 0x3e69f9fd, 0x3f39bcda, 0xbf382350, 0x3ecd1aec,
            0x3e41fd06, 0x3c12c4e5, 0xbed554b6, 0x3f3be371, 0xbf16baa7,
            0x3f0de173, 0x3f894e5f, 0xbf0ec842, 0x3f71319d, 0x3e3caa49,
            0x3f81fc54);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.1517393950396491, -0.0976116299317518,  0.4195080955516000,
   //              -0.8346165642452430,  0.0078216057137750, -0.5126918345148062,
   //              -0.9302856586058497, -0.8971839537614414,  0.1317157676127678,
   //              -0.3423297874984121,  0.7678405723111816, -0.6465198020108864,
   //              0.4795090517472360, -0.9006147069685106,  0.9841759200408695,
   //              0.8437352562659637
-  VLOAD_64(v4, 0xbfc36c324d9ae520, 0xbfb8fd1366442100, 0x3fdad9387bb34990,
+  VLOAD_64(v16, 0xbfc36c324d9ae520, 0xbfb8fd1366442100, 0x3fdad9387bb34990,
            0xbfeab52dcc044330, 0x3f8004c625f16600, 0xbfe067f8b4c55ad2,
            0xbfedc4e66df4cc5a, 0xbfecb5bb1f7cd800, 0x3fc0dc0ff121d700,
            0xbfd5e8bb327025d8, 0x3fe892266453ca54, 0xbfe4b04a4bbb4d06,
@@ -89,7 +89,7 @@ void TEST_CASE1(void) {
   //               -0.3398132406457823, -0.1436002174993440,
   //               -0.7049093483038609,  0.0726450331160087, 0.3054536350672581,
   //               -0.9906780567812383,  0.2659677084286980, -0.6111168392293305
-  VLOAD_64(v6, 0x3fd90f742ba04f2c, 0x3fa7f9df8ab696e0, 0x3fddb3217157f678,
+  VLOAD_64(v24, 0x3fd90f742ba04f2c, 0x3fa7f9df8ab696e0, 0x3fddb3217157f678,
            0x3fed70907d95274a, 0xbfe573086459defe, 0x3fe40064742efe82,
            0xbfd7c8cd8353cefc, 0x3fcc0d064ea14910, 0xbfd5bf8008d49208,
            0xbfc2617deeedd880, 0xbfe68e9e0cb3831e, 0x3fb298dd69733960,
@@ -101,20 +101,20 @@ void TEST_CASE1(void) {
   //               -0.8703598457154336, -0.2254866845234647, 0.7002825787534324,
   //               0.0892712008047818,  0.9241326299982451,  0.6615225744181676,
   //               0.7351775340550828, -0.4044996673659886
-  VLOAD_64(v2, 0x3fec9518a458e4ea, 0x3fe0c25010978504, 0xbfd7c958b04a2e10,
+  VLOAD_64(v8, 0x3fec9518a458e4ea, 0x3fe0c25010978504, 0xbfd7c958b04a2e10,
            0x3fec2e7ba402502e, 0x3fdb6d803f3895dc, 0xbfed6516b24524fa,
            0xbfd8ffe68378eb00, 0xbfebc848a4fdff0a, 0xbfebd9fce4232e3a,
            0xbfccdcbf67db1aa0, 0x3fe668b702b68b90, 0x3fb6da7a37ee6240,
            0x3fed927e97e0492a, 0x3fe52b3163d622de, 0x3fe786930930a7fe,
            0xbfd9e35292a51b70);
-  asm volatile("vfnmadd.vv v2, v4, v6");
+  asm volatile("vfnmadd.vv v8, v16, v24");
   //              -0.2560345624688988,  0.0042928888070631, -0.3081421208222118,
   //              -0.1849655060915788,  0.6669400726566582, -1.0960014534443465,
   //              0.0082438467988533, -0.9980814245844917,  0.4544533558235209,
   //              0.0664094087027049,  0.1672039722542752, -0.0149294340464271,
   //              -0.7485835961663959,  1.5864550162939111, -0.9895117344007368,
   //              0.9524074697338700
-  VCMP_U64(3, v2, 0xbfd062deca1cc612, 0x3f71956b9081d880, 0xbfd3b899badce50e,
+  VCMP_U64(3, v8, 0xbfd062deca1cc612, 0x3f71956b9081d880, 0xbfd3b899badce50e,
            0xbfc7acf31fc694ed, 0x3fe55792b50e7883, 0xbff18938d1ee9749,
            0x3f80e22663278b8b, 0xbfeff04874aabc45, 0x3fdd15c38734723f,
            0x3fb10034fe865a4b, 0x3fc566f0944bf4a6, 0xbf8e9352b7d14aa9,
@@ -126,37 +126,37 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.7461,  0.0514, -0.3071, -0.4934, -0.5220, -0.7983,  0.4907,
   //              -0.9028,  0.1752,  0.0676,  0.1040,  0.4526,  0.3525, -0.2686,
   //              0.3540, -0.0847
-  VLOAD_16(v4, 0xb9f8, 0x2a94, 0xb4ea, 0xb7e5, 0xb82d, 0xba63, 0x37da, 0xbb39,
+  VLOAD_16(v16, 0xb9f8, 0x2a94, 0xb4ea, 0xb7e5, 0xb82d, 0xba63, 0x37da, 0xbb39,
            0x319b, 0x2c54, 0x2ea8, 0x373e, 0x35a4, 0xb44c, 0x35aa, 0xad6c);
   //               0.1573, -0.7700,  0.0804, -0.9438,  0.0790,  0.7998, -0.2854,
   //               0.1963, -0.0687, -0.2123,  0.3625, -0.0002,  0.7168, -0.4033,
   //               0.2812, -0.3159
-  VLOAD_16(v6, 0x3109, 0xba29, 0x2d25, 0xbb8d, 0x2d0e, 0x3a66, 0xb491, 0x3248,
+  VLOAD_16(v24, 0x3109, 0xba29, 0x2d25, 0xbb8d, 0x2d0e, 0x3a66, 0xb491, 0x3248,
            0xac65, 0xb2cb, 0x35cd, 0x897c, 0x39bc, 0xb674, 0x3480, 0xb50e);
   VLOAD_8(v0, 0xAA, 0xAA);
   //               0.0337,  0.2034, -0.1886,  0.8242,  0.3225,  0.0331,  0.0698,
   //               0.6777, -0.2539, -0.5825, -0.4319, -0.6323,  0.0674, -0.2903,
   //               -0.8145,  0.1893
-  VLOAD_16(v2, 0x284f, 0x3282, 0xb209, 0x3a98, 0x3529, 0x283b, 0x2c77, 0x396c,
+  VLOAD_16(v8, 0x284f, 0x3282, 0xb209, 0x3a98, 0x3529, 0x283b, 0x2c77, 0x396c,
            0xb410, 0xb8a9, 0xb6e9, 0xb90f, 0x2c50, 0xb4a5, 0xba84, 0x320f);
-  asm volatile("vfnmadd.vv v2, v4, v6, v0.t");
+  asm volatile("vfnmadd.vv v8, v16, v24, v0.t");
   //               0.0337,  0.7598, -0.1886,  1.3506,  0.3225, -0.7734,  0.0698,
   //               0.4155, -0.2539,  0.2517, -0.4319,  0.2864,  0.0674,  0.3254,
   //               -0.8145,  0.3320
-  VCMP_U16(4, v2, 0x284f, 0x3a14, 0xb209, 0x3d67, 0x3529, 0xba30, 0x2c77,
+  VCMP_U16(4, v8, 0x284f, 0x3a14, 0xb209, 0x3d67, 0x3529, 0xba30, 0x2c77,
            0x36a6, 0xb410, 0x3407, 0xb6e9, 0x3495, 0x2c50, 0x3535, 0xba84,
            0x3550);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.36820358,  0.10496315, -0.32905263, -0.92334682,
   //              0.43153936,  0.92736709, -0.59600371,  0.75117606, 0.84123290,
   //              0.33028743, -0.43412161,  0.95273590,  0.06816643,
   //              -0.88978988,  0.18573478,  0.61926919
-  VLOAD_32(v4, 0xbebc852e, 0x3dd6f6ec, 0xbea87996, 0xbf6c6075, 0x3edcf2ba,
+  VLOAD_32(v16, 0xbebc852e, 0x3dd6f6ec, 0xbea87996, 0xbf6c6075, 0x3edcf2ba,
            0x3f6d67ee, 0xbf1893b3, 0x3f404d13, 0x3f575b0a, 0x3ea91b6f,
            0xbede4530, 0x3f73e680, 0x3d8b9ad8, 0xbf63c945, 0x3e3e3142,
            0x3f1e886d);
@@ -164,7 +164,7 @@ void TEST_CASE2(void) {
   //               -0.67489260,  0.23259214, -0.14038530,  0.09741956,
   //               -0.23567833,  0.75417399, -0.90357685, -0.87489468,
   //               0.54726779, -0.06705534, -0.15476358, -0.96940458
-  VLOAD_32(v6, 0x3f30dac8, 0xbea068b4, 0xbf0c4ffb, 0x3e801918, 0xbf2cc5c3,
+  VLOAD_32(v24, 0x3f30dac8, 0xbea068b4, 0xbf0c4ffb, 0x3e801918, 0xbf2cc5c3,
            0x3e6e2ca2, 0xbe0fc12a, 0x3dc783e8, 0xbe7155a9, 0x3f41118c,
            0xbf6750d0, 0xbf5ff919, 0x3f0c19be, 0xbd895450, 0xbe1e7a58,
            0xbf782ae6);
@@ -173,29 +173,29 @@ void TEST_CASE2(void) {
   //               0.63562357, -0.45508829, -0.22051410,  0.42499006,
   //               -0.59229839, -0.50074077, -0.80474108, -0.20762257,
   //               0.15367362,  0.98349953, -0.15871963, -0.07445616
-  VLOAD_32(v2, 0x3d187c0a, 0x3f4ed687, 0x3f0a0c76, 0xbf020eee, 0x3f22b83a,
+  VLOAD_32(v8, 0x3d187c0a, 0x3f4ed687, 0x3f0a0c76, 0xbf020eee, 0x3f22b83a,
            0xbee90155, 0xbe61ce73, 0x3ed9984c, 0xbf17a0de, 0xbf00308c,
            0xbf4e0383, 0xbe549b03, 0x3e1d5c9e, 0x3f7bc6a0, 0xbe228766,
            0xbd987c79);
-  asm volatile("vfnmadd.vv v2, v4, v6, v0.t");
+  asm volatile("vfnmadd.vv v8, v16, v24, v0.t");
   //               0.03722767,  0.22849269,  0.53925264, -0.71928883,
   //               0.63562357,  0.18944177, -0.22051410, -0.41666192,
   //               -0.59229839, -0.58878565, -0.80474108,  1.07270420,
   //               0.15367362,  0.94216329, -0.15871963,  1.01551294
-  VCMP_U32(5, v2, 0x3d187c0a, 0x3e69f9fd, 0x3f0a0c76, 0xbf382350, 0x3f22b83a,
+  VCMP_U32(5, v8, 0x3d187c0a, 0x3e69f9fd, 0x3f0a0c76, 0xbf382350, 0x3f22b83a,
            0x3e41fd06, 0xbe61ce73, 0xbed554b6, 0xbf17a0de, 0xbf16baa7,
            0xbf4e0383, 0x3f894e5f, 0x3e1d5c9e, 0x3f71319d, 0xbe228766,
            0x3f81fc54);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.1517393950396491, -0.0976116299317518,  0.4195080955516000,
   //              -0.8346165642452430,  0.0078216057137750, -0.5126918345148062,
   //              -0.9302856586058497, -0.8971839537614414,  0.1317157676127678,
   //              -0.3423297874984121,  0.7678405723111816, -0.6465198020108864,
   //              0.4795090517472360, -0.9006147069685106,  0.9841759200408695,
   //              0.8437352562659637
-  VLOAD_64(v4, 0xbfc36c324d9ae520, 0xbfb8fd1366442100, 0x3fdad9387bb34990,
+  VLOAD_64(v16, 0xbfc36c324d9ae520, 0xbfb8fd1366442100, 0x3fdad9387bb34990,
            0xbfeab52dcc044330, 0x3f8004c625f16600, 0xbfe067f8b4c55ad2,
            0xbfedc4e66df4cc5a, 0xbfecb5bb1f7cd800, 0x3fc0dc0ff121d700,
            0xbfd5e8bb327025d8, 0x3fe892266453ca54, 0xbfe4b04a4bbb4d06,
@@ -207,7 +207,7 @@ void TEST_CASE2(void) {
   //               -0.3398132406457823, -0.1436002174993440,
   //               -0.7049093483038609,  0.0726450331160087, 0.3054536350672581,
   //               -0.9906780567812383,  0.2659677084286980, -0.6111168392293305
-  VLOAD_64(v6, 0x3fd90f742ba04f2c, 0x3fa7f9df8ab696e0, 0x3fddb3217157f678,
+  VLOAD_64(v24, 0x3fd90f742ba04f2c, 0x3fa7f9df8ab696e0, 0x3fddb3217157f678,
            0x3fed70907d95274a, 0xbfe573086459defe, 0x3fe40064742efe82,
            0xbfd7c8cd8353cefc, 0x3fcc0d064ea14910, 0xbfd5bf8008d49208,
            0xbfc2617deeedd880, 0xbfe68e9e0cb3831e, 0x3fb298dd69733960,
@@ -220,13 +220,13 @@ void TEST_CASE2(void) {
   //               -0.8703598457154336, -0.2254866845234647, 0.7002825787534324,
   //               0.0892712008047818,  0.9241326299982451,  0.6615225744181676,
   //               0.7351775340550828, -0.4044996673659886
-  VLOAD_64(v2, 0x3fec9518a458e4ea, 0x3fe0c25010978504, 0xbfd7c958b04a2e10,
+  VLOAD_64(v8, 0x3fec9518a458e4ea, 0x3fe0c25010978504, 0xbfd7c958b04a2e10,
            0x3fec2e7ba402502e, 0x3fdb6d803f3895dc, 0xbfed6516b24524fa,
            0xbfd8ffe68378eb00, 0xbfebc848a4fdff0a, 0xbfebd9fce4232e3a,
            0xbfccdcbf67db1aa0, 0x3fe668b702b68b90, 0x3fb6da7a37ee6240,
            0x3fed927e97e0492a, 0x3fe52b3163d622de, 0x3fe786930930a7fe,
            0xbfd9e35292a51b70);
-  asm volatile("vfnmadd.vv v2, v4, v6, v0.t");
+  asm volatile("vfnmadd.vv v8, v16, v24, v0.t");
   //               0.8932002267748917,  0.0042928888070631, -0.3716642114238491,
   //               -0.1849655060915788,  0.4285584084885536,
   //               -1.0960014534443465, -0.3906189235600976,
@@ -234,7 +234,7 @@ void TEST_CASE2(void) {
   //               0.7002825787534324, -0.0149294340464271,
   //               0.9241326299982451,  1.5864550162939111,  0.7351775340550828,
   //               0.9524074697338700
-  VCMP_U64(6, v2, 0x3fec9518a458e4ea, 0x3f71956b9081d880, 0xbfd7c958b04a2e10,
+  VCMP_U64(6, v8, 0x3fec9518a458e4ea, 0x3f71956b9081d880, 0xbfd7c958b04a2e10,
            0xbfc7acf31fc694ed, 0x3fdb6d803f3895dc, 0xbff18938d1ee9749,
            0xbfd8ffe68378eb00, 0xbfeff04874aabc45, 0xbfebd9fce4232e3a,
            0x3fb10034fe865a4b, 0x3fe668b702b68b90, 0xbf8e9352b7d14aa9,
@@ -245,29 +245,29 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.2646
   BOX_HALF_IN_FLOAT(fscalar_16, 0x343c);
   //               0.4216, -0.2148,  0.0047,  0.6802, -0.8965, -0.2986, -0.1786,
   //               -0.1904,  0.2805,  0.5322, -0.5298,  0.3208,  0.0567,
   //               -0.9897, -0.5400, -0.4187
-  VLOAD_16(v4, 0x36bf, 0xb2e0, 0x1cc3, 0x3971, 0xbb2c, 0xb4c7, 0xb1b7, 0xb218,
+  VLOAD_16(v16, 0x36bf, 0xb2e0, 0x1cc3, 0x3971, 0xbb2c, 0xb4c7, 0xb1b7, 0xb218,
            0x347d, 0x3842, 0xb83d, 0x3522, 0x2b41, 0xbbeb, 0xb852, 0xb6b3);
   //              -0.7886, -0.5435, -0.8345,  0.7793,  0.5796, -0.8374, -0.8623,
   //              -0.3313, -0.2690, -0.9214,  0.2126, -0.6772, -0.6514, -0.5703,
   //              -0.2585, -0.3320
-  VLOAD_16(v2, 0xba4f, 0xb859, 0xbaad, 0x3a3c, 0x38a3, 0xbab3, 0xbae6, 0xb54d,
+  VLOAD_16(v8, 0xba4f, 0xb859, 0xbaad, 0x3a3c, 0x38a3, 0xbab3, 0xbae6, 0xb54d,
            0xb44e, 0xbb5f, 0x32ce, 0xb96b, 0xb936, 0xb890, 0xb423, 0xb550);
-  asm volatile("vfnmadd.vf v2, %[A], v4" ::[A] "f"(fscalar_16));
+  asm volatile("vfnmadd.vf v8, %[A], v16" ::[A] "f"(fscalar_16));
   //              -0.2129,  0.3586,  0.2162, -0.8867,  0.7432,  0.5200,  0.4067,
   //              0.2781, -0.2092, -0.2883,  0.4736, -0.1416,  0.1157,  1.1406,
   //              0.6084,  0.5068
-  VCMP_U16(7, v2, 0xb2d0, 0x35bd, 0x32eb, 0xbb17, 0x39f2, 0x3829, 0x3682,
+  VCMP_U16(7, v8, 0xb2d0, 0x35bd, 0x32eb, 0xbb17, 0x39f2, 0x3829, 0x3682,
            0x3473, 0xb2b3, 0xb49d, 0x3793, 0xb088, 0x2f68, 0x3c90, 0x38de,
            0x380d);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.13809182
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbe0d67f1);
@@ -275,7 +275,7 @@ void TEST_CASE3(void) {
   //              0.55768263,  0.47349435,  0.77556002,  0.16363664, 0.80314618,
   //              -0.48171839, -0.60694915,  0.16937894,  0.86316317,
   //              0.00897404, -0.96310323, -0.27890080
-  VLOAD_32(v4, 0xbe2dd934, 0xbe9db2a5, 0xbebd7e18, 0xbf6c438a, 0x3f0ec44a,
+  VLOAD_32(v16, 0xbe2dd934, 0xbe9db2a5, 0xbebd7e18, 0xbf6c438a, 0x3f0ec44a,
            0x3ef26dda, 0x3f468b1a, 0x3e27905d, 0x3f4d9afd, 0xbef6a3cb,
            0xbf1b6105, 0x3e2d71ac, 0x3f5cf843, 0x3c1307df, 0xbf768def,
            0xbe8ecc16);
@@ -283,22 +283,22 @@ void TEST_CASE3(void) {
   //              0.72045243, -0.36672497,  0.69402671,  0.44954479,
   //              -0.77024877, -0.83221292,  0.37576449, -0.77536738,
   //              -0.55040795, -0.71568310, -0.75874990,  0.91956782
-  VLOAD_32(v2, 0xbea9a47f, 0xbefabdb8, 0x3f74e1bf, 0xbf6461c8, 0x3f386f92,
+  VLOAD_32(v8, 0xbea9a47f, 0xbefabdb8, 0x3f74e1bf, 0xbf6461c8, 0x3f386f92,
            0xbebbc360, 0x3f31abbc, 0x3ee62abc, 0xbf452f06, 0xbf550be8,
            0x3ec06434, 0xbf467e7a, 0xbf0ce789, 0xbf373702, 0xbf423d6f,
            0x3f6b68cc);
-  asm volatile("vfnmadd.vf v2, %[A], v4" ::[A] "f"(fscalar_32));
+  asm volatile("vfnmadd.vf v8, %[A], v16" ::[A] "f"(fscalar_32));
   //               0.12401948,  0.24037606,  0.50219709,  0.79971153,
   //               -0.45819405, -0.52413607, -0.67972064, -0.10155818,
   //               -0.90951121,  0.36679661,  0.65883917, -0.27645081,
   //               -0.93917000, -0.10780402,  0.85832608,  0.40588558
-  VCMP_U32(8, v2, 0x3dfdfded, 0x3e762524, 0x3f008ffd, 0x3f4cb9e5, 0xbeea9869,
+  VCMP_U32(8, v8, 0x3dfdfded, 0x3e762524, 0x3f008ffd, 0x3f4cb9e5, 0xbeea9869,
            0xbf062dc8, 0xbf2e022c, 0xbdcffdbd, 0xbf68d5ba, 0x3ebbccc3,
            0x3f28a9af, 0xbe8d8af6, 0xbf706d72, 0xbddcc85b, 0x3f5bbb42,
            0x3ecfd03d);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.8978909040536565
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fecbb85b489299a);
@@ -310,7 +310,7 @@ void TEST_CASE3(void) {
   //                -0.9796673648941667,  0.2148282430178909,
   //                -0.1529278220414154, -0.7708574130314993,
   //                -0.4104905538508556
-  VLOAD_64(v4, 0x3fda5d975d575ea8, 0xbfbe7cae0e441b80, 0x3fefb0cd7ce7c8e8,
+  VLOAD_64(v16, 0x3fda5d975d575ea8, 0xbfbe7cae0e441b80, 0x3fefb0cd7ce7c8e8,
            0x3fe0fecd81607572, 0x3fc597eae3ba06f8, 0xbfec1f6077386c08,
            0x3fc81248312ba2f8, 0x3fe85ac99da9270a, 0xbfb658d7d8ca9eb0,
            0xbfe5f0214100b7de, 0xbf929ad05e338a40, 0xbfef596f5fa5b9ea,
@@ -323,20 +323,20 @@ void TEST_CASE3(void) {
   //                0.3334000822950238, -0.6004917796663505, 0.4588428764280068,
   //                0.8937156106780619,  0.8421999503441004, 0.3083609158934253,
   //                -0.2219824502919918,  0.5118870280625194
-  VLOAD_64(v2, 0x3fe028f93e467e2c, 0x3fea6cbfe4289cd0, 0xbfd0d6a877a053e0,
+  VLOAD_64(v8, 0x3fe028f93e467e2c, 0x3fea6cbfe4289cd0, 0xbfd0d6a877a053e0,
            0x3fe9bbe080247574, 0xbfa083b2550ab080, 0xbfd9907d14a5c710,
            0xbfe3b1ccad88e3e8, 0xbfed786917e1dd9e, 0x3fd5566d4c7c36a8,
            0xbfe3373a8965e1cc, 0x3fdd5dae8310b1e8, 0x3fec99517af92ea6,
            0x3feaf34d4f6d76aa, 0x3fd3bc2f6c481e9c, 0xbfcc69ebc2252060,
            0x3fe06160e798ce12);
-  asm volatile("vfnmadd.vf v2, %[A], v4" ::[A] "f"(dscalar_64));
+  asm volatile("vfnmadd.vf v8, %[A], v16" ::[A] "f"(dscalar_64));
   //              -0.8653987555659035, -0.6223659818850454, -0.7540957457254903,
   //              -1.2531735291223209, -0.1397373948516451,  1.2374872082900796,
   //              0.3645526649939371,  0.0658288599840662,
   //              -0.2120637623916150,  1.2247388386247897, -0.3938221518308497,
   //              0.1772082472555760, -0.9710319178262998, -0.1239466395049457,
   //              0.9701734360082217, -0.0491281525495393
-  VCMP_U64(9, v2, 0xbfebb158bb24f2ec, 0xbfe3ea6c104adab7, 0xbfe8218d66be32e5,
+  VCMP_U64(9, v8, 0xbfebb158bb24f2ec, 0xbfe3ea6c104adab7, 0xbfe8218d66be32e5,
            0xbff40cffafbcb13e, 0xbfc1e2ea3a754147, 0x3ff3ccbf630d300f,
            0x3fd754d4b3746402, 0x3fb0da2900c3b814, 0xbfcb24e7c611c0f4,
            0x3ff39887c0a08d49, 0xbfd93461d3a37236, 0x3fc6aec28545a7b7,
@@ -347,30 +347,30 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.2646
   BOX_HALF_IN_FLOAT(fscalar_16, 0x343c);
   //                0.4216, -0.2148,  0.0047,  0.6802, -0.8965, -0.2986,
   //                -0.1786, -0.1904,  0.2805,  0.5322, -0.5298,  0.3208,
   //                0.0567, -0.9897, -0.5400, -0.4187
-  VLOAD_16(v4, 0x36bf, 0xb2e0, 0x1cc3, 0x3971, 0xbb2c, 0xb4c7, 0xb1b7, 0xb218,
+  VLOAD_16(v16, 0x36bf, 0xb2e0, 0x1cc3, 0x3971, 0xbb2c, 0xb4c7, 0xb1b7, 0xb218,
            0x347d, 0x3842, 0xb83d, 0x3522, 0x2b41, 0xbbeb, 0xb852, 0xb6b3);
   VLOAD_8(v0, 0xAA, 0xAA);
   //               -0.7886, -0.5435, -0.8345,  0.7793,  0.5796, -0.8374,
   //               -0.8623, -0.3313, -0.2690, -0.9214,  0.2126, -0.6772,
   //               -0.6514, -0.5703, -0.2585, -0.3320
-  VLOAD_16(v2, 0xba4f, 0xb859, 0xbaad, 0x3a3c, 0x38a3, 0xbab3, 0xbae6, 0xb54d,
+  VLOAD_16(v8, 0xba4f, 0xb859, 0xbaad, 0x3a3c, 0x38a3, 0xbab3, 0xbae6, 0xb54d,
            0xb44e, 0xbb5f, 0x32ce, 0xb96b, 0xb936, 0xb890, 0xb423, 0xb550);
-  asm volatile("vfnmadd.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
+  asm volatile("vfnmadd.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_16));
   //               -0.7886,  0.3586, -0.8345, -0.8867,  0.5796,  0.5200,
   //               -0.8623,  0.2781, -0.2690, -0.2883,  0.2126, -0.1416,
   //               -0.6514,  1.1406, -0.2585,  0.5068
-  VCMP_U16(10, v2, 0xba4f, 0x35bd, 0xbaad, 0xbb17, 0x38a3, 0x3829, 0xbae6,
+  VCMP_U16(10, v8, 0xba4f, 0x35bd, 0xbaad, 0xbb17, 0x38a3, 0x3829, 0xbae6,
            0x3473, 0xb44e, 0xb49d, 0x32ce, 0xb088, 0xb936, 0x3c90, 0xb423,
            0x380d);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.13809182
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbe0d67f1);
@@ -378,7 +378,7 @@ void TEST_CASE4(void) {
   //               0.55768263,  0.47349435,  0.77556002,  0.16363664,
   //               0.80314618, -0.48171839, -0.60694915,  0.16937894,
   //               0.86316317,  0.00897404, -0.96310323, -0.27890080
-  VLOAD_32(v4, 0xbe2dd934, 0xbe9db2a5, 0xbebd7e18, 0xbf6c438a, 0x3f0ec44a,
+  VLOAD_32(v16, 0xbe2dd934, 0xbe9db2a5, 0xbebd7e18, 0xbf6c438a, 0x3f0ec44a,
            0x3ef26dda, 0x3f468b1a, 0x3e27905d, 0x3f4d9afd, 0xbef6a3cb,
            0xbf1b6105, 0x3e2d71ac, 0x3f5cf843, 0x3c1307df, 0xbf768def,
            0xbe8ecc16);
@@ -387,22 +387,22 @@ void TEST_CASE4(void) {
   //               0.72045243, -0.36672497,  0.69402671,  0.44954479,
   //               -0.77024877, -0.83221292,  0.37576449, -0.77536738,
   //               -0.55040795, -0.71568310, -0.75874990,  0.91956782
-  VLOAD_32(v2, 0xbea9a47f, 0xbefabdb8, 0x3f74e1bf, 0xbf6461c8, 0x3f386f92,
+  VLOAD_32(v8, 0xbea9a47f, 0xbefabdb8, 0x3f74e1bf, 0xbf6461c8, 0x3f386f92,
            0xbebbc360, 0x3f31abbc, 0x3ee62abc, 0xbf452f06, 0xbf550be8,
            0x3ec06434, 0xbf467e7a, 0xbf0ce789, 0xbf373702, 0xbf423d6f,
            0x3f6b68cc);
-  asm volatile("vfnmadd.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
+  asm volatile("vfnmadd.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_32));
   //               -0.33133313,  0.24037606,  0.95656961,  0.79971153,
   //               0.72045243, -0.52413607,  0.69402671, -0.10155818,
   //               -0.77024877,  0.36679661,  0.37576449, -0.27645081,
   //               -0.55040795, -0.10780402, -0.75874990,  0.40588558
-  VCMP_U32(11, v2, 0xbea9a47f, 0x3e762524, 0x3f74e1bf, 0x3f4cb9e5, 0x3f386f92,
+  VCMP_U32(11, v8, 0xbea9a47f, 0x3e762524, 0x3f74e1bf, 0x3f4cb9e5, 0x3f386f92,
            0xbf062dc8, 0x3f31abbc, 0xbdcffdbd, 0xbf452f06, 0x3ebbccc3,
            0x3ec06434, 0xbe8d8af6, 0xbf0ce789, 0xbddcc85b, 0xbf423d6f,
            0x3ecfd03d);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.8978909040536565
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fecbb85b489299a);
@@ -414,7 +414,7 @@ void TEST_CASE4(void) {
   //                 -0.0181686933036735, -0.9796673648941667,
   //                 0.2148282430178909, -0.1529278220414154,
   //                 -0.7708574130314993, -0.4104905538508556
-  VLOAD_64(v4, 0x3fda5d975d575ea8, 0xbfbe7cae0e441b80, 0x3fefb0cd7ce7c8e8,
+  VLOAD_64(v16, 0x3fda5d975d575ea8, 0xbfbe7cae0e441b80, 0x3fefb0cd7ce7c8e8,
            0x3fe0fecd81607572, 0x3fc597eae3ba06f8, 0xbfec1f6077386c08,
            0x3fc81248312ba2f8, 0x3fe85ac99da9270a, 0xbfb658d7d8ca9eb0,
            0xbfe5f0214100b7de, 0xbf929ad05e338a40, 0xbfef596f5fa5b9ea,
@@ -429,13 +429,13 @@ void TEST_CASE4(void) {
   //                 0.4588428764280068,  0.8937156106780619,
   //                 0.8421999503441004,  0.3083609158934253,
   //                 -0.2219824502919918,  0.5118870280625194
-  VLOAD_64(v2, 0x3fe028f93e467e2c, 0x3fea6cbfe4289cd0, 0xbfd0d6a877a053e0,
+  VLOAD_64(v8, 0x3fe028f93e467e2c, 0x3fea6cbfe4289cd0, 0xbfd0d6a877a053e0,
            0x3fe9bbe080247574, 0xbfa083b2550ab080, 0xbfd9907d14a5c710,
            0xbfe3b1ccad88e3e8, 0xbfed786917e1dd9e, 0x3fd5566d4c7c36a8,
            0xbfe3373a8965e1cc, 0x3fdd5dae8310b1e8, 0x3fec99517af92ea6,
            0x3feaf34d4f6d76aa, 0x3fd3bc2f6c481e9c, 0xbfcc69ebc2252060,
            0x3fe06160e798ce12);
-  asm volatile("vfnmadd.vf v2, %[A], v4, v0.t" ::[A] "f"(dscalar_64));
+  asm volatile("vfnmadd.vf v8, %[A], v16, v0.t" ::[A] "f"(dscalar_64));
   //                0.5050016609492949, -0.6223659818850454,
   //                -0.2631016891694440, -1.2531735291223209,
   //                -0.0322547653971421,  1.2374872082900796,
@@ -444,7 +444,7 @@ void TEST_CASE4(void) {
   //                0.1772082472555760,  0.8421999503441004,
   //                -0.1239466395049457, -0.2219824502919918,
   //                -0.0491281525495393
-  VCMP_U64(12, v2, 0x3fe028f93e467e2c, 0xbfe3ea6c104adab7, 0xbfd0d6a877a053e0,
+  VCMP_U64(12, v8, 0x3fe028f93e467e2c, 0xbfe3ea6c104adab7, 0xbfd0d6a877a053e0,
            0xbff40cffafbcb13e, 0xbfa083b2550ab080, 0x3ff3ccbf630d300f,
            0xbfe3b1ccad88e3e8, 0x3fb0da2900c3b814, 0x3fd5566d4c7c36a8,
            0x3ff39887c0a08d49, 0x3fdd5dae8310b1e8, 0x3fc6aec28545a7b7,
diff --git a/sw/riscvTests/isa/rv64uv/vfnmsac.c b/sw/riscvTests/isa/rv64uv/vfnmsac.c
index d3c0957f..2b46ec17 100644
--- a/sw/riscvTests/isa/rv64uv/vfnmsac.c
+++ b/sw/riscvTests/isa/rv64uv/vfnmsac.c
@@ -10,36 +10,36 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.3474, -0.9888,  0.2810,  0.4199,  0.1704, -0.3772,  0.2998,
   //               0.7871, -0.2527, -0.8618,  0.2646,  0.5488, -0.3184, -0.3508,
   //               -0.3589, -0.3914
-  VLOAD_16(v4, 0x358f, 0xbbe9, 0x347f, 0x36b8, 0x3174, 0xb609, 0x34cc, 0x3a4c,
+  VLOAD_16(v16, 0x358f, 0xbbe9, 0x347f, 0x36b8, 0x3174, 0xb609, 0x34cc, 0x3a4c,
            0xb40b, 0xbae5, 0x343c, 0x3864, 0xb518, 0xb59d, 0xb5be, 0xb643);
   //               0.0417,  0.3862, -0.9619, -0.5659,  0.1731,  0.4827,  0.7334,
   //               -0.7271, -0.9814,  0.8003, -0.4836,  0.5234, -0.8540,
   //               -0.2036, -0.8823,  0.2603
-  VLOAD_16(v6, 0x2958, 0x362e, 0xbbb2, 0xb887, 0x318a, 0x37b9, 0x39de, 0xb9d1,
+  VLOAD_16(v24, 0x2958, 0x362e, 0xbbb2, 0xb887, 0x318a, 0x37b9, 0x39de, 0xb9d1,
            0xbbda, 0x3a67, 0xb7bd, 0x3830, 0xbad5, 0xb284, 0xbb0f, 0x342a);
   //              -0.2739,  0.2146,  0.5264, -0.8853,  0.8877, -0.6748, -0.7563,
   //              -0.9634,  0.7451, -0.5166,  0.0698,  0.4790, -0.0681, -0.9746,
   //              0.2129,  0.9072
-  VLOAD_16(v2, 0xb462, 0x32de, 0x3836, 0xbb15, 0x3b1a, 0xb966, 0xba0d, 0xbbb5,
+  VLOAD_16(v8, 0xb462, 0x32de, 0x3836, 0xbb15, 0x3b1a, 0xb966, 0xba0d, 0xbbb5,
            0x39f6, 0xb822, 0x2c77, 0x37aa, 0xac5b, 0xbbcc, 0x32d0, 0x3b42);
-  asm volatile("vfnmsac.vv v2, v4, v6");
+  asm volatile("vfnmsac.vv v8, v16, v24");
   //              -0.2883,  0.5967,  0.7969, -0.6475,  0.8584, -0.4927, -0.9761,
   //              -0.3911,  0.4971,  0.1733,  0.1978,  0.1917, -0.3401, -1.0459,
   //              -0.1038,  1.0088
-  VCMP_U16(1, v2, 0xb49d, 0x38c6, 0x3a60, 0xb92e, 0x3ade, 0xb7e2, 0xbbcf,
+  VCMP_U16(1, v8, 0xb49d, 0x38c6, 0x3a60, 0xb92e, 0x3ade, 0xb7e2, 0xbbcf,
            0xb642, 0x37f4, 0x318a, 0x3254, 0x3223, 0xb570, 0xbc2f, 0xaea4,
            0x3c09);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.11577118, -0.10074481,  0.13861528,  0.44782066,
   //               0.42196107, -0.67597556,  0.34948668, -0.87903690,
   //               -0.34136006, -0.19722189,  0.76997000, -0.68663412,
   //               0.45603558,  0.60629857, -0.86984915, -0.08019307
-  VLOAD_32(v4, 0x3ded1971, 0xbdce534c, 0x3e0df12a, 0x3ee548c0, 0x3ed80b48,
+  VLOAD_32(v16, 0x3ded1971, 0xbdce534c, 0x3e0df12a, 0x3ee548c0, 0x3ed80b48,
            0xbf2d0cbc, 0x3eb2efeb, 0xbf610890, 0xbeaec6bf, 0xbe49f489,
            0x3f451cc1, 0xbf2fc741, 0x3ee97d7f, 0x3f1b3662, 0xbf5eae6f,
            0xbda43c43);
@@ -47,7 +47,7 @@ void TEST_CASE1(void) {
   //              0.47494572, -0.34277225, -0.54462087, -0.90492284, 0.60100728,
   //              -0.02819708, -0.46859986,  0.87238866,  0.46812481,
   //              0.49922746,  0.97036403,  0.04279163
-  VLOAD_32(v6, 0xbec7879f, 0x3ecf286c, 0x3f30d065, 0xbf7b28a8, 0x3ef32c16,
+  VLOAD_32(v24, 0xbec7879f, 0x3ecf286c, 0x3f30d065, 0xbf7b28a8, 0x3ef32c16,
            0xbeaf7fd8, 0xbf0b6c46, 0xbf67a906, 0x3f19db9d, 0xbce6fd92,
            0xbeefec52, 0x3f5f54dd, 0x3eefae0e, 0x3eff9abe, 0x3f7869c7,
            0x3d2f4647);
@@ -55,29 +55,29 @@ void TEST_CASE1(void) {
   //               0.15318950,  0.15531392, -0.20705318, -0.82493448,
   //               0.12047531,  0.57526720,  0.23939800, -0.19725421,
   //               0.15403098,  0.03931713, -0.45930895, -0.15395784
-  VLOAD_32(v2, 0x3f4c4ca0, 0xbf3339f2, 0xbf02ae86, 0x3ec57575, 0x3e1cddb5,
+  VLOAD_32(v8, 0x3f4c4ca0, 0xbf3339f2, 0xbf02ae86, 0x3ec57575, 0x3e1cddb5,
            0x3e1f0a9d, 0xbe5405c0, 0xbf532ee8, 0x3df6bbc3, 0x3f1344b6,
            0x3e7524c0, 0xbe49fd02, 0x3e1dba4c, 0x3d210b00, 0xbeeb2a8b,
            0xbe1da720);
-  asm volatile("vfnmsac.vv v2, v4, v6");
+  asm volatile("vfnmsac.vv v8, v16, v24");
   //               0.84316099, -0.65934104, -0.60621428,  0.82501376,
   //               -0.04721911, -0.07639174, -0.01671545, -1.62039506,
   //               0.32563519,  0.56970614,  0.60020584,  0.40175763,
   //               -0.05945060, -0.26336378,  0.38476136, -0.15052626
-  VCMP_U32(2, v2, 0x3f57d966, 0xbf28ca93, 0xbf1b30dc, 0x3f53341a, 0xbd4168d3,
+  VCMP_U32(2, v8, 0x3f57d966, 0xbf28ca93, 0xbf1b30dc, 0x3f53341a, 0xbd4168d3,
            0xbd9c7345, 0xbc88eed4, 0xbfcf691b, 0x3ea6b9a8, 0x3f11d843,
            0x3f19a717, 0x3ecdb32c, 0xbd738277, 0xbe86d79e, 0x3ec4ff71,
            0xbe1a238e);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.1779684802061718,  0.1122733699429854, -0.0166033088608786,
   //              -0.0418350503858864,  0.0809510021720363, -0.9993917101510512,
   //              -0.2139048161619248,  0.7196716914796224,  0.6489783595942558,
   //              0.5950689618839839, -0.7376256302221853, -0.5442228345597713,
   //              -0.8234113806545975, -0.6424001059348645, -0.3817524674245201,
   //              -0.8801262923106541
-  VLOAD_64(v4, 0xbfc6c7abd11a2788, 0x3fbcbdf2941de8b0, 0xbf91007532405e80,
+  VLOAD_64(v16, 0xbfc6c7abd11a2788, 0x3fbcbdf2941de8b0, 0xbf91007532405e80,
            0xbfa56b675a77c100, 0x3fb4b93472e84630, 0xbfeffb0452dfc0ba,
            0xbfcb613ba6efa978, 0x3fe7078ced586224, 0x3fe4c46e43c89c1c,
            0x3fe30ace10450114, 0xbfe79aa110cfdc92, 0xbfe16a46018575da,
@@ -89,7 +89,7 @@ void TEST_CASE1(void) {
   //               -0.9215678788036654,  0.4412210589054084, 0.3537359089001260,
   //               -0.4889461402031243,  0.2341577339668230, 0.0593866008892341,
   //               -0.4825773777931026,  0.8989772522533539
-  VLOAD_64(v6, 0x3fe5ca90cb4aba98, 0xbfd67b45dfa41e18, 0xbfd7f97c12a6b704,
+  VLOAD_64(v24, 0x3fe5ca90cb4aba98, 0xbfd67b45dfa41e18, 0xbfd7f97c12a6b704,
            0xbfe951a6c578c3ac, 0x3fea89299b6d84b0, 0x3fda42f7d4d35178,
            0xbfb5c6f9cd987320, 0xbfe2abfdad8a63b6, 0xbfed7d7beb902fcc,
            0x3fdc3cf7409388b4, 0x3fd6a39bf009666c, 0xbfdf4ae4c06b61e4,
@@ -101,20 +101,20 @@ void TEST_CASE1(void) {
   //               -0.7798663937316326, -0.1025181838739857, 0.5296250728149803,
   //               0.8832422045338422,  0.8373555508937671, -0.8622529212135799,
   //               0.4241832213372883,  0.7769982087360683
-  VLOAD_64(v2, 0x3fcc54d154555708, 0xbfe6477196411436, 0xbfb6f0878eee8940,
+  VLOAD_64(v8, 0x3fcc54d154555708, 0xbfe6477196411436, 0xbfb6f0878eee8940,
            0xbfc113b7f0547630, 0x3fc973b5c856db48, 0xbfd5b4747c9c185c,
            0xbfe3a398b77f3552, 0x3fe5a16ce1f8870a, 0xbfe8f4aa5e0a7552,
            0xbfba3ea1b6fbece0, 0x3fe0f2b047dc3902, 0x3fec438527dd6ef6,
            0x3feacb9dde46cf34, 0xbfeb9793702fc4f0, 0x3fdb25d161c9f510,
            0x3fe8dd2b58f24dc8);
-  asm volatile("vfnmsac.vv v2, v4, v6");
+  asm volatile("vfnmsac.vv v8, v16, v24");
   //               0.3425309161602823, -0.6567824407689892, -0.0958273275519495,
   //               -0.1665148733821233,  0.1317156015009752, 0.0709487030987733,
   //               -0.6319166041826899,  1.0958800635211576,
   //               -0.1817887834908719, -0.3650751413581792, 0.7905497455496533,
   //               0.6171465501654385,  1.0301636939103409, -0.8241029625112244,
   //               0.2399581166415165,  1.5682117246334322
-  VCMP_U64(3, v2, 0x3fd5ec06cab1bfc9, 0xbfe5045c9bf61361, 0xbfb88823c5e61162,
+  VCMP_U64(3, v8, 0x3fd5ec06cab1bfc9, 0xbfe5045c9bf61361, 0xbfb88823c5e61162,
            0xbfc5505bffbca57e, 0x3fc0dc0e8c68ea87, 0x3fb229b1b780ba72,
            0xbfe438a92b9872ef, 0x3ff188b9889296a1, 0xbfc744dad7efbbd3,
            0xbfd75d64202dd23c, 0x3fe94c2efadfe675, 0x3fe3bfaa1f3997d0,
@@ -126,37 +126,37 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.3474, -0.9888,  0.2810,  0.4199,  0.1704, -0.3772,  0.2998,
   //               0.7871, -0.2527, -0.8618,  0.2646,  0.5488, -0.3184, -0.3508,
   //               -0.3589, -0.3914
-  VLOAD_16(v4, 0x358f, 0xbbe9, 0x347f, 0x36b8, 0x3174, 0xb609, 0x34cc, 0x3a4c,
+  VLOAD_16(v16, 0x358f, 0xbbe9, 0x347f, 0x36b8, 0x3174, 0xb609, 0x34cc, 0x3a4c,
            0xb40b, 0xbae5, 0x343c, 0x3864, 0xb518, 0xb59d, 0xb5be, 0xb643);
   //               0.0417,  0.3862, -0.9619, -0.5659,  0.1731,  0.4827,  0.7334,
   //               -0.7271, -0.9814,  0.8003, -0.4836,  0.5234, -0.8540,
   //               -0.2036, -0.8823,  0.2603
-  VLOAD_16(v6, 0x2958, 0x362e, 0xbbb2, 0xb887, 0x318a, 0x37b9, 0x39de, 0xb9d1,
+  VLOAD_16(v24, 0x2958, 0x362e, 0xbbb2, 0xb887, 0x318a, 0x37b9, 0x39de, 0xb9d1,
            0xbbda, 0x3a67, 0xb7bd, 0x3830, 0xbad5, 0xb284, 0xbb0f, 0x342a);
   VLOAD_8(v0, 0xAA, 0xAA);
   //              -0.2739,  0.2146,  0.5264, -0.8853,  0.8877, -0.6748, -0.7563,
   //              -0.9634,  0.7451, -0.5166,  0.0698,  0.4790, -0.0681, -0.9746,
   //              0.2129,  0.9072
-  VLOAD_16(v2, 0xb462, 0x32de, 0x3836, 0xbb15, 0x3b1a, 0xb966, 0xba0d, 0xbbb5,
+  VLOAD_16(v8, 0xb462, 0x32de, 0x3836, 0xbb15, 0x3b1a, 0xb966, 0xba0d, 0xbbb5,
            0x39f6, 0xb822, 0x2c77, 0x37aa, 0xac5b, 0xbbcc, 0x32d0, 0x3b42);
-  asm volatile("vfnmsac.vv v2, v4, v6, v0.t");
+  asm volatile("vfnmsac.vv v8, v16, v24, v0.t");
   //              -0.2739,  0.5967,  0.5264, -0.6475,  0.8877, -0.4927, -0.7563,
   //              -0.3911,  0.7451,  0.1733,  0.0698,  0.1917, -0.0681, -1.0459,
   //              0.2129,  1.0088
-  VCMP_U16(4, v2, 0xb462, 0x38c6, 0x3836, 0xb92e, 0x3b1a, 0xb7e2, 0xba0d,
+  VCMP_U16(4, v8, 0xb462, 0x38c6, 0x3836, 0xb92e, 0x3b1a, 0xb7e2, 0xba0d,
            0xb642, 0x39f6, 0x318a, 0x2c77, 0x3223, 0xac5b, 0xbc2f, 0x32d0,
            0x3c09);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.11577118, -0.10074481,  0.13861528,  0.44782066,
   //               0.42196107, -0.67597556,  0.34948668, -0.87903690,
   //               -0.34136006, -0.19722189,  0.76997000, -0.68663412,
   //               0.45603558,  0.60629857, -0.86984915, -0.08019307
-  VLOAD_32(v4, 0x3ded1971, 0xbdce534c, 0x3e0df12a, 0x3ee548c0, 0x3ed80b48,
+  VLOAD_32(v16, 0x3ded1971, 0xbdce534c, 0x3e0df12a, 0x3ee548c0, 0x3ed80b48,
            0xbf2d0cbc, 0x3eb2efeb, 0xbf610890, 0xbeaec6bf, 0xbe49f489,
            0x3f451cc1, 0xbf2fc741, 0x3ee97d7f, 0x3f1b3662, 0xbf5eae6f,
            0xbda43c43);
@@ -164,7 +164,7 @@ void TEST_CASE2(void) {
   //              0.47494572, -0.34277225, -0.54462087, -0.90492284, 0.60100728,
   //              -0.02819708, -0.46859986,  0.87238866,  0.46812481,
   //              0.49922746,  0.97036403,  0.04279163
-  VLOAD_32(v6, 0xbec7879f, 0x3ecf286c, 0x3f30d065, 0xbf7b28a8, 0x3ef32c16,
+  VLOAD_32(v24, 0xbec7879f, 0x3ecf286c, 0x3f30d065, 0xbf7b28a8, 0x3ef32c16,
            0xbeaf7fd8, 0xbf0b6c46, 0xbf67a906, 0x3f19db9d, 0xbce6fd92,
            0xbeefec52, 0x3f5f54dd, 0x3eefae0e, 0x3eff9abe, 0x3f7869c7,
            0x3d2f4647);
@@ -173,29 +173,29 @@ void TEST_CASE2(void) {
   //               0.15318950,  0.15531392, -0.20705318, -0.82493448,
   //               0.12047531,  0.57526720,  0.23939800, -0.19725421,
   //               0.15403098,  0.03931713, -0.45930895, -0.15395784
-  VLOAD_32(v2, 0x3f4c4ca0, 0xbf3339f2, 0xbf02ae86, 0x3ec57575, 0x3e1cddb5,
+  VLOAD_32(v8, 0x3f4c4ca0, 0xbf3339f2, 0xbf02ae86, 0x3ec57575, 0x3e1cddb5,
            0x3e1f0a9d, 0xbe5405c0, 0xbf532ee8, 0x3df6bbc3, 0x3f1344b6,
            0x3e7524c0, 0xbe49fd02, 0x3e1dba4c, 0x3d210b00, 0xbeeb2a8b,
            0xbe1da720);
-  asm volatile("vfnmsac.vv v2, v4, v6, v0.t");
+  asm volatile("vfnmsac.vv v8, v16, v24, v0.t");
   //               0.79804420, -0.65934104, -0.51047552,  0.82501376,
   //               0.15318950, -0.07639174, -0.20705318, -1.62039506,
   //               0.12047531,  0.56970614,  0.23939800,  0.40175763,
   //               0.15403098, -0.26336378, -0.45930895, -0.15052626
-  VCMP_U32(5, v2, 0x3f4c4ca0, 0xbf28ca93, 0xbf02ae86, 0x3f53341a, 0x3e1cddb5,
+  VCMP_U32(5, v8, 0x3f4c4ca0, 0xbf28ca93, 0xbf02ae86, 0x3f53341a, 0x3e1cddb5,
            0xbd9c7345, 0xbe5405c0, 0xbfcf691b, 0x3df6bbc3, 0x3f11d843,
            0x3e7524c0, 0x3ecdb32c, 0x3e1dba4c, 0xbe86d79e, 0xbeeb2a8b,
            0xbe1a238e);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.1779684802061718,  0.1122733699429854, -0.0166033088608786,
   //              -0.0418350503858864,  0.0809510021720363, -0.9993917101510512,
   //              -0.2139048161619248,  0.7196716914796224,  0.6489783595942558,
   //              0.5950689618839839, -0.7376256302221853, -0.5442228345597713,
   //              -0.8234113806545975, -0.6424001059348645, -0.3817524674245201,
   //              -0.8801262923106541
-  VLOAD_64(v4, 0xbfc6c7abd11a2788, 0x3fbcbdf2941de8b0, 0xbf91007532405e80,
+  VLOAD_64(v16, 0xbfc6c7abd11a2788, 0x3fbcbdf2941de8b0, 0xbf91007532405e80,
            0xbfa56b675a77c100, 0x3fb4b93472e84630, 0xbfeffb0452dfc0ba,
            0xbfcb613ba6efa978, 0x3fe7078ced586224, 0x3fe4c46e43c89c1c,
            0x3fe30ace10450114, 0xbfe79aa110cfdc92, 0xbfe16a46018575da,
@@ -207,7 +207,7 @@ void TEST_CASE2(void) {
   //               -0.9215678788036654,  0.4412210589054084, 0.3537359089001260,
   //               -0.4889461402031243,  0.2341577339668230, 0.0593866008892341,
   //               -0.4825773777931026,  0.8989772522533539
-  VLOAD_64(v6, 0x3fe5ca90cb4aba98, 0xbfd67b45dfa41e18, 0xbfd7f97c12a6b704,
+  VLOAD_64(v24, 0x3fe5ca90cb4aba98, 0xbfd67b45dfa41e18, 0xbfd7f97c12a6b704,
            0xbfe951a6c578c3ac, 0x3fea89299b6d84b0, 0x3fda42f7d4d35178,
            0xbfb5c6f9cd987320, 0xbfe2abfdad8a63b6, 0xbfed7d7beb902fcc,
            0x3fdc3cf7409388b4, 0x3fd6a39bf009666c, 0xbfdf4ae4c06b61e4,
@@ -220,20 +220,20 @@ void TEST_CASE2(void) {
   //               -0.7798663937316326, -0.1025181838739857, 0.5296250728149803,
   //               0.8832422045338422,  0.8373555508937671, -0.8622529212135799,
   //               0.4241832213372883,  0.7769982087360683
-  VLOAD_64(v2, 0x3fcc54d154555708, 0xbfe6477196411436, 0xbfb6f0878eee8940,
+  VLOAD_64(v8, 0x3fcc54d154555708, 0xbfe6477196411436, 0xbfb6f0878eee8940,
            0xbfc113b7f0547630, 0x3fc973b5c856db48, 0xbfd5b4747c9c185c,
            0xbfe3a398b77f3552, 0x3fe5a16ce1f8870a, 0xbfe8f4aa5e0a7552,
            0xbfba3ea1b6fbece0, 0x3fe0f2b047dc3902, 0x3fec438527dd6ef6,
            0x3feacb9dde46cf34, 0xbfeb9793702fc4f0, 0x3fdb25d161c9f510,
            0x3fe8dd2b58f24dc8);
-  asm volatile("vfnmsac.vv v2, v4, v6, v0.t");
+  asm volatile("vfnmsac.vv v8, v16, v24, v0.t");
   //               0.2213384305747967, -0.6567824407689892, -0.0896076892809434,
   //               -0.1665148733821233,  0.1988436916560323, 0.0709487030987733,
   //               -0.6137202819751713,  1.0958800635211576,
   //               -0.7798663937316326, -0.3650751413581792, 0.5296250728149803,
   //               0.6171465501654385,  0.8373555508937671, -0.8241029625112244,
   //               0.4241832213372883,  1.5682117246334322
-  VCMP_U64(6, v2, 0x3fcc54d154555708, 0xbfe5045c9bf61361, 0xbfb6f0878eee8940,
+  VCMP_U64(6, v8, 0x3fcc54d154555708, 0xbfe5045c9bf61361, 0xbfb6f0878eee8940,
            0xbfc5505bffbca57e, 0x3fc973b5c856db48, 0x3fb229b1b780ba72,
            0xbfe3a398b77f3552, 0x3ff188b9889296a1, 0xbfe8f4aa5e0a7552,
            0xbfd75d64202dd23c, 0x3fe0f2b047dc3902, 0x3fe3bfaa1f3997d0,
@@ -244,29 +244,29 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                             -0.4771
   BOX_HALF_IN_FLOAT(fscalar_16, 0xb7a2);
   //              -0.6172,  0.8584, -0.1088, -0.6719,  0.3579,  0.5889,  0.1724,
   //              -0.5239, -0.5732, -0.6167,  0.8271, -0.7334,  0.3489, -0.7607,
   //              -0.7788, -0.5264
-  VLOAD_16(v4, 0xb8f0, 0x3ade, 0xaef7, 0xb960, 0x35ba, 0x38b6, 0x3184, 0xb831,
+  VLOAD_16(v16, 0xb8f0, 0x3ade, 0xaef7, 0xb960, 0x35ba, 0x38b6, 0x3184, 0xb831,
            0xb896, 0xb8ef, 0x3a9e, 0xb9de, 0x3595, 0xba16, 0xba3b, 0xb836);
   //               0.0186,  0.9351,  0.6201,  0.9463,  0.2512,  0.5786,  0.9424,
   //               -0.5132, -0.7646,  0.0194, -0.2507, -0.2905,  0.3452,
   //               -0.7803, -0.7666, -0.1387
-  VLOAD_16(v2, 0x24c1, 0x3b7b, 0x38f6, 0x3b92, 0x3405, 0x38a1, 0x3b8a, 0xb81b,
+  VLOAD_16(v8, 0x24c1, 0x3b7b, 0x38f6, 0x3b92, 0x3405, 0x38a1, 0x3b8a, 0xb81b,
            0xba1e, 0x24f6, 0xb403, 0xb4a6, 0x3586, 0xba3e, 0xba22, 0xb070);
-  asm volatile("vfnmsac.vf v2, %[A], v4" ::[A] "f"(fscalar_16));
+  asm volatile("vfnmsac.vf v8, %[A], v16" ::[A] "f"(fscalar_16));
   //              -0.2759,  1.3447,  0.5684,  0.6260,  0.4219,  0.8594,  1.0244,
   //              -0.7632, -1.0381, -0.2749,  0.1438, -0.6406,  0.5117, -1.1426,
   //              -1.1387, -0.3899
-  VCMP_U16(7, v2, 0xb46a, 0x3d61, 0x388c, 0x3902, 0x36c0, 0x3ae0, 0x3c19,
+  VCMP_U16(7, v8, 0xb46a, 0x3d61, 0x388c, 0x3902, 0x36c0, 0x3ae0, 0x3c19,
            0xba1b, 0xbc27, 0xb466, 0x309a, 0xb920, 0x3818, 0xbc93, 0xbc8d,
            0xb63d);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.73549986
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbf3c49b8);
@@ -274,7 +274,7 @@ void TEST_CASE3(void) {
   //               -0.77184784, -0.41120139, -0.57577437, -0.15976480,
   //               -0.05041125,  0.42673740,  0.88473374, -0.49891368,
   //               -0.84324479, -0.26009968, -0.01877740, -0.13754985
-  VLOAD_32(v4, 0x3f3e1643, 0x3f3af0b7, 0x3f404d94, 0x3d24ad6a, 0xbf4597d2,
+  VLOAD_32(v16, 0x3f3e1643, 0x3f3af0b7, 0x3f404d94, 0x3d24ad6a, 0xbf4597d2,
            0xbed288fd, 0xbf1365f3, 0xbe239962, 0xbd4e7c07, 0x3eda7d53,
            0x3f627de9, 0xbeff719d, 0xbf57dee4, 0xbe852bc9, 0xbc99d30f,
            0xbe0cd9de);
@@ -282,22 +282,22 @@ void TEST_CASE3(void) {
   //               0.28473541, -0.93230879, -0.77235961, -0.92498165,
   //               -0.55227244,  0.97729182,  0.28253901,  0.45306230,
   //               -0.50359881,  0.40307203, -0.65891176, -0.59297264
-  VLOAD_32(v2, 0x3f653838, 0x3f2f98cf, 0x3f2ccdaf, 0x3daa8aad, 0x3e91c8d7,
+  VLOAD_32(v8, 0x3f653838, 0x3f2f98cf, 0x3f2ccdaf, 0x3daa8aad, 0x3e91c8d7,
            0xbf6eabca, 0xbf45b95c, 0xbf6ccb99, 0xbf0d61ba, 0x3f7a2fcc,
            0x3e90a8f4, 0x3ee7f7c8, 0xbf00ebda, 0x3ece5f75, 0xbf28ae71,
            0xbf17cd0e);
-  asm volatile("vfnmsac.vf v2, %[A], v4" ::[A] "f"(fscalar_32));
+  asm volatile("vfnmsac.vf v8, %[A], v16" ::[A] "f"(fscalar_32));
   //               1.44151771,  1.22301352,  1.22750902,  0.11284268,
   //               -0.28295860, -1.23474741, -1.19584155, -1.04248869,
   //               -0.58934993,  1.29115713,  0.93326056,  0.08611137,
   //               -1.12380528,  0.21176875, -0.67272252, -0.69414055
-  VCMP_U32(8, v2, 0x3fb883a7, 0x3f9c8bb5, 0x3f9d1f04, 0x3de71a10, 0xbe90dff2,
+  VCMP_U32(8, v8, 0x3fb883a7, 0x3f9c8bb5, 0x3f9d1f04, 0x3de71a10, 0xbe90dff2,
            0xbf9e0c34, 0xbf991156, 0xbf857045, 0xbf16dfa3, 0x3fa544a3,
            0x3f6eea2a, 0x3db05b27, 0xbf8fd8da, 0x3e58d9e8, 0xbf2c378b,
            0xbf31b332);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.5178244899339752
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fe09204aa2ab2a0);
@@ -308,7 +308,7 @@ void TEST_CASE3(void) {
   //                0.1494192541908572,  0.0196333207724690,
   //                -0.2272946521816408,  0.9289723385226867,
   //                -0.5162193242581365, -0.3917544955022987
-  VLOAD_64(v4, 0x3febab01fbe195e4, 0x3f744c9c38b4b600, 0x3fedb10ca98026d0,
+  VLOAD_64(v16, 0x3febab01fbe195e4, 0x3f744c9c38b4b600, 0x3fedb10ca98026d0,
            0xbfec39b31560f050, 0x3fed9c01a86a6166, 0xbfb06600c7c3cc10,
            0xbfee59041b01e946, 0x3fe35149679e0d42, 0x3fe43a741f8b89d2,
            0x3fea6681d6d6ae5e, 0x3fc3202b8d123b90, 0x3f941ac1da84be40,
@@ -321,20 +321,20 @@ void TEST_CASE3(void) {
   //                0.1236692515687874,  0.9290168852760794,
   //                -0.0433411597165929, -0.8422695068160440,
   //                0.6519328829008422, -0.3347506024828231
-  VLOAD_64(v2, 0x3fd8e24f9d6331d4, 0xbfea5288d3d6317c, 0x3feaf9e847d9618e,
+  VLOAD_64(v8, 0x3fd8e24f9d6331d4, 0xbfea5288d3d6317c, 0x3feaf9e847d9618e,
            0xbfe436b76feb621e, 0xbfe56ddde1ff608c, 0x3fe39dc3f345962e,
            0xbfcd62b6d5e76d58, 0x3fc4206b1afd2970, 0xbfe82286f1e7af48,
            0x3fe3ad775d9fe964, 0x3fbfa8c9bf023cb0, 0x3fedba819e762954,
            0xbfa630cfff1b61a0, 0xbfeaf3df2e462cb6, 0x3fe4dca25967e02c,
            0xbfd56c8dca7eb8ac);
-  asm volatile("vfnmsac.vf v2, %[A], v4" ::[A] "f"(dscalar_64));
+  asm volatile("vfnmsac.vf v8, %[A], v16" ::[A] "f"(dscalar_64));
   //               -0.0589110568256553, -0.8251412828355696, 0.3625363508340025,
   //               -0.1749355920677641, -1.1488012349688719, 0.6461784703586890,
   //               0.2615122334407671, -0.1553571761707763, -1.0815499543490239,
   //               0.1877131026437891,  0.0462963024810918,  0.9188502709613655,
   //               0.0743575776140855, -1.3233141341743264,  0.9192438911788732,
   //               -0.1318905306700034
-  VCMP_U64(9, v2, 0xbfae29970ce0c2e6, 0xbfea678eb10b76d9, 0x3fd733cbaa9c5dc5,
+  VCMP_U64(9, v8, 0xbfae29970ce0c2e6, 0xbfea678eb10b76d9, 0x3fd733cbaa9c5dc5,
            0xbfc6644a1b6b315b, 0xbff2617d675cbb41, 0x3fe4ad7e78b23c6a,
            0x3fd0bc9dce8872e3, 0xbfc3e2be736d1b43, 0xbff14e07532eb5a9,
            0x3fc806fba27160c3, 0x3fa7b4262229fd93, 0x3fed6738aef664ca,
@@ -345,30 +345,30 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                             -0.4771
   BOX_HALF_IN_FLOAT(fscalar_16, 0xb7a2);
   //               -0.6172,  0.8584, -0.1088, -0.6719,  0.3579,  0.5889, 0.1724,
   //               -0.5239, -0.5732, -0.6167,  0.8271, -0.7334,  0.3489,
   //               -0.7607, -0.7788, -0.5264
-  VLOAD_16(v4, 0xb8f0, 0x3ade, 0xaef7, 0xb960, 0x35ba, 0x38b6, 0x3184, 0xb831,
+  VLOAD_16(v16, 0xb8f0, 0x3ade, 0xaef7, 0xb960, 0x35ba, 0x38b6, 0x3184, 0xb831,
            0xb896, 0xb8ef, 0x3a9e, 0xb9de, 0x3595, 0xba16, 0xba3b, 0xb836);
   VLOAD_8(v0, 0xAA, 0xAA);
   //                0.0186,  0.9351,  0.6201,  0.9463,  0.2512,  0.5786, 0.9424,
   //                -0.5132, -0.7646,  0.0194, -0.2507, -0.2905,  0.3452,
   //                -0.7803, -0.7666, -0.1387
-  VLOAD_16(v2, 0x24c1, 0x3b7b, 0x38f6, 0x3b92, 0x3405, 0x38a1, 0x3b8a, 0xb81b,
+  VLOAD_16(v8, 0x24c1, 0x3b7b, 0x38f6, 0x3b92, 0x3405, 0x38a1, 0x3b8a, 0xb81b,
            0xba1e, 0x24f6, 0xb403, 0xb4a6, 0x3586, 0xba3e, 0xba22, 0xb070);
-  asm volatile("vfnmsac.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
+  asm volatile("vfnmsac.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_16));
   //                0.0186,  1.3447,  0.6201,  0.6260,  0.2512,  0.8594, 0.9424,
   //                -0.7632, -0.7646, -0.2749, -0.2507, -0.6406,  0.3452,
   //                -1.1426, -0.7666, -0.3899
-  VCMP_U16(10, v2, 0x24c1, 0x3d61, 0x38f6, 0x3902, 0x3405, 0x3ae0, 0x3b8a,
+  VCMP_U16(10, v8, 0x24c1, 0x3d61, 0x38f6, 0x3902, 0x3405, 0x3ae0, 0x3b8a,
            0xba1b, 0xba1e, 0xb466, 0xb403, 0xb920, 0x3586, 0xbc93, 0xba22,
            0xb63d);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.73549986
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbf3c49b8);
@@ -376,7 +376,7 @@ void TEST_CASE4(void) {
   //                -0.77184784, -0.41120139, -0.57577437, -0.15976480,
   //                -0.05041125,  0.42673740,  0.88473374, -0.49891368,
   //                -0.84324479, -0.26009968, -0.01877740, -0.13754985
-  VLOAD_32(v4, 0x3f3e1643, 0x3f3af0b7, 0x3f404d94, 0x3d24ad6a, 0xbf4597d2,
+  VLOAD_32(v16, 0x3f3e1643, 0x3f3af0b7, 0x3f404d94, 0x3d24ad6a, 0xbf4597d2,
            0xbed288fd, 0xbf1365f3, 0xbe239962, 0xbd4e7c07, 0x3eda7d53,
            0x3f627de9, 0xbeff719d, 0xbf57dee4, 0xbe852bc9, 0xbc99d30f,
            0xbe0cd9de);
@@ -385,22 +385,22 @@ void TEST_CASE4(void) {
   //                0.28473541, -0.93230879, -0.77235961, -0.92498165,
   //                -0.55227244,  0.97729182,  0.28253901,  0.45306230,
   //                -0.50359881,  0.40307203, -0.65891176, -0.59297264
-  VLOAD_32(v2, 0x3f653838, 0x3f2f98cf, 0x3f2ccdaf, 0x3daa8aad, 0x3e91c8d7,
+  VLOAD_32(v8, 0x3f653838, 0x3f2f98cf, 0x3f2ccdaf, 0x3daa8aad, 0x3e91c8d7,
            0xbf6eabca, 0xbf45b95c, 0xbf6ccb99, 0xbf0d61ba, 0x3f7a2fcc,
            0x3e90a8f4, 0x3ee7f7c8, 0xbf00ebda, 0x3ece5f75, 0xbf28ae71,
            0xbf17cd0e);
-  asm volatile("vfnmsac.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
+  asm volatile("vfnmsac.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_32));
   //                0.89538908,  1.22301352,  0.67501348,  0.11284268,
   //                0.28473541, -1.23474741, -0.77235961, -1.04248869,
   //                -0.55227244,  1.29115713,  0.28253901,  0.08611137,
   //                -0.50359881,  0.21176875, -0.65891176, -0.69414055
-  VCMP_U32(11, v2, 0x3f653838, 0x3f9c8bb5, 0x3f2ccdaf, 0x3de71a10, 0x3e91c8d7,
+  VCMP_U32(11, v8, 0x3f653838, 0x3f9c8bb5, 0x3f2ccdaf, 0x3de71a10, 0x3e91c8d7,
            0xbf9e0c34, 0xbf45b95c, 0xbf857045, 0xbf0d61ba, 0x3fa544a3,
            0x3e90a8f4, 0x3db05b27, 0xbf00ebda, 0x3e58d9e8, 0xbf28ae71,
            0xbf31b332);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.5178244899339752
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fe09204aa2ab2a0);
@@ -412,7 +412,7 @@ void TEST_CASE4(void) {
   //                 0.1494192541908572,  0.0196333207724690,
   //                 -0.2272946521816408,  0.9289723385226867,
   //                 -0.5162193242581365, -0.3917544955022987
-  VLOAD_64(v4, 0x3febab01fbe195e4, 0x3f744c9c38b4b600, 0x3fedb10ca98026d0,
+  VLOAD_64(v16, 0x3febab01fbe195e4, 0x3f744c9c38b4b600, 0x3fedb10ca98026d0,
            0xbfec39b31560f050, 0x3fed9c01a86a6166, 0xbfb06600c7c3cc10,
            0xbfee59041b01e946, 0x3fe35149679e0d42, 0x3fe43a741f8b89d2,
            0x3fea6681d6d6ae5e, 0x3fc3202b8d123b90, 0x3f941ac1da84be40,
@@ -427,13 +427,13 @@ void TEST_CASE4(void) {
   //                 0.1236692515687874,  0.9290168852760794,
   //                 -0.0433411597165929, -0.8422695068160440,
   //                 0.6519328829008422, -0.3347506024828231
-  VLOAD_64(v2, 0x3fd8e24f9d6331d4, 0xbfea5288d3d6317c, 0x3feaf9e847d9618e,
+  VLOAD_64(v8, 0x3fd8e24f9d6331d4, 0xbfea5288d3d6317c, 0x3feaf9e847d9618e,
            0xbfe436b76feb621e, 0xbfe56ddde1ff608c, 0x3fe39dc3f345962e,
            0xbfcd62b6d5e76d58, 0x3fc4206b1afd2970, 0xbfe82286f1e7af48,
            0x3fe3ad775d9fe964, 0x3fbfa8c9bf023cb0, 0x3fedba819e762954,
            0xbfa630cfff1b61a0, 0xbfeaf3df2e462cb6, 0x3fe4dca25967e02c,
            0xbfd56c8dca7eb8ac);
-  asm volatile("vfnmsac.vf v2, %[A], v4, v0.t" ::[A] "f"(dscalar_64));
+  asm volatile("vfnmsac.vf v8, %[A], v16, v0.t" ::[A] "f"(dscalar_64));
   //                0.3888129269587612, -0.8251412828355696, 0.8430062678626642,
   //                -0.1749355920677641, -0.6696614660277347,
   //                0.6461784703586890, -0.2295750183537659,
@@ -441,7 +441,7 @@ void TEST_CASE4(void) {
   //                0.1877131026437891,  0.1236692515687874, 0.9188502709613655,
   //                -0.0433411597165929, -1.3233141341743264,
   //                0.6519328829008422, -0.1318905306700034
-  VCMP_U64(12, v2, 0x3fd8e24f9d6331d4, 0xbfea678eb10b76d9, 0x3feaf9e847d9618e,
+  VCMP_U64(12, v8, 0x3fd8e24f9d6331d4, 0xbfea678eb10b76d9, 0x3feaf9e847d9618e,
            0xbfc6644a1b6b315b, 0xbfe56ddde1ff608c, 0x3fe4ad7e78b23c6a,
            0xbfcd62b6d5e76d58, 0xbfc3e2be736d1b43, 0xbfe82286f1e7af48,
            0x3fc806fba27160c3, 0x3fbfa8c9bf023cb0, 0x3fed6738aef664ca,
diff --git a/sw/riscvTests/isa/rv64uv/vfnmsub.c b/sw/riscvTests/isa/rv64uv/vfnmsub.c
index 1535a169..783dd545 100644
--- a/sw/riscvTests/isa/rv64uv/vfnmsub.c
+++ b/sw/riscvTests/isa/rv64uv/vfnmsub.c
@@ -10,36 +10,36 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.0091, -0.3794, -0.0005, -0.0464,  0.4834,  0.2932, -0.3042,
   //              -0.3096, -0.9844, -0.1815, -0.8760,  0.0853, -0.3723, -0.8877,
   //              0.1584,  0.1943
-  VLOAD_16(v4, 0xa0ac, 0xb612, 0x8f83, 0xa9f0, 0x37bc, 0x34b1, 0xb4de, 0xb4f4,
+  VLOAD_16(v16, 0xa0ac, 0xb612, 0x8f83, 0xa9f0, 0x37bc, 0x34b1, 0xb4de, 0xb4f4,
            0xbbe0, 0xb1cf, 0xbb02, 0x2d75, 0xb5f5, 0xbb1a, 0x3112, 0x3238);
   //              -0.3301,  0.7769,  0.6572, -0.8193,  0.4529,  0.2349,  0.5264,
   //              -0.2456,  0.0873,  0.5381,  0.4670,  0.8564, -0.1790,  0.6641,
   //              0.0182,  0.0447
-  VLOAD_16(v6, 0xb548, 0x3a37, 0x3942, 0xba8e, 0x373f, 0x3384, 0x3836, 0xb3dc,
+  VLOAD_16(v24, 0xb548, 0x3a37, 0x3942, 0xba8e, 0x373f, 0x3384, 0x3836, 0xb3dc,
            0x2d97, 0x384e, 0x3779, 0x3ada, 0xb1ba, 0x3950, 0x24a7, 0x29b9);
   //               0.5835,  0.4404, -0.3459,  0.0516, -0.4866, -0.2191,  0.0685,
   //               -0.5430, -0.1429, -0.7539, -0.6416, -0.6758, -0.1147, 0.3438,
   //               0.3440,  0.1991
-  VLOAD_16(v2, 0x38ab, 0x370c, 0xb589, 0x2a9b, 0xb7c9, 0xb303, 0x2c62, 0xb858,
+  VLOAD_16(v8, 0x38ab, 0x370c, 0xb589, 0x2a9b, 0xb7c9, 0xb303, 0x2c62, 0xb858,
            0xb093, 0xba08, 0xb922, 0xb968, 0xaf57, 0x3580, 0x3581, 0x325f);
-  asm volatile("vfnmsub.vv v2, v4, v6");
+  asm volatile("vfnmsub.vv v8, v16, v24");
   //              -0.3247,  0.9438,  0.6572, -0.8169,  0.6880,  0.2991,  0.5474,
   //              -0.4136, -0.0534,  0.4014, -0.0950,  0.9141, -0.2217,  0.9692,
   //              -0.0363,  0.0060
-  VCMP_U16(1, v2, 0xb532, 0x3b8d, 0x3942, 0xba89, 0x3981, 0x34c9, 0x3861,
+  VCMP_U16(1, v8, 0xb532, 0x3b8d, 0x3942, 0xba89, 0x3981, 0x34c9, 0x3861,
            0xb69e, 0xaad5, 0x366b, 0xae14, 0x3b50, 0xb318, 0x3bc1, 0xa8a7,
            0x1e29);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.76259303, -0.43966120, -0.19390504, -0.57240725,
   //               -0.57148474, -0.93710214,  0.24273214,  0.44242114,
   //               -0.93160200, -0.56412256, -0.75430351, -0.02741535,
   //               -0.60542876, -0.93627954,  0.02798123,  0.23119579
-  VLOAD_32(v4, 0x3f43394c, 0xbee11b46, 0xbe468f0b, 0xbf128948, 0xbf124cd3,
+  VLOAD_32(v16, 0x3f43394c, 0xbee11b46, 0xbe468f0b, 0xbf128948, 0xbf124cd3,
            0xbf6fe5ed, 0x3e788ec6, 0x3ee28506, 0xbf6e7d78, 0xbf106a56,
            0xbf411a09, 0xbce09629, 0xbf1afd61, 0xbf6fb004, 0x3ce538e6,
            0x3e6cbe97);
@@ -47,7 +47,7 @@ void TEST_CASE1(void) {
   //               -0.16710435,  0.84761631,  0.37147006,  0.25389814,
   //               -0.44707820,  0.38169226, -0.82191414, -0.81056035,
   //               0.29047397, -0.46743703, -0.91869444, -0.08079135
-  VLOAD_32(v6, 0x3ef9888c, 0x3e49e355, 0xbef1ce59, 0x3e0cd222, 0xbe2b1d67,
+  VLOAD_32(v24, 0x3ef9888c, 0x3e49e355, 0xbef1ce59, 0x3e0cd222, 0xbe2b1d67,
            0x3f58fd62, 0x3ebe3153, 0x3e81fef0, 0xbee4e76f, 0x3ec36d2b,
            0xbf5268f7, 0xbf4f80e2, 0x3e94b901, 0xbeef53e8, 0xbf6b2f8f,
            0xbda575f0);
@@ -55,29 +55,29 @@ void TEST_CASE1(void) {
   //              0.46947387,  0.29113689, -0.11920074,  0.63394654,
   //              -0.82611400, -0.84088647, -0.13328743,  0.29885510,
   //              0.91797447, -0.15480036,  0.76857966,  0.16230854
-  VLOAD_32(v2, 0xbef91d92, 0xbf5fca01, 0x3e36d496, 0x3f2c969e, 0x3ef05ee1,
+  VLOAD_32(v8, 0xbef91d92, 0xbf5fca01, 0x3e36d496, 0x3f2c969e, 0x3ef05ee1,
            0x3e950fe5, 0xbdf41f84, 0x3f224a52, 0xbf537c35, 0xbf574456,
            0xbe087c80, 0x3e990389, 0x3f6b0060, 0xbe1e83fc, 0x3f44c1a3,
            0x3e263436);
-  asm volatile("vfnmsub.vv v2, v4, v6");
+  asm volatile("vfnmsub.vv v8, v16, v24");
   //               0.85841238, -0.18718503, -0.43765658,  0.52342200,
   //               0.10119282,  1.12044132,  0.40040392, -0.02657321,
   //               -1.21668768, -0.09267077, -0.92245328, -0.80236715,
   //               0.84624207, -0.61237341, -0.94020027, -0.11831641
-  VCMP_U32(2, v2, 0x3f5bc0ea, 0xbe3fad70, 0xbee01486, 0x3f05fefc, 0x3dcf3e2c,
+  VCMP_U32(2, v8, 0x3f5bc0ea, 0xbe3fad70, 0xbee01486, 0x3f05fefc, 0x3dcf3e2c,
            0x3f8f6a9f, 0x3ecd01be, 0xbcd9b00d, 0xbf9bbc6c, 0xbdbdca2c,
            0xbf6c25e6, 0xbf4d67ef, 0x3f58a353, 0xbf1cc481, 0xbf70b0f7,
            0xbdf24fdf);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.1307639483617093,  0.9224167823566942,  0.8635785104096312,
   //              -0.1786758246437388,  0.0810514505300033,  0.4196384170211611,
   //              0.9100790646565715, -0.5457616411379209, -0.5513001815564993,
   //              -0.4320693373833464,  0.2818536966914695,  0.5493933224246561,
   //              0.0505621823765807,  0.7247332126666939, -0.8702311369694951,
   //              -0.0660417836134264
-  VLOAD_64(v4, 0xbfc0bcdf80daccc8, 0x3fed847033301d18, 0x3feba26f66779bbe,
+  VLOAD_64(v16, 0xbfc0bcdf80daccc8, 0x3fed847033301d18, 0x3feba26f66779bbe,
            0xbfc6ded973b720d0, 0x3fb4bfc9b151d990, 0x3fdadb5b175011f8,
            0x3fed1f5e216f2d02, 0xbfe176e11e032836, 0xbfe1a44047420c82,
            0xbfdba706266a9d80, 0x3fd209e41662faec, 0x3fe194a14e0e8cc0,
@@ -89,7 +89,7 @@ void TEST_CASE1(void) {
   //               -0.3169052211432897, -0.0970247500649024, 0.8584276150948376,
   //               -0.2642287948226270,  0.2403355182026823,
   //               -0.0814065713760876, -0.7437013715700231, -0.6226210619792329
-  VLOAD_64(v6, 0x3fe5480ebb4f6ca8, 0xbfead900bb1380ea, 0x3fd4de97daca5430,
+  VLOAD_64(v24, 0x3fe5480ebb4f6ca8, 0xbfead900bb1380ea, 0x3fd4de97daca5430,
            0x3fdc4cac5e87d53c, 0xbfc8999720661708, 0xbfc7063400e0c4f8,
            0xbfe035c92894a640, 0x3fea6586b2596362, 0xbfd4482cd62f7e30,
            0xbfb8d69d306e6ba0, 0x3feb783d309a196c, 0xbfd0e91fe41b2de8,
@@ -101,20 +101,20 @@ void TEST_CASE1(void) {
   //              -0.2810978842877421, -0.3240264495739638,  0.5540367578795606,
   //              0.7398533272929233,  0.4690189457399407, -0.2427822500985419,
   //              0.2399358773396087
-  VLOAD_64(v2, 0xbfcb2c2560fa8d98, 0x3fed09b08a1d236c, 0xbfda8ff9193bbdb8,
+  VLOAD_64(v8, 0xbfcb2c2560fa8d98, 0x3fed09b08a1d236c, 0xbfda8ff9193bbdb8,
            0xbfdcdfbf03022cf4, 0xbfed34ca8b7904d0, 0xbfea5c74d801844e,
            0xbfb049b07fd1a3e0, 0x3fe6cc6a4ff0157a, 0xbfda692318304834,
            0xbfd1fd81faff66b8, 0xbfd4bcd96efd6300, 0x3fe1baab4b7bfc96,
            0x3fe7ace0e291ea9e, 0x3fde04680a4a1390, 0xbfcf137d201c7be0,
            0x3fceb6380527c498);
-  asm volatile("vfnmsub.vv v2, v4, v6");
+  asm volatile("vfnmsub.vv v8, v16, v24");
   //               0.6372868977272925, -1.6760208622190165,  0.6845034040552052,
   //               0.3615690295631244, -0.1182120133317999,  0.1658155255420807,
   //               -0.4486624012573315,  1.2137228688596235,
   //               -0.5444086454629855, -0.2184785266689677, 0.9497556677330713,
   //               -0.5686128899794636,  0.2029269193361774,
   //               -0.4213201787237407, -0.9549780451092895, -0.6067752686868729
-  VCMP_U64(3, v2, 0x3fe464a77dfd0e7c, 0xbffad0fb406a4f74, 0x3fe5e773aecd5e74,
+  VCMP_U64(3, v8, 0x3fe464a77dfd0e7c, 0xbffad0fb406a4f74, 0x3fe5e773aecd5e74,
            0x3fd723f26d4e15bc, 0xbfbe43247b412024, 0x3fc5397171afa72c,
            0xbfdcb6e281161599, 0x3ff36b68abc28cd2, 0xbfe16bcbadfd8ab4,
            0xbfcbf71ab775f310, 0x3fee6465ff835579, 0xbfe23213a8d1778a,
@@ -126,37 +126,37 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.0091, -0.3794, -0.0005, -0.0464,  0.4834,  0.2932, -0.3042,
   //              -0.3096, -0.9844, -0.1815, -0.8760,  0.0853, -0.3723, -0.8877,
   //              0.1584,  0.1943
-  VLOAD_16(v4, 0xa0ac, 0xb612, 0x8f83, 0xa9f0, 0x37bc, 0x34b1, 0xb4de, 0xb4f4,
+  VLOAD_16(v16, 0xa0ac, 0xb612, 0x8f83, 0xa9f0, 0x37bc, 0x34b1, 0xb4de, 0xb4f4,
            0xbbe0, 0xb1cf, 0xbb02, 0x2d75, 0xb5f5, 0xbb1a, 0x3112, 0x3238);
   //              -0.3301,  0.7769,  0.6572, -0.8193,  0.4529,  0.2349,  0.5264,
   //              -0.2456,  0.0873,  0.5381,  0.4670,  0.8564, -0.1790,  0.6641,
   //              0.0182,  0.0447
-  VLOAD_16(v6, 0xb548, 0x3a37, 0x3942, 0xba8e, 0x373f, 0x3384, 0x3836, 0xb3dc,
+  VLOAD_16(v24, 0xb548, 0x3a37, 0x3942, 0xba8e, 0x373f, 0x3384, 0x3836, 0xb3dc,
            0x2d97, 0x384e, 0x3779, 0x3ada, 0xb1ba, 0x3950, 0x24a7, 0x29b9);
   VLOAD_8(v0, 0xAA, 0xAA);
   //               0.5835,  0.4404, -0.3459,  0.0516, -0.4866, -0.2191,  0.0685,
   //               -0.5430, -0.1429, -0.7539, -0.6416, -0.6758, -0.1147, 0.3438,
   //               0.3440,  0.1991
-  VLOAD_16(v2, 0x38ab, 0x370c, 0xb589, 0x2a9b, 0xb7c9, 0xb303, 0x2c62, 0xb858,
+  VLOAD_16(v8, 0x38ab, 0x370c, 0xb589, 0x2a9b, 0xb7c9, 0xb303, 0x2c62, 0xb858,
            0xb093, 0xba08, 0xb922, 0xb968, 0xaf57, 0x3580, 0x3581, 0x325f);
-  asm volatile("vfnmsub.vv v2, v4, v6, v0.t");
+  asm volatile("vfnmsub.vv v8, v16, v24, v0.t");
   //               0.5835,  0.9438, -0.3459, -0.8169, -0.4866,  0.2991,  0.0685,
   //               -0.4136, -0.1429,  0.4014, -0.6416,  0.9141, -0.1147, 0.9692,
   //               0.3440,  0.0060
-  VCMP_U16(4, v2, 0x38ab, 0x3b8d, 0xb589, 0xba89, 0xb7c9, 0x34c9, 0x2c62,
+  VCMP_U16(4, v8, 0x38ab, 0x3b8d, 0xb589, 0xba89, 0xb7c9, 0x34c9, 0x2c62,
            0xb69e, 0xb093, 0x366b, 0xb922, 0x3b50, 0xaf57, 0x3bc1, 0x3581,
            0x1e29);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.76259303, -0.43966120, -0.19390504, -0.57240725,
   //               -0.57148474, -0.93710214,  0.24273214,  0.44242114,
   //               -0.93160200, -0.56412256, -0.75430351, -0.02741535,
   //               -0.60542876, -0.93627954,  0.02798123,  0.23119579
-  VLOAD_32(v4, 0x3f43394c, 0xbee11b46, 0xbe468f0b, 0xbf128948, 0xbf124cd3,
+  VLOAD_32(v16, 0x3f43394c, 0xbee11b46, 0xbe468f0b, 0xbf128948, 0xbf124cd3,
            0xbf6fe5ed, 0x3e788ec6, 0x3ee28506, 0xbf6e7d78, 0xbf106a56,
            0xbf411a09, 0xbce09629, 0xbf1afd61, 0xbf6fb004, 0x3ce538e6,
            0x3e6cbe97);
@@ -164,7 +164,7 @@ void TEST_CASE2(void) {
   //               -0.16710435,  0.84761631,  0.37147006,  0.25389814,
   //               -0.44707820,  0.38169226, -0.82191414, -0.81056035,
   //               0.29047397, -0.46743703, -0.91869444, -0.08079135
-  VLOAD_32(v6, 0x3ef9888c, 0x3e49e355, 0xbef1ce59, 0x3e0cd222, 0xbe2b1d67,
+  VLOAD_32(v24, 0x3ef9888c, 0x3e49e355, 0xbef1ce59, 0x3e0cd222, 0xbe2b1d67,
            0x3f58fd62, 0x3ebe3153, 0x3e81fef0, 0xbee4e76f, 0x3ec36d2b,
            0xbf5268f7, 0xbf4f80e2, 0x3e94b901, 0xbeef53e8, 0xbf6b2f8f,
            0xbda575f0);
@@ -173,29 +173,29 @@ void TEST_CASE2(void) {
   //              0.46947387,  0.29113689, -0.11920074,  0.63394654,
   //              -0.82611400, -0.84088647, -0.13328743,  0.29885510,
   //              0.91797447, -0.15480036,  0.76857966,  0.16230854
-  VLOAD_32(v2, 0xbef91d92, 0xbf5fca01, 0x3e36d496, 0x3f2c969e, 0x3ef05ee1,
+  VLOAD_32(v8, 0xbef91d92, 0xbf5fca01, 0x3e36d496, 0x3f2c969e, 0x3ef05ee1,
            0x3e950fe5, 0xbdf41f84, 0x3f224a52, 0xbf537c35, 0xbf574456,
            0xbe087c80, 0x3e990389, 0x3f6b0060, 0xbe1e83fc, 0x3f44c1a3,
            0x3e263436);
-  asm volatile("vfnmsub.vv v2, v4, v6, v0.t");
+  asm volatile("vfnmsub.vv v8, v16, v24, v0.t");
   //              -0.48655373, -0.18718503,  0.17854533,  0.52342200,
   //              0.46947387,  1.12044132, -0.11920074, -0.02657321,
   //              -0.82611400, -0.09267077, -0.13328743, -0.80236715,
   //              0.91797447, -0.61237341,  0.76857966, -0.11831641
-  VCMP_U32(5, v2, 0xbef91d92, 0xbe3fad70, 0x3e36d496, 0x3f05fefc, 0x3ef05ee1,
+  VCMP_U32(5, v8, 0xbef91d92, 0xbe3fad70, 0x3e36d496, 0x3f05fefc, 0x3ef05ee1,
            0x3f8f6a9f, 0xbdf41f84, 0xbcd9b00d, 0xbf537c35, 0xbdbdca2c,
            0xbe087c80, 0xbf4d67ef, 0x3f6b0060, 0xbf1cc481, 0x3f44c1a3,
            0xbdf24fdf);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.1307639483617093,  0.9224167823566942,  0.8635785104096312,
   //              -0.1786758246437388,  0.0810514505300033,  0.4196384170211611,
   //              0.9100790646565715, -0.5457616411379209, -0.5513001815564993,
   //              -0.4320693373833464,  0.2818536966914695,  0.5493933224246561,
   //              0.0505621823765807,  0.7247332126666939, -0.8702311369694951,
   //              -0.0660417836134264
-  VLOAD_64(v4, 0xbfc0bcdf80daccc8, 0x3fed847033301d18, 0x3feba26f66779bbe,
+  VLOAD_64(v16, 0xbfc0bcdf80daccc8, 0x3fed847033301d18, 0x3feba26f66779bbe,
            0xbfc6ded973b720d0, 0x3fb4bfc9b151d990, 0x3fdadb5b175011f8,
            0x3fed1f5e216f2d02, 0xbfe176e11e032836, 0xbfe1a44047420c82,
            0xbfdba706266a9d80, 0x3fd209e41662faec, 0x3fe194a14e0e8cc0,
@@ -207,7 +207,7 @@ void TEST_CASE2(void) {
   //               -0.3169052211432897, -0.0970247500649024, 0.8584276150948376,
   //               -0.2642287948226270,  0.2403355182026823,
   //               -0.0814065713760876, -0.7437013715700231, -0.6226210619792329
-  VLOAD_64(v6, 0x3fe5480ebb4f6ca8, 0xbfead900bb1380ea, 0x3fd4de97daca5430,
+  VLOAD_64(v24, 0x3fe5480ebb4f6ca8, 0xbfead900bb1380ea, 0x3fd4de97daca5430,
            0x3fdc4cac5e87d53c, 0xbfc8999720661708, 0xbfc7063400e0c4f8,
            0xbfe035c92894a640, 0x3fea6586b2596362, 0xbfd4482cd62f7e30,
            0xbfb8d69d306e6ba0, 0x3feb783d309a196c, 0xbfd0e91fe41b2de8,
@@ -220,20 +220,20 @@ void TEST_CASE2(void) {
   //              -0.2810978842877421, -0.3240264495739638,  0.5540367578795606,
   //              0.7398533272929233,  0.4690189457399407, -0.2427822500985419,
   //              0.2399358773396087
-  VLOAD_64(v2, 0xbfcb2c2560fa8d98, 0x3fed09b08a1d236c, 0xbfda8ff9193bbdb8,
+  VLOAD_64(v8, 0xbfcb2c2560fa8d98, 0x3fed09b08a1d236c, 0xbfda8ff9193bbdb8,
            0xbfdcdfbf03022cf4, 0xbfed34ca8b7904d0, 0xbfea5c74d801844e,
            0xbfb049b07fd1a3e0, 0x3fe6cc6a4ff0157a, 0xbfda692318304834,
            0xbfd1fd81faff66b8, 0xbfd4bcd96efd6300, 0x3fe1baab4b7bfc96,
            0x3fe7ace0e291ea9e, 0x3fde04680a4a1390, 0xbfcf137d201c7be0,
            0x3fceb6380527c498);
-  asm volatile("vfnmsub.vv v2, v4, v6, v0.t");
+  asm volatile("vfnmsub.vv v8, v16, v24, v0.t");
   //              -0.2122847293404504, -1.6760208622190165, -0.4150374170703475,
   //              0.3615690295631244, -0.9126942371441604,  0.1658155255420807,
   //              -0.0636244117792013,  1.2137228688596235, -0.4126670585839094,
   //              -0.2184785266689677, -0.3240264495739638, -0.5686128899794636,
   //              0.7398533272929233, -0.4213201787237407, -0.2427822500985419,
   //              -0.6067752686868729
-  VCMP_U64(6, v2, 0xbfcb2c2560fa8d98, 0xbffad0fb406a4f74, 0xbfda8ff9193bbdb8,
+  VCMP_U64(6, v8, 0xbfcb2c2560fa8d98, 0xbffad0fb406a4f74, 0xbfda8ff9193bbdb8,
            0x3fd723f26d4e15bc, 0xbfed34ca8b7904d0, 0x3fc5397171afa72c,
            0xbfb049b07fd1a3e0, 0x3ff36b68abc28cd2, 0xbfda692318304834,
            0xbfcbf71ab775f310, 0xbfd4bcd96efd6300, 0xbfe23213a8d1778a,
@@ -244,29 +244,29 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                             -0.1346
   BOX_HALF_IN_FLOAT(fscalar_16, 0xb04f);
   //              -0.1886,  0.9912, -0.0325,  0.5850,  0.2578, -0.2350, -0.8701,
   //              0.9209,  0.5859, -0.4795,  0.8682,  0.9233, -0.8896, -0.5981,
   //              -0.3223,  0.6924
-  VLOAD_16(v4, 0xb209, 0x3bee, 0xa82a, 0x38ae, 0x3420, 0xb385, 0xbaf6, 0x3b5e,
+  VLOAD_16(v16, 0xb209, 0x3bee, 0xa82a, 0x38ae, 0x3420, 0xb385, 0xbaf6, 0x3b5e,
            0x38b0, 0xb7ac, 0x3af2, 0x3b63, 0xbb1e, 0xb8c9, 0xb528, 0x398a);
   //              -0.0126,  0.9678,  0.8945, -0.9600, -0.9272,  0.4412,  0.5527,
   //              0.1136,  0.7207, -0.5181, -0.2810, -0.4048,  0.1648,  0.7612,
   //              -0.8853,  0.1761
-  VLOAD_16(v2, 0xa27a, 0x3bbe, 0x3b28, 0xbbae, 0xbb6b, 0x370f, 0x386c, 0x2f45,
+  VLOAD_16(v8, 0xa27a, 0x3bbe, 0x3b28, 0xbbae, 0xbb6b, 0x370f, 0x386c, 0x2f45,
            0x39c4, 0xb825, 0xb47f, 0xb67a, 0x3146, 0x3a17, 0xbb15, 0x31a3);
-  asm volatile("vfnmsub.vf v2, %[A], v4" ::[A] "f"(fscalar_16));
+  asm volatile("vfnmsub.vf v8, %[A], v16" ::[A] "f"(fscalar_16));
   //              -0.1903,  1.1211,  0.0879,  0.4556,  0.1329, -0.1755, -0.7959,
   //              0.9360,  0.6831, -0.5493,  0.8301,  0.8687, -0.8677, -0.4956,
   //              -0.4414,  0.7163
-  VCMP_U16(7, v2, 0xb217, 0x3c7c, 0x2da0, 0x374b, 0x3041, 0xb19e, 0xba5e,
+  VCMP_U16(7, v8, 0xb217, 0x3c7c, 0x2da0, 0x374b, 0x3041, 0xb19e, 0xba5e,
            0x3b7d, 0x3977, 0xb865, 0x3aa5, 0x3af3, 0xbaf1, 0xb7ee, 0xb710,
            0x39bb);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.16110219
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbe24f7f9);
@@ -274,7 +274,7 @@ void TEST_CASE3(void) {
   //              -0.89379781,  0.26157290,  0.56702632, -0.11594663,
   //              0.09605245,  0.45930776, -0.76518077, -0.26341528, 0.74385208,
   //              0.89362013, -0.21185355,  0.23924881
-  VLOAD_32(v4, 0xbea17872, 0xbe33d878, 0xbf4a6b46, 0x3e6ae602, 0xbf64cfef,
+  VLOAD_32(v16, 0xbea17872, 0xbe33d878, 0xbf4a6b46, 0x3e6ae602, 0xbf64cfef,
            0x3e85ece2, 0x3f1128a3, 0xbded756d, 0x3dc4b726, 0x3eeb2a63,
            0xbf43e2e3, 0xbe86de5e, 0x3f3e6d17, 0x3f64c44a, 0xbe58f023,
            0x3e74fda4);
@@ -282,22 +282,22 @@ void TEST_CASE3(void) {
   //               -0.19719712,  0.85649359,  0.36901370, -0.78377151,
   //               0.22567192, -0.75179213, -0.65690833,  0.11298654,
   //               -0.64884853, -0.48376039, -0.11539485, -0.42667609
-  VLOAD_32(v2, 0x3ea31a81, 0x3ef90b71, 0x3f1298df, 0x3e9aad57, 0xbe49ee0b,
+  VLOAD_32(v8, 0x3ea31a81, 0x3ef90b71, 0x3f1298df, 0x3e9aad57, 0xbe49ee0b,
            0x3f5b432a, 0x3ebcef5d, 0xbf48a540, 0x3e67168a, 0xbf407573,
            0xbf282b25, 0x3de7657d, 0xbf261af0, 0xbef7af71, 0xbdec5422,
            0xbeda754a);
-  asm volatile("vfnmsub.vf v2, %[A], v4" ::[A] "f"(fscalar_32));
+  asm volatile("vfnmsub.vf v8, %[A], v16" ::[A] "f"(fscalar_32));
   //              -0.26405108, -0.09726786, -0.69844496,  0.27806261,
   //              -0.92556667,  0.39955589,  0.62647521, -0.24221393,
   //              0.13240869,  0.33819240, -0.87101012, -0.24521290, 0.63932115,
   //              0.81568527, -0.23044391,  0.17051035
-  VCMP_U32(8, v2, 0xbe8731b4, 0xbdc7345f, 0xbf32cd4a, 0x3e8e5e39, 0xbf6cf1f1,
+  VCMP_U32(8, v8, 0xbe8731b4, 0xbdc7345f, 0xbf32cd4a, 0x3e8e5e39, 0xbf6cf1f1,
            0x3ecc9297, 0x3f2060ae, 0xbe7806ee, 0x3e079625, 0x3ead278e,
            0xbf5efa85, 0xbe7b1917, 0x3f23aa8d, 0x3f50d0c0, 0xbe6bf97d,
            0x3e2e9a44);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.5849101968457469
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fe2b79596d194ba);
@@ -307,7 +307,7 @@ void TEST_CASE3(void) {
   //               -0.5708244737077264, -0.7636024500128011, 0.2236424444447431,
   //               0.8245435877598175,  0.8527344486412596, -0.3097355632002228,
   //               0.0764086736442742,  0.2567358761671383,  0.1904958118727702
-  VLOAD_64(v4, 0xbfe8585129fe14da, 0xbf93b8ad045d9c40, 0x3fe5cf14ca86c05c,
+  VLOAD_64(v16, 0xbfe8585129fe14da, 0xbf93b8ad045d9c40, 0x3fe5cf14ca86c05c,
            0xbfe0864a527b2a32, 0xbfee980ddf5818b2, 0xbfebb047874a12f4,
            0x3fdd5e190b029804, 0xbfe24431afca9858, 0xbfe86f6e67be6a22,
            0x3fcca050cc719f20, 0x3fea62a93bf1c1ec, 0x3feb4999c122c714,
@@ -320,20 +320,20 @@ void TEST_CASE3(void) {
   //                -0.1509314378482451, -0.9803534868251271,
   //                0.9211862470421908,  0.7804942879773937, 0.5029472314120484,
   //                0.1158347026033590,  0.7422982722940397,  0.0792254120441500
-  VLOAD_64(v2, 0x3fbe461fd6899df0, 0xbfec054ae66457d4, 0xbfd7981d4d67fd54,
+  VLOAD_64(v8, 0x3fbe461fd6899df0, 0xbfec054ae66457d4, 0xbfd7981d4d67fd54,
            0x3fd1f045d94dd3b0, 0xbfe0894aae97abc2, 0x3fd8c9027de8d2a8,
            0xbfb0676270cf1540, 0xbfdbda75aaa8928c, 0xbfc351b8aabf8c50,
            0xbfef5f0e468ddf22, 0x3fed7a5b94924728, 0x3fe8f9cf28327c9e,
            0x3fe01824cad0e968, 0x3fbda757d36c5e40, 0x3fe7c0e84e6c2aa0,
            0x3fb4481dd9bde340);
-  asm volatile("vfnmsub.vf v2, %[A], v4" ::[A] "f"(dscalar_64));
+  asm volatile("vfnmsub.vf v8, %[A], v16" ::[A] "f"(dscalar_64));
   //              -0.8299509146929066,  0.4929151432599784,  0.8971610699324351,
   //              -0.6803373936193172, -0.6538035512838903, -1.0917858708828851,
   //              0.4963478718767876, -0.3162664568083610, -0.6753211129907725,
   //              0.7970611954020426,  0.2857323586707750,  0.3962153810234212,
   //              -0.6039145273284674,  0.0086557749429749, -0.1774419523986262,
   //              0.1441560605188410
-  VCMP_U64(9, v2, 0xbfea8ef5387c85b1, 0x3fdf8bebf5004e06, 0x3fecb58b21d3556c,
+  VCMP_U64(9, v8, 0xbfea8ef5387c85b1, 0x3fdf8bebf5004e06, 0x3fecb58b21d3556c,
            0xbfe5c552ecfae837, 0xbfe4ebf56cd8bc27, 0xbff177f4761ad476,
            0x3fdfc429dd49999d, 0xbfd43db5aa3413c6, 0xbfe59c3b05d2ff7f,
            0x3fe981867ae532b2, 0x3fd249705ff9984b, 0x3fd95b97c1eabccb,
@@ -344,30 +344,30 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                             -0.1346
   BOX_HALF_IN_FLOAT(fscalar_16, 0xb04f);
   //               -0.1886,  0.9912, -0.0325,  0.5850,  0.2578, -0.2350,
   //               -0.8701,  0.9209,  0.5859, -0.4795,  0.8682,  0.9233,
   //               -0.8896, -0.5981, -0.3223,  0.6924
-  VLOAD_16(v4, 0xb209, 0x3bee, 0xa82a, 0x38ae, 0x3420, 0xb385, 0xbaf6, 0x3b5e,
+  VLOAD_16(v16, 0xb209, 0x3bee, 0xa82a, 0x38ae, 0x3420, 0xb385, 0xbaf6, 0x3b5e,
            0x38b0, 0xb7ac, 0x3af2, 0x3b63, 0xbb1e, 0xb8c9, 0xb528, 0x398a);
   VLOAD_8(v0, 0xAA, 0xAA);
   //               -0.0126,  0.9678,  0.8945, -0.9600, -0.9272,  0.4412, 0.5527,
   //               0.1136,  0.7207, -0.5181, -0.2810, -0.4048,  0.1648,  0.7612,
   //               -0.8853,  0.1761
-  VLOAD_16(v2, 0xa27a, 0x3bbe, 0x3b28, 0xbbae, 0xbb6b, 0x370f, 0x386c, 0x2f45,
+  VLOAD_16(v8, 0xa27a, 0x3bbe, 0x3b28, 0xbbae, 0xbb6b, 0x370f, 0x386c, 0x2f45,
            0x39c4, 0xb825, 0xb47f, 0xb67a, 0x3146, 0x3a17, 0xbb15, 0x31a3);
-  asm volatile("vfnmsub.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
+  asm volatile("vfnmsub.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_16));
   //               -0.0126,  1.1211,  0.8945,  0.4556, -0.9272, -0.1755, 0.5527,
   //               0.9360,  0.7207, -0.5493, -0.2810,  0.8687,  0.1648, -0.4956,
   //               -0.8853,  0.7163
-  VCMP_U16(10, v2, 0xa27a, 0x3c7c, 0x3b28, 0x374b, 0xbb6b, 0xb19e, 0x386c,
+  VCMP_U16(10, v8, 0xa27a, 0x3c7c, 0x3b28, 0x374b, 0xbb6b, 0xb19e, 0x386c,
            0x3b7d, 0x39c4, 0xb865, 0xb47f, 0x3af3, 0x3146, 0xb7ee, 0xbb15,
            0x39bb);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.16110219
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbe24f7f9);
@@ -375,7 +375,7 @@ void TEST_CASE4(void) {
   //               -0.89379781,  0.26157290,  0.56702632, -0.11594663,
   //               0.09605245,  0.45930776, -0.76518077, -0.26341528,
   //               0.74385208,  0.89362013, -0.21185355,  0.23924881
-  VLOAD_32(v4, 0xbea17872, 0xbe33d878, 0xbf4a6b46, 0x3e6ae602, 0xbf64cfef,
+  VLOAD_32(v16, 0xbea17872, 0xbe33d878, 0xbf4a6b46, 0x3e6ae602, 0xbf64cfef,
            0x3e85ece2, 0x3f1128a3, 0xbded756d, 0x3dc4b726, 0x3eeb2a63,
            0xbf43e2e3, 0xbe86de5e, 0x3f3e6d17, 0x3f64c44a, 0xbe58f023,
            0x3e74fda4);
@@ -384,22 +384,22 @@ void TEST_CASE4(void) {
   //                -0.19719712,  0.85649359,  0.36901370, -0.78377151,
   //                0.22567192, -0.75179213, -0.65690833,  0.11298654,
   //                -0.64884853, -0.48376039, -0.11539485, -0.42667609
-  VLOAD_32(v2, 0x3ea31a81, 0x3ef90b71, 0x3f1298df, 0x3e9aad57, 0xbe49ee0b,
+  VLOAD_32(v8, 0x3ea31a81, 0x3ef90b71, 0x3f1298df, 0x3e9aad57, 0xbe49ee0b,
            0x3f5b432a, 0x3ebcef5d, 0xbf48a540, 0x3e67168a, 0xbf407573,
            0xbf282b25, 0x3de7657d, 0xbf261af0, 0xbef7af71, 0xbdec5422,
            0xbeda754a);
-  asm volatile("vfnmsub.vf v2, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
+  asm volatile("vfnmsub.vf v8, %[A], v16, v0.t" ::[A] "f"(fscalar_32));
   //                0.31856158, -0.09726786,  0.57264513,  0.27806261,
   //                -0.19719712,  0.39955589,  0.36901370, -0.24221393,
   //                0.22567192,  0.33819240, -0.65690833, -0.24521290,
   //                -0.64884853,  0.81568527, -0.11539485,  0.17051035
-  VCMP_U32(11, v2, 0x3ea31a81, 0xbdc7345f, 0x3f1298df, 0x3e8e5e39, 0xbe49ee0b,
+  VCMP_U32(11, v8, 0x3ea31a81, 0xbdc7345f, 0x3f1298df, 0x3e8e5e39, 0xbe49ee0b,
            0x3ecc9297, 0x3ebcef5d, 0xbe7806ee, 0x3e67168a, 0x3ead278e,
            0xbf282b25, 0xbe7b1917, 0xbf261af0, 0x3f50d0c0, 0xbdec5422,
            0x3e2e9a44);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.5849101968457469
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fe2b79596d194ba);
@@ -411,7 +411,7 @@ void TEST_CASE4(void) {
   //                0.8245435877598175,  0.8527344486412596,
   //                -0.3097355632002228,  0.0764086736442742,
   //                0.2567358761671383,  0.1904958118727702
-  VLOAD_64(v4, 0xbfe8585129fe14da, 0xbf93b8ad045d9c40, 0x3fe5cf14ca86c05c,
+  VLOAD_64(v16, 0xbfe8585129fe14da, 0xbf93b8ad045d9c40, 0x3fe5cf14ca86c05c,
            0xbfe0864a527b2a32, 0xbfee980ddf5818b2, 0xbfebb047874a12f4,
            0x3fdd5e190b029804, 0xbfe24431afca9858, 0xbfe86f6e67be6a22,
            0x3fcca050cc719f20, 0x3fea62a93bf1c1ec, 0x3feb4999c122c714,
@@ -426,13 +426,13 @@ void TEST_CASE4(void) {
   //                 0.9211862470421908,  0.7804942879773937,
   //                 0.5029472314120484,  0.1158347026033590,
   //                 0.7422982722940397,  0.0792254120441500
-  VLOAD_64(v2, 0x3fbe461fd6899df0, 0xbfec054ae66457d4, 0xbfd7981d4d67fd54,
+  VLOAD_64(v8, 0x3fbe461fd6899df0, 0xbfec054ae66457d4, 0xbfd7981d4d67fd54,
            0x3fd1f045d94dd3b0, 0xbfe0894aae97abc2, 0x3fd8c9027de8d2a8,
            0xbfb0676270cf1540, 0xbfdbda75aaa8928c, 0xbfc351b8aabf8c50,
            0xbfef5f0e468ddf22, 0x3fed7a5b94924728, 0x3fe8f9cf28327c9e,
            0x3fe01824cad0e968, 0x3fbda757d36c5e40, 0x3fe7c0e84e6c2aa0,
            0x3fb4481dd9bde340);
-  asm volatile("vfnmsub.vf v2, %[A], v4, v0.t" ::[A] "f"(dscalar_64));
+  asm volatile("vfnmsub.vf v8, %[A], v16, v0.t" ::[A] "f"(dscalar_64));
   //                0.1182575129292827,  0.4929151432599784,
   //                -0.3686593299789440, -0.6803373936193172,
   //                -0.5167592439660142, -1.0917858708828851,
@@ -440,7 +440,7 @@ void TEST_CASE4(void) {
   //                -0.1509314378482451,  0.7970611954020426,
   //                0.9211862470421908,  0.3962153810234212, 0.5029472314120484,
   //                0.0086557749429749,  0.7422982722940397,  0.1441560605188410
-  VCMP_U64(12, v2, 0x3fbe461fd6899df0, 0x3fdf8bebf5004e06, 0xbfd7981d4d67fd54,
+  VCMP_U64(12, v8, 0x3fbe461fd6899df0, 0x3fdf8bebf5004e06, 0xbfd7981d4d67fd54,
            0xbfe5c552ecfae837, 0xbfe0894aae97abc2, 0xbff177f4761ad476,
            0xbfb0676270cf1540, 0xbfd43db5aa3413c6, 0xbfc351b8aabf8c50,
            0x3fe981867ae532b2, 0x3fed7a5b94924728, 0x3fd95b97c1eabccb,
diff --git a/sw/riscvTests/isa/rv64uv/vfrsub.c b/sw/riscvTests/isa/rv64uv/vfrsub.c
index 40e08433..be9ac9ff 100644
--- a/sw/riscvTests/isa/rv64uv/vfrsub.c
+++ b/sw/riscvTests/isa/rv64uv/vfrsub.c
@@ -10,54 +10,54 @@
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.0273, -0.8511,  0.7173,  0.9551, -0.7842, -0.6509, -0.5771,
   //              0.6060, -0.5361,  0.6099,  0.2859,  0.6318, -0.9521,  0.3818,
   //              0.2783, -0.7905
-  VLOAD_16(v4, 0xa700, 0xbacf, 0x39bd, 0x3ba4, 0xba46, 0xb935, 0xb89e, 0x38d9,
+  VLOAD_16(v16, 0xa700, 0xbacf, 0x39bd, 0x3ba4, 0xba46, 0xb935, 0xb89e, 0x38d9,
            0xb84a, 0x38e1, 0x3493, 0x390e, 0xbb9e, 0x361c, 0x3474, 0xba53);
   float fscalar_16;
   //                              0.3062
   BOX_HALF_IN_FLOAT(fscalar_16, 0x34e6);
-  asm volatile("vfrsub.vf v2, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfrsub.vf v8, v16, %[A]" ::[A] "f"(fscalar_16));
   //               0.3335,  1.1572, -0.4111, -0.6489,  1.0898,  0.9570,  0.8833,
   //               -0.2998,  0.8423, -0.3037,  0.0203, -0.3257,  1.2578,
   //               -0.0757,  0.0278,  1.0967
-  VCMP_U16(1, v2, 0x3556, 0x3ca1, 0xb694, 0xb931, 0x3c5c, 0x3ba8, 0x3b11,
+  VCMP_U16(1, v8, 0x3556, 0x3ca1, 0xb694, 0xb931, 0x3c5c, 0x3ba8, 0x3b11,
            0xb4cc, 0x3abd, 0xb4dc, 0x2530, 0xb536, 0x3d08, 0xacd8, 0x2720,
            0x3c63);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.61218858,  0.50298065,  0.82400811, -0.50508654,
   //               -0.08447543, -0.66344708, -0.94741052,  0.85856712,
   //               -0.16725175, -0.36700448, -0.86911696,  0.82600677,
   //               -0.95377433,  0.06016647,  0.67027277,  0.08167093
-  VLOAD_32(v4, 0x3f1cb864, 0x3f00c357, 0x3f52f232, 0xbf014d5a, 0xbdad0174,
+  VLOAD_32(v16, 0x3f1cb864, 0x3f00c357, 0x3f52f232, 0xbf014d5a, 0xbdad0174,
            0xbf29d7ab, 0xbf72897f, 0x3f5bcb0e, 0xbe2b440b, 0xbebbe803,
            0xbf5e7e73, 0x3f53752e, 0xbf742a8e, 0x3d76711d, 0x3f2b96ff,
            0x3da74316);
   float fscalar_32;
   //                              -0.78482366
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbf48ea34);
-  asm volatile("vfrsub.vf v2, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfrsub.vf v8, v16, %[A]" ::[A] "f"(fscalar_32));
   //              -1.39701223, -1.28780437, -1.60883176, -0.27973711,
   //              -0.70034826, -0.12137657,  0.16258687, -1.64339077,
   //              -0.61757189, -0.41781917,  0.08429331, -1.61083043,
   //              0.16895068, -0.84499013, -1.45509648, -0.86649460
-  VCMP_U32(2, v2, 0xbfb2d14c, 0xbfa4d6c6, 0xbfcdee33, 0xbe8f39b4, 0xbf334a06,
+  VCMP_U32(2, v8, 0xbfb2d14c, 0xbfa4d6c6, 0xbfcdee33, 0xbe8f39b4, 0xbf334a06,
            0xbdf89448, 0x3e267d2c, 0xbfd25aa1, 0xbf1e1931, 0xbed5ec65,
            0x3daca1f8, 0xbfce2fb1, 0x3e2d0168, 0xbf585146, 0xbfba409a,
            0xbf5dd297);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               -0.0920900511004143,  0.2386858516984947, 0.7068975504949517,
   //               0.5997172971219242,  0.7714780386644180, -0.1053493184316212,
   //               0.8711121216121871, -0.7388672665065719,  0.0889924652556937,
   //               0.3266446452514173, -0.5909707717470494, -0.2733520923877579,
   //               0.2365505631181986,  0.9616545156279142, -0.9315790291358075,
   //               -0.8056559777055108
-  VLOAD_64(v4, 0xbfb79336adc36440, 0x3fce8d420b880e70, 0x3fe69ee79c9ff24a,
+  VLOAD_64(v16, 0xbfb79336adc36440, 0x3fce8d420b880e70, 0x3fe69ee79c9ff24a,
            0x3fe330e2543f7e66, 0x3fe8aff2b634ab34, 0xbfbaf82c4551d810,
            0x3febe026872f2710, 0xbfe7a4ccf737616c, 0x3fb6c835cfdd1640,
            0x3fd4e7bef1312ccc, 0xbfe2e93b89317464, 0xbfd17e99c6464f50,
@@ -66,14 +66,14 @@ void TEST_CASE1(void) {
   double dscalar_64;
   //                               -0.4500891854782252
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfdcce42defa6264);
-  asm volatile("vfrsub.vf v2, v4, %[A]" ::[A] "f"(dscalar_64));
+  asm volatile("vfrsub.vf v8, v16, %[A]" ::[A] "f"(dscalar_64));
   //              -0.3579991343778108, -0.6887750371767198, -1.1569867359731769,
   //              -1.0498064826001494, -1.2215672241426432, -0.3447398670466040,
   //              -1.3212013070904123,  0.2887780810283467, -0.5390816507339189,
   //              -0.7767338307296425,  0.1408815862688242, -0.1767370930904673,
   //              -0.6866397485964237, -1.4117437011061393,  0.4814898436575823,
   //              0.3555667922272856
-  VCMP_U64(3, v2, 0xbfd6e97533898954, 0xbfe60a71f25f34ce, 0xbff28304860e91be,
+  VCMP_U64(3, v8, 0xbfd6e97533898954, 0xbfe60a71f25f34ce, 0xbff28304860e91be,
            0xbff0cc01e1de57cc, 0xbff38b8a12d8ee33, 0xbfd61037cda5ec60,
            0xbff523a3fb562c21, 0x3fd27b570f746074, 0xbfe140282978d3fa,
            0xbfe8db00e815c798, 0x3fc2086866d10cc8, 0xbfc69f5231682628,
@@ -84,30 +84,30 @@ void TEST_CASE1(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               -0.0273, -0.8511,  0.7173,  0.9551, -0.7842, -0.6509,
   //               -0.5771,  0.6060, -0.5361,  0.6099,  0.2859,  0.6318,
   //               -0.9521,  0.3818,  0.2783, -0.7905
-  VLOAD_16(v4, 0xa700, 0xbacf, 0x39bd, 0x3ba4, 0xba46, 0xb935, 0xb89e, 0x38d9,
+  VLOAD_16(v16, 0xa700, 0xbacf, 0x39bd, 0x3ba4, 0xba46, 0xb935, 0xb89e, 0x38d9,
            0xb84a, 0x38e1, 0x3493, 0x390e, 0xbb9e, 0x361c, 0x3474, 0xba53);
   float fscalar_16;
   //                              0.3062
   BOX_HALF_IN_FLOAT(fscalar_16, 0x34e6);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfrsub.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v8);
+  asm volatile("vfrsub.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.0000,  1.1572,  0.0000, -0.6489,  0.0000,  0.9570, 0.0000,
   //                -0.2998,  0.0000, -0.3037,  0.0000, -0.3257,  0.0000,
   //                -0.0757,  0.0000,  1.0967
-  VCMP_U16(4, v2, 0x0, 0x3ca1, 0x0, 0xb931, 0x0, 0x3ba8, 0x0, 0xb4cc, 0x0,
+  VCMP_U16(4, v8, 0x0, 0x3ca1, 0x0, 0xb931, 0x0, 0x3ba8, 0x0, 0xb4cc, 0x0,
            0xb4dc, 0x0, 0xb536, 0x0, 0xacd8, 0x0, 0x3c63);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //                0.61218858,  0.50298065,  0.82400811, -0.50508654,
   //                -0.08447543, -0.66344708, -0.94741052,  0.85856712,
   //                -0.16725175, -0.36700448, -0.86911696,  0.82600677,
   //                -0.95377433,  0.06016647,  0.67027277,  0.08167093
-  VLOAD_32(v4, 0x3f1cb864, 0x3f00c357, 0x3f52f232, 0xbf014d5a, 0xbdad0174,
+  VLOAD_32(v16, 0x3f1cb864, 0x3f00c357, 0x3f52f232, 0xbf014d5a, 0xbdad0174,
            0xbf29d7ab, 0xbf72897f, 0x3f5bcb0e, 0xbe2b440b, 0xbebbe803,
            0xbf5e7e73, 0x3f53752e, 0xbf742a8e, 0x3d76711d, 0x3f2b96ff,
            0x3da74316);
@@ -115,18 +115,18 @@ void TEST_CASE2(void) {
   //                              -0.78482366
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbf48ea34);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfrsub.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v8);
+  asm volatile("vfrsub.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.00000000, -1.28780437,  0.00000000, -0.27973711,
   //                0.00000000, -0.12137657,  0.00000000, -1.64339077,
   //                0.00000000, -0.41781917,  0.00000000, -1.61083043,
   //                0.00000000, -0.84499013,  0.00000000, -0.86649460
-  VCMP_U32(5, v2, 0x0, 0xbfa4d6c6, 0x0, 0xbe8f39b4, 0x0, 0xbdf89448, 0x0,
+  VCMP_U32(5, v8, 0x0, 0xbfa4d6c6, 0x0, 0xbe8f39b4, 0x0, 0xbdf89448, 0x0,
            0xbfd25aa1, 0x0, 0xbed5ec65, 0x0, 0xbfce2fb1, 0x0, 0xbf585146, 0x0,
            0xbf5dd297);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                -0.0920900511004143,  0.2386858516984947,
   //                0.7068975504949517,  0.5997172971219242, 0.7714780386644180,
   //                -0.1053493184316212,  0.8711121216121871,
@@ -134,7 +134,7 @@ void TEST_CASE2(void) {
   //                0.3266446452514173, -0.5909707717470494,
   //                -0.2733520923877579,  0.2365505631181986,
   //                0.9616545156279142, -0.9315790291358075, -0.8056559777055108
-  VLOAD_64(v4, 0xbfb79336adc36440, 0x3fce8d420b880e70, 0x3fe69ee79c9ff24a,
+  VLOAD_64(v16, 0xbfb79336adc36440, 0x3fce8d420b880e70, 0x3fe69ee79c9ff24a,
            0x3fe330e2543f7e66, 0x3fe8aff2b634ab34, 0xbfbaf82c4551d810,
            0x3febe026872f2710, 0xbfe7a4ccf737616c, 0x3fb6c835cfdd1640,
            0x3fd4e7bef1312ccc, 0xbfe2e93b89317464, 0xbfd17e99c6464f50,
@@ -144,8 +144,8 @@ void TEST_CASE2(void) {
   //                               -0.4500891854782252
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfdcce42defa6264);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfrsub.vf v2, v4, %[A], v0.t" ::[A] "f"(dscalar_64));
+  VCLEAR(v8);
+  asm volatile("vfrsub.vf v8, v16, %[A], v0.t" ::[A] "f"(dscalar_64));
   //                0.0000000000000000, -0.6887750371767198, 0.0000000000000000,
   //                -1.0498064826001494,  0.0000000000000000,
   //                -0.3447398670466040,  0.0000000000000000,
@@ -153,7 +153,7 @@ void TEST_CASE2(void) {
   //                -0.7767338307296425,  0.0000000000000000,
   //                -0.1767370930904673,  0.0000000000000000,
   //                -1.4117437011061393,  0.0000000000000000, 0.3555667922272856
-  VCMP_U64(6, v2, 0x0, 0xbfe60a71f25f34ce, 0x0, 0xbff0cc01e1de57cc, 0x0,
+  VCMP_U64(6, v8, 0x0, 0xbfe60a71f25f34ce, 0x0, 0xbff0cc01e1de57cc, 0x0,
            0xbfd61037cda5ec60, 0x0, 0x3fd27b570f746074, 0x0, 0xbfe8db00e815c798,
            0x0, 0xbfc69f5231682628, 0x0, 0xbff6968090295b9e, 0x0,
            0x3fd6c19b380a3a78);
diff --git a/sw/riscvTests/isa/rv64uv/vfsgnj.c b/sw/riscvTests/isa/rv64uv/vfsgnj.c
index f84a2364..c9c02bec 100644
--- a/sw/riscvTests/isa/rv64uv/vfsgnj.c
+++ b/sw/riscvTests/isa/rv64uv/vfsgnj.c
@@ -10,31 +10,31 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.3784,  0.9043, -0.4600, -0.6748,  0.4448,  0.8804,  0.1497,
   //               0.7285,  0.9927,  0.9922,  0.8965,  0.8672, -0.1860,  0.9336,
   //               -0.2959,  0.9668
-  VLOAD_16(v4, 0x360e, 0x3b3c, 0xb75c, 0xb966, 0x371e, 0x3b0b, 0x30ca, 0x39d4,
+  VLOAD_16(v16, 0x360e, 0x3b3c, 0xb75c, 0xb966, 0x371e, 0x3b0b, 0x30ca, 0x39d4,
            0x3bf1, 0x3bf0, 0x3b2c, 0x3af0, 0xb1f4, 0x3b78, 0xb4bc, 0x3bbc);
   //              -0.7988, -0.5054, -0.9380, -0.7383, -0.7168,  0.2181, -0.1597,
   //              0.1833,  0.0045, -0.2152,  0.1919, -0.6914,  0.1748, -0.8604,
   //              0.6084,  0.1591
-  VLOAD_16(v6, 0xba64, 0xb80b, 0xbb81, 0xb9e8, 0xb9bc, 0x32fb, 0xb11c, 0x31de,
+  VLOAD_16(v24, 0xba64, 0xb80b, 0xbb81, 0xb9e8, 0xb9bc, 0x32fb, 0xb11c, 0x31de,
            0x1c8f, 0xb2e3, 0x3224, 0xb988, 0x3198, 0xbae2, 0x38de, 0x3117);
-  asm volatile("vfsgnj.vv v2, v4, v6");
+  asm volatile("vfsgnj.vv v8, v16, v24");
   //              -0.3784, -0.9043, -0.4600, -0.6748, -0.4448,  0.8804, -0.1497,
   //              0.7285,  0.9927, -0.9922,  0.8965, -0.8672,  0.1860, -0.9336,
   //              0.2959,  0.9668
-  VCMP_U16(1, v2, 0xb60e, 0xbb3c, 0xb75c, 0xb966, 0xb71e, 0x3b0b, 0xb0ca,
+  VCMP_U16(1, v8, 0xb60e, 0xbb3c, 0xb75c, 0xb966, 0xb71e, 0x3b0b, 0xb0ca,
            0x39d4, 0x3bf1, 0xbbf0, 0x3b2c, 0xbaf0, 0x31f4, 0xbb78, 0x34bc,
            0x3bbc);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.30226409,  0.06318295, -0.82590002, -0.17829193,
   //               0.45379546,  0.85831785, -0.43186289, -0.32250872,
   //               0.35404092, -0.55081791,  0.09124859, -0.13254598,
   //               0.95786512,  0.95395225,  0.19890578,  0.76956910
-  VLOAD_32(v4, 0x3e9ac25c, 0x3d816610, 0xbf536e2f, 0xbe369229, 0x3ee857e1,
+  VLOAD_32(v16, 0x3e9ac25c, 0x3d816610, 0xbf536e2f, 0xbe369229, 0x3ee857e1,
            0x3f5bbab8, 0xbedd1d22, 0xbea51fdd, 0x3eb544da, 0xbf0d0267,
            0x3dbae08b, 0xbe07ba22, 0x3f7536a6, 0x3f743637, 0x3e4badf5,
            0x3f45027b);
@@ -42,29 +42,29 @@ void TEST_CASE1(void) {
   //               -0.49171701,  0.32139263, -0.09995110, -0.34368968,
   //               0.33917251,  0.07372360,  0.70147520,  0.82915747,
   //               -0.14581841, -0.19974701, -0.58837658,  0.95794803
-  VLOAD_32(v6, 0x3d865981, 0x3ea2d8ad, 0x3e1626ca, 0xbf599c8c, 0xbefbc255,
+  VLOAD_32(v24, 0x3d865981, 0x3ea2d8ad, 0x3e1626ca, 0xbf599c8c, 0xbefbc255,
            0x3ea48d93, 0xbdccb329, 0xbeaff818, 0x3eada805, 0x3d96fc66,
            0x3f3393e1, 0x3f5443aa, 0xbe15516c, 0xbe4c8a7b, 0xbf169fd9,
            0x3f753c15);
-  asm volatile("vfsgnj.vv v2, v4, v6");
+  asm volatile("vfsgnj.vv v8, v16, v24");
   //               0.30226409,  0.06318295,  0.82590002, -0.17829193,
   //               -0.45379546,  0.85831785, -0.43186289, -0.32250872,
   //               0.35404092,  0.55081791,  0.09124859,  0.13254598,
   //               -0.95786512, -0.95395225, -0.19890578,  0.76956910
-  VCMP_U32(2, v2, 0x3e9ac25c, 0x3d816610, 0x3f536e2f, 0xbe369229, 0xbee857e1,
+  VCMP_U32(2, v8, 0x3e9ac25c, 0x3d816610, 0x3f536e2f, 0xbe369229, 0xbee857e1,
            0x3f5bbab8, 0xbedd1d22, 0xbea51fdd, 0x3eb544da, 0x3f0d0267,
            0x3dbae08b, 0x3e07ba22, 0xbf7536a6, 0xbf743637, 0xbe4badf5,
            0x3f45027b);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.1900636538602862, -0.9484843154859770,  0.5869658512198073,
   //              0.4707187701595239,  0.1954104859873083,  0.0486819373954939,
   //              -0.1899986048192088, -0.1837438621239862,  0.2694105234528963,
   //              -0.7960262036276018,  0.6381040017115214,  0.2199215324293253,
   //              0.4219965521278597, -0.6541697303087526,  0.7254411745966671,
   //              0.2439726910863504
-  VLOAD_64(v4, 0xbfc854017cbe7d20, 0xbfee59fbc778ffbc, 0x3fe2c86c9bdb73b4,
+  VLOAD_64(v16, 0xbfc854017cbe7d20, 0xbfee59fbc778ffbc, 0x3fe2c86c9bdb73b4,
            0x3fde20419edcb428, 0x3fc90335f74e33c8, 0x3fa8ecd6c20a0480,
            0xbfc851dfd0fdf7f8, 0xbfc784eb3b54e580, 0x3fd13e05a2db6b68,
            0xbfe9790bf1eadde4, 0x3fe46b59155986dc, 0x3fcc266386bc2e10,
@@ -77,13 +77,13 @@ void TEST_CASE1(void) {
   //               -0.0650991402083496, -0.1766522935757786,
   //               -0.4663829943595241, -0.1565231028144627,
   //               -0.0629224333525875, -0.9086692399439535, -0.1206057821437510
-  VLOAD_64(v6, 0x3fb24441ce2eff50, 0x3fd66612c8fd8664, 0xbfe187df69e0bb9c,
+  VLOAD_64(v24, 0x3fb24441ce2eff50, 0x3fd66612c8fd8664, 0xbfe187df69e0bb9c,
            0xbfe76fd3c4a3b1e8, 0x3fe211bf78be2e36, 0xbfe7c6f7c1644c86,
            0xbfe229ce53357d20, 0xbfe79fcc34ac1d30, 0xbfe962e04d917824,
            0xbfb0aa5656314cf0, 0xbfc69c8ad7d5ef20, 0xbfddd9380f0bd244,
            0xbfc408f2f3d40a40, 0xbfb01baf416f2160, 0xbfed13d1838e183a,
            0xbfbee005420412c0);
-  asm volatile("vfsgnj.vv v2, v4, v6");
+  asm volatile("vfsgnj.vv v8, v16, v24");
   //               0.1900636538602862,  0.9484843154859770, -0.5869658512198073,
   //               -0.4707187701595239,  0.1954104859873083,
   //               -0.0486819373954939, -0.1899986048192088,
@@ -91,7 +91,7 @@ void TEST_CASE1(void) {
   //               -0.7960262036276018, -0.6381040017115214,
   //               -0.2199215324293253, -0.4219965521278597,
   //               -0.6541697303087526, -0.7254411745966671, -0.2439726910863504
-  VCMP_U64(3, v2, 0x3fc854017cbe7d20, 0x3fee59fbc778ffbc, 0xbfe2c86c9bdb73b4,
+  VCMP_U64(3, v8, 0x3fc854017cbe7d20, 0x3fee59fbc778ffbc, 0xbfe2c86c9bdb73b4,
            0xbfde20419edcb428, 0x3fc90335f74e33c8, 0xbfa8ecd6c20a0480,
            0xbfc851dfd0fdf7f8, 0xbfc784eb3b54e580, 0xbfd13e05a2db6b68,
            0xbfe9790bf1eadde4, 0xbfe46b59155986dc, 0xbfcc266386bc2e10,
@@ -103,32 +103,32 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.3784,  0.9043, -0.4600, -0.6748,  0.4448,  0.8804,  0.1497,
   //               0.7285,  0.9927,  0.9922,  0.8965,  0.8672, -0.1860,  0.9336,
   //               -0.2959,  0.9668
-  VLOAD_16(v4, 0x360e, 0x3b3c, 0xb75c, 0xb966, 0x371e, 0x3b0b, 0x30ca, 0x39d4,
+  VLOAD_16(v16, 0x360e, 0x3b3c, 0xb75c, 0xb966, 0x371e, 0x3b0b, 0x30ca, 0x39d4,
            0x3bf1, 0x3bf0, 0x3b2c, 0x3af0, 0xb1f4, 0x3b78, 0xb4bc, 0x3bbc);
   //              -0.7988, -0.5054, -0.9380, -0.7383, -0.7168,  0.2181, -0.1597,
   //              0.1833,  0.0045, -0.2152,  0.1919, -0.6914,  0.1748, -0.8604,
   //              0.6084,  0.1591
-  VLOAD_16(v6, 0xba64, 0xb80b, 0xbb81, 0xb9e8, 0xb9bc, 0x32fb, 0xb11c, 0x31de,
+  VLOAD_16(v24, 0xba64, 0xb80b, 0xbb81, 0xb9e8, 0xb9bc, 0x32fb, 0xb11c, 0x31de,
            0x1c8f, 0xb2e3, 0x3224, 0xb988, 0x3198, 0xbae2, 0x38de, 0x3117);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnj.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfsgnj.vv v8, v16, v24, v0.t");
   //               0.0000, -0.9043,  0.0000, -0.6748,  0.0000,  0.8804,  0.0000,
   //               0.7285,  0.0000, -0.9922,  0.0000, -0.8672,  0.0000, -0.9336,
   //               0.0000,  0.9668
-  VCMP_U16(4, v2, 0x0, 0xbb3c, 0x0, 0xb966, 0x0, 0x3b0b, 0x0, 0x39d4, 0x0,
+  VCMP_U16(4, v8, 0x0, 0xbb3c, 0x0, 0xb966, 0x0, 0x3b0b, 0x0, 0x39d4, 0x0,
            0xbbf0, 0x0, 0xbaf0, 0x0, 0xbb78, 0x0, 0x3bbc);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.30226409,  0.06318295, -0.82590002, -0.17829193,
   //               0.45379546,  0.85831785, -0.43186289, -0.32250872,
   //               0.35404092, -0.55081791,  0.09124859, -0.13254598,
   //               0.95786512,  0.95395225,  0.19890578,  0.76956910
-  VLOAD_32(v4, 0x3e9ac25c, 0x3d816610, 0xbf536e2f, 0xbe369229, 0x3ee857e1,
+  VLOAD_32(v16, 0x3e9ac25c, 0x3d816610, 0xbf536e2f, 0xbe369229, 0x3ee857e1,
            0x3f5bbab8, 0xbedd1d22, 0xbea51fdd, 0x3eb544da, 0xbf0d0267,
            0x3dbae08b, 0xbe07ba22, 0x3f7536a6, 0x3f743637, 0x3e4badf5,
            0x3f45027b);
@@ -136,30 +136,30 @@ void TEST_CASE2(void) {
   //               -0.49171701,  0.32139263, -0.09995110, -0.34368968,
   //               0.33917251,  0.07372360,  0.70147520,  0.82915747,
   //               -0.14581841, -0.19974701, -0.58837658,  0.95794803
-  VLOAD_32(v6, 0x3d865981, 0x3ea2d8ad, 0x3e1626ca, 0xbf599c8c, 0xbefbc255,
+  VLOAD_32(v24, 0x3d865981, 0x3ea2d8ad, 0x3e1626ca, 0xbf599c8c, 0xbefbc255,
            0x3ea48d93, 0xbdccb329, 0xbeaff818, 0x3eada805, 0x3d96fc66,
            0x3f3393e1, 0x3f5443aa, 0xbe15516c, 0xbe4c8a7b, 0xbf169fd9,
            0x3f753c15);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnj.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfsgnj.vv v8, v16, v24, v0.t");
   //               0.00000000,  0.06318295,  0.00000000, -0.17829193,
   //               0.00000000,  0.85831785,  0.00000000, -0.32250872,
   //               0.00000000,  0.55081791,  0.00000000,  0.13254598,
   //               0.00000000, -0.95395225,  0.00000000,  0.76956910
-  VCMP_U32(5, v2, 0x0, 0x3d816610, 0x0, 0xbe369229, 0x0, 0x3f5bbab8, 0x0,
+  VCMP_U32(5, v8, 0x0, 0x3d816610, 0x0, 0xbe369229, 0x0, 0x3f5bbab8, 0x0,
            0xbea51fdd, 0x0, 0x3f0d0267, 0x0, 0x3e07ba22, 0x0, 0xbf743637, 0x0,
            0x3f45027b);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.1900636538602862, -0.9484843154859770,  0.5869658512198073,
   //              0.4707187701595239,  0.1954104859873083,  0.0486819373954939,
   //              -0.1899986048192088, -0.1837438621239862,  0.2694105234528963,
   //              -0.7960262036276018,  0.6381040017115214,  0.2199215324293253,
   //              0.4219965521278597, -0.6541697303087526,  0.7254411745966671,
   //              0.2439726910863504
-  VLOAD_64(v4, 0xbfc854017cbe7d20, 0xbfee59fbc778ffbc, 0x3fe2c86c9bdb73b4,
+  VLOAD_64(v16, 0xbfc854017cbe7d20, 0xbfee59fbc778ffbc, 0x3fe2c86c9bdb73b4,
            0x3fde20419edcb428, 0x3fc90335f74e33c8, 0x3fa8ecd6c20a0480,
            0xbfc851dfd0fdf7f8, 0xbfc784eb3b54e580, 0x3fd13e05a2db6b68,
            0xbfe9790bf1eadde4, 0x3fe46b59155986dc, 0x3fcc266386bc2e10,
@@ -172,15 +172,15 @@ void TEST_CASE2(void) {
   //               -0.0650991402083496, -0.1766522935757786,
   //               -0.4663829943595241, -0.1565231028144627,
   //               -0.0629224333525875, -0.9086692399439535, -0.1206057821437510
-  VLOAD_64(v6, 0x3fb24441ce2eff50, 0x3fd66612c8fd8664, 0xbfe187df69e0bb9c,
+  VLOAD_64(v24, 0x3fb24441ce2eff50, 0x3fd66612c8fd8664, 0xbfe187df69e0bb9c,
            0xbfe76fd3c4a3b1e8, 0x3fe211bf78be2e36, 0xbfe7c6f7c1644c86,
            0xbfe229ce53357d20, 0xbfe79fcc34ac1d30, 0xbfe962e04d917824,
            0xbfb0aa5656314cf0, 0xbfc69c8ad7d5ef20, 0xbfddd9380f0bd244,
            0xbfc408f2f3d40a40, 0xbfb01baf416f2160, 0xbfed13d1838e183a,
            0xbfbee005420412c0);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnj.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfsgnj.vv v8, v16, v24, v0.t");
   //               0.0000000000000000,  0.9484843154859770,  0.0000000000000000,
   //               -0.4707187701595239,  0.0000000000000000,
   //               -0.0486819373954939,  0.0000000000000000,
@@ -188,7 +188,7 @@ void TEST_CASE2(void) {
   //               -0.7960262036276018,  0.0000000000000000,
   //               -0.2199215324293253,  0.0000000000000000,
   //               -0.6541697303087526,  0.0000000000000000, -0.2439726910863504
-  VCMP_U64(6, v2, 0x0, 0x3fee59fbc778ffbc, 0x0, 0xbfde20419edcb428, 0x0,
+  VCMP_U64(6, v8, 0x0, 0x3fee59fbc778ffbc, 0x0, 0xbfde20419edcb428, 0x0,
            0xbfa8ecd6c20a0480, 0x0, 0xbfc784eb3b54e580, 0x0, 0xbfe9790bf1eadde4,
            0x0, 0xbfcc266386bc2e10, 0x0, 0xbfe4eef55bb6b208, 0x0,
            0xbfcf3a7f44aa9f48);
@@ -197,24 +197,24 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.9023
   BOX_HALF_IN_FLOAT(fscalar_16, 0x3b38);
   //               0.5586,  0.0221,  0.7397,  0.9844, -0.1426,  0.6958,  0.0319,
   //               0.3943, -0.5425,  0.9814,  0.7852, -0.7271, -0.1810, -0.7485,
   //               -0.3499, -0.2178
-  VLOAD_16(v4, 0x3878, 0x25a7, 0x39eb, 0x3be0, 0xb090, 0x3991, 0x2816, 0x364f,
+  VLOAD_16(v16, 0x3878, 0x25a7, 0x39eb, 0x3be0, 0xb090, 0x3991, 0x2816, 0x364f,
            0xb857, 0x3bda, 0x3a48, 0xb9d1, 0xb1cb, 0xb9fd, 0xb599, 0xb2f8);
-  asm volatile("vfsgnj.vf v2, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfsgnj.vf v8, v16, %[A]" ::[A] "f"(fscalar_16));
   //               0.5586,  0.0221,  0.7397,  0.9844,  0.1426,  0.6958,  0.0319,
   //               0.3943,  0.5425,  0.9814,  0.7852,  0.7271,  0.1810,  0.7485,
   //               0.3499,  0.2178
-  VCMP_U16(7, v2, 0x3878, 0x25a7, 0x39eb, 0x3be0, 0x3090, 0x3991, 0x2816,
+  VCMP_U16(7, v8, 0x3878, 0x25a7, 0x39eb, 0x3be0, 0x3090, 0x3991, 0x2816,
            0x364f, 0x3857, 0x3bda, 0x3a48, 0x39d1, 0x31cb, 0x39fd, 0x3599,
            0x32f8);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                               0.64529878
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x3f25324d);
@@ -222,22 +222,22 @@ void TEST_CASE3(void) {
   //               -0.02381280, -0.27677080, -0.58998328,  0.15329099,
   //               0.52908343, -0.63265759,  0.48432603,  0.70191479,
   //               -0.55785930,  0.34719029, -0.06872076, -0.69960916
-  VLOAD_32(v4, 0x3e8e4f20, 0x3f25af14, 0x3f61cbb2, 0xbe8e15a7, 0xbcc31310,
+  VLOAD_32(v16, 0x3e8e4f20, 0x3f25af14, 0x3f61cbb2, 0xbe8e15a7, 0xbcc31310,
            0xbe8db4e7, 0xbf170925, 0x3e1cf850, 0x3f077203, 0xbf21f5d9,
            0x3ef7f995, 0x3f33b0b0, 0xbf0ecfde, 0x3eb1c2ed, 0xbd8cbd78,
            0xbf331996);
-  asm volatile("vfsgnj.vf v2, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfsgnj.vf v8, v16, %[A]" ::[A] "f"(fscalar_32));
   //               0.27794743,  0.64720273,  0.88201439,  0.27750894,
   //               0.02381280,  0.27677080,  0.58998328,  0.15329099,
   //               0.52908343,  0.63265759,  0.48432603,  0.70191479,
   //               0.55785930,  0.34719029,  0.06872076,  0.69960916
-  VCMP_U32(8, v2, 0x3e8e4f20, 0x3f25af14, 0x3f61cbb2, 0x3e8e15a7, 0x3cc31310,
+  VCMP_U32(8, v8, 0x3e8e4f20, 0x3f25af14, 0x3f61cbb2, 0x3e8e15a7, 0x3cc31310,
            0x3e8db4e7, 0x3f170925, 0x3e1cf850, 0x3f077203, 0x3f21f5d9,
            0x3ef7f995, 0x3f33b0b0, 0x3f0ecfde, 0x3eb1c2ed, 0x3d8cbd78,
            0x3f331996);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.4863995754678485
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fdf212baf5b0d68);
@@ -248,20 +248,20 @@ void TEST_CASE3(void) {
   //                -0.3345487709580650,  0.1693366988903542,
   //                0.4095982059989967,  0.7157757577569959,
   //                -0.5339346851091937,  0.4946553559543683
-  VLOAD_64(v4, 0x3fdd4bce893c3600, 0xbfb9577828444dc0, 0xbfe14ce6b790591e,
+  VLOAD_64(v16, 0x3fdd4bce893c3600, 0xbfb9577828444dc0, 0xbfe14ce6b790591e,
            0xbfe611ba2bf06f2a, 0x3fecf85fb3ebc33c, 0xbfe860673bd8363e,
            0x3fddc16ed6b90158, 0x3fe6227560ee74e0, 0x3fcc3b744f738cd0,
            0x3fbf2984b325f230, 0xbfd5693f3f8ba3fc, 0x3fc5acd32fdf92e8,
            0x3fda36db64d10584, 0x3fe6e7a28fdabfd2, 0xbfe115fe3157cf38,
            0x3fdfa86ef0276044);
-  asm volatile("vfsgnj.vf v2, v4, %[A]" ::[A] "f"(dscalar_64));
+  asm volatile("vfsgnj.vf v8, v16, %[A]" ::[A] "f"(dscalar_64));
   //               0.4577518787562838,  0.0989909265811582,  0.5406373582107198,
   //               0.6896639688670565,  0.9053190721589099,  0.7617679756965072,
   //               0.4649312111760273,  0.6917063611214438,  0.2205644023843889,
   //               0.1217272698758698,  0.3345487709580650,  0.1693366988903542,
   //               0.4095982059989967,  0.7157757577569959,  0.5339346851091937,
   //               0.4946553559543683
-  VCMP_U64(9, v2, 0x3fdd4bce893c3600, 0x3fb9577828444dc0, 0x3fe14ce6b790591e,
+  VCMP_U64(9, v8, 0x3fdd4bce893c3600, 0x3fb9577828444dc0, 0x3fe14ce6b790591e,
            0x3fe611ba2bf06f2a, 0x3fecf85fb3ebc33c, 0x3fe860673bd8363e,
            0x3fddc16ed6b90158, 0x3fe6227560ee74e0, 0x3fcc3b744f738cd0,
            0x3fbf2984b325f230, 0x3fd5693f3f8ba3fc, 0x3fc5acd32fdf92e8,
@@ -272,25 +272,25 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                              0.9023
   BOX_HALF_IN_FLOAT(fscalar_16, 0x3b38);
   //                0.5586,  0.0221,  0.7397,  0.9844, -0.1426,  0.6958, 0.0319,
   //                0.3943, -0.5425,  0.9814,  0.7852, -0.7271, -0.1810,
   //                -0.7485, -0.3499, -0.2178
-  VLOAD_16(v4, 0x3878, 0x25a7, 0x39eb, 0x3be0, 0xb090, 0x3991, 0x2816, 0x364f,
+  VLOAD_16(v16, 0x3878, 0x25a7, 0x39eb, 0x3be0, 0xb090, 0x3991, 0x2816, 0x364f,
            0xb857, 0x3bda, 0x3a48, 0xb9d1, 0xb1cb, 0xb9fd, 0xb599, 0xb2f8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnj.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v8);
+  asm volatile("vfsgnj.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.0000,  0.0221,  0.0000,  0.9844,  0.0000,  0.6958, 0.0000,
   //                0.3943,  0.0000,  0.9814,  0.0000,  0.7271,  0.0000, 0.7485,
   //                0.0000,  0.2178
-  VCMP_U16(10, v2, 0x0, 0x25a7, 0x0, 0x3be0, 0x0, 0x3991, 0x0, 0x364f, 0x0,
+  VCMP_U16(10, v8, 0x0, 0x25a7, 0x0, 0x3be0, 0x0, 0x3991, 0x0, 0x364f, 0x0,
            0x3bda, 0x0, 0x39d1, 0x0, 0x39fd, 0x0, 0x32f8);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                               0.64529878
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x3f25324d);
@@ -298,23 +298,23 @@ void TEST_CASE4(void) {
   //                -0.02381280, -0.27677080, -0.58998328,  0.15329099,
   //                0.52908343, -0.63265759,  0.48432603,  0.70191479,
   //                -0.55785930,  0.34719029, -0.06872076, -0.69960916
-  VLOAD_32(v4, 0x3e8e4f20, 0x3f25af14, 0x3f61cbb2, 0xbe8e15a7, 0xbcc31310,
+  VLOAD_32(v16, 0x3e8e4f20, 0x3f25af14, 0x3f61cbb2, 0xbe8e15a7, 0xbcc31310,
            0xbe8db4e7, 0xbf170925, 0x3e1cf850, 0x3f077203, 0xbf21f5d9,
            0x3ef7f995, 0x3f33b0b0, 0xbf0ecfde, 0x3eb1c2ed, 0xbd8cbd78,
            0xbf331996);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnj.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v8);
+  asm volatile("vfsgnj.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.00000000,  0.64720273,  0.00000000,  0.27750894,
   //                0.00000000,  0.27677080,  0.00000000,  0.15329099,
   //                0.00000000,  0.63265759,  0.00000000,  0.70191479,
   //                0.00000000,  0.34719029,  0.00000000,  0.69960916
-  VCMP_U32(11, v2, 0x0, 0x3f25af14, 0x0, 0x3e8e15a7, 0x0, 0x3e8db4e7, 0x0,
+  VCMP_U32(11, v8, 0x0, 0x3f25af14, 0x0, 0x3e8e15a7, 0x0, 0x3e8db4e7, 0x0,
            0x3e1cf850, 0x0, 0x3f21f5d9, 0x0, 0x3f33b0b0, 0x0, 0x3eb1c2ed, 0x0,
            0x3f331996);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.4863995754678485
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fdf212baf5b0d68);
@@ -326,22 +326,22 @@ void TEST_CASE4(void) {
   //                 -0.3345487709580650,  0.1693366988903542,
   //                 0.4095982059989967,  0.7157757577569959,
   //                 -0.5339346851091937,  0.4946553559543683
-  VLOAD_64(v4, 0x3fdd4bce893c3600, 0xbfb9577828444dc0, 0xbfe14ce6b790591e,
+  VLOAD_64(v16, 0x3fdd4bce893c3600, 0xbfb9577828444dc0, 0xbfe14ce6b790591e,
            0xbfe611ba2bf06f2a, 0x3fecf85fb3ebc33c, 0xbfe860673bd8363e,
            0x3fddc16ed6b90158, 0x3fe6227560ee74e0, 0x3fcc3b744f738cd0,
            0x3fbf2984b325f230, 0xbfd5693f3f8ba3fc, 0x3fc5acd32fdf92e8,
            0x3fda36db64d10584, 0x3fe6e7a28fdabfd2, 0xbfe115fe3157cf38,
            0x3fdfa86ef0276044);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnj.vf v2, v4, %[A], v0.t" ::[A] "f"(dscalar_64));
+  VCLEAR(v8);
+  asm volatile("vfsgnj.vf v8, v16, %[A], v0.t" ::[A] "f"(dscalar_64));
   //                0.0000000000000000,  0.0989909265811582, 0.0000000000000000,
   //                0.6896639688670565,  0.0000000000000000, 0.7617679756965072,
   //                0.0000000000000000,  0.6917063611214438, 0.0000000000000000,
   //                0.1217272698758698,  0.0000000000000000, 0.1693366988903542,
   //                0.0000000000000000,  0.7157757577569959, 0.0000000000000000,
   //                0.4946553559543683
-  VCMP_U64(12, v2, 0x0, 0x3fb9577828444dc0, 0x0, 0x3fe611ba2bf06f2a, 0x0,
+  VCMP_U64(12, v8, 0x0, 0x3fb9577828444dc0, 0x0, 0x3fe611ba2bf06f2a, 0x0,
            0x3fe860673bd8363e, 0x0, 0x3fe6227560ee74e0, 0x0, 0x3fbf2984b325f230,
            0x0, 0x3fc5acd32fdf92e8, 0x0, 0x3fe6e7a28fdabfd2, 0x0,
            0x3fdfa86ef0276044);
@@ -352,48 +352,48 @@ void TEST_CASE4(void) {
 // raise any exceptions
 void TEST_CASE5(void) {
   CLEAR_FFLAGS;
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   CHECK_FFLAGS(0);
-  VLOAD_16(v4, 0x0000, 0x3b3c, 0xb75c, 0x7fff, 0x371e, 0x3b0b, 0x30ca, 0x39d4,
+  VLOAD_16(v16, 0x0000, 0x3b3c, 0xb75c, 0x7fff, 0x371e, 0x3b0b, 0x30ca, 0x39d4,
            0x3bf1, 0x3bf0, 0x0000, 0x3af0, 0xb1f4, 0x3b78, 0xb4bc, 0x3bbc);
-  VLOAD_16(v6, 0x8000, 0xffff, 0xffff, 0xb9e8, 0xb9bc, 0x7fff, 0xb11c, 0x31de,
+  VLOAD_16(v24, 0x8000, 0xffff, 0xffff, 0xb9e8, 0xb9bc, 0x7fff, 0xb11c, 0x31de,
            0x1c8f, 0xb2e3, 0x7fff, 0xb988, 0x3198, 0xbae2, 0x38de, 0x3117);
-  asm volatile("vfsgnj.vv v2, v4, v6");
-  VCMP_U16(13, v2, 0x8000, 0xbb3c, 0xb75c, 0xffff, 0xb71e, 0x3b0b, 0xb0ca,
+  asm volatile("vfsgnj.vv v8, v16, v24");
+  VCMP_U16(13, v8, 0x8000, 0xbb3c, 0xb75c, 0xffff, 0xb71e, 0x3b0b, 0xb0ca,
            0x39d4, 0x3bf1, 0xbbf0, 0x0000, 0xbaf0, 0x31f4, 0xbb78, 0x34bc,
            0x3bbc);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000000, 0x3d816610, 0xbf536e2f, 0xbe369229, 0x3ee857e1,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000000, 0x3d816610, 0xbf536e2f, 0xbe369229, 0x3ee857e1,
            0x7fffffff, 0x80000000, 0xbea51fdd, 0x3eb544da, 0xbf0d0267,
            0x3dbae08b, 0xbe07ba22, 0x3f7536a6, 0x3f743637, 0x3e4badf5,
            0x3f45027b);
-  VLOAD_32(v6, 0x80000000, 0x7fffffff, 0x3e1626ca, 0xffffffff, 0xbefbc255,
+  VLOAD_32(v24, 0x80000000, 0x7fffffff, 0x3e1626ca, 0xffffffff, 0xbefbc255,
            0x7fffffff, 0xffffffff, 0xbeaff818, 0x3eada805, 0x3d96fc66,
            0x3f3393e1, 0x3f5443aa, 0xbe15516c, 0xbe4c8a7b, 0xbf169fd9,
            0x3f753c15);
-  asm volatile("vfsgnj.vv v2, v4, v6");
-  VCMP_U32(14, v2, 0x80000000, 0x3d816610, 0x3f536e2f, 0xbe369229, 0xbee857e1,
+  asm volatile("vfsgnj.vv v8, v16, v24");
+  VCMP_U32(14, v8, 0x80000000, 0x3d816610, 0x3f536e2f, 0xbe369229, 0xbee857e1,
            0x7fffffff, 0x80000000, 0xbea51fdd, 0x3eb544da, 0x3f0d0267,
            0x3dbae08b, 0x3e07ba22, 0xbf7536a6, 0xbf743637, 0xbe4badf5,
            0x3f45027b);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000000, 0xbfee59fbc778ffbc, 0x7fffffffffffffff,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000000, 0xbfee59fbc778ffbc, 0x7fffffffffffffff,
            0x3fde20419edcb428, 0x8000000000000000, 0x3fa8ecd6c20a0480,
            0xbfc851dfd0fdf7f8, 0xbfc784eb3b54e580, 0x3fd13e05a2db6b68,
            0xbfe9790bf1eadde4, 0x3fe46b59155986dc, 0x3fcc266386bc2e10,
            0x3fdb01fdd39a7d9c, 0xbfe4eef55bb6b208, 0x3fe736d06902107a,
            0x3fcf3a7f44aa9f48);
-  VLOAD_64(v6, 0x8000000000000000, 0x7fffffffffffffff, 0xbfe187df69e0bb9c,
+  VLOAD_64(v24, 0x8000000000000000, 0x7fffffffffffffff, 0xbfe187df69e0bb9c,
            0xbfe76fd3c4a3b1e8, 0x0000000000000001, 0xbfe7c6f7c1644c86,
            0xbfe229ce53357d20, 0xbfe79fcc34ac1d30, 0xbfe962e04d917824,
            0xbfb0aa5656314cf0, 0xbfc69c8ad7d5ef20, 0xbfddd9380f0bd244,
            0xbfc408f2f3d40a40, 0xbfb01baf416f2160, 0xbfed13d1838e183a,
            0xbfbee005420412c0);
-  asm volatile("vfsgnj.vv v2, v4, v6");
-  VCMP_U64(15, v2, 0x8000000000000000, 0x3fee59fbc778ffbc, 0xffffffffffffffff,
+  asm volatile("vfsgnj.vv v8, v16, v24");
+  VCMP_U64(15, v8, 0x8000000000000000, 0x3fee59fbc778ffbc, 0xffffffffffffffff,
            0xbfde20419edcb428, 0x0000000000000000, 0xbfa8ecd6c20a0480,
            0xbfc851dfd0fdf7f8, 0xbfc784eb3b54e580, 0xbfd13e05a2db6b68,
            0xbfe9790bf1eadde4, 0xbfe46b59155986dc, 0xbfcc266386bc2e10,
diff --git a/sw/riscvTests/isa/rv64uv/vfsgnjn.c b/sw/riscvTests/isa/rv64uv/vfsgnjn.c
index 83f5877b..8d69a20f 100644
--- a/sw/riscvTests/isa/rv64uv/vfsgnjn.c
+++ b/sw/riscvTests/isa/rv64uv/vfsgnjn.c
@@ -10,31 +10,31 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.5278, -0.6548,  0.2776,  0.8730,  0.2180,  0.6172, -0.8408,
   //               0.9922,  0.4250,  0.7393,  0.2549,  0.4998,  0.4609, -0.6348,
   //               0.1127, -0.1804
-  VLOAD_16(v4, 0x3839, 0xb93d, 0x3471, 0x3afc, 0x32fa, 0x38f0, 0xbaba, 0x3bf0,
+  VLOAD_16(v16, 0x3839, 0xb93d, 0x3471, 0x3afc, 0x32fa, 0x38f0, 0xbaba, 0x3bf0,
            0x36cd, 0x39ea, 0x3414, 0x37ff, 0x3760, 0xb914, 0x2f36, 0xb1c6);
   //              -0.6348, -0.4368, -0.1896,  0.9419, -0.6108, -0.3594, -0.5166,
   //              -0.1266, -0.9233,  0.2368,  0.1243,  0.3745,  0.0945, -0.3088,
   //              0.0190, -0.6289
-  VLOAD_16(v6, 0xb914, 0xb6fd, 0xb211, 0x3b89, 0xb8e3, 0xb5c0, 0xb822, 0xb00d,
+  VLOAD_16(v24, 0xb914, 0xb6fd, 0xb211, 0x3b89, 0xb8e3, 0xb5c0, 0xb822, 0xb00d,
            0xbb63, 0x3394, 0x2ff5, 0x35fe, 0x2e0c, 0xb4f1, 0x24da, 0xb908);
-  asm volatile("vfsgnjn.vv v2, v4, v6");
+  asm volatile("vfsgnjn.vv v8, v16, v24");
   //               0.5278,  0.6548,  0.2776, -0.8730,  0.2180,  0.6172,  0.8408,
   //               0.9922,  0.4250, -0.7393, -0.2549, -0.4998, -0.4609,  0.6348,
   //               -0.1127,  0.1804
-  VCMP_U16(1, v2, 0x3839, 0x393d, 0x3471, 0xbafc, 0x32fa, 0x38f0, 0x3aba,
+  VCMP_U16(1, v8, 0x3839, 0x393d, 0x3471, 0xbafc, 0x32fa, 0x38f0, 0x3aba,
            0x3bf0, 0x36cd, 0xb9ea, 0xb414, 0xb7ff, 0xb760, 0x3914, 0xaf36,
            0x31c6);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.64186704,  0.87601262, -0.93132722,  0.53574133,
   //              0.17954259, -0.80486834, -0.95272040, -0.45182621, 0.20335940,
   //              0.96179944,  0.80393785,  0.06180594,  0.86447370,
   //              -0.24008171, -0.42264909, -0.01868468
-  VLOAD_32(v4, 0xbf245166, 0x3f60425d, 0xbf6e6b76, 0x3f092658, 0x3e37da03,
+  VLOAD_32(v16, 0xbf245166, 0x3f60425d, 0xbf6e6b76, 0x3f092658, 0x3e37da03,
            0xbf4e0bda, 0xbf73e57c, 0xbee755c4, 0x3e503d72, 0x3f76387d,
            0x3f4dcedf, 0x3d7d283b, 0x3f5d4e26, 0xbe75d7fb, 0xbed86576,
            0xbc99109c);
@@ -42,29 +42,29 @@ void TEST_CASE1(void) {
   //               0.44768164,  0.66998041,  0.39474848, -0.39895460,
   //               -0.06065369,  0.53388232, -0.60164928, -0.09839682,
   //               -0.38704434,  0.47123700,  0.40912241, -0.54495376
-  VLOAD_32(v6, 0x3ea8e123, 0xbf48664e, 0x3f3afa0d, 0x3f7d982e, 0x3ee53687,
+  VLOAD_32(v24, 0x3ea8e123, 0xbf48664e, 0x3f3afa0d, 0x3f7d982e, 0x3ee53687,
            0x3f2b83d6, 0x3eca1c79, 0xbecc43c7, 0xbd787002, 0x3f08ac83,
            0xbf1a05b0, 0xbdc98446, 0xbec62aad, 0x3ef145fa, 0x3ed1787e,
            0xbf0b8217);
-  asm volatile("vfsgnjn.vv v2, v4, v6");
+  asm volatile("vfsgnjn.vv v8, v16, v24");
   //              -0.64186704,  0.87601262, -0.93132722, -0.53574133,
   //              -0.17954259, -0.80486834, -0.95272040,  0.45182621,
   //              0.20335940, -0.96179944,  0.80393785,  0.06180594, 0.86447370,
   //              -0.24008171, -0.42264909,  0.01868468
-  VCMP_U32(2, v2, 0xbf245166, 0x3f60425d, 0xbf6e6b76, 0xbf092658, 0xbe37da03,
+  VCMP_U32(2, v8, 0xbf245166, 0x3f60425d, 0xbf6e6b76, 0xbf092658, 0xbe37da03,
            0xbf4e0bda, 0xbf73e57c, 0x3ee755c4, 0x3e503d72, 0xbf76387d,
            0x3f4dcedf, 0x3d7d283b, 0x3f5d4e26, 0xbe75d7fb, 0xbed86576,
            0x3c99109c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               0.3054868811191440, -0.2848737407493320,  0.8796894022735833,
   //               -0.2053728688878902, -0.3336030943630310, 0.2807217618714037,
   //               0.4723331455917303, -0.8582398814993568,  0.8015611350975347,
   //               0.0545934239457773,  0.8461592442963186,  0.5731810427237676,
   //               0.9004228762726765, -0.5815114412549589, -0.4481603571708770,
   //               -0.3109452697316515
-  VLOAD_64(v4, 0x3fd38d18d8f0e180, 0xbfd23b5f12007bec, 0x3fec266a63ace3f8,
+  VLOAD_64(v16, 0x3fd38d18d8f0e180, 0xbfd23b5f12007bec, 0x3fec266a63ace3f8,
            0xbfca49a87dadf9c0, 0xbfd559c0cb088d3c, 0x3fd1f75868a0d7ec,
            0x3fde3ab4cd4887cc, 0xbfeb76b37be53474, 0x3fe9a663899fa232,
            0x3fabf3ab54d8f940, 0x3feb13bc8d2ebe92, 0x3fe2577fc525f1c0,
@@ -76,20 +76,20 @@ void TEST_CASE1(void) {
   //              -0.7302340801247744,  0.1579280396497211, -0.6128023516491234,
   //              0.2706272563647967, -0.7982929669593624, -0.2521632643799878,
   //              0.9025785865542095
-  VLOAD_64(v6, 0xbfeb866abced1b2e, 0xbfc9e5a5e5d1f648, 0x3fe68ce5791f15e4,
+  VLOAD_64(v24, 0xbfeb866abced1b2e, 0xbfc9e5a5e5d1f648, 0x3fe68ce5791f15e4,
            0x3fb121ba83e404a0, 0xbfee62f88b14a294, 0x3fdccf2004e2dd30,
            0x3fc3905c3a38c700, 0xbfd19add326bc2ac, 0xbfe1ba450e13ef3a,
            0xbfe75e13dc91f006, 0x3fc436fc6ab55e68, 0xbfe39c13ad67d608,
            0x3fd151f4fbdf8d78, 0xbfe98b9db136f3e0, 0xbfd023716370f004,
            0x3fece1ec7cea3f5e);
-  asm volatile("vfsgnjn.vv v2, v4, v6");
+  asm volatile("vfsgnjn.vv v8, v16, v24");
   //               0.3054868811191440,  0.2848737407493320, -0.8796894022735833,
   //               -0.2053728688878902,  0.3336030943630310,
   //               -0.2807217618714037, -0.4723331455917303, 0.8582398814993568,
   //               0.8015611350975347,  0.0545934239457773, -0.8461592442963186,
   //               0.5731810427237676, -0.9004228762726765,  0.5815114412549589,
   //               0.4481603571708770, -0.3109452697316515
-  VCMP_U64(3, v2, 0x3fd38d18d8f0e180, 0x3fd23b5f12007bec, 0xbfec266a63ace3f8,
+  VCMP_U64(3, v8, 0x3fd38d18d8f0e180, 0x3fd23b5f12007bec, 0xbfec266a63ace3f8,
            0xbfca49a87dadf9c0, 0x3fd559c0cb088d3c, 0xbfd1f75868a0d7ec,
            0xbfde3ab4cd4887cc, 0x3feb76b37be53474, 0x3fe9a663899fa232,
            0x3fabf3ab54d8f940, 0xbfeb13bc8d2ebe92, 0x3fe2577fc525f1c0,
@@ -101,32 +101,32 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.5278, -0.6548,  0.2776,  0.8730,  0.2180,  0.6172, -0.8408,
   //               0.9922,  0.4250,  0.7393,  0.2549,  0.4998,  0.4609, -0.6348,
   //               0.1127, -0.1804
-  VLOAD_16(v4, 0x3839, 0xb93d, 0x3471, 0x3afc, 0x32fa, 0x38f0, 0xbaba, 0x3bf0,
+  VLOAD_16(v16, 0x3839, 0xb93d, 0x3471, 0x3afc, 0x32fa, 0x38f0, 0xbaba, 0x3bf0,
            0x36cd, 0x39ea, 0x3414, 0x37ff, 0x3760, 0xb914, 0x2f36, 0xb1c6);
   //              -0.6348, -0.4368, -0.1896,  0.9419, -0.6108, -0.3594, -0.5166,
   //              -0.1266, -0.9233,  0.2368,  0.1243,  0.3745,  0.0945, -0.3088,
   //              0.0190, -0.6289
-  VLOAD_16(v6, 0xb914, 0xb6fd, 0xb211, 0x3b89, 0xb8e3, 0xb5c0, 0xb822, 0xb00d,
+  VLOAD_16(v24, 0xb914, 0xb6fd, 0xb211, 0x3b89, 0xb8e3, 0xb5c0, 0xb822, 0xb00d,
            0xbb63, 0x3394, 0x2ff5, 0x35fe, 0x2e0c, 0xb4f1, 0x24da, 0xb908);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnjn.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfsgnjn.vv v8, v16, v24, v0.t");
   //               0.0000,  0.6548,  0.0000, -0.8730,  0.0000,  0.6172,  0.0000,
   //               0.9922,  0.0000, -0.7393,  0.0000, -0.4998,  0.0000,  0.6348,
   //               0.0000,  0.1804
-  VCMP_U16(4, v2, 0x0, 0x393d, 0x0, 0xbafc, 0x0, 0x38f0, 0x0, 0x3bf0, 0x0,
+  VCMP_U16(4, v8, 0x0, 0x393d, 0x0, 0xbafc, 0x0, 0x38f0, 0x0, 0x3bf0, 0x0,
            0xb9ea, 0x0, 0xb7ff, 0x0, 0x3914, 0x0, 0x31c6);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.64186704,  0.87601262, -0.93132722,  0.53574133,
   //              0.17954259, -0.80486834, -0.95272040, -0.45182621, 0.20335940,
   //              0.96179944,  0.80393785,  0.06180594,  0.86447370,
   //              -0.24008171, -0.42264909, -0.01868468
-  VLOAD_32(v4, 0xbf245166, 0x3f60425d, 0xbf6e6b76, 0x3f092658, 0x3e37da03,
+  VLOAD_32(v16, 0xbf245166, 0x3f60425d, 0xbf6e6b76, 0x3f092658, 0x3e37da03,
            0xbf4e0bda, 0xbf73e57c, 0xbee755c4, 0x3e503d72, 0x3f76387d,
            0x3f4dcedf, 0x3d7d283b, 0x3f5d4e26, 0xbe75d7fb, 0xbed86576,
            0xbc99109c);
@@ -134,30 +134,30 @@ void TEST_CASE2(void) {
   //               0.44768164,  0.66998041,  0.39474848, -0.39895460,
   //               -0.06065369,  0.53388232, -0.60164928, -0.09839682,
   //               -0.38704434,  0.47123700,  0.40912241, -0.54495376
-  VLOAD_32(v6, 0x3ea8e123, 0xbf48664e, 0x3f3afa0d, 0x3f7d982e, 0x3ee53687,
+  VLOAD_32(v24, 0x3ea8e123, 0xbf48664e, 0x3f3afa0d, 0x3f7d982e, 0x3ee53687,
            0x3f2b83d6, 0x3eca1c79, 0xbecc43c7, 0xbd787002, 0x3f08ac83,
            0xbf1a05b0, 0xbdc98446, 0xbec62aad, 0x3ef145fa, 0x3ed1787e,
            0xbf0b8217);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnjn.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfsgnjn.vv v8, v16, v24, v0.t");
   //               0.00000000,  0.87601262,  0.00000000, -0.53574133,
   //               0.00000000, -0.80486834,  0.00000000,  0.45182621,
   //               0.00000000, -0.96179944,  0.00000000,  0.06180594,
   //               0.00000000, -0.24008171,  0.00000000,  0.01868468
-  VCMP_U32(5, v2, 0x0, 0x3f60425d, 0x0, 0xbf092658, 0x0, 0xbf4e0bda, 0x0,
+  VCMP_U32(5, v8, 0x0, 0x3f60425d, 0x0, 0xbf092658, 0x0, 0xbf4e0bda, 0x0,
            0x3ee755c4, 0x0, 0xbf76387d, 0x0, 0x3d7d283b, 0x0, 0xbe75d7fb, 0x0,
            0x3c99109c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               0.3054868811191440, -0.2848737407493320,  0.8796894022735833,
   //               -0.2053728688878902, -0.3336030943630310, 0.2807217618714037,
   //               0.4723331455917303, -0.8582398814993568,  0.8015611350975347,
   //               0.0545934239457773,  0.8461592442963186,  0.5731810427237676,
   //               0.9004228762726765, -0.5815114412549589, -0.4481603571708770,
   //               -0.3109452697316515
-  VLOAD_64(v4, 0x3fd38d18d8f0e180, 0xbfd23b5f12007bec, 0x3fec266a63ace3f8,
+  VLOAD_64(v16, 0x3fd38d18d8f0e180, 0xbfd23b5f12007bec, 0x3fec266a63ace3f8,
            0xbfca49a87dadf9c0, 0xbfd559c0cb088d3c, 0x3fd1f75868a0d7ec,
            0x3fde3ab4cd4887cc, 0xbfeb76b37be53474, 0x3fe9a663899fa232,
            0x3fabf3ab54d8f940, 0x3feb13bc8d2ebe92, 0x3fe2577fc525f1c0,
@@ -169,22 +169,22 @@ void TEST_CASE2(void) {
   //              -0.7302340801247744,  0.1579280396497211, -0.6128023516491234,
   //              0.2706272563647967, -0.7982929669593624, -0.2521632643799878,
   //              0.9025785865542095
-  VLOAD_64(v6, 0xbfeb866abced1b2e, 0xbfc9e5a5e5d1f648, 0x3fe68ce5791f15e4,
+  VLOAD_64(v24, 0xbfeb866abced1b2e, 0xbfc9e5a5e5d1f648, 0x3fe68ce5791f15e4,
            0x3fb121ba83e404a0, 0xbfee62f88b14a294, 0x3fdccf2004e2dd30,
            0x3fc3905c3a38c700, 0xbfd19add326bc2ac, 0xbfe1ba450e13ef3a,
            0xbfe75e13dc91f006, 0x3fc436fc6ab55e68, 0xbfe39c13ad67d608,
            0x3fd151f4fbdf8d78, 0xbfe98b9db136f3e0, 0xbfd023716370f004,
            0x3fece1ec7cea3f5e);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnjn.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfsgnjn.vv v8, v16, v24, v0.t");
   //               0.0000000000000000,  0.2848737407493320,  0.0000000000000000,
   //               -0.2053728688878902,  0.0000000000000000,
   //               -0.2807217618714037,  0.0000000000000000, 0.8582398814993568,
   //               0.0000000000000000,  0.0545934239457773,  0.0000000000000000,
   //               0.5731810427237676,  0.0000000000000000,  0.5815114412549589,
   //               0.0000000000000000, -0.3109452697316515
-  VCMP_U64(6, v2, 0x0, 0x3fd23b5f12007bec, 0x0, 0xbfca49a87dadf9c0, 0x0,
+  VCMP_U64(6, v8, 0x0, 0x3fd23b5f12007bec, 0x0, 0xbfca49a87dadf9c0, 0x0,
            0xbfd1f75868a0d7ec, 0x0, 0x3feb76b37be53474, 0x0, 0x3fabf3ab54d8f940,
            0x0, 0x3fe2577fc525f1c0, 0x0, 0x3fe29bbde1ce1372, 0x0,
            0xbfd3e686fd15f950);
@@ -193,24 +193,24 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                             -0.6143
   BOX_HALF_IN_FLOAT(fscalar_16, 0xb8ea);
   //              -0.9351,  0.6538, -0.6743, -0.4695, -0.1439,  0.6250, -0.1511,
   //              -0.7476,  0.8496,  0.6279,  0.5234,  0.2610,  0.6299, -0.0123,
   //              -0.9995, -0.3872
-  VLOAD_16(v4, 0xbb7b, 0x393b, 0xb965, 0xb783, 0xb09b, 0x3900, 0xb0d6, 0xb9fb,
+  VLOAD_16(v16, 0xbb7b, 0x393b, 0xb965, 0xb783, 0xb09b, 0x3900, 0xb0d6, 0xb9fb,
            0x3acc, 0x3906, 0x3830, 0x342d, 0x390a, 0xa24d, 0xbbff, 0xb632);
-  asm volatile("vfsgnjn.vf v2, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfsgnjn.vf v8, v16, %[A]" ::[A] "f"(fscalar_16));
   //               0.9351,  0.6538,  0.6743,  0.4695,  0.1439,  0.6250,  0.1511,
   //               0.7476,  0.8496,  0.6279,  0.5234,  0.2610,  0.6299,  0.0123,
   //               0.9995,  0.3872
-  VCMP_U16(7, v2, 0x3b7b, 0x393b, 0x3965, 0x3783, 0x309b, 0x3900, 0x30d6,
+  VCMP_U16(7, v8, 0x3b7b, 0x393b, 0x3965, 0x3783, 0x309b, 0x3900, 0x30d6,
            0x39fb, 0x3acc, 0x3906, 0x3830, 0x342d, 0x390a, 0x224d, 0x3bff,
            0x3632);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                               0.56259364
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x3f100623);
@@ -218,22 +218,22 @@ void TEST_CASE3(void) {
   //              0.90217608,  0.57424510,  0.05995686, -0.00974263,
   //              -0.45620662, -0.36967716, -0.56535333, -0.93745488,
   //              -0.55570704,  0.04399948, -0.57520008, -0.05702910
-  VLOAD_32(v4, 0xbc053c4a, 0xbec60586, 0x3f719cc7, 0x3eca7d19, 0x3f66f503,
+  VLOAD_32(v16, 0xbc053c4a, 0xbec60586, 0x3f719cc7, 0x3eca7d19, 0x3f66f503,
            0x3f1301ba, 0x3d759554, 0xbc1f9f8d, 0xbee993ea, 0xbebd4653,
            0xbf10baff, 0xbf6ffd0b, 0xbf0e42d1, 0x3d3438cd, 0xbf134050,
            0xbd699758);
-  asm volatile("vfsgnjn.vf v2, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfsgnjn.vf v8, v16, %[A]" ::[A] "f"(fscalar_32));
   //              -0.00813205, -0.38676089, -0.94379848, -0.39548567,
   //              -0.90217608, -0.57424510, -0.05995686, -0.00974263,
   //              -0.45620662, -0.36967716, -0.56535333, -0.93745488,
   //              -0.55570704, -0.04399948, -0.57520008, -0.05702910
-  VCMP_U32(8, v2, 0xbc053c4a, 0xbec60586, 0xbf719cc7, 0xbeca7d19, 0xbf66f503,
+  VCMP_U32(8, v8, 0xbc053c4a, 0xbec60586, 0xbf719cc7, 0xbeca7d19, 0xbf66f503,
            0xbf1301ba, 0xbd759554, 0xbc1f9f8d, 0xbee993ea, 0xbebd4653,
            0xbf10baff, 0xbf6ffd0b, 0xbf0e42d1, 0xbd3438cd, 0xbf134050,
            0xbd699758);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.1909501680714165
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fc8710e1b8426e8);
@@ -243,20 +243,20 @@ void TEST_CASE3(void) {
   //               -0.0001555883762874,  0.5283267089670276, 0.5439688283816015,
   //               -0.2866314604291811, -0.0576946087921848, 0.7960283598249005,
   //               -0.8999056473475127,  0.2142070697411482
-  VLOAD_64(v4, 0xbfd13b3694df2b24, 0xbfd4eaea07180958, 0x3fead67ca8cd9566,
+  VLOAD_64(v16, 0xbfd13b3694df2b24, 0xbfd4eaea07180958, 0x3fead67ca8cd9566,
            0xbfe214d9ba40b584, 0xbfe47283a0c1e25c, 0x3fe10547bd8d051e,
            0xbfe904219ee4fb76, 0xbfe22c593425cec0, 0xbf2464adf9bfe000,
            0x3fe0e80d6a13bbf4, 0x3fe1683150fe2844, 0xbfd2582b7b231344,
            0xbfad8a25d3d5fd40, 0x3fe9791077845df2, 0xbfeccc06ed9afc1e,
            0x3fcb6b23238e1bc8);
-  asm volatile("vfsgnjn.vf v2, v4, %[A]" ::[A] "f"(dscalar_64));
+  asm volatile("vfsgnjn.vf v8, v16, %[A]" ::[A] "f"(dscalar_64));
   //              -0.2692390874696449, -0.3268380231167121, -0.8386824891028197,
   //              -0.5650452268361481, -0.6389787807266418, -0.5318945600667211,
   //              -0.7817543128402196, -0.5679136293897145, -0.0001555883762874,
   //              -0.5283267089670276, -0.5439688283816015, -0.2866314604291811,
   //              -0.0576946087921848, -0.7960283598249005, -0.8999056473475127,
   //              -0.2142070697411482
-  VCMP_U64(9, v2, 0xbfd13b3694df2b24, 0xbfd4eaea07180958, 0xbfead67ca8cd9566,
+  VCMP_U64(9, v8, 0xbfd13b3694df2b24, 0xbfd4eaea07180958, 0xbfead67ca8cd9566,
            0xbfe214d9ba40b584, 0xbfe47283a0c1e25c, 0xbfe10547bd8d051e,
            0xbfe904219ee4fb76, 0xbfe22c593425cec0, 0xbf2464adf9bfe000,
            0xbfe0e80d6a13bbf4, 0xbfe1683150fe2844, 0xbfd2582b7b231344,
@@ -267,25 +267,25 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                             -0.6143
   BOX_HALF_IN_FLOAT(fscalar_16, 0xb8ea);
   //               -0.9351,  0.6538, -0.6743, -0.4695, -0.1439,  0.6250,
   //               -0.1511, -0.7476,  0.8496,  0.6279,  0.5234,  0.2610, 0.6299,
   //               -0.0123, -0.9995, -0.3872
-  VLOAD_16(v4, 0xbb7b, 0x393b, 0xb965, 0xb783, 0xb09b, 0x3900, 0xb0d6, 0xb9fb,
+  VLOAD_16(v16, 0xbb7b, 0x393b, 0xb965, 0xb783, 0xb09b, 0x3900, 0xb0d6, 0xb9fb,
            0x3acc, 0x3906, 0x3830, 0x342d, 0x390a, 0xa24d, 0xbbff, 0xb632);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnjn.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v8);
+  asm volatile("vfsgnjn.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.0000,  0.6538,  0.0000,  0.4695,  0.0000,  0.6250, 0.0000,
   //                0.7476,  0.0000,  0.6279,  0.0000,  0.2610,  0.0000, 0.0123,
   //                0.0000,  0.3872
-  VCMP_U16(10, v2, 0x0, 0x393b, 0x0, 0x3783, 0x0, 0x3900, 0x0, 0x39fb, 0x0,
+  VCMP_U16(10, v8, 0x0, 0x393b, 0x0, 0x3783, 0x0, 0x3900, 0x0, 0x39fb, 0x0,
            0x3906, 0x0, 0x342d, 0x0, 0x224d, 0x0, 0x3632);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                               0.56259364
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x3f100623);
@@ -293,23 +293,23 @@ void TEST_CASE4(void) {
   //               0.90217608,  0.57424510,  0.05995686, -0.00974263,
   //               -0.45620662, -0.36967716, -0.56535333, -0.93745488,
   //               -0.55570704,  0.04399948, -0.57520008, -0.05702910
-  VLOAD_32(v4, 0xbc053c4a, 0xbec60586, 0x3f719cc7, 0x3eca7d19, 0x3f66f503,
+  VLOAD_32(v16, 0xbc053c4a, 0xbec60586, 0x3f719cc7, 0x3eca7d19, 0x3f66f503,
            0x3f1301ba, 0x3d759554, 0xbc1f9f8d, 0xbee993ea, 0xbebd4653,
            0xbf10baff, 0xbf6ffd0b, 0xbf0e42d1, 0x3d3438cd, 0xbf134050,
            0xbd699758);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnjn.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v8);
+  asm volatile("vfsgnjn.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.00000000, -0.38676089,  0.00000000, -0.39548567,
   //                0.00000000, -0.57424510,  0.00000000, -0.00974263,
   //                0.00000000, -0.36967716,  0.00000000, -0.93745488,
   //                0.00000000, -0.04399948,  0.00000000, -0.05702910
-  VCMP_U32(11, v2, 0x0, 0xbec60586, 0x0, 0xbeca7d19, 0x0, 0xbf1301ba, 0x0,
+  VCMP_U32(11, v8, 0x0, 0xbec60586, 0x0, 0xbeca7d19, 0x0, 0xbf1301ba, 0x0,
            0xbc1f9f8d, 0x0, 0xbebd4653, 0x0, 0xbf6ffd0b, 0x0, 0xbd3438cd, 0x0,
            0xbd699758);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                                0.1909501680714165
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0x3fc8710e1b8426e8);
@@ -321,15 +321,15 @@ void TEST_CASE4(void) {
   //                0.5439688283816015, -0.2866314604291811,
   //                -0.0576946087921848,  0.7960283598249005,
   //                -0.8999056473475127,  0.2142070697411482
-  VLOAD_64(v4, 0xbfd13b3694df2b24, 0xbfd4eaea07180958, 0x3fead67ca8cd9566,
+  VLOAD_64(v16, 0xbfd13b3694df2b24, 0xbfd4eaea07180958, 0x3fead67ca8cd9566,
            0xbfe214d9ba40b584, 0xbfe47283a0c1e25c, 0x3fe10547bd8d051e,
            0xbfe904219ee4fb76, 0xbfe22c593425cec0, 0xbf2464adf9bfe000,
            0x3fe0e80d6a13bbf4, 0x3fe1683150fe2844, 0xbfd2582b7b231344,
            0xbfad8a25d3d5fd40, 0x3fe9791077845df2, 0xbfeccc06ed9afc1e,
            0x3fcb6b23238e1bc8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnjn.vf v2, v4, %[A], v0.t" ::[A] "f"(dscalar_64));
+  VCLEAR(v8);
+  asm volatile("vfsgnjn.vf v8, v16, %[A], v0.t" ::[A] "f"(dscalar_64));
   //                0.0000000000000000, -0.3268380231167121, 0.0000000000000000,
   //                -0.5650452268361481,  0.0000000000000000,
   //                -0.5318945600667211,  0.0000000000000000,
@@ -338,7 +338,7 @@ void TEST_CASE4(void) {
   //                -0.2866314604291811,  0.0000000000000000,
   //                -0.7960283598249005,  0.0000000000000000,
   //                -0.2142070697411482
-  VCMP_U64(12, v2, 0x0, 0xbfd4eaea07180958, 0x0, 0xbfe214d9ba40b584, 0x0,
+  VCMP_U64(12, v8, 0x0, 0xbfd4eaea07180958, 0x0, 0xbfe214d9ba40b584, 0x0,
            0xbfe10547bd8d051e, 0x0, 0xbfe22c593425cec0, 0x0, 0xbfe0e80d6a13bbf4,
            0x0, 0xbfd2582b7b231344, 0x0, 0xbfe9791077845df2, 0x0,
            0xbfcb6b23238e1bc8);
diff --git a/sw/riscvTests/isa/rv64uv/vfsgnjx.c b/sw/riscvTests/isa/rv64uv/vfsgnjx.c
index 68a0e505..5d844248 100644
--- a/sw/riscvTests/isa/rv64uv/vfsgnjx.c
+++ b/sw/riscvTests/isa/rv64uv/vfsgnjx.c
@@ -10,31 +10,31 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.0371,  0.8374,  0.7183,  0.8086, -0.8940,  0.4626,  0.5449,
   //              0.6831,  0.4661,  0.2981,  0.5615, -0.6167, -0.7075, -0.7603,
   //              0.8438, -0.2742
-  VLOAD_16(v4, 0xa8c1, 0x3ab3, 0x39bf, 0x3a78, 0xbb27, 0x3767, 0x385c, 0x3977,
+  VLOAD_16(v16, 0xa8c1, 0x3ab3, 0x39bf, 0x3a78, 0xbb27, 0x3767, 0x385c, 0x3977,
            0x3775, 0x34c5, 0x387e, 0xb8ef, 0xb9a9, 0xba15, 0x3ac0, 0xb463);
   //               0.3516,  0.7925, -0.5034, -0.1672,  0.0703, -0.9731,  0.0361,
   //               -0.4077,  0.8965,  0.8242, -0.7822,  0.0265, -0.5361, 0.1226,
   //               -0.9917,  0.5415
-  VLOAD_16(v6, 0x35a0, 0x3a57, 0xb807, 0xb15a, 0x2c7f, 0xbbc9, 0x289f, 0xb686,
+  VLOAD_16(v24, 0x35a0, 0x3a57, 0xb807, 0xb15a, 0x2c7f, 0xbbc9, 0x289f, 0xb686,
            0x3b2c, 0x3a98, 0xba42, 0x26cb, 0xb84a, 0x2fd8, 0xbbef, 0x3855);
-  asm volatile("vfsgnjx.vv v2, v4, v6");
+  asm volatile("vfsgnjx.vv v8, v16, v24");
   //              -0.0371,  0.8374, -0.7183, -0.8086, -0.8940, -0.4626,  0.5449,
   //              -0.6831,  0.4661,  0.2981, -0.5615, -0.6167,  0.7075, -0.7603,
   //              -0.8438, -0.2742
-  VCMP_U16(1, v2, 0xa8c1, 0x3ab3, 0xb9bf, 0xba78, 0xbb27, 0xb767, 0x385c,
+  VCMP_U16(1, v8, 0xa8c1, 0x3ab3, 0xb9bf, 0xba78, 0xbb27, 0xb767, 0x385c,
            0xb977, 0x3775, 0x34c5, 0xb87e, 0xb8ef, 0x39a9, 0xba15, 0xbac0,
            0xb463);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.00918692, -0.23372029,  0.42919466,  0.95128548,
   //              0.05014091,  0.08194520,  0.65458435,  0.38167605,
   //              -0.52784044,  0.46330592,  0.66792834,  0.94584799,
   //              -0.11679628,  0.12139154,  0.61421394, -0.71422517
-  VLOAD_32(v4, 0xbc1684ba, 0xbe6f545f, 0x3edbbf67, 0x3f738772, 0x3d4d608d,
+  VLOAD_32(v16, 0xbc1684ba, 0xbe6f545f, 0x3edbbf67, 0x3f738772, 0x3d4d608d,
            0x3da7d2e2, 0x3f2792d7, 0x3ec36b0b, 0xbf07208d, 0x3eed366f,
            0x3f2afd5a, 0x3f722318, 0xbdef32e4, 0x3df89c21, 0x3f1d3d20,
            0xbf36d776);
@@ -42,29 +42,29 @@ void TEST_CASE1(void) {
   //              0.23285799,  0.19133335,  0.78484982, -0.40654737,
   //              -0.40144378, -0.94419461,  0.60990387, -0.37662670,
   //              0.75369638, -0.82297397,  0.24545205, -0.75572032
-  VLOAD_32(v6, 0xbf771aaf, 0xbf543b53, 0xbf7c3bb6, 0x3ebd01e4, 0x3e6e7253,
+  VLOAD_32(v24, 0xbf771aaf, 0xbf543b53, 0xbf7c3bb6, 0x3ebd01e4, 0x3e6e7253,
            0x3e43ece4, 0x3f48ebeb, 0xbed026fa, 0xbecd8a0a, 0xbf71b6bd,
            0x3f1c22a9, 0xbec0d537, 0x3f40f23f, 0xbf52ae6c, 0x3e7b57c8,
            0xbf4176e3);
-  asm volatile("vfsgnjx.vv v2, v4, v6");
+  asm volatile("vfsgnjx.vv v8, v16, v24");
   //               0.00918692,  0.23372029, -0.42919466,  0.95128548,
   //               0.05014091,  0.08194520,  0.65458435, -0.38167605,
   //               0.52784044, -0.46330592,  0.66792834, -0.94584799,
   //               -0.11679628, -0.12139154,  0.61421394,  0.71422517
-  VCMP_U32(2, v2, 0x3c1684ba, 0x3e6f545f, 0xbedbbf67, 0x3f738772, 0x3d4d608d,
+  VCMP_U32(2, v8, 0x3c1684ba, 0x3e6f545f, 0xbedbbf67, 0x3f738772, 0x3d4d608d,
            0x3da7d2e2, 0x3f2792d7, 0xbec36b0b, 0x3f07208d, 0xbeed366f,
            0x3f2afd5a, 0xbf722318, 0xbdef32e4, 0xbdf89c21, 0x3f1d3d20,
            0x3f36d776);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.4085246287477386,  0.8681744372264055, -0.9782992825101422,
   //              0.9959576051606904, -0.7910104167136705,  0.0799315061445605,
   //              0.2562329212571202, -0.0401280831920132, -0.6164331117742006,
   //              0.0314794700215042, -0.2391312835511448,  0.2944948324466776,
   //              -0.3469257666022745,  0.3129356083924371,  0.1418123916338592,
   //              -0.2697778839142546
-  VLOAD_64(v4, 0xbfda25447c0540c8, 0x3febc815c1e38a2c, 0xbfef4e3a4c029a38,
+  VLOAD_64(v16, 0xbfda25447c0540c8, 0x3febc815c1e38a2c, 0xbfef4e3a4c029a38,
            0x3fefdee27bcbc3c2, 0xbfe94ff513d293d6, 0x3fb4766424cf97d0,
            0x3fd0661ec43d4dd0, 0xbfa48bab09ebf660, 0xbfe3b9d1eee7bc0a,
            0x3fa01e13bc79bd60, 0xbfce9bda9926bde0, 0x3fd2d900da8cc448,
@@ -76,13 +76,13 @@ void TEST_CASE1(void) {
   //              -0.1361158534833962,  0.1558021548512183,  0.9766583762298613,
   //              0.2768845956890595,  0.6672273199701737, -0.4444943981200347,
   //              0.5095574851608440
-  VLOAD_64(v6, 0xbfecef7ffd03691e, 0x3fd2e79c5b6133f0, 0xbfdbfe36b251f164,
+  VLOAD_64(v24, 0xbfecef7ffd03691e, 0x3fd2e79c5b6133f0, 0xbfdbfe36b251f164,
            0x3fc2bf4992d91480, 0xbfe0840fa43663a0, 0xbfd68f847062a774,
            0xbfb1b9459f0cf460, 0xbfefaea9bfed2a32, 0x3fe3eb8fa49aeb32,
            0xbfc16c3e8996d300, 0x3fc3f15333ddbc58, 0x3fef40c91128b1ea,
            0x3fd1b87a2ad00b5c, 0x3fe559ed1bc8a0c2, 0xbfdc7298a1cb9174,
            0x3fe04e4b7fc654a0);
-  asm volatile("vfsgnjx.vv v2, v4, v6");
+  asm volatile("vfsgnjx.vv v8, v16, v24");
   //               0.4085246287477386,  0.8681744372264055,  0.9782992825101422,
   //               0.9959576051606904,  0.7910104167136705, -0.0799315061445605,
   //               -0.2562329212571202,  0.0401280831920132,
@@ -90,7 +90,7 @@ void TEST_CASE1(void) {
   //               -0.2391312835511448,  0.2944948324466776,
   //               -0.3469257666022745,  0.3129356083924371,
   //               -0.1418123916338592, -0.2697778839142546
-  VCMP_U64(3, v2, 0x3fda25447c0540c8, 0x3febc815c1e38a2c, 0x3fef4e3a4c029a38,
+  VCMP_U64(3, v8, 0x3fda25447c0540c8, 0x3febc815c1e38a2c, 0x3fef4e3a4c029a38,
            0x3fefdee27bcbc3c2, 0x3fe94ff513d293d6, 0xbfb4766424cf97d0,
            0xbfd0661ec43d4dd0, 0x3fa48bab09ebf660, 0xbfe3b9d1eee7bc0a,
            0xbfa01e13bc79bd60, 0xbfce9bda9926bde0, 0x3fd2d900da8cc448,
@@ -102,32 +102,32 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.0371,  0.8374,  0.7183,  0.8086, -0.8940,  0.4626,  0.5449,
   //              0.6831,  0.4661,  0.2981,  0.5615, -0.6167, -0.7075, -0.7603,
   //              0.8438, -0.2742
-  VLOAD_16(v4, 0xa8c1, 0x3ab3, 0x39bf, 0x3a78, 0xbb27, 0x3767, 0x385c, 0x3977,
+  VLOAD_16(v16, 0xa8c1, 0x3ab3, 0x39bf, 0x3a78, 0xbb27, 0x3767, 0x385c, 0x3977,
            0x3775, 0x34c5, 0x387e, 0xb8ef, 0xb9a9, 0xba15, 0x3ac0, 0xb463);
   //               0.3516,  0.7925, -0.5034, -0.1672,  0.0703, -0.9731,  0.0361,
   //               -0.4077,  0.8965,  0.8242, -0.7822,  0.0265, -0.5361, 0.1226,
   //               -0.9917,  0.5415
-  VLOAD_16(v6, 0x35a0, 0x3a57, 0xb807, 0xb15a, 0x2c7f, 0xbbc9, 0x289f, 0xb686,
+  VLOAD_16(v24, 0x35a0, 0x3a57, 0xb807, 0xb15a, 0x2c7f, 0xbbc9, 0x289f, 0xb686,
            0x3b2c, 0x3a98, 0xba42, 0x26cb, 0xb84a, 0x2fd8, 0xbbef, 0x3855);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnjx.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfsgnjx.vv v8, v16, v24, v0.t");
   //               0.0000,  0.8374,  0.0000, -0.8086,  0.0000, -0.4626,  0.0000,
   //               -0.6831,  0.0000,  0.2981,  0.0000, -0.6167,  0.0000,
   //               -0.7603,  0.0000, -0.2742
-  VCMP_U16(4, v2, 0x0, 0x3ab3, 0x0, 0xba78, 0x0, 0xb767, 0x0, 0xb977, 0x0,
+  VCMP_U16(4, v8, 0x0, 0x3ab3, 0x0, 0xba78, 0x0, 0xb767, 0x0, 0xb977, 0x0,
            0x34c5, 0x0, 0xb8ef, 0x0, 0xba15, 0x0, 0xb463);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.00918692, -0.23372029,  0.42919466,  0.95128548,
   //              0.05014091,  0.08194520,  0.65458435,  0.38167605,
   //              -0.52784044,  0.46330592,  0.66792834,  0.94584799,
   //              -0.11679628,  0.12139154,  0.61421394, -0.71422517
-  VLOAD_32(v4, 0xbc1684ba, 0xbe6f545f, 0x3edbbf67, 0x3f738772, 0x3d4d608d,
+  VLOAD_32(v16, 0xbc1684ba, 0xbe6f545f, 0x3edbbf67, 0x3f738772, 0x3d4d608d,
            0x3da7d2e2, 0x3f2792d7, 0x3ec36b0b, 0xbf07208d, 0x3eed366f,
            0x3f2afd5a, 0x3f722318, 0xbdef32e4, 0x3df89c21, 0x3f1d3d20,
            0xbf36d776);
@@ -135,30 +135,30 @@ void TEST_CASE2(void) {
   //              0.23285799,  0.19133335,  0.78484982, -0.40654737,
   //              -0.40144378, -0.94419461,  0.60990387, -0.37662670,
   //              0.75369638, -0.82297397,  0.24545205, -0.75572032
-  VLOAD_32(v6, 0xbf771aaf, 0xbf543b53, 0xbf7c3bb6, 0x3ebd01e4, 0x3e6e7253,
+  VLOAD_32(v24, 0xbf771aaf, 0xbf543b53, 0xbf7c3bb6, 0x3ebd01e4, 0x3e6e7253,
            0x3e43ece4, 0x3f48ebeb, 0xbed026fa, 0xbecd8a0a, 0xbf71b6bd,
            0x3f1c22a9, 0xbec0d537, 0x3f40f23f, 0xbf52ae6c, 0x3e7b57c8,
            0xbf4176e3);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnjx.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfsgnjx.vv v8, v16, v24, v0.t");
   //               0.00000000,  0.23372029,  0.00000000,  0.95128548,
   //               0.00000000,  0.08194520,  0.00000000, -0.38167605,
   //               0.00000000, -0.46330592,  0.00000000, -0.94584799,
   //               0.00000000, -0.12139154,  0.00000000,  0.71422517
-  VCMP_U32(5, v2, 0x0, 0x3e6f545f, 0x0, 0x3f738772, 0x0, 0x3da7d2e2, 0x0,
+  VCMP_U32(5, v8, 0x0, 0x3e6f545f, 0x0, 0x3f738772, 0x0, 0x3da7d2e2, 0x0,
            0xbec36b0b, 0x0, 0xbeed366f, 0x0, 0xbf722318, 0x0, 0xbdf89c21, 0x0,
            0x3f36d776);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.4085246287477386,  0.8681744372264055, -0.9782992825101422,
   //              0.9959576051606904, -0.7910104167136705,  0.0799315061445605,
   //              0.2562329212571202, -0.0401280831920132, -0.6164331117742006,
   //              0.0314794700215042, -0.2391312835511448,  0.2944948324466776,
   //              -0.3469257666022745,  0.3129356083924371,  0.1418123916338592,
   //              -0.2697778839142546
-  VLOAD_64(v4, 0xbfda25447c0540c8, 0x3febc815c1e38a2c, 0xbfef4e3a4c029a38,
+  VLOAD_64(v16, 0xbfda25447c0540c8, 0x3febc815c1e38a2c, 0xbfef4e3a4c029a38,
            0x3fefdee27bcbc3c2, 0xbfe94ff513d293d6, 0x3fb4766424cf97d0,
            0x3fd0661ec43d4dd0, 0xbfa48bab09ebf660, 0xbfe3b9d1eee7bc0a,
            0x3fa01e13bc79bd60, 0xbfce9bda9926bde0, 0x3fd2d900da8cc448,
@@ -170,22 +170,22 @@ void TEST_CASE2(void) {
   //              -0.1361158534833962,  0.1558021548512183,  0.9766583762298613,
   //              0.2768845956890595,  0.6672273199701737, -0.4444943981200347,
   //              0.5095574851608440
-  VLOAD_64(v6, 0xbfecef7ffd03691e, 0x3fd2e79c5b6133f0, 0xbfdbfe36b251f164,
+  VLOAD_64(v24, 0xbfecef7ffd03691e, 0x3fd2e79c5b6133f0, 0xbfdbfe36b251f164,
            0x3fc2bf4992d91480, 0xbfe0840fa43663a0, 0xbfd68f847062a774,
            0xbfb1b9459f0cf460, 0xbfefaea9bfed2a32, 0x3fe3eb8fa49aeb32,
            0xbfc16c3e8996d300, 0x3fc3f15333ddbc58, 0x3fef40c91128b1ea,
            0x3fd1b87a2ad00b5c, 0x3fe559ed1bc8a0c2, 0xbfdc7298a1cb9174,
            0x3fe04e4b7fc654a0);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnjx.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfsgnjx.vv v8, v16, v24, v0.t");
   //               0.0000000000000000,  0.8681744372264055,  0.0000000000000000,
   //               0.9959576051606904,  0.0000000000000000, -0.0799315061445605,
   //               0.0000000000000000,  0.0401280831920132,  0.0000000000000000,
   //               -0.0314794700215042,  0.0000000000000000, 0.2944948324466776,
   //               0.0000000000000000,  0.3129356083924371,  0.0000000000000000,
   //               -0.2697778839142546
-  VCMP_U64(6, v2, 0x0, 0x3febc815c1e38a2c, 0x0, 0x3fefdee27bcbc3c2, 0x0,
+  VCMP_U64(6, v8, 0x0, 0x3febc815c1e38a2c, 0x0, 0x3fefdee27bcbc3c2, 0x0,
            0xbfb4766424cf97d0, 0x0, 0x3fa48bab09ebf660, 0x0, 0xbfa01e13bc79bd60,
            0x0, 0x3fd2d900da8cc448, 0x0, 0x3fd4072312f3290c, 0x0,
            0xbfd1440a752621b8);
@@ -194,24 +194,24 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                             -0.9766
   BOX_HALF_IN_FLOAT(fscalar_16, 0xbbd0);
   //               0.8535, -0.3750, -0.8066, -0.9097, -0.2216, -0.5645, -0.3149,
   //               -0.4512,  0.5981,  0.6587,  0.9546, -0.3040, -0.6157, 0.5723,
   //               0.8438, -0.1544
-  VLOAD_16(v4, 0x3ad4, 0xb600, 0xba74, 0xbb47, 0xb317, 0xb884, 0xb50a, 0xb738,
+  VLOAD_16(v16, 0x3ad4, 0xb600, 0xba74, 0xbb47, 0xb317, 0xb884, 0xb50a, 0xb738,
            0x38c9, 0x3945, 0x3ba3, 0xb4dd, 0xb8ed, 0x3894, 0x3ac0, 0xb0f1);
-  asm volatile("vfsgnjx.vf v2, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfsgnjx.vf v8, v16, %[A]" ::[A] "f"(fscalar_16));
   //              -0.8535,  0.3750,  0.8066,  0.9097,  0.2216,  0.5645,  0.3149,
   //              0.4512, -0.5981, -0.6587, -0.9546,  0.3040,  0.6157, -0.5723,
   //              -0.8438,  0.1544
-  VCMP_U16(7, v2, 0xbad4, 0x3600, 0x3a74, 0x3b47, 0x3317, 0x3884, 0x350a,
+  VCMP_U16(7, v8, 0xbad4, 0x3600, 0x3a74, 0x3b47, 0x3317, 0x3884, 0x350a,
            0x3738, 0xb8c9, 0xb945, 0xbba3, 0x34dd, 0x38ed, 0xb894, 0xbac0,
            0x30f1);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.71056527
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbf35e79b);
@@ -219,22 +219,22 @@ void TEST_CASE3(void) {
   //              0.00040700, -0.59566921, -0.88075870,  0.08096603, 0.94059193,
   //              -0.29601631, -0.54263371, -0.86016685, -0.57158113,
   //              0.85538357, -0.76839548,  0.28374606
-  VLOAD_32(v4, 0xbe08b4c6, 0xbe3ee62f, 0x3e9a619a, 0xbf1eeaa9, 0x39d561f4,
+  VLOAD_32(v16, 0xbe08b4c6, 0xbe3ee62f, 0x3e9a619a, 0xbf1eeaa9, 0x39d561f4,
            0xbf187dc7, 0xbf617967, 0x3da5d185, 0x3f70caa2, 0xbe978f73,
            0xbf0aea0b, 0xbf5c33e5, 0xbf125324, 0x3f5afa6b, 0xbf44b591,
            0x3e91472a);
-  asm volatile("vfsgnjx.vf v2, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfsgnjx.vf v8, v16, %[A]" ::[A] "f"(fscalar_32));
   //               0.13350210,  0.18642496, -0.30152589,  0.62076813,
   //               -0.00040700,  0.59566921,  0.88075870, -0.08096603,
   //               -0.94059193,  0.29601631,  0.54263371,  0.86016685,
   //               0.57158113, -0.85538357,  0.76839548, -0.28374606
-  VCMP_U32(8, v2, 0x3e08b4c6, 0x3e3ee62f, 0xbe9a619a, 0x3f1eeaa9, 0xb9d561f4,
+  VCMP_U32(8, v8, 0x3e08b4c6, 0x3e3ee62f, 0xbe9a619a, 0x3f1eeaa9, 0xb9d561f4,
            0x3f187dc7, 0x3f617967, 0xbda5d185, 0xbf70caa2, 0x3e978f73,
            0x3f0aea0b, 0x3f5c33e5, 0x3f125324, 0xbf5afa6b, 0x3f44b591,
            0xbe91472a);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                               -0.1599292306617626
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfc4788f9faef060);
@@ -244,20 +244,20 @@ void TEST_CASE3(void) {
   //               -0.3241690978469995,  0.9848431705043186, 0.5835571766262024,
   //               0.6934128987139432, -0.8499240402166686,  0.9392758702585176,
   //               0.8754505566292561, -0.4187493105472220, -0.7967172481248119
-  VLOAD_64(v4, 0xbfd8216314b1d540, 0x3fe3152420f10f90, 0xbfdb0fb918f3a4fc,
+  VLOAD_64(v16, 0xbfd8216314b1d540, 0x3fe3152420f10f90, 0xbfdb0fb918f3a4fc,
            0xbfeadd7aa9f60146, 0x3fd275a6c6712e84, 0xbfeddcd9cc23cf06,
            0xbfd3b2a7ff2d8ea0, 0xbfd4bf2fbe681ba4, 0x3fef83d5d32028f6,
            0x3fe2ac80199e9490, 0x3fe630703f533af4, 0xbfeb3293e69a12ae,
            0x3fee0e8c4515d52c, 0x3fec03b0e2bf9ad6, 0xbfdaccc9e88176a4,
            0xbfe97eb52b9b5dac);
-  asm volatile("vfsgnjx.vf v2, v4, %[A]" ::[A] "f"(dscalar_64));
+  asm volatile("vfsgnjx.vf v8, v16, %[A]" ::[A] "f"(dscalar_64));
   //               0.3770377828689853, -0.5963307040587882,  0.4228346580189990,
   //               0.8395360297727528, -0.2884308755790033,  0.9332093226534830,
   //               0.3077793113682024,  0.3241690978469995, -0.9848431705043186,
   //               -0.5835571766262024, -0.6934128987139432, 0.8499240402166686,
   //               -0.9392758702585176, -0.8754505566292561, 0.4187493105472220,
   //               0.7967172481248119
-  VCMP_U64(9, v2, 0x3fd8216314b1d540, 0xbfe3152420f10f90, 0x3fdb0fb918f3a4fc,
+  VCMP_U64(9, v8, 0x3fd8216314b1d540, 0xbfe3152420f10f90, 0x3fdb0fb918f3a4fc,
            0x3feadd7aa9f60146, 0xbfd275a6c6712e84, 0x3feddcd9cc23cf06,
            0x3fd3b2a7ff2d8ea0, 0x3fd4bf2fbe681ba4, 0xbfef83d5d32028f6,
            0xbfe2ac80199e9490, 0xbfe630703f533af4, 0x3feb3293e69a12ae,
@@ -268,25 +268,25 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   float fscalar_16;
   //                             -0.9766
   BOX_HALF_IN_FLOAT(fscalar_16, 0xbbd0);
   //                0.8535, -0.3750, -0.8066, -0.9097, -0.2216, -0.5645,
   //                -0.3149, -0.4512,  0.5981,  0.6587,  0.9546, -0.3040,
   //                -0.6157,  0.5723,  0.8438, -0.1544
-  VLOAD_16(v4, 0x3ad4, 0xb600, 0xba74, 0xbb47, 0xb317, 0xb884, 0xb50a, 0xb738,
+  VLOAD_16(v16, 0x3ad4, 0xb600, 0xba74, 0xbb47, 0xb317, 0xb884, 0xb50a, 0xb738,
            0x38c9, 0x3945, 0x3ba3, 0xb4dd, 0xb8ed, 0x3894, 0x3ac0, 0xb0f1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnjx.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v8);
+  asm volatile("vfsgnjx.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.0000,  0.3750,  0.0000,  0.9097,  0.0000,  0.5645, 0.0000,
   //                0.4512,  0.0000, -0.6587,  0.0000,  0.3040,  0.0000,
   //                -0.5723,  0.0000,  0.1544
-  VCMP_U16(10, v2, 0x0, 0x3600, 0x0, 0x3b47, 0x0, 0x3884, 0x0, 0x3738, 0x0,
+  VCMP_U16(10, v8, 0x0, 0x3600, 0x0, 0x3b47, 0x0, 0x3884, 0x0, 0x3738, 0x0,
            0xb945, 0x0, 0x34dd, 0x0, 0xb894, 0x0, 0x30f1);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   float fscalar_32;
   //                              -0.71056527
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbf35e79b);
@@ -294,23 +294,23 @@ void TEST_CASE4(void) {
   //               0.00040700, -0.59566921, -0.88075870,  0.08096603,
   //               0.94059193, -0.29601631, -0.54263371, -0.86016685,
   //               -0.57158113,  0.85538357, -0.76839548,  0.28374606
-  VLOAD_32(v4, 0xbe08b4c6, 0xbe3ee62f, 0x3e9a619a, 0xbf1eeaa9, 0x39d561f4,
+  VLOAD_32(v16, 0xbe08b4c6, 0xbe3ee62f, 0x3e9a619a, 0xbf1eeaa9, 0x39d561f4,
            0xbf187dc7, 0xbf617967, 0x3da5d185, 0x3f70caa2, 0xbe978f73,
            0xbf0aea0b, 0xbf5c33e5, 0xbf125324, 0x3f5afa6b, 0xbf44b591,
            0x3e91472a);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnjx.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v8);
+  asm volatile("vfsgnjx.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.00000000,  0.18642496,  0.00000000,  0.62076813,
   //                0.00000000,  0.59566921,  0.00000000, -0.08096603,
   //                0.00000000,  0.29601631,  0.00000000,  0.86016685,
   //                0.00000000, -0.85538357,  0.00000000, -0.28374606
-  VCMP_U32(11, v2, 0x0, 0x3e3ee62f, 0x0, 0x3f1eeaa9, 0x0, 0x3f187dc7, 0x0,
+  VCMP_U32(11, v8, 0x0, 0x3e3ee62f, 0x0, 0x3f1eeaa9, 0x0, 0x3f187dc7, 0x0,
            0xbda5d185, 0x0, 0x3e978f73, 0x0, 0x3f5c33e5, 0x0, 0xbf5afa6b, 0x0,
            0xbe91472a);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   double dscalar_64;
   //                               -0.1599292306617626
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfc4788f9faef060);
@@ -321,22 +321,22 @@ void TEST_CASE4(void) {
   //                0.9848431705043186,  0.5835571766262024, 0.6934128987139432,
   //                -0.8499240402166686,  0.9392758702585176,
   //                0.8754505566292561, -0.4187493105472220, -0.7967172481248119
-  VLOAD_64(v4, 0xbfd8216314b1d540, 0x3fe3152420f10f90, 0xbfdb0fb918f3a4fc,
+  VLOAD_64(v16, 0xbfd8216314b1d540, 0x3fe3152420f10f90, 0xbfdb0fb918f3a4fc,
            0xbfeadd7aa9f60146, 0x3fd275a6c6712e84, 0xbfeddcd9cc23cf06,
            0xbfd3b2a7ff2d8ea0, 0xbfd4bf2fbe681ba4, 0x3fef83d5d32028f6,
            0x3fe2ac80199e9490, 0x3fe630703f533af4, 0xbfeb3293e69a12ae,
            0x3fee0e8c4515d52c, 0x3fec03b0e2bf9ad6, 0xbfdaccc9e88176a4,
            0xbfe97eb52b9b5dac);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsgnjx.vf v2, v4, %[A], v0.t" ::[A] "f"(dscalar_64));
+  VCLEAR(v8);
+  asm volatile("vfsgnjx.vf v8, v16, %[A], v0.t" ::[A] "f"(dscalar_64));
   //                0.0000000000000000, -0.5963307040587882, 0.0000000000000000,
   //                0.8395360297727528,  0.0000000000000000, 0.9332093226534830,
   //                0.0000000000000000,  0.3241690978469995, 0.0000000000000000,
   //                -0.5835571766262024,  0.0000000000000000,
   //                0.8499240402166686,  0.0000000000000000,
   //                -0.8754505566292561,  0.0000000000000000, 0.7967172481248119
-  VCMP_U64(12, v2, 0x0, 0xbfe3152420f10f90, 0x0, 0x3feadd7aa9f60146, 0x0,
+  VCMP_U64(12, v8, 0x0, 0xbfe3152420f10f90, 0x0, 0x3feadd7aa9f60146, 0x0,
            0x3feddcd9cc23cf06, 0x0, 0x3fd4bf2fbe681ba4, 0x0, 0xbfe2ac80199e9490,
            0x0, 0x3feb3293e69a12ae, 0x0, 0xbfec03b0e2bf9ad6, 0x0,
            0x3fe97eb52b9b5dac);
diff --git a/sw/riscvTests/isa/rv64uv/vfsub.c b/sw/riscvTests/isa/rv64uv/vfsub.c
index c5ec7a09..75363d65 100644
--- a/sw/riscvTests/isa/rv64uv/vfsub.c
+++ b/sw/riscvTests/isa/rv64uv/vfsub.c
@@ -10,31 +10,31 @@
 
 // Simple random test with similar values + 1 subnormal
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.2161,  0.7432,  0.7871,  0.7583, -0.4546, -0.0478,  0.1260,
   //              -0.4824,  0.9282, -0.6221,  0.6543,  0.3025, -0.1420, -0.7236,
   //              0.2333, -0.0269
-  VLOAD_16(v4, 0xb2ea, 0x39f2, 0x3a4c, 0x3a11, 0xb746, 0xaa1f, 0x3008, 0xb7b8,
+  VLOAD_16(v16, 0xb2ea, 0x39f2, 0x3a4c, 0x3a11, 0xb746, 0xaa1f, 0x3008, 0xb7b8,
            0x3b6d, 0xb8fa, 0x393c, 0x34d7, 0xb08b, 0xb9ca, 0x3377, 0xa6e5);
   //              -0.3289, -0.8408, -0.1754, -0.8472,  0.7739, -0.9111, -0.3152,
   //              0.4519, -0.2537,  0.9287, -0.7163, -0.2318,  0.0615, -0.2563,
   //              0.1448,  0.6606
-  VLOAD_16(v6, 0xb543, 0xbaba, 0xb19d, 0xbac7, 0x3a31, 0xbb4a, 0xb50b, 0x373b,
+  VLOAD_16(v24, 0xb543, 0xbaba, 0xb19d, 0xbac7, 0x3a31, 0xbb4a, 0xb50b, 0x373b,
            0xb40f, 0x3b6e, 0xb9bb, 0xb36b, 0x2bde, 0xb41a, 0x30a2, 0x3949);
-  asm volatile("vfsub.vv v2, v4, v6");
+  asm volatile("vfsub.vv v8, v16, v24");
   //               0.1128,  1.5840,  0.9624,  1.6055, -1.2285,  0.8633,  0.4412,
   //               -0.9346,  1.1816, -1.5508,  1.3711,  0.5342, -0.2034,
   //               -0.4673,  0.0885, -0.6875
-  VCMP_U16(1, v2, 0x2f38, 0x3e56, 0x3bb3, 0x3e6c, 0xbcea, 0x3ae8, 0x370f,
+  VCMP_U16(1, v8, 0x2f38, 0x3e56, 0x3bb3, 0x3e6c, 0xbcea, 0x3ae8, 0x370f,
            0xbb7a, 0x3cba, 0xbe34, 0x3d7c, 0x3846, 0xb282, 0xb77a, 0x2daa,
            0xb980);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.12869358,  0.96847999, -0.85811919, -0.21122381,
   //              -0.05195865,  0.43910158,  0.86828148, -0.90407801,
   //              0.62089461, -0.65907389,  0.91886526, -0.57595438,
   //              -0.35377914, -0.26657876,  0.49153560,  0.42637765
-  VLOAD_32(v4, 0xbe03c840, 0x3f77ee4e, 0xbf5badb3, 0xbe584b0e, 0xbd54d298,
+  VLOAD_32(v16, 0xbe03c840, 0x3f77ee4e, 0xbf5badb3, 0xbe584b0e, 0xbd54d298,
            0x3ee0d1ec, 0x3f5e47b2, 0xbf6771a8, 0x3f1ef2f3, 0xbf28b911,
            0x3f6b3ac1, 0xbf1371bf, 0xbeb5228a, 0xbe887d03, 0x3efbaa8e,
            0x3eda4e2c);
@@ -42,30 +42,30 @@ void TEST_CASE1(void) {
   //              -0.00441748,  0.72763014,  0.81834352, -0.49977919,
   //              -0.94507313, -0.60766727,  0.21069343,  0.35644454,
   //              -0.51639801, -0.74812186, -0.97028691,  0.42650157
-  VLOAD_32(v6, 0xbf021a25, 0xbf11ab20, 0xbf62ecf7, 0x3f6949f4, 0xbb90c083,
+  VLOAD_32(v24, 0xbf021a25, 0xbf11ab20, 0xbf62ecf7, 0x3f6949f4, 0xbb90c083,
            0x3f3a45f8, 0x3f517ef6, 0xbeffe30f, 0xbf71f050, 0xbf1b9015,
            0x3e57c005, 0x3eb67fe6, 0xbf0432a9, 0xbf3f84ea, 0xbf7864b9,
            0x3eda5e6a);
-  asm volatile("vfsub.vv v2, v4, v6");
+  asm volatile("vfsub.vv v8, v16, v24");
   //               0.37951785,  1.53749740,  0.02830911, -1.12250853,
   //               -0.04754117, -0.28852856,  0.04993796,
   //               -0.40429881,  1.56596780, -0.05140662,  0.70817184,
   //               -0.93239892,  0.16261888,  0.48154309,  1.46182251,
   //               -0.00012392
-  VCMP_U32(2, v2, 0x3ec2502a, 0x3fc4ccb7, 0x3ce7e880, 0xbf8fae5c, 0xbd42ba88,
+  VCMP_U32(2, v8, 0x3ec2502a, 0x3fc4ccb7, 0x3ce7e880, 0xbf8fae5c, 0xbd42ba88,
            0xbe93ba04, 0x3d4c8bc0, 0xbecf0041, 0x3fc871a2, 0xbd528fc0,
            0x3f354ac0, 0xbf6eb1b2, 0x3e268590, 0x3ef68cd1, 0x3fbb1d00,
            0xb901f000);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.5053356652713634, -0.6291854947278097,  0.6181258713941662,
   //              -0.6097328085365348,  0.8960683065358290,  0.1233825892982841,
   //              -0.7071646124826323, -0.6783334309218909,  0.3533001486660008,
   //              0.4732651306122215, -0.7335080825789513, -0.9296500813876505,
   //              0.5349827137885166, -0.0621174552558810, -0.8122743533756343,
   //              -0.8908485518923974
-  VLOAD_64(v4, 0xbfe02bb5b37af91c, 0xbfe422499e5f271a, 0x3fe3c7afe84e61dc,
+  VLOAD_64(v16, 0xbfe02bb5b37af91c, 0xbfe422499e5f271a, 0x3fe3c7afe84e61dc,
            0xbfe382ee60fece00, 0x3fecac9770f1b62e, 0x3fbf960059ee92f0,
            0xbfe6a117ae700ba0, 0xbfe5b4e84fb2f9d4, 0x3fd69c783a0c5078,
            0x3fde49f9d4944428, 0xbfe778e5f140e788, 0xbfedbfb18709140c,
@@ -77,13 +77,13 @@ void TEST_CASE1(void) {
   //              0.8778238674058336,  0.9294006140978470, -0.8775508592745904,
   //              0.7472392658861982, -0.3880038279796372, -0.6483706997783654,
   //              -0.1530785884604509
-  VLOAD_64(v6, 0xbfe3556b82731260, 0x3fc5a6ff3fe2c608, 0xbfd8acfaee5fcdc0,
+  VLOAD_64(v24, 0xbfe3556b82731260, 0x3fc5a6ff3fe2c608, 0xbfd8acfaee5fcdc0,
            0xbfed762b3b913c28, 0x3fe67b0770a53a4a, 0xbfefb2aaa9ceeb06,
            0x3fee6f68a5fe3800, 0x3fd1a071594983a8, 0x3fe0dec527d80c9a,
            0x3fec172214450060, 0x3fedbda65b4dd79c, 0xbfec14e58a252770,
            0x3fe7e962522895aa, 0xbfd8d50e01f94d70, 0xbfe4bf73e8e77264,
            0xbfc398144593e6c0);
-  asm volatile("vfsub.vv v2, v4, v6");
+  asm volatile("vfsub.vv v8, v16, v24");
   //               0.0988415758481911, -0.7983443408145550,  1.0036837449172462,
   //               0.3109421032890554,  0.1935501104197752,  1.1139424835327358,
   //               -1.6582643174207199, -0.9537510803764819,
@@ -91,7 +91,7 @@ void TEST_CASE1(void) {
   //               -1.6629086966767983, -0.0520992221130601,
   //               -0.2122565520976816,  0.3258863727237562,
   //               -0.1639036535972689, -0.7377699634319466
-  VCMP_U64(3, v2, 0x3fb94dae77c0ca20, 0xbfe98c096e57d89c, 0x3ff00f16afbf245e,
+  VCMP_U64(3, v8, 0x3fb94dae77c0ca20, 0xbfe98c096e57d89c, 0x3ff00f16afbf245e,
            0x3fd3e679b524dc50, 0x3fc8c6400131ef90, 0x3ff1d2b55a865eb2,
            0xbffa88402a3721d0, 0xbfee8520fc57bba8, 0xbfc642242b479178,
            0xbfd9e44a53f5bc98, 0xbffa9b4626475f92, 0xbfaaacbfce3ec9c0,
@@ -103,32 +103,32 @@ void TEST_CASE1(void) {
 // Simple random test with similar values + 1 subnormal (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //              -0.2161,  0.7432,  0.7871,  0.7583, -0.4546, -0.0478,  0.1260,
   //              -0.4824,  0.9282, -0.6221,  0.6543,  0.3025, -0.1420, -0.7236,
   //              0.2333, -0.0269
-  VLOAD_16(v4, 0xb2ea, 0x39f2, 0x3a4c, 0x3a11, 0xb746, 0xaa1f, 0x3008, 0xb7b8,
+  VLOAD_16(v16, 0xb2ea, 0x39f2, 0x3a4c, 0x3a11, 0xb746, 0xaa1f, 0x3008, 0xb7b8,
            0x3b6d, 0xb8fa, 0x393c, 0x34d7, 0xb08b, 0xb9ca, 0x3377, 0xa6e5);
   //              -0.3289, -0.8408, -0.1754, -0.8472,  0.7739, -0.9111, -0.3152,
   //              0.4519, -0.2537,  0.9287, -0.7163, -0.2318,  0.0615, -0.2563,
   //              0.1448,  0.6606
-  VLOAD_16(v6, 0xb543, 0xbaba, 0xb19d, 0xbac7, 0x3a31, 0xbb4a, 0xb50b, 0x373b,
+  VLOAD_16(v24, 0xb543, 0xbaba, 0xb19d, 0xbac7, 0x3a31, 0xbb4a, 0xb50b, 0x373b,
            0xb40f, 0x3b6e, 0xb9bb, 0xb36b, 0x2bde, 0xb41a, 0x30a2, 0x3949);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsub.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfsub.vv v8, v16, v24, v0.t");
   //               0.0000,  1.5840,  0.0000,  1.6055,  0.0000,  0.8633,  0.0000,
   //               -0.9346,  0.0000, -1.5508,  0.0000,  0.5342,  0.0000,
   //               -0.4673,  0.0000, -0.6875
-  VCMP_U16(4, v2, 0x0, 0x3e56, 0x0, 0x3e6c, 0x0, 0x3ae8, 0x0, 0xbb7a, 0x0,
+  VCMP_U16(4, v8, 0x0, 0x3e56, 0x0, 0x3e6c, 0x0, 0x3ae8, 0x0, 0xbb7a, 0x0,
            0xbe34, 0x0, 0x3846, 0x0, 0xb77a, 0x0, 0xb980);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //              -0.12869358,  0.96847999, -0.85811919, -0.21122381,
   //              -0.05195865,  0.43910158,  0.86828148, -0.90407801,
   //              0.62089461, -0.65907389,  0.91886526, -0.57595438,
   //              -0.35377914, -0.26657876,  0.49153560,  0.42637765
-  VLOAD_32(v4, 0xbe03c840, 0x3f77ee4e, 0xbf5badb3, 0xbe584b0e, 0xbd54d298,
+  VLOAD_32(v16, 0xbe03c840, 0x3f77ee4e, 0xbf5badb3, 0xbe584b0e, 0xbd54d298,
            0x3ee0d1ec, 0x3f5e47b2, 0xbf6771a8, 0x3f1ef2f3, 0xbf28b911,
            0x3f6b3ac1, 0xbf1371bf, 0xbeb5228a, 0xbe887d03, 0x3efbaa8e,
            0x3eda4e2c);
@@ -136,30 +136,30 @@ void TEST_CASE2(void) {
   //              -0.00441748,  0.72763014,  0.81834352, -0.49977919,
   //              -0.94507313, -0.60766727,  0.21069343,  0.35644454,
   //              -0.51639801, -0.74812186, -0.97028691,  0.42650157
-  VLOAD_32(v6, 0xbf021a25, 0xbf11ab20, 0xbf62ecf7, 0x3f6949f4, 0xbb90c083,
+  VLOAD_32(v24, 0xbf021a25, 0xbf11ab20, 0xbf62ecf7, 0x3f6949f4, 0xbb90c083,
            0x3f3a45f8, 0x3f517ef6, 0xbeffe30f, 0xbf71f050, 0xbf1b9015,
            0x3e57c005, 0x3eb67fe6, 0xbf0432a9, 0xbf3f84ea, 0xbf7864b9,
            0x3eda5e6a);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsub.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfsub.vv v8, v16, v24, v0.t");
   //               0.00000000,  1.53749740,  0.00000000, -1.12250853,
   //               0.00000000, -0.28852856,  0.00000000, -0.40429881,
   //               0.00000000, -0.05140662,  0.00000000, -0.93239892,
   //               0.00000000,  0.48154309,  0.00000000, -0.00012392
-  VCMP_U32(5, v2, 0x0, 0x3fc4ccb7, 0x0, 0xbf8fae5c, 0x0, 0xbe93ba04, 0x0,
+  VCMP_U32(5, v8, 0x0, 0x3fc4ccb7, 0x0, 0xbf8fae5c, 0x0, 0xbe93ba04, 0x0,
            0xbecf0041, 0x0, 0xbd528fc0, 0x0, 0xbf6eb1b2, 0x0, 0x3ef68cd1, 0x0,
            0xb901f000);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //              -0.5053356652713634, -0.6291854947278097,  0.6181258713941662,
   //              -0.6097328085365348,  0.8960683065358290,  0.1233825892982841,
   //              -0.7071646124826323, -0.6783334309218909,  0.3533001486660008,
   //              0.4732651306122215, -0.7335080825789513, -0.9296500813876505,
   //              0.5349827137885166, -0.0621174552558810, -0.8122743533756343,
   //              -0.8908485518923974
-  VLOAD_64(v4, 0xbfe02bb5b37af91c, 0xbfe422499e5f271a, 0x3fe3c7afe84e61dc,
+  VLOAD_64(v16, 0xbfe02bb5b37af91c, 0xbfe422499e5f271a, 0x3fe3c7afe84e61dc,
            0xbfe382ee60fece00, 0x3fecac9770f1b62e, 0x3fbf960059ee92f0,
            0xbfe6a117ae700ba0, 0xbfe5b4e84fb2f9d4, 0x3fd69c783a0c5078,
            0x3fde49f9d4944428, 0xbfe778e5f140e788, 0xbfedbfb18709140c,
@@ -171,22 +171,22 @@ void TEST_CASE2(void) {
   //              0.8778238674058336,  0.9294006140978470, -0.8775508592745904,
   //              0.7472392658861982, -0.3880038279796372, -0.6483706997783654,
   //              -0.1530785884604509
-  VLOAD_64(v6, 0xbfe3556b82731260, 0x3fc5a6ff3fe2c608, 0xbfd8acfaee5fcdc0,
+  VLOAD_64(v24, 0xbfe3556b82731260, 0x3fc5a6ff3fe2c608, 0xbfd8acfaee5fcdc0,
            0xbfed762b3b913c28, 0x3fe67b0770a53a4a, 0xbfefb2aaa9ceeb06,
            0x3fee6f68a5fe3800, 0x3fd1a071594983a8, 0x3fe0dec527d80c9a,
            0x3fec172214450060, 0x3fedbda65b4dd79c, 0xbfec14e58a252770,
            0x3fe7e962522895aa, 0xbfd8d50e01f94d70, 0xbfe4bf73e8e77264,
            0xbfc398144593e6c0);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsub.vv v2, v4, v6, v0.t");
+  VCLEAR(v8);
+  asm volatile("vfsub.vv v8, v16, v24, v0.t");
   //               0.0000000000000000, -0.7983443408145550,  0.0000000000000000,
   //               0.3109421032890554,  0.0000000000000000,  1.1139424835327358,
   //               0.0000000000000000, -0.9537510803764819,  0.0000000000000000,
   //               -0.4045587367936121,  0.0000000000000000,
   //               -0.0520992221130601,  0.0000000000000000, 0.3258863727237562,
   //               0.0000000000000000, -0.7377699634319466
-  VCMP_U64(6, v2, 0x0, 0xbfe98c096e57d89c, 0x0, 0x3fd3e679b524dc50, 0x0,
+  VCMP_U64(6, v8, 0x0, 0xbfe98c096e57d89c, 0x0, 0x3fd3e679b524dc50, 0x0,
            0x3ff1d2b55a865eb2, 0x0, 0xbfee8520fc57bba8, 0x0, 0xbfd9e44a53f5bc98,
            0x0, 0xbfaaacbfce3ec9c0, 0x0, 0x3fd4db528443e0dc, 0x0,
            0xbfe79bcfc11d2996);
@@ -195,55 +195,55 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //               0.9727,  0.7676,  0.0876, -0.4526, -0.1158,  0.6221,  0.7612,
   //               -0.7539,  0.3875, -0.2002,  0.2168, -0.1055, -0.4348, 0.9795,
   //               0.3650,  0.5171
-  VLOAD_16(v4, 0x3bc8, 0x3a24, 0x2d9c, 0xb73e, 0xaf6a, 0x38fa, 0x3a17, 0xba08,
+  VLOAD_16(v16, 0x3bc8, 0x3a24, 0x2d9c, 0xb73e, 0xaf6a, 0x38fa, 0x3a17, 0xba08,
            0x3633, 0xb268, 0x32f0, 0xaec0, 0xb6f5, 0x3bd6, 0x35d7, 0x3823);
   float fscalar_16;
   //                             -0.8667
   BOX_HALF_IN_FLOAT(fscalar_16, 0xbaef);
-  asm volatile("vfsub.vf v2, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfsub.vf v8, v16, %[A]" ::[A] "f"(fscalar_16));
   //               1.8398,  1.6348,  0.9541,  0.4141,  0.7510,  1.4883,  1.6279,
   //               0.1128,  1.2539,  0.6665,  1.0840,  0.7612,
   //               0.4319,  1.8457,  1.2314,  1.3838
-  VCMP_U16(7, v2, 0x3f5c, 0x3e8a, 0x3ba2, 0x36a0, 0x3a02, 0x3df4, 0x3e83,
+  VCMP_U16(7, v8, 0x3f5c, 0x3e8a, 0x3ba2, 0x36a0, 0x3a02, 0x3df4, 0x3e83,
            0x2f38, 0x3d04, 0x3955, 0x3c56, 0x3a17, 0x36e9, 0x3f62, 0x3ced,
            0x3d89);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //               0.85933530, -0.31821987,  0.18340160, -0.58902484,
   //               -0.83326858, -0.98716992, -0.74268776, -0.50486410,
   //               0.91496444, -0.46108878, -0.75265163, -0.17853038,
   //               0.09909800, -0.22828153,  0.31248060,  0.70940411
-  VLOAD_32(v4, 0x3f5bfd66, 0xbea2edb7, 0x3e3bcda1, 0xbf16ca55, 0xbf555117,
+  VLOAD_32(v16, 0x3f5bfd66, 0xbea2edb7, 0x3e3bcda1, 0xbf16ca55, 0xbf555117,
            0xbf7cb72b, 0xbf3e20c9, 0xbf013ec6, 0x3f6a3b1c, 0xbeec13d4,
            0xbf40adc7, 0xbe36d0ab, 0x3dcaf3e5, 0xbe69c2a2, 0x3e9ffd75,
            0x3f359b82);
   float fscalar_32;
   //                              -0.16449618
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbe2871b0);
-  asm volatile("vfsub.vf v2, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfsub.vf v8, v16, %[A]" ::[A] "f"(fscalar_32));
   //               1.02383149, -0.15372369,  0.34789777, -0.42452866,
   //               -0.66877240, -0.82267374, -0.57819158,
   //               -0.34036791,  1.07946062, -0.29659259, -0.58815545,
   //               -0.01403420,  0.26359418, -0.06378534,  0.47697678,
   //               0.87390029
-  VCMP_U32(8, v2, 0x3f830ce9, 0xbe1d69be, 0x3eb21fa8, 0xbed95bd2, 0xbf2b34ab,
+  VCMP_U32(8, v8, 0x3f830ce9, 0xbe1d69be, 0x3eb21fa8, 0xbed95bd2, 0xbf2b34ab,
            0xbf529abf, 0xbf14045d, 0xbeae44b4, 0x3f8a2bc4, 0xbe97dafc,
            0xbf16915b, 0xbc65efb0, 0x3e86f5d1, 0xbd82a1e4, 0x3ef4364d,
            0x3f5fb7ee);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //               -0.5270370833343294, -0.3892108170289901, 0.3278104985181656,
   //               0.8978904717616114,  0.2838388271052681,  0.1890152734369528,
   //               -0.5587120809764872,  0.0329118609761476, 0.2661042157694802,
   //               0.4284631655495406,  0.3525175873513684, -0.7218762878034530,
   //               -0.1902187411555145,  0.0621279131630217,
   //               -0.3175600204168794,  0.2653267716685161
-  VLOAD_64(v4, 0xbfe0dd7cdf9667ce, 0xbfd8e8d47c98e498, 0x3fd4fad8e29af14c,
+  VLOAD_64(v16, 0xbfe0dd7cdf9667ce, 0xbfd8e8d47c98e498, 0x3fd4fad8e29af14c,
            0x3fecbb84cc736570, 0x3fd22a6a53f022d0, 0x3fc831a708ed9848,
            0xbfe1e0f82875925c, 0x3fa0d9d2cd160b00, 0x3fd107d9fa03b074,
            0x3fdb6bf0c4e4dbb8, 0x3fd68fa5ed3c17c4, 0xbfe7199c4cfbf578,
@@ -252,14 +252,14 @@ void TEST_CASE3(void) {
   double dscalar_64;
   //                               -0.3447987329466446
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfd6112eb46d5120);
-  asm volatile("vfsub.vf v2, v4, %[A]" ::[A] "f"(dscalar_64));
+  asm volatile("vfsub.vf v8, v16, %[A]" ::[A] "f"(dscalar_64));
   //              -0.1822383503876848, -0.0444120840823454,
   //              0.6726092314648102,  1.2426892047082561,  0.6286375600519127,
   //              0.5338140063835974, -0.2139133480298425,  0.3777105939227923,
   //              0.6109029487161248,  0.7732618984961852,  0.6973163202980130,
   //              -0.3770775548568084,  0.1545799917911301,  0.4069266461096663,
   //              0.0272387125297653,  0.6101255046151608
-  VCMP_U64(9, v2, 0xbfc75396157efcf8, 0xbfa6bd2e415c9bc0, 0x3fe58603cb842136,
+  VCMP_U64(9, v8, 0xbfc75396157efcf8, 0xbfa6bd2e415c9bc0, 0x3fe58603cb842136,
            0x3ff3e20e13550700, 0x3fe41dcc842eb9f8, 0x3fe115011c720ea2,
            0xbfcb618338fba730, 0x3fd82c690e101280, 0x3fe38c84573880ca,
            0x3fe8be8fbca9166c, 0x3fe6506a50d4b472, 0xbfd82209e58a99d0,
@@ -270,30 +270,30 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   //                0.9727,  0.7676,  0.0876, -0.4526, -0.1158,  0.6221, 0.7612,
   //                -0.7539,  0.3875, -0.2002,  0.2168, -0.1055, -0.4348,
   //                0.9795,  0.3650,  0.5171
-  VLOAD_16(v4, 0x3bc8, 0x3a24, 0x2d9c, 0xb73e, 0xaf6a, 0x38fa, 0x3a17, 0xba08,
+  VLOAD_16(v16, 0x3bc8, 0x3a24, 0x2d9c, 0xb73e, 0xaf6a, 0x38fa, 0x3a17, 0xba08,
            0x3633, 0xb268, 0x32f0, 0xaec0, 0xb6f5, 0x3bd6, 0x35d7, 0x3823);
   float fscalar_16;
   //                             -0.8667
   BOX_HALF_IN_FLOAT(fscalar_16, 0xbaef);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsub.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v8);
+  asm volatile("vfsub.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.0000,  1.6348,  0.0000,  0.4141,  0.0000,  1.4883, 0.0000,
   //                0.1128,  0.0000,  0.6665,  0.0000,  0.7612, 0.0000,  1.8457,
   //                0.0000,  1.3838
-  VCMP_U16(10, v2, 0x0, 0x3e8a, 0x0, 0x36a0, 0x0, 0x3df4, 0x0, 0x2f38, 0x0,
+  VCMP_U16(10, v8, 0x0, 0x3e8a, 0x0, 0x36a0, 0x0, 0x3df4, 0x0, 0x2f38, 0x0,
            0x3955, 0x0, 0x3a17, 0x0, 0x3f62, 0x0, 0x3d89);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   //                0.85933530, -0.31821987,  0.18340160, -0.58902484,
   //                -0.83326858, -0.98716992, -0.74268776, -0.50486410,
   //                0.91496444, -0.46108878, -0.75265163, -0.17853038,
   //                0.09909800, -0.22828153,  0.31248060,  0.70940411
-  VLOAD_32(v4, 0x3f5bfd66, 0xbea2edb7, 0x3e3bcda1, 0xbf16ca55, 0xbf555117,
+  VLOAD_32(v16, 0x3f5bfd66, 0xbea2edb7, 0x3e3bcda1, 0xbf16ca55, 0xbf555117,
            0xbf7cb72b, 0xbf3e20c9, 0xbf013ec6, 0x3f6a3b1c, 0xbeec13d4,
            0xbf40adc7, 0xbe36d0ab, 0x3dcaf3e5, 0xbe69c2a2, 0x3e9ffd75,
            0x3f359b82);
@@ -301,25 +301,25 @@ void TEST_CASE4(void) {
   //                              -0.16449618
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xbe2871b0);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsub.vf v2, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v8);
+  asm volatile("vfsub.vf v8, v16, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.00000000, -0.15372369,  0.00000000, -0.42452866,
   //                0.00000000, -0.82267374,  0.00000000, -0.34036791,
   //                0.00000000, -0.29659259,  0.00000000, -0.01403420,
   //                0.00000000, -0.06378534,  0.00000000,  0.87390029
-  VCMP_U32(11, v2, 0x0, 0xbe1d69be, 0x0, 0xbed95bd2, 0x0, 0xbf529abf, 0x0,
+  VCMP_U32(11, v8, 0x0, 0xbe1d69be, 0x0, 0xbed95bd2, 0x0, 0xbf529abf, 0x0,
            0xbeae44b4, 0x0, 0xbe97dafc, 0x0, 0xbc65efb0, 0x0, 0xbd82a1e4, 0x0,
            0x3f5fb7ee);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   //                -0.5270370833343294, -0.3892108170289901,
   //                0.3278104985181656,  0.8978904717616114, 0.2838388271052681,
   //                0.1890152734369528, -0.5587120809764872, 0.0329118609761476,
   //                0.2661042157694802,  0.4284631655495406, 0.3525175873513684,
   //                -0.7218762878034530, -0.1902187411555145,
   //                0.0621279131630217, -0.3175600204168794,  0.2653267716685161
-  VLOAD_64(v4, 0xbfe0dd7cdf9667ce, 0xbfd8e8d47c98e498, 0x3fd4fad8e29af14c,
+  VLOAD_64(v16, 0xbfe0dd7cdf9667ce, 0xbfd8e8d47c98e498, 0x3fd4fad8e29af14c,
            0x3fecbb84cc736570, 0x3fd22a6a53f022d0, 0x3fc831a708ed9848,
            0xbfe1e0f82875925c, 0x3fa0d9d2cd160b00, 0x3fd107d9fa03b074,
            0x3fdb6bf0c4e4dbb8, 0x3fd68fa5ed3c17c4, 0xbfe7199c4cfbf578,
@@ -329,15 +329,15 @@ void TEST_CASE4(void) {
   //                               -0.3447987329466446
   BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfd6112eb46d5120);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vfsub.vf v2, v4, %[A], v0.t" ::[A] "f"(dscalar_64));
+  VCLEAR(v8);
+  asm volatile("vfsub.vf v8, v16, %[A], v0.t" ::[A] "f"(dscalar_64));
   //                0.0000000000000000, -0.0444120840823454, 0.0000000000000000,
   //                1.2426892047082561,  0.0000000000000000, 0.5338140063835974,
   //                0.0000000000000000,  0.3777105939227923, 0.0000000000000000,
   //                0.7732618984961852,  0.0000000000000000,
   //                -0.3770775548568084,  0.0000000000000000,
   //                0.4069266461096663,  0.0000000000000000,  0.6101255046151608
-  VCMP_U64(12, v2, 0x0, 0xbfa6bd2e415c9bc0, 0x0, 0x3ff3e20e13550700, 0x0,
+  VCMP_U64(12, v8, 0x0, 0xbfa6bd2e415c9bc0, 0x0, 0x3ff3e20e13550700, 0x0,
            0x3fe115011c720ea2, 0x0, 0x3fd82c690e101280, 0x0, 0x3fe8be8fbca9166c,
            0x0, 0xbfd82209e58a99d0, 0x0, 0x3fda0b160f3a5dec, 0x0,
            0x3fe38625ec18e234);
diff --git a/sw/riscvTests/isa/rv64uv/vfwadd.c b/sw/riscvTests/isa/rv64uv/vfwadd.c
index e99c42cd..71e37f6b 100644
--- a/sw/riscvTests/isa/rv64uv/vfwadd.c
+++ b/sw/riscvTests/isa/rv64uv/vfwadd.c
@@ -11,7 +11,7 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //               10.5312,  79.6250,  12.2891,  89.5000,  62.5938,  53.5625,
   //               -37.3438, -48.3750,  49.3438,  1.1475, -79.6250,  52.0000,
   //               -61.0312,  5.1641,  48.7500, -25.6250
@@ -21,20 +21,20 @@ void TEST_CASE1(void) {
   //               -7.0742,  20.2656,  72.3125,  88.5625,  36.0000,  96.6250,  70.4375,
   //               -87.6875,  87.6875,  8.7891, -18.8906, -40.1562,  88.8750,
   //               -55.5312,  2.1875
-  VLOAD_16(v6, 0x5443, 0xc713, 0x4d11, 0x5485, 0x5589, 0x5080, 0x560a, 0x5467,
+  VLOAD_16(v8, 0x5443, 0xc713, 0x4d11, 0x5485, 0x5589, 0x5080, 0x560a, 0x5467,
            0xd57b, 0x557b, 0x4865, 0xccb9, 0xd105, 0x558e, 0xd2f1, 0x4060);
-  asm volatile("vfwadd.vv v8, v4, v6");
+  asm volatile("vfwadd.vv v16, v4, v8");
   //               78.71875000,  72.55078125,  32.55468750,  161.81250000,
   //               151.15625000,  89.56250000,  59.28125000,  22.06250000,
   //               -38.34375000,  88.83496094, -70.83593750,  33.10937500,
   //               -101.18750000,  94.03906250, -6.78125000, -23.43750000
-  VCMP_U32(1, v8, 0x429d7000, 0x42911a00, 0x42023800, 0x4321d000, 0x43172800,
+  VCMP_U32(1, v16, 0x429d7000, 0x42911a00, 0x42023800, 0x4321d000, 0x43172800,
            0x42b32000, 0x426d2000, 0x41b08000, 0xc2196000, 0x42b1ab80,
            0xc28dac00, 0x42047000, 0xc2ca6000, 0x42bc1400, 0xc0d90000,
            0xc1bb8000);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //              -35386.17187500, -52670.69531250,  69391.31250000,
   //              3219.84130859,  74596.35156250, -45488.69921875,
   //              6598.72949219,  20221.24609375,  75105.62500000,
@@ -51,11 +51,11 @@ void TEST_CASE1(void) {
   //              38042.19140625, -61343.24218750,  76844.01562500,
   //              26642.50390625,  91893.05468750,  88349.72656250,
   //              29134.96093750
-  VLOAD_32(v6, 0xc7b19c9c, 0xc78d3489, 0x46936664, 0xc40100fa, 0xc64fd475,
+  VLOAD_32(v8, 0xc7b19c9c, 0xc78d3489, 0x46936664, 0xc40100fa, 0xc64fd475,
            0x47a65ab5, 0xc6fa9eb6, 0xc6b9b538, 0x47197f6f, 0x47149a31,
            0xc76f9f3e, 0x47961602, 0x46d02502, 0x47b37a87, 0x47ac8edd,
            0x46e39dec);
-  asm volatile("vfwadd.vv v8, v4, v6");
+  asm volatile("vfwadd.vv v16, v4, v8");
   //              -126323.3906250000000000, -124967.7656250000000000,
   //              88258.5078125000000000,  2703.8260498046875000,
   //              61295.2373046875000000,  39684.7148437500000000,
@@ -64,7 +64,7 @@ void TEST_CASE1(void) {
   //              -28499.0507812500000000,  3373.8281250000000000,
   //              -1735.1699218750000000,  153891.1640625000000000,
   //              113041.2695312500000000, -738.4941406250000000
-  VCMP_U64(2, v8, 0xc0fed73640000000, 0xc0fe827c40000000, 0x40f58c2820000000,
+  VCMP_U64(2, v16, 0xc0fed73640000000, 0xc0fe827c40000000, 0x40f58c2820000000,
            0x40a51fa6f0000000, 0x40edede798000000, 0x40e36096e0000000,
            0xc0d8e22810000000, 0xc0abbaba00000000, 0x40fbee10f0000000,
            0x40f9bb5030000000, 0xc0dbd4c340000000, 0x40aa5ba800000000,
@@ -76,7 +76,7 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //               10.5312,  79.6250,  12.2891,  89.5000,  62.5938,  53.5625,
   //               -37.3438, -48.3750,  49.3438,  1.1475, -79.6250,  52.0000,
   //               -61.0312,  5.1641,  48.7500, -25.6250
@@ -86,21 +86,21 @@ void TEST_CASE2(void) {
   //               -7.0742,  20.2656,  72.3125,  88.5625,  36.0000,  96.6250,  70.4375,
   //               -87.6875,  87.6875,  8.7891, -18.8906, -40.1562,  88.8750,
   //               -55.5312,  2.1875
-  VLOAD_16(v6, 0x5443, 0xc713, 0x4d11, 0x5485, 0x5589, 0x5080, 0x560a, 0x5467,
+  VLOAD_16(v8, 0x5443, 0xc713, 0x4d11, 0x5485, 0x5589, 0x5080, 0x560a, 0x5467,
            0xd57b, 0x557b, 0x4865, 0xccb9, 0xd105, 0x558e, 0xd2f1, 0x4060);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwadd.vv v8, v4, v6, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfwadd.vv v16, v4, v8, v0.t");
   //               0.00000000,  72.55078125,  0.00000000,  161.81250000,
   //               0.00000000,  89.56250000,  0.00000000,  22.06250000,
   //               0.00000000,  88.83496094,  0.00000000,  33.10937500,
   //               0.00000000,  94.03906250,  0.00000000, -23.43750000
-  VCMP_U32(3, v8, 0x0, 0x42911a00, 0x0, 0x4321d000, 0x0, 0x42b32000, 0x0,
+  VCMP_U32(3, v16, 0x0, 0x42911a00, 0x0, 0x4321d000, 0x0, 0x42b32000, 0x0,
            0x41b08000, 0x0, 0x42b1ab80, 0x0, 0x42047000, 0x0, 0x42bc1400, 0x0,
            0xc1bb8000);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //              -35386.17187500, -52670.69531250,  69391.31250000,
   //              3219.84130859,  74596.35156250, -45488.69921875,
   //              6598.72949219,  20221.24609375,  75105.62500000,
@@ -117,13 +117,13 @@ void TEST_CASE2(void) {
   //              38042.19140625, -61343.24218750,  76844.01562500,
   //              26642.50390625,  91893.05468750,  88349.72656250,
   //              29134.96093750
-  VLOAD_32(v6, 0xc7b19c9c, 0xc78d3489, 0x46936664, 0xc40100fa, 0xc64fd475,
+  VLOAD_32(v8, 0xc7b19c9c, 0xc78d3489, 0x46936664, 0xc40100fa, 0xc64fd475,
            0x47a65ab5, 0xc6fa9eb6, 0xc6b9b538, 0x47197f6f, 0x47149a31,
            0xc76f9f3e, 0x47961602, 0x46d02502, 0x47b37a87, 0x47ac8edd,
            0x46e39dec);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwadd.vv v8, v4, v6, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfwadd.vv v16, v4, v8, v0.t");
   //               0.0000000000000000, -124967.7656250000000000,
   //               0.0000000000000000,  2703.8260498046875000,
   //               0.0000000000000000,  39684.7148437500000000,
@@ -132,7 +132,7 @@ void TEST_CASE2(void) {
   //               0.0000000000000000,  3373.8281250000000000,
   //               0.0000000000000000,  153891.1640625000000000,
   //               0.0000000000000000, -738.4941406250000000
-  VCMP_U64(4, v8, 0x0, 0xc0fe827c40000000, 0x0, 0x40a51fa6f0000000, 0x0,
+  VCMP_U64(4, v16, 0x0, 0xc0fe827c40000000, 0x0, 0x40a51fa6f0000000, 0x0,
            0x40e36096e0000000, 0x0, 0xc0abbaba00000000, 0x0, 0x40f9bb5030000000,
            0x0, 0x40aa5ba800000000, 0x0, 0x4102c91950000000, 0x0,
            0xc08713f400000000);
@@ -141,7 +141,7 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //                              12.5859
   BOX_HALF_IN_FLOAT(fscalar_16, 0x4a4b);
@@ -151,19 +151,19 @@ void TEST_CASE3(void) {
   //               -83.6875
   VLOAD_16(v4, 0x4038, 0x5367, 0x5597, 0x54b4, 0xc413, 0x540c, 0xd52f, 0xd54f,
            0xd202, 0xc61a, 0x4f7e, 0x494f, 0x5293, 0xc840, 0x5468, 0xd53b);
-  asm volatile("vfwadd.vf v8, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfwadd.vf v16, v4, %[A]" ::[A] "f"(fscalar_16));
   //               14.69531250,  71.80468750,
   //               102.02343750,  87.83593750,  8.51171875,  77.33593750,
   //               -70.35156250, -72.35156250,
   //               -35.47656250,  6.48437500,  42.55468750,  23.20312500,  65.17968750,
   //               4.08593750,  83.08593750, -71.10156250
-  VCMP_U32(5, v8, 0x416b2000, 0x428f9c00, 0x42cc0c00, 0x42afac00, 0x41083000,
+  VCMP_U32(5, v16, 0x416b2000, 0x428f9c00, 0x42cc0c00, 0x42afac00, 0x41083000,
            0x429aac00, 0xc28cb400, 0xc290b400, 0xc20de800, 0x40cf8000,
            0x422a3800, 0x41b9a000, 0x42825c00, 0x4082c000, 0x42a62c00,
            0xc28e3400);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //                              -497871.25000000
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xc8f319e8);
@@ -177,7 +177,7 @@ void TEST_CASE3(void) {
            0x488da31d, 0x4901961c, 0x485d9f5c, 0x488b6ed5, 0xc970fed5,
            0xc8cec087, 0xc8095e14, 0xc94e3244, 0x490643c8, 0x4894ddfc,
            0xc92009e7);
-  asm volatile("vfwadd.vf v8, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfwadd.vf v16, v4, %[A]" ::[A] "f"(fscalar_32));
   //              -1066378.2500000000000000, -39875.2812500000000000,
   //              -88318.0625000000000000, -1295738.1250000000000000,
   //              -234350.7500000000000000, -207798.3437500000000000,
@@ -186,7 +186,7 @@ void TEST_CASE3(void) {
   //              -921299.4687500000000000, -638535.5625000000000000,
   //              -1342451.5000000000000000,  52077.2500000000000000,
   //              -192991.3750000000000000, -1153389.6875000000000000
-  VCMP_U64(6, v8, 0xc130458a40000000, 0xc0e3786900000000, 0xc0f58fe100000000,
+  VCMP_U64(6, v16, 0xc130458a40000000, 0xc0e3786900000000, 0xc0f58fe100000000,
            0xc133c57a20000000, 0xc10c9b7600000000, 0xc1095db2c0000000,
            0x40e0125000000000, 0xc110894740000000, 0xc109eac4c0000000,
            0xc136a8bc90000000, 0xc12c1da6f0000000, 0xc1237c8f20000000,
@@ -197,7 +197,7 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //                              12.5859
   BOX_HALF_IN_FLOAT(fscalar_16, 0x4a4b);
@@ -208,18 +208,18 @@ void TEST_CASE4(void) {
   VLOAD_16(v4, 0x4038, 0x5367, 0x5597, 0x54b4, 0xc413, 0x540c, 0xd52f, 0xd54f,
            0xd202, 0xc61a, 0x4f7e, 0x494f, 0x5293, 0xc840, 0x5468, 0xd53b);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwadd.vf v8, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v16);
+  asm volatile("vfwadd.vf v16, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.00000000,  71.80468750,  0.00000000,  87.83593750,
   //                0.00000000,  77.33593750,  0.00000000, -72.35156250,
   //                0.00000000,  6.48437500,  0.00000000,  23.20312500,
   //                0.00000000,  4.08593750,  0.00000000, -71.10156250
-  VCMP_U32(7, v8, 0x0, 0x428f9c00, 0x0, 0x42afac00, 0x0, 0x429aac00, 0x0,
+  VCMP_U32(7, v16, 0x0, 0x428f9c00, 0x0, 0x42afac00, 0x0, 0x429aac00, 0x0,
            0xc290b400, 0x0, 0x40cf8000, 0x0, 0x41b9a000, 0x0, 0x4082c000, 0x0,
            0xc28e3400);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //                              -497871.25000000
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xc8f319e8);
@@ -234,8 +234,8 @@ void TEST_CASE4(void) {
            0xc8cec087, 0xc8095e14, 0xc94e3244, 0x490643c8, 0x4894ddfc,
            0xc92009e7);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwadd.vf v8, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v16);
+  asm volatile("vfwadd.vf v16, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.0000000000000000, -39875.2812500000000000,
   //                0.0000000000000000, -1295738.1250000000000000,
   //                0.0000000000000000, -207798.3437500000000000,
@@ -244,7 +244,7 @@ void TEST_CASE4(void) {
   //                0.0000000000000000, -638535.5625000000000000,
   //                0.0000000000000000,  52077.2500000000000000,
   //                0.0000000000000000, -1153389.6875000000000000
-  VCMP_U64(8, v8, 0x0, 0xc0e3786900000000, 0x0, 0xc133c57a20000000, 0x0,
+  VCMP_U64(8, v16, 0x0, 0xc0e3786900000000, 0x0, 0xc133c57a20000000, 0x0,
            0xc1095db2c0000000, 0x0, 0xc110894740000000, 0x0, 0xc136a8bc90000000,
            0x0, 0xc1237c8f20000000, 0x0, 0x40e96da800000000, 0x0,
            0xc131996db0000000);
@@ -253,7 +253,7 @@ void TEST_CASE4(void) {
 
 // Simple random test with similar values
 void TEST_CASE5(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //              -4.22890615,  94.35176849, -2.66183305,  81.53971863,
   //              -30.80995941, -61.45680237,  53.70308304,  26.43629074,
   //              -50.49792862,  12.57134342, -18.77090454, -0.50017655,
@@ -266,20 +266,20 @@ void TEST_CASE5(void) {
   //              -22.7500,  51.3438,  8.8594,  23.0938,  32.6875,  71.7500,  7.6758,
   //              -12.8047,  98.0625, -8.7734, -73.5625,
   //              -59.0312,  44.9688,  63.8438,  30.1406
-  VLOAD_16(v6, 0xd0c6, 0xcdb0, 0x526b, 0x486e, 0x4dc6, 0x5016, 0x547c, 0x47ad,
+  VLOAD_16(v8, 0xd0c6, 0xcdb0, 0x526b, 0x486e, 0x4dc6, 0x5016, 0x547c, 0x47ad,
            0xca67, 0x5621, 0xc863, 0xd499, 0xd361, 0x519f, 0x53fb, 0x4f89);
-  asm volatile("vfwadd.wv v8, v4, v6");
+  asm volatile("vfwadd.wv v16, v4, v8");
   //              -42.41640472,  71.60176849,  48.68191528,  90.39909363,
   //              -7.71620941, -28.76930237,  125.45307922,  34.11207199,
   //              -63.30261612,  110.63384247, -27.54434204, -74.06267548,
   //              -92.74699402,  59.61531448,  153.41766357,  124.46500397
-  VCMP_U32(9, v8, 0xc229aa66, 0x428f341b, 0x4242ba48, 0x42b4cc56, 0xc0f6eb30,
+  VCMP_U32(9, v16, 0xc229aa66, 0x428f341b, 0x4242ba48, 0x42b4cc56, 0xc0f6eb30,
            0xc1e62788, 0x42fae7fa, 0x420872c3, 0xc27d35e1, 0x42dd4487,
            0xc1dc5ad0, 0xc2942017, 0xc2b97e76, 0x426e7615, 0x43196aec,
            0x42f8ee15);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //              -55997.9824854041071376,  64501.1750668793683872,
   //              -29542.1742966430028901, -97235.1376669598394074,
   //              -76290.1568635256844573, -53719.7602741207738291,
@@ -300,11 +300,11 @@ void TEST_CASE5(void) {
   //              -46430.30078125,  30247.85937500, -94111.64843750,
   //              89016.30468750, -52090.74609375,  72764.65625000,
   //              -47109.86328125
-  VLOAD_32(v6, 0xc78fa064, 0x47606ea4, 0xc6ff6be9, 0xc75b8d18, 0x464386d6,
+  VLOAD_32(v8, 0xc78fa064, 0x47606ea4, 0xc6ff6be9, 0xc75b8d18, 0x464386d6,
            0x46a2f5a5, 0x463ff3c6, 0x4770b95a, 0xc639d572, 0xc7355e4d,
            0x46ec4fb8, 0xc7b7cfd3, 0x47addc27, 0xc74b7abf, 0x478e1e54,
            0xc73805dd);
-  asm volatile("vfwadd.wv v8, v4, v6");
+  asm volatile("vfwadd.wv v16, v4, v8");
   //              -129534.7637354041071376,  121955.8156918793683872,
   //              -62236.1293747680028901, -153440.2314169598394074,
   //              -63776.4478791506844573, -32860.9380084957738291,
@@ -313,7 +313,7 @@ void TEST_CASE5(void) {
   //              -56940.3199660585087258, -74256.3294054225261789,
   //              106525.8939759960630909, -21905.3437088813807350,
   //              126968.0232140090665780, -104994.2581431879953016
-  VCMP_U64(10, v8, 0xc0ff9fec38429d77, 0x40fdc63d0d12ed98, 0xc0ee638423d68db0,
+  VCMP_U64(10, v16, 0xc0ff9fec38429d77, 0x40fdc63d0d12ed98, 0xc0ee638423d68db0,
            0xc102bb01d9f12292, 0xc0ef240e5506a818, 0xc0e00b9e042a6497,
            0xc0ed07c03cf1f908, 0x4100cf868295a558, 0x40f2a13ce859ab28,
            0xc0ebe25e8231134e, 0xc0ebcd8a3d2975a4, 0xc0f22105453e9ece,
@@ -325,7 +325,7 @@ void TEST_CASE5(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE6(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //              -4.22890615,  94.35176849, -2.66183305,  81.53971863,
   //              -30.80995941, -61.45680237,  53.70308304,  26.43629074,
   //              -50.49792862,  12.57134342, -18.77090454, -0.50017655,
@@ -338,21 +338,21 @@ void TEST_CASE6(void) {
   //              -22.7500,  51.3438,  8.8594,  23.0938,  32.6875,  71.7500,  7.6758,
   //              -12.8047,  98.0625, -8.7734, -73.5625,
   //              -59.0312,  44.9688,  63.8438,  30.1406
-  VLOAD_16(v6, 0xd0c6, 0xcdb0, 0x526b, 0x486e, 0x4dc6, 0x5016, 0x547c, 0x47ad,
+  VLOAD_16(v8, 0xd0c6, 0xcdb0, 0x526b, 0x486e, 0x4dc6, 0x5016, 0x547c, 0x47ad,
            0xca67, 0x5621, 0xc863, 0xd499, 0xd361, 0x519f, 0x53fb, 0x4f89);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwadd.wv v8, v4, v6, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfwadd.wv v16, v4, v8, v0.t");
   //               0.00000000,  71.60176849,  0.00000000,  90.39909363,
   //               0.00000000, -28.76930237,  0.00000000,  34.11207199,
   //               0.00000000,  110.63384247,  0.00000000, -74.06267548,
   //               0.00000000,  59.61531448,  0.00000000,  124.46500397
-  VCMP_U32(11, v8, 0x0, 0x428f341b, 0x0, 0x42b4cc56, 0x0, 0xc1e62788, 0x0,
+  VCMP_U32(11, v16, 0x0, 0x428f341b, 0x0, 0x42b4cc56, 0x0, 0xc1e62788, 0x0,
            0x420872c3, 0x0, 0x42dd4487, 0x0, 0xc2942017, 0x0, 0x426e7615, 0x0,
            0x42f8ee15);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //              -55997.9824854041071376,  64501.1750668793683872,
   //              -29542.1742966430028901, -97235.1376669598394074,
   //              -76290.1568635256844573, -53719.7602741207738291,
@@ -373,13 +373,13 @@ void TEST_CASE6(void) {
   //              -46430.30078125,  30247.85937500, -94111.64843750,
   //              89016.30468750, -52090.74609375,  72764.65625000,
   //              -47109.86328125
-  VLOAD_32(v6, 0xc78fa064, 0x47606ea4, 0xc6ff6be9, 0xc75b8d18, 0x464386d6,
+  VLOAD_32(v8, 0xc78fa064, 0x47606ea4, 0xc6ff6be9, 0xc75b8d18, 0x464386d6,
            0x46a2f5a5, 0x463ff3c6, 0x4770b95a, 0xc639d572, 0xc7355e4d,
            0x46ec4fb8, 0xc7b7cfd3, 0x47addc27, 0xc74b7abf, 0x478e1e54,
            0xc73805dd);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwadd.wv v8, v4, v6, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfwadd.wv v16, v4, v8, v0.t");
   //               0.0000000000000000,  121955.8156918793683872,
   //               0.0000000000000000, -153440.2314169598394074,
   //               0.0000000000000000, -32860.9380084957738291,
@@ -388,7 +388,7 @@ void TEST_CASE6(void) {
   //               0.0000000000000000, -74256.3294054225261789,
   //               0.0000000000000000, -21905.3437088813807350,
   //               0.0000000000000000, -104994.2581431879953016
-  VCMP_U64(12, v8, 0x0, 0x40fdc63d0d12ed98, 0x0, 0xc102bb01d9f12292, 0x0,
+  VCMP_U64(12, v16, 0x0, 0x40fdc63d0d12ed98, 0x0, 0xc102bb01d9f12292, 0x0,
            0xc0e00b9e042a6497, 0x0, 0x4100cf868295a558, 0x0, 0xc0ebe25e8231134e,
            0x0, 0xc0f22105453e9ece, 0x0, 0xc0d56455ff538938, 0x0,
            0xc0f9a224215ac062);
@@ -397,7 +397,7 @@ void TEST_CASE6(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE7(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //              -16.64103889,  69.17821503,  38.24327850,
   //              -60.26666641,  97.95110321, -47.38455200,  94.12043762,
@@ -410,19 +410,19 @@ void TEST_CASE7(void) {
            0x425e44d8);
   //                              53.8750
   BOX_HALF_IN_FLOAT(fscalar_16, 0x52bc);
-  asm volatile("vfwadd.wf v8, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfwadd.wf v16, v4, %[A]" ::[A] "f"(fscalar_16));
   //               37.23396301,  123.05321503,  92.11827850, -6.39166641,
   //               151.82611084,  6.49044800,  147.99543762,
   //               -36.52123260,  36.85481644,  81.97482300, -32.04139709,
   //               127.47602081, -44.73761749, -27.88364410,  93.95490265,
   //               109.44223022
-  VCMP_U32(13, v8, 0x4214ef94, 0x42f61b3f, 0x42b83c8f, 0xc0cc8888, 0x4317d37c,
+  VCMP_U32(13, v16, 0x4214ef94, 0x42f61b3f, 0x42b83c8f, 0xc0cc8888, 0x4317d37c,
            0x40cfb1c0, 0x4313fed5, 0xc21215be, 0x42136b55, 0x42a3f31c,
            0xc2002a64, 0x42fef3b9, 0xc232f352, 0xc1df11b4, 0x42bbe8e9,
            0x42dae26c);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //               366783.2934919928666204, -648147.5638866436202079,
   //               24949.3815817765425891, -211759.8585660880198702,
@@ -440,7 +440,7 @@ void TEST_CASE7(void) {
            0x411dfc51be066c64);
   //                               572932.37500000
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x490be046);
-  asm volatile("vfwadd.wf v8, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfwadd.wf v16, v4, %[A]" ::[A] "f"(fscalar_32));
   //               939715.6684919928666204, -75215.1888866436202079,
   //               597881.7565817765425891,  361172.5164339119801298,
   //               910672.7464956413023174,  44373.0132952487329021,
@@ -449,7 +449,7 @@ void TEST_CASE7(void) {
   //               565911.6885785305639729,  1412211.0259590207133442,
   //               129607.2289743639994413,  670221.7175237806513906,
   //               792941.4536798361223191,  1064216.8105713783297688
-  VCMP_U64(14, v8, 0x412cad875644951e, 0xc0f25cf305ae0050, 0x41223ef3835eafc6,
+  VCMP_U64(14, v16, 0x412cad875644951e, 0xc0f25cf305ae0050, 0x41223ef3835eafc6,
            0x41160b5210d40d2a, 0x412bcaa17e34ad3c, 0x40e5aaa06cea2850,
            0xc111c31f94f4acd4, 0x40faa1bc6e3d0400, 0x41375f8fae943e83,
            0xc111242cc019fb2c, 0x4121452f608d5d7b, 0x41358c7306a54019,
@@ -460,7 +460,7 @@ void TEST_CASE7(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE8(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //               -16.64103889,  69.17821503,  38.24327850,
   //               -60.26666641,  97.95110321, -47.38455200,  94.12043762,
@@ -474,18 +474,18 @@ void TEST_CASE8(void) {
   //                              53.8750
   BOX_HALF_IN_FLOAT(fscalar_16, 0x52bc);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwadd.wf v8, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v16);
+  asm volatile("vfwadd.wf v16, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.00000000,  123.05321503,  0.00000000, -6.39166641,
   //                0.00000000,  6.49044800,  0.00000000, -36.52123260,
   //                0.00000000,  81.97482300,  0.00000000,  127.47602081,
   //                0.00000000, -27.88364410,  0.00000000,  109.44223022
-  VCMP_U32(15, v8, 0x0, 0x42f61b3f, 0x0, 0xc0cc8888, 0x0, 0x40cfb1c0, 0x0,
+  VCMP_U32(15, v16, 0x0, 0x42f61b3f, 0x0, 0xc0cc8888, 0x0, 0x40cfb1c0, 0x0,
            0xc21215be, 0x0, 0x42a3f31c, 0x0, 0x42fef3b9, 0x0, 0xc1df11b4, 0x0,
            0x42dae26c);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //                366783.2934919928666204, -648147.5638866436202079,
   //                24949.3815817765425891, -211759.8585660880198702,
@@ -504,8 +504,8 @@ void TEST_CASE8(void) {
   //                               572932.37500000
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0x490be046);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwadd.wf v8, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v16);
+  asm volatile("vfwadd.wf v16, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.0000000000000000, -75215.1888866436202079,
   //                0.0000000000000000,  361172.5164339119801298,
   //                0.0000000000000000,  44373.0132952487329021,
@@ -514,7 +514,7 @@ void TEST_CASE8(void) {
   //                0.0000000000000000,  1412211.0259590207133442,
   //                0.0000000000000000,  670221.7175237806513906,
   //                0.0000000000000000,  1064216.8105713783297688
-  VCMP_U64(16, v8, 0x0, 0xc0f25cf305ae0050, 0x0, 0x41160b5210d40d2a, 0x0,
+  VCMP_U64(16, v16, 0x0, 0xc0f25cf305ae0050, 0x0, 0x41160b5210d40d2a, 0x0,
            0x40e5aaa06cea2850, 0x0, 0x40faa1bc6e3d0400, 0x0, 0xc111242cc019fb2c,
            0x0, 0x41358c7306a54019, 0x0, 0x4124741b6f5f46e8, 0x0,
            0x41303d18cf819b19);
diff --git a/sw/riscvTests/isa/rv64uv/vfwmacc.c b/sw/riscvTests/isa/rv64uv/vfwmacc.c
index 83e87093..3306c7da 100644
--- a/sw/riscvTests/isa/rv64uv/vfwmacc.c
+++ b/sw/riscvTests/isa/rv64uv/vfwmacc.c
@@ -11,7 +11,7 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //               52.7812,  74.1875,  0.3564,  97.5000,  7.8477,  53.2188,
   //               -26.4688, -48.1250, -32.9688,  7.8750,
   //               -38.4375,  51.5625,  46.2188, -75.1875,  23.5625, -77.8125
@@ -20,29 +20,29 @@ void TEST_CASE1(void) {
   //               49.6875,  28.5312,  13.4766, -90.5625,  58.0000,
   //               -63.8125,  49.0625,  0.3325,  30.8906,  11.2266, -93.9375,
   //               -54.6875,  61.7500,  38.3438,  95.8125,  10.0938
-  VLOAD_16(v6, 0x5236, 0x4f22, 0x4abd, 0xd5a9, 0x5340, 0xd3fa, 0x5222, 0x3552,
+  VLOAD_16(v8, 0x5236, 0x4f22, 0x4abd, 0xd5a9, 0x5340, 0xd3fa, 0x5222, 0x3552,
            0x4fb9, 0x499d, 0xd5df, 0xd2d6, 0x53b8, 0x50cb, 0x55fd, 0x490c);
   //              -83.87223053, -48.34465408,  70.48658752, -1.26614821,
   //              -24.13150024, -65.13838196,
   //              0.84671319,  34.34510040,  72.80049896,
   //              -86.23424530,  25.52654839, -68.44364929,  9.81109142,
   //              -85.20966339, -81.00300598,  16.25512505
-  VLOAD_32(v8, 0xc2a7be95, 0xc24160ed, 0x428cf922, 0xbfa21125, 0xc1c10d50,
+  VLOAD_32(v16, 0xc2a7be95, 0xc24160ed, 0x428cf922, 0xbfa21125, 0xc1c10d50,
            0xc28246da, 0x3f58c232, 0x42096162, 0x429199db, 0xc2ac77ef,
            0x41cc365f, 0xc288e326, 0x411cfa3b, 0xc2aa6b59, 0xc2a2018a,
            0x41820a7f);
-  asm volatile("vfwmacc.vv v8, v4, v6");
+  asm volatile("vfwmacc.vv v16, v4, v8");
   //               2538.69604492,  2068.31738281,  75.29024506, -8831.11035156,
   //               431.03256226, -3461.15991211, -1297.77636719,  18.34259796,
   //               -945.62481689,  2.17493439,  3636.24926758, -2888.26782227,
   //               2863.81884766, -2968.18041992,  2176.57910156, -769.16479492
-  VCMP_U32(1, v8, 0x451eab23, 0x45014514, 0x4296949b, 0xc609fc71, 0x43d7842b,
+  VCMP_U32(1, v16, 0x451eab23, 0x45014514, 0x4296949b, 0xc609fc71, 0x43d7842b,
            0xc558528f, 0xc4a238d8, 0x4192bda4, 0xc46c67fd, 0x400b3220,
            0x456343fd, 0xc5348449, 0x4532fd1a, 0xc53982e3, 0x45080944,
            0xc4404a8c);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //              -3306.98510742, -33314.88281250,  64578.31250000,
   //              11648.08203125, -92704.16406250,  33998.11328125,
   //              23406.90429688,  44169.36718750, -1206.53601074,
@@ -59,7 +59,7 @@ void TEST_CASE1(void) {
   //              -47420.98437500, -40235.07421875,  44342.39453125,
   //              90261.61718750,  76035.55468750, -92912.59375000,
   //              40474.20703125
-  VLOAD_32(v6, 0xc74ca10e, 0xc6f48a33, 0x44e8d318, 0x47a8a448, 0x46156046,
+  VLOAD_32(v8, 0xc74ca10e, 0xc6f48a33, 0x44e8d318, 0x47a8a448, 0x46156046,
            0xc7b72376, 0xc7864a70, 0x4726833b, 0xc7af0272, 0xc7393cfc,
            0xc71d2b13, 0x472d3665, 0x47b04acf, 0x479481c7, 0xc7b5784c,
            0x471e1a35);
@@ -71,13 +71,13 @@ void TEST_CASE1(void) {
   //              53604.5772563865466509, -30101.3490022116457112,
   //              80638.7360704737366177, -75019.8948306038219016,
   //              63887.5576457676361315,  1225.3713199536578031
-  VLOAD_64(v8, 0xc0c39e04b6396548, 0x40c97877ac90a6f8, 0x40f5b541d179217e,
+  VLOAD_64(v16, 0xc0c39e04b6396548, 0x40c97877ac90a6f8, 0x40f5b541d179217e,
            0x40f35406fd087c82, 0x40d51ac614b2f890, 0xc0d9d5eb37ccffac,
            0x40b75bacee1f5340, 0xc0f859574a437b9d, 0x40f4c951e845a8f0,
            0xc0f571e03f956903, 0x40ea2c9278e262b4, 0xc0dd6556560d5f50,
            0x40f3afebc6f1d544, 0xc0f250be5139e52e, 0x40ef31f1d83befd8,
            0x4093257c3b4c4540);
-  asm volatile("vfwmacc.vv v8, v4, v6");
+  asm volatile("vfwmacc.vv v16, v4, v8");
   //               173226551.6662319302558899,  1042805506.3236714601516724,
   //               120372266.5559626817703247,  1005827715.3891682624816895,
   //               -886236534.5412018299102783, -3187924887.6156492233276367,
@@ -86,7 +86,7 @@ void TEST_CASE1(void) {
   //               3608622049.7550821304321289,  2122430044.9128692150115967,
   //               -6517279175.0161266326904297,  3100051665.0599727630615234,
   //               -8910693010.2487506866455078,  3887273396.3922243118286133
-  VCMP_U64(2, v8, 0x41a4a6746f551c5a, 0x41cf13f981296e11, 0x419cb2f0aa394e48,
+  VCMP_U64(2, v16, 0x41a4a6746f551c5a, 0x41cf13f981296e11, 0x419cb2f0aa394e48,
            0x41cdf9db41b1d044, 0xc1ca6972bb45461a, 0xc1e7c07bf2f3b366,
            0xc1d7fb4bc74ce878, 0x41dc0dffdb538172, 0x4199cbccf19668ea,
            0xc1a9d55ecb9731ad, 0x41eae2e67c3829a2, 0x41dfa06d973a6c73,
@@ -98,7 +98,7 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //               52.7812,  74.1875,  0.3564,  97.5000,  7.8477,  53.2188,
   //               -26.4688, -48.1250, -32.9688,  7.8750,
   //               -38.4375,  51.5625,  46.2188, -75.1875,  23.5625, -77.8125
@@ -107,7 +107,7 @@ void TEST_CASE2(void) {
   //               49.6875,  28.5312,  13.4766, -90.5625,  58.0000,
   //               -63.8125,  49.0625,  0.3325,  30.8906,  11.2266, -93.9375,
   //               -54.6875,  61.7500,  38.3438,  95.8125,  10.0938
-  VLOAD_16(v6, 0x5236, 0x4f22, 0x4abd, 0xd5a9, 0x5340, 0xd3fa, 0x5222, 0x3552,
+  VLOAD_16(v8, 0x5236, 0x4f22, 0x4abd, 0xd5a9, 0x5340, 0xd3fa, 0x5222, 0x3552,
            0x4fb9, 0x499d, 0xd5df, 0xd2d6, 0x53b8, 0x50cb, 0x55fd, 0x490c);
   VLOAD_8(v0, 0xAA, 0xAA);
   //              -83.87223053, -48.34465408,  70.48658752, -1.26614821,
@@ -115,23 +115,23 @@ void TEST_CASE2(void) {
   //              0.84671319,  34.34510040,  72.80049896,
   //              -86.23424530,  25.52654839, -68.44364929,  9.81109142,
   //              -85.20966339, -81.00300598,  16.25512505
-  VLOAD_32(v8, 0xc2a7be95, 0xc24160ed, 0x428cf922, 0xbfa21125, 0xc1c10d50,
+  VLOAD_32(v16, 0xc2a7be95, 0xc24160ed, 0x428cf922, 0xbfa21125, 0xc1c10d50,
            0xc28246da, 0x3f58c232, 0x42096162, 0x429199db, 0xc2ac77ef,
            0x41cc365f, 0xc288e326, 0x411cfa3b, 0xc2aa6b59, 0xc2a2018a,
            0x41820a7f);
-  asm volatile("vfwmacc.vv v8, v4, v6, v0.t");
+  asm volatile("vfwmacc.vv v16, v4, v8, v0.t");
   //              -83.87223053,  2068.31738281,  70.48658752, -8831.11035156,
   //              -24.13150024, -3461.15991211,
   //              0.84671319,  18.34259796,  72.80049896,  2.17493439,  25.52654839,
   //              -2888.26782227,  9.81109142, -2968.18041992, -81.00300598,
   //              -769.16479492
-  VCMP_U32(3, v8, 0xc2a7be95, 0x45014514, 0x428cf922, 0xc609fc71, 0xc1c10d50,
+  VCMP_U32(3, v16, 0xc2a7be95, 0x45014514, 0x428cf922, 0xc609fc71, 0xc1c10d50,
            0xc558528f, 0x3f58c232, 0x4192bda4, 0x429199db, 0x400b3220,
            0x41cc365f, 0xc5348449, 0x411cfa3b, 0xc53982e3, 0xc2a2018a,
            0xc4404a8c);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //              -3306.98510742, -33314.88281250,  64578.31250000,
   //              11648.08203125, -92704.16406250,  33998.11328125,
   //              23406.90429688,  44169.36718750, -1206.53601074,
@@ -148,7 +148,7 @@ void TEST_CASE2(void) {
   //              -47420.98437500, -40235.07421875,  44342.39453125,
   //              90261.61718750,  76035.55468750, -92912.59375000,
   //              40474.20703125
-  VLOAD_32(v6, 0xc74ca10e, 0xc6f48a33, 0x44e8d318, 0x47a8a448, 0x46156046,
+  VLOAD_32(v8, 0xc74ca10e, 0xc6f48a33, 0x44e8d318, 0x47a8a448, 0x46156046,
            0xc7b72376, 0xc7864a70, 0x4726833b, 0xc7af0272, 0xc7393cfc,
            0xc71d2b13, 0x472d3665, 0x47b04acf, 0x479481c7, 0xc7b5784c,
            0x471e1a35);
@@ -161,13 +161,13 @@ void TEST_CASE2(void) {
   //              53604.5772563865466509, -30101.3490022116457112,
   //              80638.7360704737366177, -75019.8948306038219016,
   //              63887.5576457676361315,  1225.3713199536578031
-  VLOAD_64(v8, 0xc0c39e04b6396548, 0x40c97877ac90a6f8, 0x40f5b541d179217e,
+  VLOAD_64(v16, 0xc0c39e04b6396548, 0x40c97877ac90a6f8, 0x40f5b541d179217e,
            0x40f35406fd087c82, 0x40d51ac614b2f890, 0xc0d9d5eb37ccffac,
            0x40b75bacee1f5340, 0xc0f859574a437b9d, 0x40f4c951e845a8f0,
            0xc0f571e03f956903, 0x40ea2c9278e262b4, 0xc0dd6556560d5f50,
            0x40f3afebc6f1d544, 0xc0f250be5139e52e, 0x40ef31f1d83befd8,
            0x4093257c3b4c4540);
-  asm volatile("vfwmacc.vv v8, v4, v6, v0.t");
+  asm volatile("vfwmacc.vv v16, v4, v8, v0.t");
   //              -10044.0368110413110116,  1042805506.3236714601516724,
   //              88916.1136409099854063,  1005827715.3891682624816895,
   //              21611.0950133731239475, -3187924887.6156492233276367,
@@ -176,7 +176,7 @@ void TEST_CASE2(void) {
   //              53604.5772563865466509,  2122430044.9128692150115967,
   //              80638.7360704737366177,  3100051665.0599727630615234,
   //              63887.5576457676361315,  3887273396.3922243118286133
-  VCMP_U64(4, v8, 0xc0c39e04b6396548, 0x41cf13f981296e11, 0x40f5b541d179217e,
+  VCMP_U64(4, v16, 0xc0c39e04b6396548, 0x41cf13f981296e11, 0x40f5b541d179217e,
            0x41cdf9db41b1d044, 0x40d51ac614b2f890, 0xc1e7c07bf2f3b366,
            0x40b75bacee1f5340, 0x41dc0dffdb538172, 0x40f4c951e845a8f0,
            0xc1a9d55ecb9731ad, 0x40ea2c9278e262b4, 0x41dfa06d973a6c73,
@@ -187,7 +187,7 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //              -15.3750,  11.9375,
   //              -31.7656,  27.0625,  3.0684,  71.2500,  63.2500, -95.6875,
@@ -202,23 +202,23 @@ void TEST_CASE3(void) {
   //              -92.09814453,  92.33961487,  42.48206329,  99.15431976,
   //              -5.94871950, -55.92549133,  59.99367523, -45.05080032,
   //              -68.93397522,  55.13935089, -80.23659515
-  VLOAD_32(v8, 0xc28c7596, 0x4288b9ff, 0xc28b8355, 0xc2b90586, 0xc256459e,
+  VLOAD_32(v16, 0xc28c7596, 0x4288b9ff, 0xc28b8355, 0xc2b90586, 0xc256459e,
            0xc2b83240, 0x42b8ade2, 0x4229eda2, 0x42c64f03, 0xc0be5be9,
            0xc25fb3b4, 0x426ff986, 0xc2343405, 0xc289de32, 0x425c8eb2,
            0xc2a07923);
-  asm volatile("vfwmacc.vf v8, %[A], v4" ::[A] "f"(fscalar_16));
+  asm volatile("vfwmacc.vf v16, %[A], v4" ::[A] "f"(fscalar_16));
   //              -566.55389404,  453.72070312, -1095.19055176,
   //              781.10052490,  45.48249054,  2207.94091797,  2134.12866211,
   //              -3046.42993164, -1904.30078125, -901.24902344,  1736.69262695,
   //              -1947.49658203, -1406.91601562, -3145.74072266,  931.27264404,
   //              -626.49584961
-  VCMP_U32(5, v8, 0xc40da373, 0x43e2dc40, 0xc488e619, 0x4443466f, 0x4235ee12,
+  VCMP_U32(5, v16, 0xc40da373, 0x43e2dc40, 0xc488e619, 0x4443466f, 0x4235ee12,
            0x4509ff0e, 0x4505620f, 0xc53e66e1, 0xc4ee09a0, 0xc4614ff0,
            0x44d9162a, 0xc4f36fe4, 0xc4afdd50, 0xc5449bda, 0x4468d173,
            0xc41c9fbc);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //              -260866.17187500, -221967.43750000, -907157.25000000,
   //              754760.87500000, -585546.12500000,  260611.84375000,
@@ -240,13 +240,13 @@ void TEST_CASE3(void) {
   //              -602138.5575914122164249,  253718.7884360067546368,
   //              7255.4825419568223879,  957493.0229552322998643,
   //              -446793.8022573012858629, -757660.7323241395642981
-  VLOAD_64(v8, 0xc1264913d6b92745, 0xc12b09866c1c7afb, 0xc12692f023f9fc22,
+  VLOAD_64(v16, 0xc1264913d6b92745, 0xc12b09866c1c7afb, 0xc12692f023f9fc22,
            0x412e4029e4afcdba, 0xc120956863b251fa, 0x412a37fec6d2858e,
            0x412a5066f3e1f4bc, 0x41143879910d5c64, 0x412c95f62ac3038c,
            0xc128d534d9539c30, 0xc12260351d7c9f20, 0x410ef8b64eb78980,
            0x40bc577b87dea380, 0x412d386a0bc0c9c8, 0xc11b45273582f020,
            0xc1271f3976f3308b);
-  asm volatile("vfwmacc.vf v8, %[A], v4" ::[A] "f"(fscalar_32));
+  asm volatile("vfwmacc.vf v16, %[A], v4" ::[A] "f"(fscalar_32));
   //               42998415581.0217819213867188,  36586495789.9245910644531250,
   //               149527988394.2461547851562500,
   //               -124407906605.8560791015625000, 96516314402.8619232177734375,
@@ -256,7 +256,7 @@ void TEST_CASE3(void) {
   //               -87875091201.5038757324218750, 131558913220.3411712646484375,
   //               -10993283369.2012958526611328, -40577380186.7228927612304688,
   //               -120034697981.6674957275390625, 123503190798.8887634277343750
-  VCMP_U64(6, v8, 0x422405cf81ba0b27, 0x422109733e5bd964, 0x4241684804551f82,
+  VCMP_U64(6, v16, 0x422405cf81ba0b27, 0x422109733e5bd964, 0x4241684804551f82,
            0xc23cf74a012ddb28, 0x423678d21522dca7, 0xc22400cc3b5cc8ed,
            0x423d7dec86478af1, 0x42120c7671f50d4d, 0x423206ce01931202,
            0xc23dbf2b74cb7eaa, 0xc23475c37b0180fe, 0x423ea185b4c45757,
@@ -267,7 +267,7 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //               -15.3750,  11.9375,
   //               -31.7656,  27.0625,  3.0684,  71.2500,  63.2500, -95.6875,
@@ -283,23 +283,23 @@ void TEST_CASE4(void) {
   //               -92.09814453,  92.33961487,  42.48206329,  99.15431976,
   //               -5.94871950, -55.92549133,  59.99367523, -45.05080032,
   //               -68.93397522,  55.13935089, -80.23659515
-  VLOAD_32(v8, 0xc28c7596, 0x4288b9ff, 0xc28b8355, 0xc2b90586, 0xc256459e,
+  VLOAD_32(v16, 0xc28c7596, 0x4288b9ff, 0xc28b8355, 0xc2b90586, 0xc256459e,
            0xc2b83240, 0x42b8ade2, 0x4229eda2, 0x42c64f03, 0xc0be5be9,
            0xc25fb3b4, 0x426ff986, 0xc2343405, 0xc289de32, 0x425c8eb2,
            0xc2a07923);
-  asm volatile("vfwmacc.vf v8, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
+  asm volatile("vfwmacc.vf v16, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
   //               -70.22966003,  453.72070312, -69.75650787,  781.10052490,
   //               -53.56798553,  2207.94091797,  92.33961487,
   //               -3046.42993164,  99.15431976, -901.24902344, -55.92549133,
   //               -1947.49658203, -45.05080032, -3145.74072266,  55.13935089,
   //               -626.49584961
-  VCMP_U32(7, v8, 0xc28c7596, 0x43e2dc40, 0xc28b8355, 0x4443466f, 0xc256459e,
+  VCMP_U32(7, v16, 0xc28c7596, 0x43e2dc40, 0xc28b8355, 0x4443466f, 0xc256459e,
            0x4509ff0e, 0x42b8ade2, 0xc53e66e1, 0x42c64f03, 0xc4614ff0,
            0xc25fb3b4, 0xc4f36fe4, 0xc2343405, 0xc5449bda, 0x425c8eb2,
            0xc41c9fbc);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //               -260866.17187500, -221967.43750000, -907157.25000000,
   //               754760.87500000, -585546.12500000,  260611.84375000,
@@ -322,13 +322,13 @@ void TEST_CASE4(void) {
   //               -602138.5575914122164249,  253718.7884360067546368,
   //               7255.4825419568223879,  957493.0229552322998643,
   //               -446793.8022573012858629, -757660.7323241395642981
-  VLOAD_64(v8, 0xc1264913d6b92745, 0xc12b09866c1c7afb, 0xc12692f023f9fc22,
+  VLOAD_64(v16, 0xc1264913d6b92745, 0xc12b09866c1c7afb, 0xc12692f023f9fc22,
            0x412e4029e4afcdba, 0xc120956863b251fa, 0x412a37fec6d2858e,
            0x412a5066f3e1f4bc, 0x41143879910d5c64, 0x412c95f62ac3038c,
            0xc128d534d9539c30, 0xc12260351d7c9f20, 0x410ef8b64eb78980,
            0x40bc577b87dea380, 0x412d386a0bc0c9c8, 0xc11b45273582f020,
            0xc1271f3976f3308b);
-  asm volatile("vfwmacc.vf v8, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
+  asm volatile("vfwmacc.vf v16, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
   //               -730249.9193813583115116,  36586495789.9245910644531250,
   //               -739704.0702666083816439, -124407906605.8560791015625000,
   //               -543412.1947198503185064, -42956365230.3924331665039062,
@@ -337,7 +337,7 @@ void TEST_CASE4(void) {
   //               -602138.5575914122164249,  131558913220.3411712646484375,
   //               7255.4825419568223879, -40577380186.7228927612304688,
   //               -446793.8022573012858629,  123503190798.8887634277343750
-  VCMP_U64(8, v8, 0xc1264913d6b92745, 0x422109733e5bd964, 0xc12692f023f9fc22,
+  VCMP_U64(8, v16, 0xc1264913d6b92745, 0x422109733e5bd964, 0xc12692f023f9fc22,
            0xc23cf74a012ddb28, 0xc120956863b251fa, 0xc22400cc3b5cc8ed,
            0x412a5066f3e1f4bc, 0x42120c7671f50d4d, 0x412c95f62ac3038c,
            0xc23dbf2b74cb7eaa, 0xc12260351d7c9f20, 0x423ea185b4c45757,
diff --git a/sw/riscvTests/isa/rv64uv/vfwmsac.c b/sw/riscvTests/isa/rv64uv/vfwmsac.c
index dcbd793c..492273d0 100644
--- a/sw/riscvTests/isa/rv64uv/vfwmsac.c
+++ b/sw/riscvTests/isa/rv64uv/vfwmsac.c
@@ -11,7 +11,7 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //              -93.0000, -55.1250, -68.5625,  76.3125, -61.2188,  48.9375,
   //              -56.3125,  71.0000, -74.5625, -38.7188,
   //              -50.3438,  93.3750,  80.2500, -7.4141,  93.8125,  83.1875
@@ -20,29 +20,29 @@ void TEST_CASE1(void) {
   //              -60.0312, -31.7188, -74.2500, -0.9077,  30.4844, -56.2500,
   //              -4.8320,  34.2812,  66.6875,  37.9375,  78.1875,  5.6094,
   //              -81.8125,  67.6250,  29.4531, -64.9375
-  VLOAD_16(v6, 0xd381, 0xcfee, 0xd4a4, 0xbb43, 0x4f9f, 0xd308, 0xc4d5, 0x5049,
+  VLOAD_16(v8, 0xd381, 0xcfee, 0xd4a4, 0xbb43, 0x4f9f, 0xd308, 0xc4d5, 0x5049,
            0x542b, 0x50be, 0x54e3, 0x459c, 0xd51d, 0x543a, 0x4f5d, 0xd40f);
   //               31.29529381, -66.12346649,
   //               -48.59321213,  21.66906929,  92.08473206,  1.95985305,
   //               -96.55027771,  77.65225220, -82.48660278,
   //               -35.32508850,  42.91923141,
   //               -76.65069580,  25.13817024,  72.89311981,  21.44047737,  69.71634674
-  VLOAD_32(v8, 0x41fa5cc3, 0xc2843f37, 0xc2425f73, 0x41ad5a41, 0x42b82b62,
+  VLOAD_32(v16, 0x41fa5cc3, 0xc2843f37, 0xc2425f73, 0x41ad5a41, 0x42b82b62,
            0x3ffadc77, 0xc2c119be, 0x429b4df4, 0xc2a4f924, 0xc20d4ce4,
            0x422bad4b, 0xc2994d28, 0x41c91af9, 0x4291c947, 0x41ab8619,
            0x428b6ec5);
-  asm volatile("vfwmsac.vv v8, v4, v6");
+  asm volatile("vfwmsac.vv v16, v4, v8");
   //               5551.61083984,  1814.61950684,  5139.35888672, -90.93905640,
   //               -1958.30004883, -2754.69433594,  368.65405273, 2356.31640625,
   //               -4889.89990234, -1433.56750488, -3979.17114258, 600.42608643,
   //               -6590.59130859, -574.26910400,  2741.63085938, -5471.70458984
-  VCMP_U32(1, v8, 0x45ad7ce3, 0x44e2d3d3, 0x45a09adf, 0xc2b5e0cc, 0xc4f4c99a,
+  VCMP_U32(1, v16, 0x45ad7ce3, 0x44e2d3d3, 0x45a09adf, 0xc2b5e0cc, 0xc4f4c99a,
            0xc52c2b1c, 0x43b853b8, 0x45134510, 0xc598cf33, 0xc4b33229,
            0xc578b2bd, 0x44161b45, 0xc5cdf4bb, 0xc40f9139, 0x452b5a18,
            0xc5aafda3);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //              -71423.96093750, -46625.21875000, -59851.39453125,
   //              -43461.99218750, -10255.72753906,  37671.59765625,
   //              96842.05468750,  33293.05859375,  27126.79296875,
@@ -59,7 +59,7 @@ void TEST_CASE1(void) {
   //               -84006.54687500,  31506.48437500,  2731.77905273,
   //               -20272.41992188,  53550.01953125, -85441.62500000,
   //               -33418.07031250
-  VLOAD_32(v6, 0x47b6ec94, 0xc6dda234, 0xc724b9ea, 0xc6a703e9, 0x467ed187,
+  VLOAD_32(v8, 0x47b6ec94, 0xc6dda234, 0xc724b9ea, 0xc6a703e9, 0x467ed187,
            0x477c05d8, 0xc642d6de, 0xc7966144, 0xc70397d6, 0xc7a41346,
            0x46f624f8, 0x452abc77, 0xc69e60d7, 0x47512e05, 0xc7a6e0d0,
            0xc7028a12);
@@ -71,13 +71,13 @@ void TEST_CASE1(void) {
   //               58906.1301468654128257, -84146.7844421620393405,
   //               -23969.5482366856886074,  92255.7186088700836990,
   //               -35519.3091108352309675, -65623.9480113173485734
-  VLOAD_64(v8, 0x40cd6718fdfdcea0, 0xc0e3104c8d763c4c, 0xc0f46625a9c52662,
+  VLOAD_64(v16, 0x40cd6718fdfdcea0, 0xc0e3104c8d763c4c, 0xc0f46625a9c52662,
            0x40e1797d8df4a4ac, 0xc0e0f368e8fd81b0, 0x40e1851120d4d47c,
            0xc0e99a3f0b1a1b69, 0xc0e3efea13a0e433, 0xc0abe35c94436520,
            0x40f2cda2435b507a, 0x40ecc3442a29c254, 0xc0f48b2c8d133979,
            0xc0d76863164f52e0, 0x40f685fb7f6c03ba, 0xc0e157e9e43c6805,
            0xc0f0057f2b0dea44);
-  asm volatile("vfwmsac.vv v8, v4, v6");
+  asm volatile("vfwmsac.vv v16, v4, v8");
   //              -6689380123.7125854492187500,  1322754608.4847974777221680,
   //              2524011718.2575426101684570,  929092728.6666160821914673,
   //              -167219605.4339296817779541,  2430454370.8635458946228027,
@@ -86,7 +86,7 @@ void TEST_CASE1(void) {
   //              844792333.7375594377517700,  78362512.5631930530071259,
   //              115575080.3336923867464066,  3779577314.6337165832519531,
   //              507279209.1484052538871765, -1452948809.7560596466064453
-  VCMP_U64(2, v8, 0xc1f8eb7d71bb66c0, 0x41d3b5e88c1f06ec, 0x41e2ce2b98c83dca,
+  VCMP_U64(2, v16, 0xc1f8eb7d71bb66c0, 0x41d3b5e88c1f06ec, 0x41e2ce2b98c83dca,
            0x41cbb06a3c5553ad, 0xc1a3ef232ade2c08, 0x41e21bb94c5ba22b,
            0xc1d1fe66d480ac0c, 0xc1e31930221fab5f, 0xc1cb3c0a8aae33ef,
            0x41e11d15572a5b49, 0x41c92d4106de6859, 0x4192aede4240b5ae,
@@ -98,7 +98,7 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //              -93.0000, -55.1250, -68.5625,  76.3125, -61.2188,  48.9375,
   //              -56.3125,  71.0000, -74.5625, -38.7188,
   //              -50.3438,  93.3750,  80.2500, -7.4141,  93.8125,  83.1875
@@ -107,7 +107,7 @@ void TEST_CASE2(void) {
   //              -60.0312, -31.7188, -74.2500, -0.9077,  30.4844, -56.2500,
   //              -4.8320,  34.2812,  66.6875,  37.9375,  78.1875,  5.6094,
   //              -81.8125,  67.6250,  29.4531, -64.9375
-  VLOAD_16(v6, 0xd381, 0xcfee, 0xd4a4, 0xbb43, 0x4f9f, 0xd308, 0xc4d5, 0x5049,
+  VLOAD_16(v8, 0xd381, 0xcfee, 0xd4a4, 0xbb43, 0x4f9f, 0xd308, 0xc4d5, 0x5049,
            0x542b, 0x50be, 0x54e3, 0x459c, 0xd51d, 0x543a, 0x4f5d, 0xd40f);
   VLOAD_8(v0, 0xAA, 0xAA);
   //               31.29529381, -66.12346649,
@@ -115,23 +115,23 @@ void TEST_CASE2(void) {
   //               -96.55027771,  77.65225220, -82.48660278,
   //               -35.32508850,  42.91923141,
   //               -76.65069580,  25.13817024,  72.89311981,  21.44047737,  69.71634674
-  VLOAD_32(v8, 0x41fa5cc3, 0xc2843f37, 0xc2425f73, 0x41ad5a41, 0x42b82b62,
+  VLOAD_32(v16, 0x41fa5cc3, 0xc2843f37, 0xc2425f73, 0x41ad5a41, 0x42b82b62,
            0x3ffadc77, 0xc2c119be, 0x429b4df4, 0xc2a4f924, 0xc20d4ce4,
            0x422bad4b, 0xc2994d28, 0x41c91af9, 0x4291c947, 0x41ab8619,
            0x428b6ec5);
-  asm volatile("vfwmsac.vv v8, v4, v6, v0.t");
+  asm volatile("vfwmsac.vv v16, v4, v8, v0.t");
   //               31.29529381,  1814.61950684, -48.59321213,
   //               -90.93905640,  92.08473206, -2754.69433594, -96.55027771,
   //               2356.31640625, -82.48660278, -1433.56750488,  42.91923141,
   //               600.42608643,  25.13817024, -574.26910400,  21.44047737,
   //               -5471.70458984
-  VCMP_U32(3, v8, 0x41fa5cc3, 0x44e2d3d3, 0xc2425f73, 0xc2b5e0cc, 0x42b82b62,
+  VCMP_U32(3, v16, 0x41fa5cc3, 0x44e2d3d3, 0xc2425f73, 0xc2b5e0cc, 0x42b82b62,
            0xc52c2b1c, 0xc2c119be, 0x45134510, 0xc2a4f924, 0xc4b33229,
            0x422bad4b, 0x44161b45, 0x41c91af9, 0xc40f9139, 0x41ab8619,
            0xc5aafda3);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //              -71423.96093750, -46625.21875000, -59851.39453125,
   //              -43461.99218750, -10255.72753906,  37671.59765625,
   //              96842.05468750,  33293.05859375,  27126.79296875,
@@ -148,7 +148,7 @@ void TEST_CASE2(void) {
   //               -84006.54687500,  31506.48437500,  2731.77905273,
   //               -20272.41992188,  53550.01953125, -85441.62500000,
   //               -33418.07031250
-  VLOAD_32(v6, 0x47b6ec94, 0xc6dda234, 0xc724b9ea, 0xc6a703e9, 0x467ed187,
+  VLOAD_32(v8, 0x47b6ec94, 0xc6dda234, 0xc724b9ea, 0xc6a703e9, 0x467ed187,
            0x477c05d8, 0xc642d6de, 0xc7966144, 0xc70397d6, 0xc7a41346,
            0x46f624f8, 0x452abc77, 0xc69e60d7, 0x47512e05, 0xc7a6e0d0,
            0xc7028a12);
@@ -161,13 +161,13 @@ void TEST_CASE2(void) {
   //               58906.1301468654128257, -84146.7844421620393405,
   //               -23969.5482366856886074,  92255.7186088700836990,
   //               -35519.3091108352309675, -65623.9480113173485734
-  VLOAD_64(v8, 0x40cd6718fdfdcea0, 0xc0e3104c8d763c4c, 0xc0f46625a9c52662,
+  VLOAD_64(v16, 0x40cd6718fdfdcea0, 0xc0e3104c8d763c4c, 0xc0f46625a9c52662,
            0x40e1797d8df4a4ac, 0xc0e0f368e8fd81b0, 0x40e1851120d4d47c,
            0xc0e99a3f0b1a1b69, 0xc0e3efea13a0e433, 0xc0abe35c94436520,
            0x40f2cda2435b507a, 0x40ecc3442a29c254, 0xc0f48b2c8d133979,
            0xc0d76863164f52e0, 0x40f685fb7f6c03ba, 0xc0e157e9e43c6805,
            0xc0f0057f2b0dea44);
-  asm volatile("vfwmsac.vv v8, v4, v6, v0.t");
+  asm volatile("vfwmsac.vv v16, v4, v8, v0.t");
   //               15054.1952512034331448,  1322754608.4847974777221680,
   //               -83554.3539477824524511,  929092728.6666160821914673,
   //               -34715.2784411938628182,  2430454370.8635458946228027,
@@ -176,7 +176,7 @@ void TEST_CASE2(void) {
   //               58906.1301468654128257,  78362512.5631930530071259,
   //               -23969.5482366856886074,  3779577314.6337165832519531,
   //               -35519.3091108352309675, -1452948809.7560596466064453
-  VCMP_U64(4, v8, 0x40cd6718fdfdcea0, 0x41d3b5e88c1f06ec, 0xc0f46625a9c52662,
+  VCMP_U64(4, v16, 0x40cd6718fdfdcea0, 0x41d3b5e88c1f06ec, 0xc0f46625a9c52662,
            0x41cbb06a3c5553ad, 0xc0e0f368e8fd81b0, 0x41e21bb94c5ba22b,
            0xc0e99a3f0b1a1b69, 0xc1e31930221fab5f, 0xc0abe35c94436520,
            0x41e11d15572a5b49, 0x40ecc3442a29c254, 0x4192aede4240b5ae,
@@ -187,7 +187,7 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //               8.1562,  2.6836,  56.7188,  38.4688,  33.8125,
   //               -83.0625,  37.7812, -28.0938, -33.0625,  61.1562,  13.0859,
@@ -201,23 +201,23 @@ void TEST_CASE3(void) {
   //               -6.17113161,  55.22229004,  7.96844339, -92.84493256,
   //               -90.90106201,  78.59468842, -58.67407608,  39.90958405,
   //               -93.58789825
-  VLOAD_32(v8, 0x4262adf8, 0x426f58b7, 0xc10361a2, 0xc199626a, 0xc2bab748,
+  VLOAD_32(v16, 0x4262adf8, 0x426f58b7, 0xc10361a2, 0xc199626a, 0xc2bab748,
            0xc2090508, 0x423bfb61, 0xc0c579e9, 0x425ce3a0, 0x40fefd7d,
            0xc2b9b09b, 0xc2b5cd58, 0x429d307b, 0xc26ab241, 0x421fa36a,
            0xc2bb2d01);
-  asm volatile("vfwmsac.vf v8, %[A], v4" ::[A] "f"(fscalar_16));
+  asm volatile("vfwmsac.vf v16, %[A], v4" ::[A] "f"(fscalar_16));
   //               268.05081177,  47.00394058,  2266.32666016,  1550.71020508,
   //               1439.51806641, -3272.67089844,  1457.17053223,
   //               -1112.31127930, -1371.52307129,  2426.81469727, 613.82879639,
   //               -3114.00512695,  3039.22167969, -1456.68920898,
   //               1156.95373535, -3036.66992188
-  VCMP_U32(5, v8, 0x43860681, 0x423c0409, 0x450da53a, 0x44c1d6ba, 0x44b3f094,
+  VCMP_U32(5, v16, 0x43860681, 0x423c0409, 0x450da53a, 0x44c1d6ba, 0x44b3f094,
            0xc54c8abc, 0x44b62575, 0xc48b09f6, 0xc4ab70bd, 0x4517ad09,
            0x4419750b, 0xc542a015, 0x453df38c, 0xc4b6160e, 0x44909e85,
            0xc53dcab8);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //               580253.06250000, -300331.93750000,  485801.21875000,
   //               -751037.87500000, -360868.65625000,  893035.68750000,
@@ -239,13 +239,13 @@ void TEST_CASE3(void) {
   //               -520724.0386287728324533, -616193.5881990450434387,
   //               79952.4583538805600256, -869849.3916852036491036,
   //               535808.2751473840326071, -306070.6657954099355265
-  VLOAD_64(v8, 0x4121ac782445c8ae, 0x411fd06534e7065c, 0x411902cc1eee8218,
+  VLOAD_64(v16, 0x4121ac782445c8ae, 0x411fd06534e7065c, 0x411902cc1eee8218,
            0x411bc45dc1f5fbb4, 0xc1238e7e27bbe00c, 0x4110059bbe7ba1fc,
            0xc1001eedcb11c418, 0xc11ff065b604bcf3, 0x41284fb7e8343a7c,
            0x4104ded328699cd0, 0xc11fc850278e4d10, 0xc122ce032d286cdc,
            0x40f38507556ae0f0, 0xc12a8bb2c88af688, 0x41205a008ce01e30,
            0xc112ae5aa9c6459e);
-  asm volatile("vfwmsac.vf v8, %[A], v4" ::[A] "f"(fscalar_32));
+  asm volatile("vfwmsac.vf v16, %[A], v4" ::[A] "f"(fscalar_32));
   //               389346650932.4642944335937500,
   //               -201521918580.8290100097656250,
   //               325970052259.3115844726562500,
@@ -259,7 +259,7 @@ void TEST_CASE3(void) {
   //               -622875321499.4388427734375000,
   //               201786282974.1514587402343750,
   //               -432857718253.1149902343750000,  68797853286.6418762207031250
-  VCMP_U64(6, v8, 0x4256a9b79acd1db7, 0xc24775d2393a6a1d, 0x4252f9551128d3f1,
+  VCMP_U64(6, v16, 0x4256a9b79acd1db7, 0xc24775d2393a6a1d, 0x4252f9551128d3f1,
            0xc25d555807b2779f, 0xc24c305a5e770151, 0x4261708ea338766c,
            0x425522df13d3d659, 0x42504fa86f178920, 0xc26239cb6e8c51e3,
            0xc25edba5e2f2ddc3, 0x42536932b980cb59, 0x4251c60c36a04a85,
@@ -270,7 +270,7 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //                8.1562,  2.6836,  56.7188,  38.4688,  33.8125,
   //                -83.0625,  37.7812, -28.0938, -33.0625,  61.1562,  13.0859,
@@ -285,23 +285,23 @@ void TEST_CASE4(void) {
   //                -6.17113161,  55.22229004,  7.96844339, -92.84493256,
   //                -90.90106201,  78.59468842, -58.67407608,  39.90958405,
   //                -93.58789825
-  VLOAD_32(v8, 0x4262adf8, 0x426f58b7, 0xc10361a2, 0xc199626a, 0xc2bab748,
+  VLOAD_32(v16, 0x4262adf8, 0x426f58b7, 0xc10361a2, 0xc199626a, 0xc2bab748,
            0xc2090508, 0x423bfb61, 0xc0c579e9, 0x425ce3a0, 0x40fefd7d,
            0xc2b9b09b, 0xc2b5cd58, 0x429d307b, 0xc26ab241, 0x421fa36a,
            0xc2bb2d01);
-  asm volatile("vfwmsac.vf v8, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
+  asm volatile("vfwmsac.vf v16, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
   //                56.66989136,  47.00394058, -8.21133614,  1550.71020508,
   //                -93.35797119, -3272.67089844,  46.99548721,
   //                -1112.31127930,  55.22229004,  2426.81469727, -92.84493256,
   //                -3114.00512695,  78.59468842, -1456.68920898,  39.90958405,
   //                -3036.66992188
-  VCMP_U32(7, v8, 0x4262adf8, 0x423c0409, 0xc10361a2, 0x44c1d6ba, 0xc2bab748,
+  VCMP_U32(7, v16, 0x4262adf8, 0x423c0409, 0xc10361a2, 0x44c1d6ba, 0xc2bab748,
            0xc54c8abc, 0x423bfb61, 0xc48b09f6, 0x425ce3a0, 0x4517ad09,
            0xc2b9b09b, 0xc542a015, 0x429d307b, 0xc4b6160e, 0x421fa36a,
            0xc53dcab8);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //                580253.06250000, -300331.93750000,  485801.21875000,
   //                -751037.87500000, -360868.65625000,  893035.68750000,
@@ -324,13 +324,13 @@ void TEST_CASE4(void) {
   //                -520724.0386287728324533, -616193.5881990450434387,
   //                79952.4583538805600256, -869849.3916852036491036,
   //                535808.2751473840326071, -306070.6657954099355265
-  VLOAD_64(v8, 0x4121ac782445c8ae, 0x411fd06534e7065c, 0x411902cc1eee8218,
+  VLOAD_64(v16, 0x4121ac782445c8ae, 0x411fd06534e7065c, 0x411902cc1eee8218,
            0x411bc45dc1f5fbb4, 0xc1238e7e27bbe00c, 0x4110059bbe7ba1fc,
            0xc1001eedcb11c418, 0xc11ff065b604bcf3, 0x41284fb7e8343a7c,
            0x4104ded328699cd0, 0xc11fc850278e4d10, 0xc122ce032d286cdc,
            0x40f38507556ae0f0, 0xc12a8bb2c88af688, 0x41205a008ce01e30,
            0xc112ae5aa9c6459e);
-  asm volatile("vfwmsac.vf v8, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
+  asm volatile("vfwmsac.vf v16, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
   //                579132.0708449089433998, -201521918580.8290100097656250,
   //                409779.0302067114971578, -503943536329.8690795898437500,
   //                -640831.0776052488945425,  599222720963.7006835937500000,
@@ -339,7 +339,7 @@ void TEST_CASE4(void) {
   //                -520724.0386287728324533,  305348532865.1643676757812500,
   //                79952.4583538805600256,  201786282974.1514587402343750,
   //                535808.2751473840326071,  68797853286.6418762207031250
-  VCMP_U64(8, v8, 0x4121ac782445c8ae, 0xc24775d2393a6a1d, 0x411902cc1eee8218,
+  VCMP_U64(8, v16, 0x4121ac782445c8ae, 0xc24775d2393a6a1d, 0x411902cc1eee8218,
            0xc25d555807b2779f, 0xc1238e7e27bbe00c, 0x4261708ea338766c,
            0xc1001eedcb11c418, 0x42504fa86f178920, 0x41284fb7e8343a7c,
            0xc25edba5e2f2ddc3, 0xc11fc850278e4d10, 0x4251c60c36a04a85,
diff --git a/sw/riscvTests/isa/rv64uv/vfwmul.c b/sw/riscvTests/isa/rv64uv/vfwmul.c
index 83bedd38..3ea2f5d9 100644
--- a/sw/riscvTests/isa/rv64uv/vfwmul.c
+++ b/sw/riscvTests/isa/rv64uv/vfwmul.c
@@ -11,7 +11,7 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //              -56.5312,  95.3750,  86.3750, -33.4375,  4.7656,  58.8438,
   //              -80.4375, -96.4375,  74.3750, -92.7500, -57.2812, -90.0625,
   //              -93.2500,  40.6875, -32.2812, -36.8125
@@ -21,20 +21,20 @@ void TEST_CASE1(void) {
   //               -5.9180,  32.8750,  32.8750, -74.8125,
   //               -10.3750,  39.5938,  43.2812,  15.0547, -31.9062,
   //               -11.2500,  16.3594,  28.6094
-  VLOAD_16(v6, 0x5607, 0xd62d, 0xd224, 0xd4ee, 0xc5eb, 0x501c, 0x501c, 0xd4ad,
+  VLOAD_16(v8, 0x5607, 0xd62d, 0xd224, 0xd4ee, 0xc5eb, 0x501c, 0x501c, 0xd4ad,
            0xc930, 0x50f3, 0x5169, 0x4b87, 0xcffa, 0xc9a0, 0x4c17, 0x4f27);
-  asm volatile("vfwmul.vv v8, v4, v6");
+  asm volatile("vfwmul.vv v16, v4, v8");
   //              -5451.73242188, -9424.24218750, -4243.17187500, 2637.38281250,
   //              -28.20281982,  1934.48828125, -2644.38281250,  7214.73046875,
   //              -771.64062500, -3672.32031250, -2479.20410156, -1355.86279297,
   //              2975.25781250, -457.73437500, -528.10107422, -1053.18261719
-  VCMP_U32(1, v8, 0xc5aa5ddc, 0xc61340f8, 0xc5849960, 0x4524d620, 0xc1e19f60,
+  VCMP_U32(1, v16, 0xc5aa5ddc, 0xc61340f8, 0xc5849960, 0x4524d620, 0xc1e19f60,
            0x44f1cfa0, 0xc5254620, 0x45e175d8, 0xc440e900, 0xc5658520,
            0xc51af344, 0xc4a97b9c, 0x4539f420, 0xc3e4de00, 0xc4040678,
            0xc483a5d8);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //              -89875.40625000,  87678.49218750, -37342.58593750,
   //              -47507.81640625, -80717.72656250,  2230.02978516,
   //              -68805.99218750,  79032.60156250, -43338.95703125,
@@ -51,11 +51,11 @@ void TEST_CASE1(void) {
   //               85817.48437500, -23627.74023438, -79522.11718750,
   //               51590.63671875,  7574.55957031, -93117.57812500,
   //               28056.31054688
-  VLOAD_32(v6, 0x47c29733, 0x4710d4bc, 0xc7812302, 0xc7c2faed, 0xc79a0fe0,
+  VLOAD_32(v8, 0x47c29733, 0x4710d4bc, 0xc7812302, 0xc7c2faed, 0xc79a0fe0,
            0x4793b8ee, 0xc7b0e214, 0xc7a556be, 0x470746cf, 0x47a79cbe,
            0xc6b8977b, 0xc79b510f, 0x474986a3, 0x45ecb47a, 0xc7b5deca,
            0x46db309f);
-  asm volatile("vfwmul.vv v8, v4, v6");
+  asm volatile("vfwmul.vv v16, v4, v8");
   //              -8954322534.4196777343750000,  3250832165.2364501953125000,
   //              2469017680.4935302734375000,  4742698259.8944396972656250,
   //              6366994091.8183593750000000,  168665759.1725692749023438,
@@ -64,7 +64,7 @@ void TEST_CASE1(void) {
   //              152328975.7866010665893555, -2031330201.5839996337890625,
   //              306722104.6965751647949219, -359104602.5425643920898438,
   //              4042715658.8806152343750000,  2599960105.6150360107421875
-  VCMP_U64(2, v8, 0xc200adc0f3335b80, 0x41e8387864a79100, 0x41e265470a0fcb00,
+  VCMP_U64(2, v16, 0xc200adc0f3335b80, 0x41e8387864a79100, 0x41e265470a0fcb00,
            0x41f1aafd513e4fa0, 0x41f7b809eabd1800, 0x41a41b453e585b00,
            0x41f736af4d367b00, 0xc1f8ec72ccd7c980, 0xc1d65d56a56686c0,
            0x41eb03cc41e5e700, 0x41a228b61f92bd60, 0xc1de44e8e6656040,
@@ -76,7 +76,7 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //              -56.5312,  95.3750,  86.3750, -33.4375,  4.7656,  58.8438,
   //              -80.4375, -96.4375,  74.3750, -92.7500, -57.2812, -90.0625,
   //              -93.2500,  40.6875, -32.2812, -36.8125
@@ -86,21 +86,21 @@ void TEST_CASE2(void) {
   //               -5.9180,  32.8750,  32.8750, -74.8125,
   //               -10.3750,  39.5938,  43.2812,  15.0547, -31.9062,
   //               -11.2500,  16.3594,  28.6094
-  VLOAD_16(v6, 0x5607, 0xd62d, 0xd224, 0xd4ee, 0xc5eb, 0x501c, 0x501c, 0xd4ad,
+  VLOAD_16(v8, 0x5607, 0xd62d, 0xd224, 0xd4ee, 0xc5eb, 0x501c, 0x501c, 0xd4ad,
            0xc930, 0x50f3, 0x5169, 0x4b87, 0xcffa, 0xc9a0, 0x4c17, 0x4f27);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwmul.vv v8, v4, v6, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfwmul.vv v16, v4, v8, v0.t");
   //               0.00000000, -9424.24218750,  0.00000000,  2637.38281250,
   //               0.00000000,  1934.48828125,  0.00000000,  7214.73046875,
   //               0.00000000, -3672.32031250,  0.00000000, -1355.86279297,
   //               0.00000000, -457.73437500,  0.00000000, -1053.18261719
-  VCMP_U32(3, v8, 0x0, 0xc61340f8, 0x0, 0x4524d620, 0x0, 0x44f1cfa0, 0x0,
+  VCMP_U32(3, v16, 0x0, 0xc61340f8, 0x0, 0x4524d620, 0x0, 0x44f1cfa0, 0x0,
            0x45e175d8, 0x0, 0xc5658520, 0x0, 0xc4a97b9c, 0x0, 0xc3e4de00, 0x0,
            0xc483a5d8);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //              -89875.40625000,  87678.49218750, -37342.58593750,
   //              -47507.81640625, -80717.72656250,  2230.02978516,
   //              -68805.99218750,  79032.60156250, -43338.95703125,
@@ -117,13 +117,13 @@ void TEST_CASE2(void) {
   //               85817.48437500, -23627.74023438, -79522.11718750,
   //               51590.63671875,  7574.55957031, -93117.57812500,
   //               28056.31054688
-  VLOAD_32(v6, 0x47c29733, 0x4710d4bc, 0xc7812302, 0xc7c2faed, 0xc79a0fe0,
+  VLOAD_32(v8, 0x47c29733, 0x4710d4bc, 0xc7812302, 0xc7c2faed, 0xc79a0fe0,
            0x4793b8ee, 0xc7b0e214, 0xc7a556be, 0x470746cf, 0x47a79cbe,
            0xc6b8977b, 0xc79b510f, 0x474986a3, 0x45ecb47a, 0xc7b5deca,
            0x46db309f);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwmul.vv v8, v4, v6, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfwmul.vv v16, v4, v8, v0.t");
   //               0.0000000000000000,  3250832165.2364501953125000,
   //               0.0000000000000000,  4742698259.8944396972656250,
   //               0.0000000000000000,  168665759.1725692749023438,
@@ -132,7 +132,7 @@ void TEST_CASE2(void) {
   //               0.0000000000000000, -2031330201.5839996337890625,
   //               0.0000000000000000, -359104602.5425643920898438,
   //               0.0000000000000000,  2599960105.6150360107421875
-  VCMP_U64(4, v8, 0x0, 0x41e8387864a79100, 0x0, 0x41f1aafd513e4fa0, 0x0,
+  VCMP_U64(4, v16, 0x0, 0x41e8387864a79100, 0x0, 0x41f1aafd513e4fa0, 0x0,
            0x41a41b453e585b00, 0x0, 0xc1f8ec72ccd7c980, 0x0, 0x41eb03cc41e5e700,
            0x0, 0xc1de44e8e6656040, 0x0, 0xc1b567805a8ae580, 0x0,
            0x41e35f07c533ae60);
@@ -141,7 +141,7 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //              -44.4062, -27.0781, -21.6562,  75.5625, -84.5000,
   //              -1.0713,  72.5625, -84.6250,  83.9375, -52.3438,
@@ -150,19 +150,19 @@ void TEST_CASE3(void) {
            0x553f, 0xd28b, 0xd112, 0x3e9c, 0x54fb, 0xd089, 0x5033, 0xd487);
   //                             -58.9688
   BOX_HALF_IN_FLOAT(fscalar_16, 0xd35f);
-  asm volatile("vfwmul.vf v8, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfwmul.vf v16, v4, %[A]" ::[A] "f"(fscalar_16));
   //               2618.58105469,  1596.76318359,  1277.04199219,
   //               -4455.82617188,  4982.85937500,  63.17257690, -4278.91992188,
   //               4990.23046875, -4949.68945312,  3086.64550781, 2391.91992188,
   //               -97.43664551, -4699.07226562,  2139.45996094, -1980.98144531,
   //               4271.54882812
-  VCMP_U32(5, v8, 0x4523a94c, 0x44c7986c, 0x449fa158, 0xc58b3e9c, 0x459bb6e0,
+  VCMP_U32(5, v16, 0x4523a94c, 0x44c7986c, 0x449fa158, 0xc58b3e9c, 0x459bb6e0,
            0x427cb0b8, 0xc585b75c, 0x459bf1d8, 0xc59aad84, 0x4540ea54,
            0x45157eb8, 0xc2c2df90, 0xc592d894, 0x4505b75c, 0xc4f79f68,
            0x45857c64);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //              -187018.20312500, -714032.18750000, -891429.25000000,
   //              -378265.00000000,  211566.90625000,  231934.78125000,
@@ -176,7 +176,7 @@ void TEST_CASE3(void) {
            0x495f02eb);
   //                              -50557.21484375
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xc7457d37);
-  asm volatile("vfwmul.vf v8, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfwmul.vf v16, v4, %[A]" ::[A] "f"(fscalar_32));
   //               9455119475.0827026367187500,  36099478708.7902832031250000,
   //               45068180110.2529296875000000,  19124024872.8710937500000000,
   //               -10696233533.1087646484375000, -11725976565.3944091796875000,
@@ -185,7 +185,7 @@ void TEST_CASE3(void) {
   //               41326042501.6000976562500000,  26399370819.9219970703125000,
   //               33773309655.5700683593750000, -37618062611.2260742187500000,
   //               31363405215.2648925781250000, -46181724885.9680175781250000
-  VCMP_U64(6, v8, 0x42019c8d6398a960, 0x4220cf64a96994a0, 0x4224fc8bb51c8180,
+  VCMP_U64(6, v16, 0x42019c8d6398a960, 0x4220cf64a96994a0, 0x4224fc8bb51c8180,
            0x4211cf85d8a37c00, 0xc203ec5c91e8dec0, 0xc205d7619fab27c0,
            0xc2264bc096681480, 0x4206c8b43b6a45c0, 0x42170e3d0f7f7d00,
            0x42228d33006859a0, 0x42233e72bb0b3340, 0x42189619b90fb020,
@@ -196,7 +196,7 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //               -44.4062, -27.0781, -21.6562,  75.5625, -84.5000,
   //               -1.0713,  72.5625, -84.6250,  83.9375, -52.3438,
@@ -206,18 +206,18 @@ void TEST_CASE4(void) {
   //                             -58.9688
   BOX_HALF_IN_FLOAT(fscalar_16, 0xd35f);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwmul.vf v8, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v16);
+  asm volatile("vfwmul.vf v16, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.00000000,  1596.76318359,  0.00000000, -4455.82617188,
   //                0.00000000,  63.17257690,  0.00000000,  4990.23046875,
   //                0.00000000,  3086.64550781,  0.00000000, -97.43664551,
   //                0.00000000,  2139.45996094,  0.00000000,  4271.54882812
-  VCMP_U32(7, v8, 0x0, 0x44c7986c, 0x0, 0xc58b3e9c, 0x0, 0x427cb0b8, 0x0,
+  VCMP_U32(7, v16, 0x0, 0x44c7986c, 0x0, 0xc58b3e9c, 0x0, 0x427cb0b8, 0x0,
            0x459bf1d8, 0x0, 0x4540ea54, 0x0, 0xc2c2df90, 0x0, 0x4505b75c, 0x0,
            0x45857c64);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //               -187018.20312500, -714032.18750000, -891429.25000000,
   //               -378265.00000000,  211566.90625000,  231934.78125000,
@@ -232,8 +232,8 @@ void TEST_CASE4(void) {
   //                              -50557.21484375
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xc7457d37);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwmul.vf v8, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v16);
+  asm volatile("vfwmul.vf v16, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.0000000000000000,  36099478708.7902832031250000,
   //                0.0000000000000000,  19124024872.8710937500000000,
   //                0.0000000000000000, -11725976565.3944091796875000,
@@ -242,7 +242,7 @@ void TEST_CASE4(void) {
   //                0.0000000000000000,  26399370819.9219970703125000,
   //                0.0000000000000000, -37618062611.2260742187500000,
   //                0.0000000000000000, -46181724885.9680175781250000
-  VCMP_U64(8, v8, 0x0, 0x4220cf64a96994a0, 0x0, 0x4211cf85d8a37c00, 0x0,
+  VCMP_U64(8, v16, 0x0, 0x4220cf64a96994a0, 0x0, 0x4211cf85d8a37c00, 0x0,
            0xc205d7619fab27c0, 0x0, 0x4206c8b43b6a45c0, 0x0, 0x42228d33006859a0,
            0x0, 0x42189619b90fb020, 0x0, 0xc221846c2a2673c0, 0x0,
            0xc225814a65abefa0);
diff --git a/sw/riscvTests/isa/rv64uv/vfwnmacc.c b/sw/riscvTests/isa/rv64uv/vfwnmacc.c
index c91db595..981f30c9 100644
--- a/sw/riscvTests/isa/rv64uv/vfwnmacc.c
+++ b/sw/riscvTests/isa/rv64uv/vfwnmacc.c
@@ -11,7 +11,7 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //               33.9375,  31.7344, -56.0000, -62.0625,  77.6875, -7.7383,
   //               -75.3750,  4.1953,  79.5625, -87.3750,
   //               -37.2188,  90.5000,  68.0625,  69.0625,  54.0312, -64.6875
@@ -21,29 +21,29 @@ void TEST_CASE1(void) {
   //              -79.6875,  3.9375,  37.2812,  50.7812, -3.9375, -55.9688,
   //              -31.5312,  76.0000,  69.1875, -8.2578, -52.5000,
   //              -98.4375,  40.3438
-  VLOAD_16(v6, 0xd5c5, 0xd4bf, 0x4e87, 0xd4fb, 0x43e0, 0x50a9, 0x5259, 0xc3e0,
+  VLOAD_16(v8, 0xd5c5, 0xd4bf, 0x4e87, 0xd4fb, 0x43e0, 0x50a9, 0x5259, 0xc3e0,
            0xd2ff, 0xcfe2, 0x54c0, 0x5453, 0xc821, 0xd290, 0xd627, 0x510b);
   //               75.62483215,  29.19676971,  69.45310211, -70.36167145,
   //               -0.92180759, -77.84928131,  86.66299438, -43.34124756,
   //               -3.36894345,  7.33576536, -64.43717194, -80.48993683,
   //               -5.57641745,  89.34833527, -39.19780731, -55.64332581
-  VLOAD_32(v8, 0x42973fea, 0x41e992fc, 0x428ae7fd, 0xc28cb92d, 0xbf6bfb95,
+  VLOAD_32(v16, 0x42973fea, 0x41e992fc, 0x428ae7fd, 0xc28cb92d, 0xbf6bfb95,
            0xc29bb2d5, 0x42ad5374, 0xc22d5d70, 0xc0579cc5, 0x40eabe97,
            0xc280dfd5, 0xc2a0fad9, 0xc0b27203, 0x42b2b259, 0xc21cca8e,
            0xc25e92c4);
-  asm volatile("vfwnmacc.vv v8, v4, v6");
+  asm volatile("vfwnmacc.vv v16, v4, v8");
   //               3057.23071289,  2380.63232422,  1392.67187500,
   //               -4875.24365234, -304.97271729,  366.34207153,
   //               3740.97363281,  59.86029053,  4456.38281250, -2762.37866211,
   //               2893.06225586, -6180.97900391,  567.62377930,  3536.43286133,
   //               5357.89892578,  2665.37963867
-  VCMP_U32(1, v8, 0x453f13b1, 0x4514ca1e, 0x44ae1580, 0xc59859f3, 0xc3987c82,
+  VCMP_U32(1, v16, 0x453f13b1, 0x4514ca1e, 0x44ae1580, 0xc59859f3, 0xc3987c82,
            0x43b72bc9, 0x4569cf94, 0x426f70f0, 0x458b4310, 0xc52ca60f,
            0x4534d0ff, 0xc5c127d5, 0x440de7ec, 0x455d06ed, 0x45a76f31,
            0x45269613);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //               24686.12304688,  45012.43359375,  5708.16113281,
   //               -32777.98828125,  74121.31250000, -74877.15625000,
   //               -60082.02734375,  46400.20312500, -45509.65234375,
@@ -60,7 +60,7 @@ void TEST_CASE1(void) {
   //              -91567.60156250, -25929.78515625, -88250.83593750,
   //              -49992.60156250,  34217.12500000,  49765.98046875,
   //              8088.22802734
-  VLOAD_32(v6, 0xc7aa2211, 0xc5f5885c, 0xc71d75ee, 0xc797355e, 0x46e2353e,
+  VLOAD_32(v8, 0xc7aa2211, 0xc5f5885c, 0xc71d75ee, 0xc797355e, 0x46e2353e,
            0xc6ddc243, 0x47258058, 0xc6ff097f, 0x47ae7783, 0xc7b2d7cd,
            0xc6ca9392, 0xc7ac5d6b, 0xc743489a, 0x4705a920, 0x474265fb,
            0x45fcc1d3);
@@ -72,13 +72,13 @@ void TEST_CASE1(void) {
   //              21060.8546093095501419, -76483.1707763712329324,
   //              83261.7813338561973069, -99608.0446094776270911,
   //              32602.1877863906847779,  52037.0826651407405734
-  VLOAD_64(v8, 0xc0f73b7b4184cd41, 0xc0d92483139dacd4, 0xc0f5cb85138e8ec3,
+  VLOAD_64(v16, 0xc0f73b7b4184cd41, 0xc0d92483139dacd4, 0xc0f5cb85138e8ec3,
            0xc0ec05d1a74c6a5f, 0x40f7f5bfacdd39bc, 0xc0f042fad9eb5535,
            0x40f08ccc2a0135e2, 0xc0f61e1c762fe5e5, 0xc0f09d8034c5c7e1,
            0xc0e220ff29d6512c, 0x40d49136b1eb3ed8, 0xc0f2ac32bb800116,
            0x40f453dc8057edfa, 0xc0f85180b6b86d78, 0x40dfd68c04b135a8,
            0x40e968a2a5315d80);
-  asm volatile("vfwnmacc.vv v8, v4, v6");
+  asm volatile("vfwnmacc.vv v16, v4, v8");
   //               2150457244.6964006423950195,  353690458.8370813727378845,
   //               230184846.2258668541908264, -2537572977.5412845611572266,
   //               -2146252658.3886387348175049, -2125331270.8559157848358154,
@@ -87,7 +87,7 @@ void TEST_CASE1(void) {
   //               -225446839.1319110989570618,  5090653244.5816955566406250,
   //               3520603131.4329605102539062, -3112554462.7102732658386230,
   //               -804160451.3248255252838135,  734216828.7275727987289429
-  VCMP_U64(2, v8, 0x41e005abf39648ea, 0x41b514e35ad64af7, 0x41ab70af1c73a4d2,
+  VCMP_U64(2, v16, 0x41e005abf39648ea, 0x41b514e35ad64af7, 0x41ab70af1c73a4d2,
            0xc1e2e8094e315234, 0xc1dffb4ddc98df75, 0xc1dfab7ed1b6c753,
            0x41e2f72becddf8fe, 0x41d6928e17879240, 0x41ee49f691b1c6cc,
            0xc1f5d45553c90855, 0xc1aae0176e4389da, 0x41f2f6d343c94ea0,
@@ -99,7 +99,7 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //               33.9375,  31.7344, -56.0000, -62.0625,  77.6875, -7.7383,
   //               -75.3750,  4.1953,  79.5625, -87.3750,
   //               -37.2188,  90.5000,  68.0625,  69.0625,  54.0312, -64.6875
@@ -109,29 +109,29 @@ void TEST_CASE2(void) {
   //              -79.6875,  3.9375,  37.2812,  50.7812, -3.9375, -55.9688,
   //              -31.5312,  76.0000,  69.1875, -8.2578, -52.5000,
   //              -98.4375,  40.3438
-  VLOAD_16(v6, 0xd5c5, 0xd4bf, 0x4e87, 0xd4fb, 0x43e0, 0x50a9, 0x5259, 0xc3e0,
+  VLOAD_16(v8, 0xd5c5, 0xd4bf, 0x4e87, 0xd4fb, 0x43e0, 0x50a9, 0x5259, 0xc3e0,
            0xd2ff, 0xcfe2, 0x54c0, 0x5453, 0xc821, 0xd290, 0xd627, 0x510b);
   VLOAD_8(v0, 0xAA, 0xAA);
   //               75.62483215,  29.19676971,  69.45310211, -70.36167145,
   //               -0.92180759, -77.84928131,  86.66299438, -43.34124756,
   //               -3.36894345,  7.33576536, -64.43717194, -80.48993683,
   //               -5.57641745,  89.34833527, -39.19780731, -55.64332581
-  VLOAD_32(v8, 0x42973fea, 0x41e992fc, 0x428ae7fd, 0xc28cb92d, 0xbf6bfb95,
+  VLOAD_32(v16, 0x42973fea, 0x41e992fc, 0x428ae7fd, 0xc28cb92d, 0xbf6bfb95,
            0xc29bb2d5, 0x42ad5374, 0xc22d5d70, 0xc0579cc5, 0x40eabe97,
            0xc280dfd5, 0xc2a0fad9, 0xc0b27203, 0x42b2b259, 0xc21cca8e,
            0xc25e92c4);
-  asm volatile("vfwnmacc.vv v8, v4, v6, v0.t");
+  asm volatile("vfwnmacc.vv v16, v4, v8, v0.t");
   //               75.62483215,  2380.63232422,  69.45310211, -4875.24365234,
   //               -0.92180759,  366.34207153,  86.66299438,  59.86029053,
   //               -3.36894345, -2762.37866211, -64.43717194, -6180.97900391,
   //               -5.57641745,  3536.43286133, -39.19780731,  2665.37963867
-  VCMP_U32(3, v8, 0x42973fea, 0x4514ca1e, 0x428ae7fd, 0xc59859f3, 0xbf6bfb95,
+  VCMP_U32(3, v16, 0x42973fea, 0x4514ca1e, 0x428ae7fd, 0xc59859f3, 0xbf6bfb95,
            0x43b72bc9, 0x42ad5374, 0x426f70f0, 0xc0579cc5, 0xc52ca60f,
            0xc280dfd5, 0xc5c127d5, 0xc0b27203, 0x455d06ed, 0xc21cca8e,
            0x45269613);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //               24686.12304688,  45012.43359375,  5708.16113281,
   //               -32777.98828125,  74121.31250000, -74877.15625000,
   //               -60082.02734375,  46400.20312500, -45509.65234375,
@@ -148,7 +148,7 @@ void TEST_CASE2(void) {
   //              -91567.60156250, -25929.78515625, -88250.83593750,
   //              -49992.60156250,  34217.12500000,  49765.98046875,
   //              8088.22802734
-  VLOAD_32(v6, 0xc7aa2211, 0xc5f5885c, 0xc71d75ee, 0xc797355e, 0x46e2353e,
+  VLOAD_32(v8, 0xc7aa2211, 0xc5f5885c, 0xc71d75ee, 0xc797355e, 0x46e2353e,
            0xc6ddc243, 0x47258058, 0xc6ff097f, 0x47ae7783, 0xc7b2d7cd,
            0xc6ca9392, 0xc7ac5d6b, 0xc743489a, 0x4705a920, 0x474265fb,
            0x45fcc1d3);
@@ -161,13 +161,13 @@ void TEST_CASE2(void) {
   //              21060.8546093095501419, -76483.1707763712329324,
   //              83261.7813338561973069, -99608.0446094776270911,
   //              32602.1877863906847779,  52037.0826651407405734
-  VLOAD_64(v8, 0xc0f73b7b4184cd41, 0xc0d92483139dacd4, 0xc0f5cb85138e8ec3,
+  VLOAD_64(v16, 0xc0f73b7b4184cd41, 0xc0d92483139dacd4, 0xc0f5cb85138e8ec3,
            0xc0ec05d1a74c6a5f, 0x40f7f5bfacdd39bc, 0xc0f042fad9eb5535,
            0x40f08ccc2a0135e2, 0xc0f61e1c762fe5e5, 0xc0f09d8034c5c7e1,
            0xc0e220ff29d6512c, 0x40d49136b1eb3ed8, 0xc0f2ac32bb800116,
            0x40f453dc8057edfa, 0xc0f85180b6b86d78, 0x40dfd68c04b135a8,
            0x40e968a2a5315d80);
-  asm volatile("vfwnmacc.vv v8, v4, v6, v0.t");
+  asm volatile("vfwnmacc.vv v16, v4, v8, v0.t");
   //              -95159.7034957902651513,  353690458.8370813727378845,
   //              -89272.3172746254567755, -2537572977.5412845611572266,
   //              98139.9797031646012329, -2125331270.8559157848358154,
@@ -176,7 +176,7 @@ void TEST_CASE2(void) {
   //              21060.8546093095501419,  5090653244.5816955566406250,
   //              83261.7813338561973069, -3112554462.7102732658386230,
   //              32602.1877863906847779,  734216828.7275727987289429
-  VCMP_U64(4, v8, 0xc0f73b7b4184cd41, 0x41b514e35ad64af7, 0xc0f5cb85138e8ec3,
+  VCMP_U64(4, v16, 0xc0f73b7b4184cd41, 0x41b514e35ad64af7, 0xc0f5cb85138e8ec3,
            0xc1e2e8094e315234, 0x40f7f5bfacdd39bc, 0xc1dfab7ed1b6c753,
            0x40f08ccc2a0135e2, 0x41d6928e17879240, 0xc0f09d8034c5c7e1,
            0xc1f5d45553c90855, 0x40d49136b1eb3ed8, 0x41f2f6d343c94ea0,
@@ -187,7 +187,7 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //               85.2500, -7.6602, -81.8125, -37.2500,
   //               -48.0000,  14.9531,  25.9844,  96.1875,  46.5000,
@@ -202,23 +202,23 @@ void TEST_CASE3(void) {
   //               -82.18785095,  3.87765026, -34.03960037,
   //               -92.34690857,  46.98464203,  28.09385681,  58.44809723,  57.04935455,
   //               -44.62148285,  83.52678680
-  VLOAD_32(v8, 0x40c62ff4, 0xc2a28694, 0xc29b7f46, 0x41761cdd, 0x41daf76d,
+  VLOAD_32(v16, 0x40c62ff4, 0xc2a28694, 0xc29b7f46, 0x41761cdd, 0x41daf76d,
            0x42433e74, 0xc2a4602e, 0x40782b6c, 0xc208288d, 0xc2b8b19e,
            0x423bf046, 0x41e0c038, 0x4269cada, 0x4264328a, 0xc2327c66,
            0x42a70db7);
-  asm volatile("vfwnmacc.vf v8, %[A], v4" ::[A] "f"(fscalar_16));
+  asm volatile("vfwnmacc.vf v16, %[A], v4" ::[A] "f"(fscalar_16));
   //               4080.47851562, -285.94589233, -3844.13818359, -1801.05395508,
   //               -2328.37084961,  668.00445557,  1327.81384277, 4607.11083984,
   //               2263.13330078, -3619.81323242,  2135.66967773,
   //               -3323.79687500,  2762.37426758, -3439.63916016,
   //               -2157.50732422, -4421.87060547
-  VCMP_U32(5, v8, 0x457f07a8, 0xc38ef913, 0xc5704236, 0xc4e121ba, 0xc51185ef,
+  VCMP_U32(5, v16, 0x457f07a8, 0xc38ef913, 0xc5704236, 0xc4e121ba, 0xc51185ef,
            0x44270049, 0x44a5fa0b, 0x458ff8e3, 0x450d7222, 0xc5623d03,
            0x45057ab7, 0xc54fbcc0, 0x452ca5fd, 0xc556fa3a, 0xc506d81e,
            0xc58a2ef7);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //               415907.75000000,  16644.92773438, -320087.15625000,
   //               -560497.81250000,  51200.66406250,  175961.67187500,
@@ -240,13 +240,13 @@ void TEST_CASE3(void) {
   //              97767.4262132318690419, -208046.9794710964197293,
   //              -303699.6372622016351670, -710697.5104083393234760,
   //              -907884.7086961114546284, -326406.2730544115183875
-  VLOAD_64(v8, 0xc0ad62e3ae9e7200, 0x410ea4eb56509b38, 0xc129662b849df069,
+  VLOAD_64(v16, 0xc0ad62e3ae9e7200, 0x410ea4eb56509b38, 0xc129662b849df069,
            0xc128f6256c256024, 0xc1238e5bb5417d8a, 0xc0f54479c1acb530,
            0xc126db6acbf67002, 0x410fabde5f5c7320, 0xc11ca2b22fd69018,
            0xc109032e93c94df0, 0x40f7de76d1c4f740, 0xc1096577d5f4f134,
            0xc112894e8c8e766c, 0xc125b05305543dea, 0xc12bb4d96ada377b,
            0xc113ec19179b935e);
-  asm volatile("vfwnmacc.vf v8, %[A], v4" ::[A] "f"(fscalar_32));
+  asm volatile("vfwnmacc.vf v16, %[A], v4" ::[A] "f"(fscalar_32));
   //               269632972092.2103271484375000,  10790654572.4701824188232422,
   //               -207511651113.6687316894531250,
   //               -363369878873.9254760742187500, 33194028125.5312614440917969,
@@ -257,7 +257,7 @@ void TEST_CASE3(void) {
   //               -31275968950.3095932006835938, 444146336412.5474243164062500,
   //               176955637312.9947814941406250, 335876029304.3336791992187500,
   //               -226662309098.3402404785156250
-  VCMP_U64(6, v8, 0x424f63b0529e1aec, 0x420419629363c2ef, 0xc24828544194d599,
+  VCMP_U64(6, v16, 0x424f63b0529e1aec, 0x420419629363c2ef, 0xc24828544194d599,
            0xc25526a215567b3b, 0x421eea12b1762003, 0x423a8f760c56915b,
            0xc222cc8c6659986a, 0xc2183b8b6ce755ee, 0x4224852ec0739f2b,
            0x425f6a693fc0285e, 0xc24514c310654d4e, 0xc21d20c5a6d93d06,
@@ -268,7 +268,7 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //                85.2500, -7.6602, -81.8125, -37.2500,
   //                -48.0000,  14.9531,  25.9844,  96.1875,  46.5000,
@@ -284,23 +284,23 @@ void TEST_CASE4(void) {
   //                -82.18785095,  3.87765026, -34.03960037,
   //                -92.34690857,  46.98464203,  28.09385681,  58.44809723,  57.04935455,
   //                -44.62148285,  83.52678680
-  VLOAD_32(v8, 0x40c62ff4, 0xc2a28694, 0xc29b7f46, 0x41761cdd, 0x41daf76d,
+  VLOAD_32(v16, 0x40c62ff4, 0xc2a28694, 0xc29b7f46, 0x41761cdd, 0x41daf76d,
            0x42433e74, 0xc2a4602e, 0x40782b6c, 0xc208288d, 0xc2b8b19e,
            0x423bf046, 0x41e0c038, 0x4269cada, 0x4264328a, 0xc2327c66,
            0x42a70db7);
-  asm volatile("vfwnmacc.vf v8, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
+  asm volatile("vfwnmacc.vf v16, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
   //                6.19335365, -285.94589233, -77.74858093,
   //                -1801.05395508,  27.37081337,  668.00445557, -82.18785095,
   //                4607.11083984, -34.03960037, -3619.81323242,  46.98464203,
   //                -3323.79687500,  58.44809723, -3439.63916016, -44.62148285,
   //                -4421.87060547
-  VCMP_U32(7, v8, 0x40c62ff4, 0xc38ef913, 0xc29b7f46, 0xc4e121ba, 0x41daf76d,
+  VCMP_U32(7, v16, 0x40c62ff4, 0xc38ef913, 0xc29b7f46, 0xc4e121ba, 0x41daf76d,
            0x44270049, 0xc2a4602e, 0x458ff8e3, 0xc208288d, 0xc5623d03,
            0x423bf046, 0xc54fbcc0, 0x4269cada, 0xc556fa3a, 0xc2327c66,
            0xc58a2ef7);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //                415907.75000000,  16644.92773438, -320087.15625000,
   //                -560497.81250000,  51200.66406250,  175961.67187500,
@@ -323,13 +323,13 @@ void TEST_CASE4(void) {
   //               97767.4262132318690419, -208046.9794710964197293,
   //               -303699.6372622016351670, -710697.5104083393234760,
   //               -907884.7086961114546284, -326406.2730544115183875
-  VLOAD_64(v8, 0xc0ad62e3ae9e7200, 0x410ea4eb56509b38, 0xc129662b849df069,
+  VLOAD_64(v16, 0xc0ad62e3ae9e7200, 0x410ea4eb56509b38, 0xc129662b849df069,
            0xc128f6256c256024, 0xc1238e5bb5417d8a, 0xc0f54479c1acb530,
            0xc126db6acbf67002, 0x410fabde5f5c7320, 0xc11ca2b22fd69018,
            0xc109032e93c94df0, 0x40f7de76d1c4f740, 0xc1096577d5f4f134,
            0xc112894e8c8e766c, 0xc125b05305543dea, 0xc12bb4d96ada377b,
            0xc113ec19179b935e);
-  asm volatile("vfwnmacc.vf v8, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
+  asm volatile("vfwnmacc.vf v16, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
   //               -3761.4446916116867214,  10790654572.4701824188232422,
   //               -832277.7590174797223881, -363369878873.9254760742187500,
   //               -640813.8540152770001441,  114076027990.5677947998046875,
@@ -338,7 +338,7 @@ void TEST_CASE4(void) {
   //               97767.4262132318690419, -31275968950.3095932006835938,
   //               -303699.6372622016351670,  176955637312.9947814941406250,
   //               -907884.7086961114546284, -226662309098.3402404785156250
-  VCMP_U64(8, v8, 0xc0ad62e3ae9e7200, 0x420419629363c2ef, 0xc129662b849df069,
+  VCMP_U64(8, v16, 0xc0ad62e3ae9e7200, 0x420419629363c2ef, 0xc129662b849df069,
            0xc25526a215567b3b, 0xc1238e5bb5417d8a, 0x423a8f760c56915b,
            0xc126db6acbf67002, 0xc2183b8b6ce755ee, 0xc11ca2b22fd69018,
            0x425f6a693fc0285e, 0x40f7de76d1c4f740, 0xc21d20c5a6d93d06,
diff --git a/sw/riscvTests/isa/rv64uv/vfwnmsac.c b/sw/riscvTests/isa/rv64uv/vfwnmsac.c
index c35d1863..7eccfc2e 100644
--- a/sw/riscvTests/isa/rv64uv/vfwnmsac.c
+++ b/sw/riscvTests/isa/rv64uv/vfwnmsac.c
@@ -11,7 +11,7 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //              -27.1719,  16.3438, -76.1250,  73.7500,  39.2500,  32.8438,
   //              -48.0312, -62.9062, -52.3125,  50.8750, -32.1562, -86.3750,
   //              -42.7812,  97.2500, -83.6250,  46.6250
@@ -21,29 +21,29 @@ void TEST_CASE1(void) {
   //              -78.0625,  13.7344,  6.3164,  19.1250,  23.3125,  72.4375,
   //              -53.2812, -16.3438, -95.0625, -96.2500,  10.4141,
   //              -44.4688,  42.5938
-  VLOAD_16(v6, 0xcc8b, 0xd1d1, 0xd48c, 0xd4e1, 0x4ade, 0x4651, 0x4cc8, 0x4dd4,
+  VLOAD_16(v8, 0xcc8b, 0xd1d1, 0xd48c, 0xd4e1, 0x4ade, 0x4651, 0x4cc8, 0x4dd4,
            0x5487, 0xd2a9, 0xcc16, 0xd5f1, 0xd604, 0x4935, 0xd18f, 0x5153);
   //               69.72727966,  14.41778183,
   //               -64.82620239,  5.66590357,  73.33881378,
   //               -23.97786140,  94.91672516,  17.38204765, -39.07393646,
   //               -50.71182251, -11.98221493, -36.07648849,
   //               -86.86090088,  55.96418381,  61.43484116, -88.02533722
-  VLOAD_32(v8, 0x428b745e, 0x4166af3c, 0xc281a704, 0x40b54f15, 0x4292ad79,
+  VLOAD_32(v16, 0x428b745e, 0x4166af3c, 0xc281a704, 0x40b54f15, 0x4292ad79,
            0xc1bfd2a9, 0x42bdd55d, 0x418b0e6f, 0xc21c4bb6, 0xc24ad8e8,
            0xc13fb727, 0xc2104e53, 0xc2adb8c8, 0x425fdb53, 0x4275bd47,
            0xc2b00cf9);
-  asm volatile("vfwnmsac.vv v8, v4, v6");
+  asm volatile("vfwnmsac.vv v16, v4, v8");
   //              -424.03662109,  774.91290283, -5602.91992188,  5762.77539062,
   //              -465.73541260, -231.43232727,  1013.51440430,  1483.88403320,
   //              3750.31274414,  2659.97167969, -537.53594971, -8247.09960938,
   //              -4204.55615234, -956.80340576, -3657.26440430, -2073.95898438
-  VCMP_U32(1, v8, 0xc3d404b0, 0x4441ba6d, 0xc5af175c, 0x45b41634, 0xc3e8de22,
+  VCMP_U32(1, v16, 0xc3d404b0, 0x4441ba6d, 0xc5af175c, 0x45b41634, 0xc3e8de22,
            0xc3676ead, 0x447d60ec, 0x44b97c4a, 0x456a6501, 0x45263f8c,
            0xc406624d, 0xc600dc66, 0xc5836473, 0xc46f336b, 0xc564943b,
            0xc5019f58);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //               76109.13281250,  56176.41406250, -69127.14843750,
   //               -80327.49218750,  42920.59375000, -22857.18164062,
   //               -74227.70312500, -2650.23828125,  34254.71093750,
@@ -59,7 +59,7 @@ void TEST_CASE1(void) {
   //              6145.43457031, -31624.23242188, -69962.68750000, 468.94165039,
   //              10443.93554688, -6054.45410156, -26090.46093750,
   //              83534.57031250,  49878.42968750, -62082.53125000
-  VLOAD_32(v6, 0xc70f0e8b, 0xc76de453, 0xc70f03b3, 0xc7915587, 0xc6ca1338,
+  VLOAD_32(v8, 0xc70f0e8b, 0xc76de453, 0xc70f03b3, 0xc7915587, 0xc6ca1338,
            0xc7832be2, 0x45c00b7a, 0xc6f71077, 0xc788a558, 0x43ea7888,
            0x46232fbe, 0xc5bd33a2, 0xc6cbd4ec, 0x47a32749, 0x4742d66e,
            0xc7728288);
@@ -71,13 +71,13 @@ void TEST_CASE1(void) {
   //               25915.8242703938303748,  82619.8738822988234460,
   //               36865.7501246419560630,  41236.4660055586136878,
   //               -5735.0030344506667461,  97965.1847665070963558
-  VLOAD_64(v8, 0x40f0f91647b040e6, 0x40f7fd7ad092e40e, 0xc0f7ec74490921f9,
+  VLOAD_64(v16, 0x40f0f91647b040e6, 0x40f7fd7ad092e40e, 0xc0f7ec74490921f9,
            0xc0ef02de4f5de1b8, 0x40efe63fc51a00c4, 0xc0e1163812edb722,
            0xc0ceeba02257b050, 0xc0ab6cc617554220, 0x40e6fb9e2131a44c,
            0xc0d356993b5a8e58, 0x40d94ef4c0d89c24, 0x40f42bbdfb6c0160,
            0x40e20038010564a4, 0x40e4228ee9847d40, 0xc0b66700c6dda260,
            0x40f7ead2f4cdb996);
-  asm volatile("vfwnmsac.vv v8, v4, v6");
+  asm volatile("vfwnmsac.vv v16, v4, v8");
   //               2787379508.1325840950012207,  3421260093.5289182662963867,
   //               -2530960357.7114648818969727, -5977316925.0209798812866211,
   //               1110232642.0733766555786133, -1535117955.5847384929656982,
@@ -86,7 +86,7 @@ void TEST_CASE1(void) {
   //               -170625991.9771288335323334, -290729271.1712532043457031,
   //               1329539.2864317980129272,  3989167748.8218097686767578,
   //               4771532019.5777149200439453,  5122659058.9813976287841797
-  VCMP_U64(2, v8, 0x41e4c48126843e21, 0x41e97d8927b0ece6, 0xc1e2db6c7cb6c452,
+  VCMP_U64(2, v16, 0x41e4c48126843e21, 0x41e97d8927b0ece6, 0xc1e2db6c7cb6c452,
            0xc1f64469e3d055ef, 0x41d08b339084b234, 0xc1d6e002a0e56c5b,
            0x41bb303afd9bb451, 0xc193fbad7710e4ab, 0x41e1db2636354532,
            0x41747cdc1763715c, 0xc1a457178ff44a3b, 0xc1b1542d372bd740,
@@ -98,7 +98,7 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //              -27.1719,  16.3438, -76.1250,  73.7500,  39.2500,  32.8438,
   //              -48.0312, -62.9062, -52.3125,  50.8750, -32.1562, -86.3750,
   //              -42.7812,  97.2500, -83.6250,  46.6250
@@ -108,7 +108,7 @@ void TEST_CASE2(void) {
   //              -78.0625,  13.7344,  6.3164,  19.1250,  23.3125,  72.4375,
   //              -53.2812, -16.3438, -95.0625, -96.2500,  10.4141,
   //              -44.4688,  42.5938
-  VLOAD_16(v6, 0xcc8b, 0xd1d1, 0xd48c, 0xd4e1, 0x4ade, 0x4651, 0x4cc8, 0x4dd4,
+  VLOAD_16(v8, 0xcc8b, 0xd1d1, 0xd48c, 0xd4e1, 0x4ade, 0x4651, 0x4cc8, 0x4dd4,
            0x5487, 0xd2a9, 0xcc16, 0xd5f1, 0xd604, 0x4935, 0xd18f, 0x5153);
   VLOAD_8(v0, 0xAA, 0xAA);
   //               69.72727966,  14.41778183,
@@ -116,23 +116,23 @@ void TEST_CASE2(void) {
   //               -23.97786140,  94.91672516,  17.38204765, -39.07393646,
   //               -50.71182251, -11.98221493, -36.07648849,
   //               -86.86090088,  55.96418381,  61.43484116, -88.02533722
-  VLOAD_32(v8, 0x428b745e, 0x4166af3c, 0xc281a704, 0x40b54f15, 0x4292ad79,
+  VLOAD_32(v16, 0x428b745e, 0x4166af3c, 0xc281a704, 0x40b54f15, 0x4292ad79,
            0xc1bfd2a9, 0x42bdd55d, 0x418b0e6f, 0xc21c4bb6, 0xc24ad8e8,
            0xc13fb727, 0xc2104e53, 0xc2adb8c8, 0x425fdb53, 0x4275bd47,
            0xc2b00cf9);
-  asm volatile("vfwnmsac.vv v8, v4, v6, v0.t");
+  asm volatile("vfwnmsac.vv v16, v4, v8, v0.t");
   //               69.72727966,  774.91290283, -64.82620239,
   //               5762.77539062,  73.33881378, -231.43232727,  94.91672516,
   //               1483.88403320, -39.07393646,  2659.97167969, -11.98221493,
   //               -8247.09960938, -86.86090088, -956.80340576,  61.43484116,
   //               -2073.95898438
-  VCMP_U32(3, v8, 0x428b745e, 0x4441ba6d, 0xc281a704, 0x45b41634, 0x4292ad79,
+  VCMP_U32(3, v16, 0x428b745e, 0x4441ba6d, 0xc281a704, 0x45b41634, 0x4292ad79,
            0xc3676ead, 0x42bdd55d, 0x44b97c4a, 0xc21c4bb6, 0x45263f8c,
            0xc13fb727, 0xc600dc66, 0xc2adb8c8, 0xc46f336b, 0x4275bd47,
            0xc5019f58);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //               76109.13281250,  56176.41406250, -69127.14843750,
   //               -80327.49218750,  42920.59375000, -22857.18164062,
   //               -74227.70312500, -2650.23828125,  34254.71093750,
@@ -148,7 +148,7 @@ void TEST_CASE2(void) {
   //              6145.43457031, -31624.23242188, -69962.68750000, 468.94165039,
   //              10443.93554688, -6054.45410156, -26090.46093750,
   //              83534.57031250,  49878.42968750, -62082.53125000
-  VLOAD_32(v6, 0xc70f0e8b, 0xc76de453, 0xc70f03b3, 0xc7915587, 0xc6ca1338,
+  VLOAD_32(v8, 0xc70f0e8b, 0xc76de453, 0xc70f03b3, 0xc7915587, 0xc6ca1338,
            0xc7832be2, 0x45c00b7a, 0xc6f71077, 0xc788a558, 0x43ea7888,
            0x46232fbe, 0xc5bd33a2, 0xc6cbd4ec, 0x47a32749, 0x4742d66e,
            0xc7728288);
@@ -161,13 +161,13 @@ void TEST_CASE2(void) {
   //               25915.8242703938303748,  82619.8738822988234460,
   //               36865.7501246419560630,  41236.4660055586136878,
   //               -5735.0030344506667461,  97965.1847665070963558
-  VLOAD_64(v8, 0x40f0f91647b040e6, 0x40f7fd7ad092e40e, 0xc0f7ec74490921f9,
+  VLOAD_64(v16, 0x40f0f91647b040e6, 0x40f7fd7ad092e40e, 0xc0f7ec74490921f9,
            0xc0ef02de4f5de1b8, 0x40efe63fc51a00c4, 0xc0e1163812edb722,
            0xc0ceeba02257b050, 0xc0ab6cc617554220, 0x40e6fb9e2131a44c,
            0xc0d356993b5a8e58, 0x40d94ef4c0d89c24, 0x40f42bbdfb6c0160,
            0x40e20038010564a4, 0x40e4228ee9847d40, 0xc0b66700c6dda260,
            0x40f7ead2f4cdb996);
-  asm volatile("vfwnmsac.vv v8, v4, v6, v0.t");
+  asm volatile("vfwnmsac.vv v16, v4, v8, v0.t");
   //               69521.3925020728202071,  3421260093.5289182662963867,
   //               -97991.2678309752518544, -5977316925.0209798812866211,
   //               65329.9928102507547010, -1535117955.5847384929656982,
@@ -176,7 +176,7 @@ void TEST_CASE2(void) {
   //               25915.8242703938303748, -290729271.1712532043457031,
   //               36865.7501246419560630,  3989167748.8218097686767578,
   //               -5735.0030344506667461,  5122659058.9813976287841797
-  VCMP_U64(4, v8, 0x40f0f91647b040e6, 0x41e97d8927b0ece6, 0xc0f7ec74490921f9,
+  VCMP_U64(4, v16, 0x40f0f91647b040e6, 0x41e97d8927b0ece6, 0xc0f7ec74490921f9,
            0xc1f64469e3d055ef, 0x40efe63fc51a00c4, 0xc1d6e002a0e56c5b,
            0xc0ceeba02257b050, 0xc193fbad7710e4ab, 0x40e6fb9e2131a44c,
            0x41747cdc1763715c, 0x40d94ef4c0d89c24, 0xc1b1542d372bd740,
@@ -187,7 +187,7 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //               15.1797, -57.5312, -39.9688,  95.8125,  22.3906,
   //               -30.2344,  61.3438,  67.1250, -80.6250, -20.6875, -34.1250,
@@ -201,22 +201,22 @@ void TEST_CASE3(void) {
   //              -61.63031769, -55.39078903,  21.99703789,  29.49930191,
   //              -64.56553650, -17.54965782,  84.51310730, -88.96613312,
   //              -6.75917578
-  VLOAD_32(v8, 0xc2b4f48b, 0xc2b3f2af, 0xc208d482, 0xc2bb782b, 0x42a3831b,
+  VLOAD_32(v16, 0xc2b4f48b, 0xc2b3f2af, 0xc208d482, 0xc2bb782b, 0x42a3831b,
            0x42a134b8, 0x4292e873, 0xc2768572, 0xc25d902b, 0x41aff9ef,
            0x41ebfe92, 0xc281218e, 0xc18c65b3, 0x42a906b6, 0xc2b1eea9,
            0xc0d84b2b);
-  asm volatile("vfwnmsac.vf v8, %[A], v4" ::[A] "f"(fscalar_16));
+  asm volatile("vfwnmsac.vf v16, %[A], v4" ::[A] "f"(fscalar_16));
   //               330.52151489, -1685.56726074, -1142.71582031,  2563.56518555,
   //               702.74603271, -757.92852783,  1774.78454590,  1800.03955078,
   //               -2291.47485352, -551.75787354, -916.93621826, -277.44854736,
   //               -715.24255371,  1882.04724121,  688.02972412, -1448.07995605
-  VCMP_U32(5, v8, 0x43a542c1, 0xc4d2b227, 0xc48ed6e8, 0x4520390b, 0x442fafbf,
+  VCMP_U32(5, v16, 0x43a542c1, 0xc4d2b227, 0xc48ed6e8, 0x4520390b, 0x442fafbf,
            0xc43d7b6d, 0x44ddd91b, 0x44e10144, 0xc50f3799, 0xc409f081,
            0xc4653beb, 0xc38ab96a, 0xc432cf86, 0x44eb4183, 0x442c01e7,
            0xc4b5028f);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //               467373.87500000, -160965.29687500,  883060.25000000,
   //               -737665.37500000, -482502.81250000, -983579.31250000,
@@ -238,13 +238,13 @@ void TEST_CASE3(void) {
   //              -388606.5700500296661630,  47697.1169114386430010,
   //              -665347.3327810273040086,  976438.6193965608254075,
   //              -498588.0437998892739415,  793291.0511387982405722
-  VLOAD_64(v8, 0xc11c1ed27139f9a2, 0xc12cd6554cbddf2f, 0xc1128659ecb82f10,
+  VLOAD_64(v16, 0xc11c1ed27139f9a2, 0xc12cd6554cbddf2f, 0xc1128659ecb82f10,
            0xc126d3f3549612d1, 0x4117a9d8000c4d34, 0xc12b49af53e9b790,
            0x40f804b11f89b0f0, 0xc12d03c239c68719, 0xc126de2b77b7d27e,
            0x412b6bb412c65e12, 0xc117b7fa47bb31ea, 0x40e74a23bdbd0eb0,
            0xc1244e06aa62465a, 0x412dcc6d3d218bc8, 0xc11e6e702cd9e0d0,
            0x412835961a2edd54);
-  asm volatile("vfwnmsac.vf v8, %[A], v4" ::[A] "f"(fscalar_32));
+  asm volatile("vfwnmsac.vf v16, %[A], v4" ::[A] "f"(fscalar_32));
   //              -109912672670.3254089355468750,  37853228716.2851715087890625,
   //              -207669389333.5514831542968750, 173475856848.7839965820312500,
   //              113470468570.1348114013671875,  231307237594.9865112304687500,
@@ -253,7 +253,7 @@ void TEST_CASE3(void) {
   //              -37859206864.6847991943359375,  2145428350.5620102882385254,
   //              166549954299.5226745605468750, -179467181235.7380371093750000,
   //              80153027927.0138244628906250,  155923943542.1058349609375000
-  VCMP_U64(6, v8, 0xc239974e499e534e, 0x4221a074dd589202, 0xc2482d07b40ac697,
+  VCMP_U64(6, v16, 0xc239974e499e534e, 0x4221a074dd589202, 0xc2482d07b40ac697,
            0x424431fbc0e8645a, 0x423a6b5df1da2283, 0x424aed7e2c6d7e46,
            0x4236505f071a24b9, 0xc23eee3ac1143363, 0x421a884888b36990,
            0xc24463f954175e4e, 0xc221a12b4da15e9e, 0x41dff828dfa3f7fa,
@@ -264,7 +264,7 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //                15.1797, -57.5312, -39.9688,  95.8125,  22.3906,
   //                -30.2344,  61.3438,  67.1250, -80.6250, -20.6875, -34.1250,
@@ -279,23 +279,23 @@ void TEST_CASE4(void) {
   //               -61.63031769, -55.39078903,  21.99703789,  29.49930191,
   //               -64.56553650, -17.54965782,  84.51310730, -88.96613312,
   //               -6.75917578
-  VLOAD_32(v8, 0xc2b4f48b, 0xc2b3f2af, 0xc208d482, 0xc2bb782b, 0x42a3831b,
+  VLOAD_32(v16, 0xc2b4f48b, 0xc2b3f2af, 0xc208d482, 0xc2bb782b, 0x42a3831b,
            0x42a134b8, 0x4292e873, 0xc2768572, 0xc25d902b, 0x41aff9ef,
            0x41ebfe92, 0xc281218e, 0xc18c65b3, 0x42a906b6, 0xc2b1eea9,
            0xc0d84b2b);
-  asm volatile("vfwnmsac.vf v8, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
+  asm volatile("vfwnmsac.vf v16, %[A], v4, v0.t" ::[A] "f"(fscalar_16));
   //               -90.47762299, -1685.56726074, -34.20752716,
   //               2563.56518555,  81.75606537, -757.92852783,  73.45400238,
   //               1800.03955078, -55.39078903, -551.75787354,  29.49930191,
   //               -277.44854736, -17.54965782,  1882.04724121, -88.96613312,
   //               -1448.07995605
-  VCMP_U32(7, v8, 0xc2b4f48b, 0xc4d2b227, 0xc208d482, 0x4520390b, 0x42a3831b,
+  VCMP_U32(7, v16, 0xc2b4f48b, 0xc4d2b227, 0xc208d482, 0x4520390b, 0x42a3831b,
            0xc43d7b6d, 0x4292e873, 0x44e10144, 0xc25d902b, 0xc409f081,
            0x41ebfe92, 0xc38ab96a, 0xc18c65b3, 0x44eb4183, 0xc2b1eea9,
            0xc4b5028f);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //                467373.87500000, -160965.29687500,  883060.25000000,
   //                -737665.37500000, -482502.81250000, -983579.31250000,
@@ -318,13 +318,13 @@ void TEST_CASE4(void) {
   //               -388606.5700500296661630,  47697.1169114386430010,
   //               -665347.3327810273040086,  976438.6193965608254075,
   //               -498588.0437998892739415,  793291.0511387982405722
-  VLOAD_64(v8, 0xc11c1ed27139f9a2, 0xc12cd6554cbddf2f, 0xc1128659ecb82f10,
+  VLOAD_64(v16, 0xc11c1ed27139f9a2, 0xc12cd6554cbddf2f, 0xc1128659ecb82f10,
            0xc126d3f3549612d1, 0x4117a9d8000c4d34, 0xc12b49af53e9b790,
            0x40f804b11f89b0f0, 0xc12d03c239c68719, 0xc126de2b77b7d27e,
            0x412b6bb412c65e12, 0xc117b7fa47bb31ea, 0x40e74a23bdbd0eb0,
            0xc1244e06aa62465a, 0x412dcc6d3d218bc8, 0xc11e6e702cd9e0d0,
            0x412835961a2edd54);
-  asm volatile("vfwnmsac.vf v8, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
+  asm volatile("vfwnmsac.vf v16, %[A], v4, v0.t" ::[A] "f"(fscalar_32));
   //               -460724.6105727200629190,  37853228716.2851715087890625,
   //               -303510.4811713555827737,  173475856848.7839965820312500,
   //               387702.0000469267833978,  231307237594.9865112304687500,
@@ -333,7 +333,7 @@ void TEST_CASE4(void) {
   //               -388606.5700500296661630,  2145428350.5620102882385254,
   //               -665347.3327810273040086, -179467181235.7380371093750000,
   //               -498588.0437998892739415,  155923943542.1058349609375000
-  VCMP_U64(8, v8, 0xc11c1ed27139f9a2, 0x4221a074dd589202, 0xc1128659ecb82f10,
+  VCMP_U64(8, v16, 0xc11c1ed27139f9a2, 0x4221a074dd589202, 0xc1128659ecb82f10,
            0x424431fbc0e8645a, 0x4117a9d8000c4d34, 0x424aed7e2c6d7e46,
            0x40f804b11f89b0f0, 0xc23eee3ac1143363, 0xc126de2b77b7d27e,
            0xc24463f954175e4e, 0xc117b7fa47bb31ea, 0x41dff828dfa3f7fa,
diff --git a/sw/riscvTests/isa/rv64uv/vfwsub.c b/sw/riscvTests/isa/rv64uv/vfwsub.c
index 9110889b..400a06ab 100644
--- a/sw/riscvTests/isa/rv64uv/vfwsub.c
+++ b/sw/riscvTests/isa/rv64uv/vfwsub.c
@@ -11,7 +11,7 @@
 
 // Simple random test with similar values
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //              -15.5625,  95.7500, -42.4375,  30.7188, -50.7500, -90.2500,
   //              -95.5000,  29.5938, -41.4062, -94.0000,  34.3438,
   //              -69.5625,  31.5625, -75.0625,  46.2500, -63.6875
@@ -20,21 +20,21 @@ void TEST_CASE1(void) {
   //               57.2500,  43.2812, -49.4062, -53.5625, -54.7812,
   //               -12.1406,  92.1875,  67.1875, -19.7656, -41.2812,  98.0625,
   //               -41.9062,  10.1719, -84.6250, -7.1016,  62.8750
-  VLOAD_16(v6, 0x5328, 0x5169, 0xd22d, 0xd2b2, 0xd2d9, 0xca12, 0x55c3, 0x5433,
+  VLOAD_16(v8, 0x5328, 0x5169, 0xd22d, 0xd2b2, 0xd2d9, 0xca12, 0x55c3, 0x5433,
            0xccf1, 0xd129, 0x5621, 0xd13d, 0x4916, 0xd54a, 0xc71a, 0x53dc);
-  asm volatile("vfwsub.vv v8, v4, v6");
+  asm volatile("vfwsub.vv v16, v4, v8");
   //              -72.81250000,  52.46875000,  6.96875000,  84.28125000,  4.03125000,
   //              -78.10937500, -187.68750000, -37.59375000, -21.64062500,
   //              -52.71875000, -63.71875000,
   //              -27.65625000,  21.39062500,  9.56250000,  53.35156250,
   //              -126.56250000
-  VCMP_U32(1, v8, 0xc291a000, 0x4251e000, 0x40df0000, 0x42a89000, 0x40810000,
+  VCMP_U32(1, v16, 0xc291a000, 0x4251e000, 0x40df0000, 0x42a89000, 0x40810000,
            0xc29c3800, 0xc33bb000, 0xc2166000, 0xc1ad2000, 0xc252e000,
            0xc27ee000, 0xc1dd4000, 0x41ab2000, 0x41190000, 0x42556800,
            0xc2fd2000);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //               74632.77343750, -65636.60937500,  16165.84765625,
   //               -17815.85937500, -85604.03125000, -76754.03125000,
   //               21778.01171875, -70512.52343750,  85301.90625000,
@@ -51,11 +51,11 @@ void TEST_CASE1(void) {
   //               57701.78906250, -81581.38281250,  53319.19531250,
   //               -86229.57031250,  44376.69531250,  46809.38671875,
   //               -92887.27343750
-  VLOAD_32(v6, 0x45a87dc7, 0xc7b1442f, 0xc6b36264, 0x46469280, 0x47aa21cc,
+  VLOAD_32(v8, 0x45a87dc7, 0xc7b1442f, 0xc6b36264, 0x46469280, 0x47aa21cc,
            0x4756537c, 0x47588065, 0xc78b8601, 0xc7704177, 0x476165ca,
            0xc79f56b1, 0x47504732, 0xc7a86ac9, 0x472d58b2, 0x4736d963,
            0xc7b56ba3);
-  asm volatile("vfwsub.vv v8, v4, v6");
+  asm volatile("vfwsub.vv v16, v4, v8");
   //               69241.0512695312500000,  25123.7578125000000000,
   //               39127.0429687500000000, -30524.4843750000000000,
   //               -172711.6250000000000000, -131621.5156250000000000,
@@ -64,7 +64,7 @@ void TEST_CASE1(void) {
   //               179839.4375000000000000, -103740.7265625000000000,
   //               156072.1093750000000000, -109596.6562500000000000,
   //               -112075.4765625000000000,  2146.6718750000000000
-  VCMP_U64(2, v8, 0x40f0e790d2000000, 0x40d888f080000000, 0x40e31ae160000000,
+  VCMP_U64(2, v16, 0x40f0e790d2000000, 0x40d888f080000000, 0x40e31ae160000000,
            0xc0ddcf1f00000000, 0xc105153d00000000, 0xc100112c20000000,
            0xc0e06dcc40000000, 0x408cdbe000000000, 0x4101ebbaf8000000,
            0xc0f0226e64000000, 0x4105f3fb80000000, 0xc0f953cba0000000,
@@ -76,7 +76,7 @@ void TEST_CASE1(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //              -15.5625,  95.7500, -42.4375,  30.7188, -50.7500, -90.2500,
   //              -95.5000,  29.5938, -41.4062, -94.0000,  34.3438,
   //              -69.5625,  31.5625, -75.0625,  46.2500, -63.6875
@@ -85,21 +85,21 @@ void TEST_CASE2(void) {
   //               57.2500,  43.2812, -49.4062, -53.5625, -54.7812,
   //               -12.1406,  92.1875,  67.1875, -19.7656, -41.2812,  98.0625,
   //               -41.9062,  10.1719, -84.6250, -7.1016,  62.8750
-  VLOAD_16(v6, 0x5328, 0x5169, 0xd22d, 0xd2b2, 0xd2d9, 0xca12, 0x55c3, 0x5433,
+  VLOAD_16(v8, 0x5328, 0x5169, 0xd22d, 0xd2b2, 0xd2d9, 0xca12, 0x55c3, 0x5433,
            0xccf1, 0xd129, 0x5621, 0xd13d, 0x4916, 0xd54a, 0xc71a, 0x53dc);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwsub.vv v8, v4, v6, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfwsub.vv v16, v4, v8, v0.t");
   //               0.00000000,  52.46875000,  0.00000000,  84.28125000,
   //               0.00000000, -78.10937500,  0.00000000, -37.59375000,
   //               0.00000000, -52.71875000,  0.00000000, -27.65625000,
   //               0.00000000,  9.56250000,  0.00000000, -126.56250000
-  VCMP_U32(3, v8, 0x0, 0x4251e000, 0x0, 0x42a89000, 0x0, 0xc29c3800, 0x0,
+  VCMP_U32(3, v16, 0x0, 0x4251e000, 0x0, 0x42a89000, 0x0, 0xc29c3800, 0x0,
            0xc2166000, 0x0, 0xc252e000, 0x0, 0xc1dd4000, 0x0, 0x41190000, 0x0,
            0xc2fd2000);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //               74632.77343750, -65636.60937500,  16165.84765625,
   //               -17815.85937500, -85604.03125000, -76754.03125000,
   //               21778.01171875, -70512.52343750,  85301.90625000,
@@ -116,13 +116,13 @@ void TEST_CASE2(void) {
   //               57701.78906250, -81581.38281250,  53319.19531250,
   //               -86229.57031250,  44376.69531250,  46809.38671875,
   //               -92887.27343750
-  VLOAD_32(v6, 0x45a87dc7, 0xc7b1442f, 0xc6b36264, 0x46469280, 0x47aa21cc,
+  VLOAD_32(v8, 0x45a87dc7, 0xc7b1442f, 0xc6b36264, 0x46469280, 0x47aa21cc,
            0x4756537c, 0x47588065, 0xc78b8601, 0xc7704177, 0x476165ca,
            0xc79f56b1, 0x47504732, 0xc7a86ac9, 0x472d58b2, 0x4736d963,
            0xc7b56ba3);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwsub.vv v8, v4, v6, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfwsub.vv v16, v4, v8, v0.t");
   //               0.0000000000000000,  25123.7578125000000000,
   //               0.0000000000000000, -30524.4843750000000000,
   //               0.0000000000000000, -131621.5156250000000000,
@@ -131,7 +131,7 @@ void TEST_CASE2(void) {
   //               0.0000000000000000, -103740.7265625000000000,
   //               0.0000000000000000, -109596.6562500000000000,
   //               0.0000000000000000,  2146.6718750000000000
-  VCMP_U64(4, v8, 0x0, 0x40d888f080000000, 0x0, 0xc0ddcf1f00000000, 0x0,
+  VCMP_U64(4, v16, 0x0, 0x40d888f080000000, 0x0, 0xc0ddcf1f00000000, 0x0,
            0xc100112c20000000, 0x0, 0x408cdbe000000000, 0x0, 0xc0f0226e64000000,
            0x0, 0xc0f953cba0000000, 0x0, 0xc0fac1ca80000000, 0x0,
            0x40a0c55800000000);
@@ -140,7 +140,7 @@ void TEST_CASE2(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE3(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //                              36.4375
   BOX_HALF_IN_FLOAT(fscalar_16, 0x508e);
@@ -150,19 +150,19 @@ void TEST_CASE3(void) {
   //               -96.8750
   VLOAD_16(v4, 0x545d, 0xd0aa, 0xd4d4, 0x5017, 0xd530, 0x54c5, 0x4b78, 0x5488,
            0x50f4, 0xd3a7, 0x508b, 0x55d8, 0xd573, 0xc6ed, 0x4e47, 0xd60e);
-  asm volatile("vfwsub.vf v8, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfwsub.vf v16, v4, %[A]" ::[A] "f"(fscalar_16));
   //               33.37500000, -73.75000000, -113.68750000, -3.71875000,
   //               -119.43750000,  39.87500000,
   //               -21.50000000,  36.06250000,  3.18750000, -97.65625000,
   //               -0.09375000,  57.06250000, -123.62500000, -43.36328125,
   //               -11.32812500, -133.31250000
-  VCMP_U32(5, v8, 0x42058000, 0xc2938000, 0xc2e36000, 0xc06e0000, 0xc2eee000,
+  VCMP_U32(5, v16, 0x42058000, 0xc2938000, 0xc2e36000, 0xc06e0000, 0xc2eee000,
            0x421f8000, 0xc1ac0000, 0x42104000, 0x404c0000, 0xc2c35000,
            0xbdc00000, 0x42644000, 0xc2f74000, 0xc22d7400, 0xc1354000,
            0xc3055000);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //                              -138614.20312500
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xc8075d8d);
@@ -176,7 +176,7 @@ void TEST_CASE3(void) {
            0xc915db06, 0xc83281a2, 0x47ec8d39, 0xc96a049d, 0x4890262d,
            0x488948fb, 0xc9337dbe, 0xc93f66e9, 0x48cd8ef5, 0x496903a2,
            0xc8910b91);
-  asm volatile("vfwsub.vf v8, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfwsub.vf v16, v4, %[A]" ::[A] "f"(fscalar_32));
   //               611722.1406250000000000,  300589.2812500000000000,
   //               -34430.6875000000000000, -183431.8906250000000000,
   //               -346993.3593750000000000, -475194.1718750000000000,
@@ -185,7 +185,7 @@ void TEST_CASE3(void) {
   //               419774.0468750000000000, -596581.6718750000000000,
   //               -645368.3593750000000000,  559597.8593750000000000,
   //               1093040.3281250000000000, -158438.3281250000000000
-  VCMP_U64(6, v8, 0x4122ab1448000000, 0x411258b520000000, 0xc0e0cfd600000000,
+  VCMP_U64(6, v16, 0x4122ab1448000000, 0x411258b520000000, 0xc0e0cfd600000000,
            0xc106643f20000000, 0xc1152dc570000000, 0xc11d00e8b0000000,
            0xc0e5920a80000000, 0x410fb48530000000, 0xc12905a738000000,
            0x411a7a9e70000000, 0x41199ef830000000, 0xc12234cb58000000,
@@ -196,7 +196,7 @@ void TEST_CASE3(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE4(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //                              36.4375
   BOX_HALF_IN_FLOAT(fscalar_16, 0x508e);
@@ -207,18 +207,18 @@ void TEST_CASE4(void) {
   VLOAD_16(v4, 0x545d, 0xd0aa, 0xd4d4, 0x5017, 0xd530, 0x54c5, 0x4b78, 0x5488,
            0x50f4, 0xd3a7, 0x508b, 0x55d8, 0xd573, 0xc6ed, 0x4e47, 0xd60e);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwsub.vf v8, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v16);
+  asm volatile("vfwsub.vf v16, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.00000000, -73.75000000,  0.00000000, -3.71875000,
   //                0.00000000,  39.87500000,  0.00000000,  36.06250000,
   //                0.00000000, -97.65625000,  0.00000000,  57.06250000,
   //                0.00000000, -43.36328125,  0.00000000, -133.31250000
-  VCMP_U32(7, v8, 0x0, 0xc2938000, 0x0, 0xc06e0000, 0x0, 0x421f8000, 0x0,
+  VCMP_U32(7, v16, 0x0, 0xc2938000, 0x0, 0xc06e0000, 0x0, 0x421f8000, 0x0,
            0x42104000, 0x0, 0xc2c35000, 0x0, 0x42644000, 0x0, 0xc22d7400, 0x0,
            0xc3055000);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //                              -138614.20312500
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xc8075d8d);
@@ -233,8 +233,8 @@ void TEST_CASE4(void) {
            0x488948fb, 0xc9337dbe, 0xc93f66e9, 0x48cd8ef5, 0x496903a2,
            0xc8910b91);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwsub.vf v8, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v16);
+  asm volatile("vfwsub.vf v16, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.0000000000000000,  300589.2812500000000000,
   //                0.0000000000000000, -183431.8906250000000000,
   //                0.0000000000000000, -475194.1718750000000000,
@@ -243,7 +243,7 @@ void TEST_CASE4(void) {
   //                0.0000000000000000, -596581.6718750000000000,
   //                0.0000000000000000,  559597.8593750000000000,
   //                0.0000000000000000, -158438.3281250000000000
-  VCMP_U64(8, v8, 0x0, 0x411258b520000000, 0x0, 0xc106643f20000000, 0x0,
+  VCMP_U64(8, v16, 0x0, 0x411258b520000000, 0x0, 0xc106643f20000000, 0x0,
            0xc11d00e8b0000000, 0x0, 0x410fb48530000000, 0x0, 0x411a7a9e70000000,
            0x0, 0xc12234cb58000000, 0x0, 0x412113dbb8000000, 0x0,
            0xc1035732a0000000);
@@ -251,7 +251,7 @@ void TEST_CASE4(void) {
 };
 // Simple random test with similar values
 void TEST_CASE5(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //              -92.15529633,  27.66998672,
   //              -5.68499708,  78.95133209,  57.52299500,  15.45270920,  50.26883316,
   //              46.63587189,  71.16806793, -80.68485260,
@@ -264,21 +264,21 @@ void TEST_CASE5(void) {
   //              -72.5625, -83.4375,  28.8281,  33.5938,
   //              -85.7500,  67.5000,  91.0625, -91.8750, -9.2578, -64.2500,
   //              -58.6250,  50.3438, -70.5000,  36.6250,  5.7930,  86.6875
-  VLOAD_16(v6, 0xd489, 0xd537, 0x4f35, 0x5033, 0xd55c, 0x5438, 0x55b1, 0xd5be,
+  VLOAD_16(v8, 0xd489, 0xd537, 0x4f35, 0x5033, 0xd55c, 0x5438, 0x55b1, 0xd5be,
            0xc8a1, 0xd404, 0xd354, 0x524b, 0xd468, 0x5094, 0x45cb, 0x556b);
-  asm volatile("vfwsub.wv v8, v4, v6");
+  asm volatile("vfwsub.wv v16, v4, v8");
   //              -19.59279633,  111.10748291, -34.51312256,  45.35758209,
   //              143.27299500, -52.04729080, -40.79366684,
   //              138.51086426,  80.42588043, -16.43485260,  36.28306580,
   //              -10.17347717,  164.04611206, -10.76483917,  36.03541946,
   //              -4.18495178
-  VCMP_U32(9, v8, 0xc19cbe0c, 0x42de3708, 0xc20a0d70, 0x42356e2a, 0x430f45e3,
+  VCMP_U32(9, v16, 0xc19cbe0c, 0x42de3708, 0xc20a0d70, 0x42356e2a, 0x430f45e3,
            0xc250306d, 0xc2232cb7, 0x430a82c8, 0x42a0da0d, 0xc1837a94,
            0x421121dc, 0xc122c690, 0x43240bce, 0xc12c3cc8, 0x42102445,
            0xc085eb20);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //              -79494.9435096215456724,  81629.4152202270051930,
   //              60506.1876363231276628, -81020.4028176319407066,
   //              -6814.2587861350475578,  11974.4045779409498209,
@@ -299,11 +299,11 @@ void TEST_CASE5(void) {
   //               39975.67578125, -71197.53125000, -66640.12500000,
   //               47459.75390625, -34899.84375000, -21371.85937500,
   //               17582.65820312
-  VLOAD_32(v6, 0x47bb2751, 0x46aa3aff, 0xc725a96e, 0x476b0ce4, 0xc7351794,
+  VLOAD_32(v8, 0x47bb2751, 0x46aa3aff, 0xc725a96e, 0x476b0ce4, 0xc7351794,
            0xc78b222b, 0x4580e2df, 0xc79d4780, 0x46d64d69, 0x471c27ad,
            0xc78b0ec4, 0xc7822810, 0x473963c1, 0xc70853d8, 0xc6a6f7b8,
            0x46895d51);
-  asm volatile("vfwsub.wv v8, v4, v6");
+  asm volatile("vfwsub.wv v16, v4, v8");
   //              -175317.5763221215456724,  59839.9171733520051930,
   //              102915.6173238231276628, -141193.2934426319552585,
   //              39545.3193388649524422,  83210.7405154409498209,
@@ -312,7 +312,7 @@ void TEST_CASE5(void) {
   //              100155.9076395476586185,  30252.7584680835425388,
   //              -137859.5532296942838002, -43872.2568954367889091,
   //              -41482.7561000282003079,  20275.9804473698022775
-  VCMP_U64(10, v8, 0xc10566ac9c4ec5c0, 0x40ed37fd597bedf4, 0x40f92039e08ef1f6,
+  VCMP_U64(10, v16, 0xc10566ac9c4ec5c0, 0x40ed37fd597bedf4, 0x40f92039e08ef1f6,
            0xc1013c4a58f8735c, 0x40e34f2a380623aa, 0x40f450abd926b811,
            0x40f6e9b5904af21e, 0xc0c90f706042ba00, 0x40f0bb0bc1192628,
            0xc0f80c81aba217f7, 0x40f873be85b10bdc, 0x40dd8b308abdb778,
@@ -324,7 +324,7 @@ void TEST_CASE5(void) {
 // Simple random test with similar values (masked)
 // The numbers are the same of TEST_CASE1
 void TEST_CASE6(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   //              -92.15529633,  27.66998672,
   //              -5.68499708,  78.95133209,  57.52299500,  15.45270920,  50.26883316,
   //              46.63587189,  71.16806793, -80.68485260,
@@ -337,21 +337,21 @@ void TEST_CASE6(void) {
   //              -72.5625, -83.4375,  28.8281,  33.5938,
   //              -85.7500,  67.5000,  91.0625, -91.8750, -9.2578, -64.2500,
   //              -58.6250,  50.3438, -70.5000,  36.6250,  5.7930,  86.6875
-  VLOAD_16(v6, 0xd489, 0xd537, 0x4f35, 0x5033, 0xd55c, 0x5438, 0x55b1, 0xd5be,
+  VLOAD_16(v8, 0xd489, 0xd537, 0x4f35, 0x5033, 0xd55c, 0x5438, 0x55b1, 0xd5be,
            0xc8a1, 0xd404, 0xd354, 0x524b, 0xd468, 0x5094, 0x45cb, 0x556b);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwsub.wv v8, v4, v6, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfwsub.wv v16, v4, v8, v0.t");
   //               0.00000000,  111.10748291,  0.00000000,  45.35758209,
   //               0.00000000, -52.04729080,  0.00000000,  138.51086426,
   //               0.00000000, -16.43485260,  0.00000000, -10.17347717,
   //               0.00000000, -10.76483917,  0.00000000, -4.18495178
-  VCMP_U32(11, v8, 0x0, 0x42de3708, 0x0, 0x42356e2a, 0x0, 0xc250306d, 0x0,
+  VCMP_U32(11, v16, 0x0, 0x42de3708, 0x0, 0x42356e2a, 0x0, 0xc250306d, 0x0,
            0x430a82c8, 0x0, 0xc1837a94, 0x0, 0xc122c690, 0x0, 0xc12c3cc8, 0x0,
            0xc085eb20);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   //              -79494.9435096215456724,  81629.4152202270051930,
   //              60506.1876363231276628, -81020.4028176319407066,
   //              -6814.2587861350475578,  11974.4045779409498209,
@@ -372,13 +372,13 @@ void TEST_CASE6(void) {
   //               39975.67578125, -71197.53125000, -66640.12500000,
   //               47459.75390625, -34899.84375000, -21371.85937500,
   //               17582.65820312
-  VLOAD_32(v6, 0x47bb2751, 0x46aa3aff, 0xc725a96e, 0x476b0ce4, 0xc7351794,
+  VLOAD_32(v8, 0x47bb2751, 0x46aa3aff, 0xc725a96e, 0x476b0ce4, 0xc7351794,
            0xc78b222b, 0x4580e2df, 0xc79d4780, 0x46d64d69, 0x471c27ad,
            0xc78b0ec4, 0xc7822810, 0x473963c1, 0xc70853d8, 0xc6a6f7b8,
            0x46895d51);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwsub.wv v8, v4, v6, v0.t");
+  VCLEAR(v16);
+  asm volatile("vfwsub.wv v16, v4, v8, v0.t");
   //               0.0000000000000000,  59839.9171733520051930,
   //               0.0000000000000000, -141193.2934426319552585,
   //               0.0000000000000000,  83210.7405154409498209,
@@ -387,7 +387,7 @@ void TEST_CASE6(void) {
   //               0.0000000000000000,  30252.7584680835425388,
   //               0.0000000000000000, -43872.2568954367889091,
   //               0.0000000000000000,  20275.9804473698022775
-  VCMP_U64(12, v8, 0x0, 0x40ed37fd597bedf4, 0x0, 0xc1013c4a58f8735c, 0x0,
+  VCMP_U64(12, v16, 0x0, 0x40ed37fd597bedf4, 0x0, 0xc1013c4a58f8735c, 0x0,
            0x40f450abd926b811, 0x0, 0xc0c90f706042ba00, 0x0, 0xc0f80c81aba217f7,
            0x0, 0x40dd8b308abdb778, 0x0, 0xc0e56c08387cc770, 0x0,
            0x40d3ccfebfa65330);
@@ -396,7 +396,7 @@ void TEST_CASE6(void) {
 
 // Simple random test with similar values (vector-scalar)
 void TEST_CASE7(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //              -8.76965809,  55.45920181,  71.29286957, -84.65414429,
   //              -81.93881226,  75.13192749, -75.44019318, -48.81898499,
@@ -408,18 +408,18 @@ void TEST_CASE7(void) {
            0xc25c49f3);
   //                              34.7812
   BOX_HALF_IN_FLOAT(fscalar_16, 0x5059);
-  asm volatile("vfwsub.wf v8, v4, %[A]" ::[A] "f"(fscalar_16));
+  asm volatile("vfwsub.wf v16, v4, %[A]" ::[A] "f"(fscalar_16));
   //              -43.55090714,  20.67795181,  36.51161957, -119.43539429,
   //              -116.72006226,  40.35067749, -110.22144318, -83.60023499,
   //              -34.67818832, -59.97023392,  14.89881516,  37.88153076,
   //              -59.69005966, -67.37556458, -20.19248962, -89.85346985
-  VCMP_U32(13, v8, 0xc22e3421, 0x41a56c72, 0x42120be6, 0xc2eedeec, 0xc2e970ac,
+  VCMP_U32(13, v16, 0xc22e3421, 0x41a56c72, 0x42120be6, 0xc2eedeec, 0xc2e970ac,
            0x42216718, 0xc2dc7161, 0xc2a73352, 0xc20ab677, 0xc26fe185,
            0x416e618c, 0x421786b0, 0xc26ec29f, 0xc286c04a, 0xc1a18a38,
            0xc2b3b4fa);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //               322189.5706008458510041,  914899.9451866354793310,
   //               -620811.0881863175891340, -456926.2657179111847654,
@@ -437,7 +437,7 @@ void TEST_CASE7(void) {
            0x4128f812f63066de);
   //                              -83388.08593750
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xc7a2de0b);
-  asm volatile("vfwsub.wf v8, v4, %[A]" ::[A] "f"(fscalar_32));
+  asm volatile("vfwsub.wf v16, v4, %[A]" ::[A] "f"(fscalar_32));
   //               405577.6565383458510041,  998288.0311241354793310,
   //               -537423.0022488175891340, -373538.1797804111847654,
   //               -466557.7857936944346875, -303426.8900513321859762,
@@ -446,7 +446,7 @@ void TEST_CASE7(void) {
   //               -699427.3162755169905722, -478041.7009790195152164,
   //               838760.0551206718664616, -871480.0901815977413207,
   //               -522879.0126630428712815,  901573.5667755266185850
-  VCMP_U64(14, v8, 0x4118c126a04b9690, 0x412e77200fef80b0, 0xc120669e0126c1cc,
+  VCMP_U64(14, v16, 0x4118c126a04b9690, 0x412e77200fef80b0, 0xc120669e0126c1cc,
            0xc116cc88b8185b2a, 0xc11c79f724a71a2c, 0xc112850b8f699dce,
            0x412964833c5f5108, 0x412b9bddba2eeaae, 0x41300e592553b4fb,
            0xc10fc693bfd2c18c, 0xc1255846a1eedd54, 0xc11d2d66cdcd71b0,
@@ -457,7 +457,7 @@ void TEST_CASE7(void) {
 
 // Simple random test with similar values (vector-scalar) (masked)
 void TEST_CASE8(void) {
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   float fscalar_16;
   //               -8.76965809,  55.45920181,  71.29286957, -84.65414429,
   //               -81.93881226,  75.13192749, -75.44019318, -48.81898499,
@@ -470,18 +470,18 @@ void TEST_CASE8(void) {
   //                              34.7812
   BOX_HALF_IN_FLOAT(fscalar_16, 0x5059);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwsub.wf v8, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
+  VCLEAR(v16);
+  asm volatile("vfwsub.wf v16, v4, %[A], v0.t" ::[A] "f"(fscalar_16));
   //                0.00000000,  20.67795181,  0.00000000, -119.43539429,
   //                0.00000000,  40.35067749,  0.00000000, -83.60023499,
   //                0.00000000, -59.97023392,  0.00000000,  37.88153076,
   //                0.00000000, -67.37556458,  0.00000000, -89.85346985
-  VCMP_U32(15, v8, 0x0, 0x41a56c72, 0x0, 0xc2eedeec, 0x0, 0x42216718, 0x0,
+  VCMP_U32(15, v16, 0x0, 0x41a56c72, 0x0, 0xc2eedeec, 0x0, 0x42216718, 0x0,
            0xc2a73352, 0x0, 0xc26fe185, 0x0, 0x421786b0, 0x0, 0xc286c04a, 0x0,
            0xc2b3b4fa);
 
 #if ELEN == 64
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   float fscalar_32;
   //                322189.5706008458510041,  914899.9451866354793310,
   //                -620811.0881863175891340, -456926.2657179111847654,
@@ -500,8 +500,8 @@ void TEST_CASE8(void) {
   //                              -83388.08593750
   BOX_FLOAT_IN_FLOAT(fscalar_32, 0xc7a2de0b);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v8);
-  asm volatile("vfwsub.wf v8, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
+  VCLEAR(v16);
+  asm volatile("vfwsub.wf v16, v4, %[A], v0.t" ::[A] "f"(fscalar_32));
   //                0.0000000000000000,  998288.0311241354793310,
   //                0.0000000000000000, -373538.1797804111847654,
   //                0.0000000000000000, -303426.8900513321859762,
@@ -510,7 +510,7 @@ void TEST_CASE8(void) {
   //                0.0000000000000000, -478041.7009790195152164,
   //                0.0000000000000000, -871480.0901815977413207,
   //                0.0000000000000000,  901573.5667755266185850
-  VCMP_U64(16, v8, 0x0, 0x412e77200fef80b0, 0x0, 0xc116cc88b8185b2a, 0x0,
+  VCMP_U64(16, v16, 0x0, 0x412e77200fef80b0, 0x0, 0xc116cc88b8185b2a, 0x0,
            0xc112850b8f699dce, 0x0, 0x412b9bddba2eeaae, 0x0, 0xc10fc693bfd2c18c,
            0x0, 0xc11d2d66cdcd71b0, 0x0, 0xc12a98702e2c484a, 0x0,
            0x412b838b223066de);
diff --git a/sw/riscvTests/isa/rv64uv/vmacc.c b/sw/riscvTests/isa/rv64uv/vmacc.c
index 4758f198..e24d7323 100644
--- a/sw/riscvTests/isa/rv64uv/vmacc.c
+++ b/sw/riscvTests/isa/rv64uv/vmacc.c
@@ -8,70 +8,70 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(16, e8, m2);
-  VLOAD_8(v6, 0x21, 0x75, 0x7f, 0x3a, 0x50, 0x6d, 0x3f, 0x3e, 0x74, 0x11, 0x29,
+  VSET(16, e8, m8);
+  VLOAD_8(v24, 0x21, 0x75, 0x7f, 0x3a, 0x50, 0x6d, 0x3f, 0x3e, 0x74, 0x11, 0x29,
           0xea, 0x14, 0xce, 0xb0, 0x37);
-  VLOAD_8(v4, 0xfe, 0xa7, 0x06, 0xaa, 0x35, 0x3c, 0x2c, 0x58, 0xa1, 0xc4, 0x40,
+  VLOAD_8(v16, 0xfe, 0xa7, 0x06, 0xaa, 0x35, 0x3c, 0x2c, 0x58, 0xa1, 0xc4, 0x40,
           0x42, 0x52, 0x40, 0xa8, 0x53);
-  VLOAD_8(v2, 0x30, 0xef, 0xb4, 0x12, 0x6d, 0x3b, 0x2c, 0x5e, 0xf0, 0x25, 0xd7,
+  VLOAD_8(v8, 0x30, 0xef, 0xb4, 0x12, 0x6d, 0x3b, 0x2c, 0x5e, 0xf0, 0x25, 0xd7,
           0x70, 0xc2, 0x62, 0xe0, 0x99);
-  asm volatile("vmacc.vv v2, v4, v6");
-  VCMP_U8(1, v2, 0xee, 0x42, 0xae, 0x96, 0xfd, 0xc7, 0x00, 0xae, 0xe4, 0x29,
+  asm volatile("vmacc.vv v8, v16, v24");
+  VCMP_U8(1, v8, 0xee, 0x42, 0xae, 0x96, 0xfd, 0xc7, 0x00, 0xae, 0xe4, 0x29,
           0x17, 0xc4, 0x2a, 0xe2, 0x60, 0x6e);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x1c20, 0x11e4, 0xde38, 0x642f, 0x3eb5, 0xa0af, 0x48e1, 0x5fc4,
+  VSET(16, e16, m8);
+  VLOAD_16(v24, 0x1c20, 0x11e4, 0xde38, 0x642f, 0x3eb5, 0xa0af, 0x48e1, 0x5fc4,
            0x3d2a, 0x67d5, 0x3f07, 0x2889, 0x8812, 0x0bd9, 0x56f4, 0xe068);
-  VLOAD_16(v4, 0x02cc, 0xd99c, 0xdba2, 0xf282, 0x0f99, 0xa219, 0x2dcc, 0x17cc,
+  VLOAD_16(v16, 0x02cc, 0xd99c, 0xdba2, 0xf282, 0x0f99, 0xa219, 0x2dcc, 0x17cc,
            0xe8fb, 0x1e83, 0xed20, 0xbfee, 0xee87, 0x6b0f, 0xf6cf, 0x4cd1);
-  VLOAD_16(v2, 0xe3f0, 0x42db, 0x2fde, 0x1983, 0x910c, 0x853b, 0x82aa, 0x9ac2,
+  VLOAD_16(v8, 0xe3f0, 0x42db, 0x2fde, 0x1983, 0x910c, 0x853b, 0x82aa, 0x9ac2,
            0x4631, 0x1f8b, 0x68c3, 0x6fbc, 0x3b5c, 0xf98b, 0x2db1, 0x8e75);
-  asm volatile("vmacc.vv v2, v4, v6");
-  VCMP_U16(2, v2, 0x8d70, 0x6dcb, 0xb74e, 0x6761, 0xa639, 0xf452, 0x22f6,
+  asm volatile("vmacc.vv v8, v16, v24");
+  VCMP_U16(2, v8, 0x8d70, 0x6dcb, 0xb74e, 0x6761, 0xa639, 0xf452, 0x22f6,
            0x86f2, 0x4e5f, 0x378a, 0xc4a3, 0x561a, 0xb8da, 0x5e42, 0xf4fd,
            0xa35d);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0x0401c584, 0x69049955, 0x4a71aa0c, 0xc651666f, 0x273fcd5d,
+  VSET(16, e32, m8);
+  VLOAD_32(v24, 0x0401c584, 0x69049955, 0x4a71aa0c, 0xc651666f, 0x273fcd5d,
            0x23ca1d7d, 0x599c994e, 0xb2d8adc5, 0x4710afae, 0x69c61cad,
            0x96ee5026, 0x2c197996, 0xd95da451, 0x3a654fb9, 0xbe990e4b,
            0xc41fd55a);
-  VLOAD_32(v4, 0x39d5b56a, 0xc578a540, 0x51283b5c, 0x07b4ba9d, 0xe5aba5e4,
+  VLOAD_32(v16, 0x39d5b56a, 0xc578a540, 0x51283b5c, 0x07b4ba9d, 0xe5aba5e4,
            0x28720dc8, 0x600fb42b, 0xf2937fa7, 0x4032d36f, 0xc676e3b3,
            0xf1cd5f96, 0x1c14bcbf, 0x7dea81ed, 0x40270562, 0x9577b3be,
            0xea615f0a);
-  VLOAD_32(v2, 0xa055bbb6, 0x71f9a668, 0x0be640c9, 0x2336ca55, 0xca121638,
+  VLOAD_32(v8, 0xa055bbb6, 0x71f9a668, 0x0be640c9, 0x2336ca55, 0xca121638,
            0xbf234fb5, 0xe7c83142, 0xb7048f12, 0x8eb340e3, 0xef253e93,
            0xffef4a03, 0xdf346833, 0xd0922181, 0xf159ee1d, 0xf86a7c06,
            0xfcb24a2d);
-  asm volatile("vmacc.vv v2, v4, v6");
-  VCMP_U32(3, v2, 0x448bd85e, 0xf2cbc4a8, 0x5cd02119, 0xf69b4268, 0x3c60ee0c,
+  asm volatile("vmacc.vv v8, v16, v24");
+  VCMP_U32(3, v8, 0x448bd85e, 0xf2cbc4a8, 0x5cd02119, 0xf69b4268, 0x3c60ee0c,
            0xa233b25d, 0x4c72c95c, 0xe2b1a595, 0xefb7d755, 0x95d6b28a,
            0xd3be5a47, 0x6338471d, 0xfb1a117e, 0xabe00fef, 0xbede88b0,
            0x913705b1);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0x9cffef345b95f00b, 0x85d366e07e4bbc6b, 0xadfda1d2464c6433,
+  VSET(16, e64, m8);
+  VLOAD_64(v24, 0x9cffef345b95f00b, 0x85d366e07e4bbc6b, 0xadfda1d2464c6433,
            0x610bf2c1435b3cf6, 0x8a0c6e4bc950e81f, 0x4296e7147ef94d7a,
            0x27d7ec90ba159756, 0x2a6c87932c3aef86, 0xbfd90c33e58a8fe3,
            0x1114f7672cf625c1, 0x1a7b72dd8ac39fab, 0xdb80f952e5fd2e5b,
            0x6b01c18a3daf288b, 0x69b4b0e4335f26d5, 0x0c059f365ec6d3d5,
            0xc22568276f1dcdd0);
-  VLOAD_64(v4, 0x6dc8e88769e54465, 0xce8cda83d16c3859, 0x1465ee5b6eb0d2b8,
+  VLOAD_64(v16, 0x6dc8e88769e54465, 0xce8cda83d16c3859, 0x1465ee5b6eb0d2b8,
            0x4827a9b40add2507, 0xd24c4005695a64d6, 0xb97c8e41e912f84a,
            0xc8c22e3b3b2e2fa1, 0x26712aa325bd00b6, 0xdf7ad19151df27b5,
            0x68ba6d050ffcba1e, 0x94448979a2b854e6, 0x84bf5d544f97f739,
            0x6d4bfa429e9d6ef0, 0xdb6c54b9a91ab935, 0x1a0051ca72162c5e,
            0xe04b73fdf1b61f9c);
-  VLOAD_64(v2, 0x32a4c1edbbfe5591, 0xf6baf4e747f4a120, 0x3a29727ae38b9b92,
+  VLOAD_64(v8, 0x32a4c1edbbfe5591, 0xf6baf4e747f4a120, 0x3a29727ae38b9b92,
            0xf173f78d09c997e4, 0xaab9d34e4aeaa57a, 0xa8fe3bf12b7c95e8,
            0xc4bd99b066821092, 0x9c2f1daf5fe2db9d, 0xa8b041a876aabcae,
            0xb9a2e6f9ded9a60a, 0x8bdf55954f50101d, 0x704f0e648c11d63f,
            0x0c8ca4d0a6d1a982, 0xa74d01c12ae6aea5, 0x3f2cd5d2e2f5b538,
            0x79803b24efa2caa3);
-  asm volatile("vmacc.vv v2, v4, v6");
-  VCMP_U64(4, v2, 0xf7c2044aeebff5e8, 0xad447a1b99a48a53, 0x78676efbe1b5763a,
+  asm volatile("vmacc.vv v8, v16, v24");
+  VCMP_U64(4, v8, 0xf7c2044aeebff5e8, 0xad447a1b99a48a53, 0x78676efbe1b5763a,
            0x813582af4d75d09e, 0x483adf8d811ecb64, 0x36d90fe4df2f2b2c,
            0xf833b173685307a8, 0x955c2ac405b724e1, 0xdcf9681f074b0d2d,
            0x10277404741c4ca8, 0x25d9bca0245d9fbf, 0x58439c4175d7f582,
@@ -81,74 +81,74 @@ void TEST_CASE1() {
 }
 
 void TEST_CASE2() {
-  VSET(16, e8, m2);
-  VLOAD_8(v6, 0x21, 0x75, 0x7f, 0x3a, 0x50, 0x6d, 0x3f, 0x3e, 0x74, 0x11, 0x29,
+  VSET(16, e8, m8);
+  VLOAD_8(v24, 0x21, 0x75, 0x7f, 0x3a, 0x50, 0x6d, 0x3f, 0x3e, 0x74, 0x11, 0x29,
           0xea, 0x14, 0xce, 0xb0, 0x37);
-  VLOAD_8(v4, 0xfe, 0xa7, 0x06, 0xaa, 0x35, 0x3c, 0x2c, 0x58, 0xa1, 0xc4, 0x40,
+  VLOAD_8(v16, 0xfe, 0xa7, 0x06, 0xaa, 0x35, 0x3c, 0x2c, 0x58, 0xa1, 0xc4, 0x40,
           0x42, 0x52, 0x40, 0xa8, 0x53);
-  VLOAD_8(v2, 0x30, 0xef, 0xb4, 0x12, 0x6d, 0x3b, 0x2c, 0x5e, 0xf0, 0x25, 0xd7,
+  VLOAD_8(v8, 0x30, 0xef, 0xb4, 0x12, 0x6d, 0x3b, 0x2c, 0x5e, 0xf0, 0x25, 0xd7,
           0x70, 0xc2, 0x62, 0xe0, 0x99);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmacc.vv v2, v4, v6, v0.t");
-  VCMP_U8(5, v2, 0x30, 0x42, 0xb4, 0x96, 0x6d, 0xc7, 0x2c, 0xae, 0xf0, 0x29,
+  asm volatile("vmacc.vv v8, v16, v24, v0.t");
+  VCMP_U8(5, v8, 0x30, 0x42, 0xb4, 0x96, 0x6d, 0xc7, 0x2c, 0xae, 0xf0, 0x29,
           0xd7, 0xc4, 0xc2, 0xe2, 0xe0, 0x6e);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x1c20, 0x11e4, 0xde38, 0x642f, 0x3eb5, 0xa0af, 0x48e1, 0x5fc4,
+  VSET(16, e16, m8);
+  VLOAD_16(v24, 0x1c20, 0x11e4, 0xde38, 0x642f, 0x3eb5, 0xa0af, 0x48e1, 0x5fc4,
            0x3d2a, 0x67d5, 0x3f07, 0x2889, 0x8812, 0x0bd9, 0x56f4, 0xe068);
-  VLOAD_16(v4, 0x02cc, 0xd99c, 0xdba2, 0xf282, 0x0f99, 0xa219, 0x2dcc, 0x17cc,
+  VLOAD_16(v16, 0x02cc, 0xd99c, 0xdba2, 0xf282, 0x0f99, 0xa219, 0x2dcc, 0x17cc,
            0xe8fb, 0x1e83, 0xed20, 0xbfee, 0xee87, 0x6b0f, 0xf6cf, 0x4cd1);
-  VLOAD_16(v2, 0xe3f0, 0x42db, 0x2fde, 0x1983, 0x910c, 0x853b, 0x82aa, 0x9ac2,
+  VLOAD_16(v8, 0xe3f0, 0x42db, 0x2fde, 0x1983, 0x910c, 0x853b, 0x82aa, 0x9ac2,
            0x4631, 0x1f8b, 0x68c3, 0x6fbc, 0x3b5c, 0xf98b, 0x2db1, 0x8e75);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmacc.vv v2, v4, v6, v0.t");
-  VCMP_U16(6, v2, 0xe3f0, 0x6dcb, 0x2fde, 0x6761, 0x910c, 0xf452, 0x82aa,
+  asm volatile("vmacc.vv v8, v16, v24, v0.t");
+  VCMP_U16(6, v8, 0xe3f0, 0x6dcb, 0x2fde, 0x6761, 0x910c, 0xf452, 0x82aa,
            0x86f2, 0x4631, 0x378a, 0x68c3, 0x561a, 0x3b5c, 0x5e42, 0x2db1,
            0xa35d);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0x0401c584, 0x69049955, 0x4a71aa0c, 0xc651666f, 0x273fcd5d,
+  VSET(16, e32, m8);
+  VLOAD_32(v24, 0x0401c584, 0x69049955, 0x4a71aa0c, 0xc651666f, 0x273fcd5d,
            0x23ca1d7d, 0x599c994e, 0xb2d8adc5, 0x4710afae, 0x69c61cad,
            0x96ee5026, 0x2c197996, 0xd95da451, 0x3a654fb9, 0xbe990e4b,
            0xc41fd55a);
-  VLOAD_32(v4, 0x39d5b56a, 0xc578a540, 0x51283b5c, 0x07b4ba9d, 0xe5aba5e4,
+  VLOAD_32(v16, 0x39d5b56a, 0xc578a540, 0x51283b5c, 0x07b4ba9d, 0xe5aba5e4,
            0x28720dc8, 0x600fb42b, 0xf2937fa7, 0x4032d36f, 0xc676e3b3,
            0xf1cd5f96, 0x1c14bcbf, 0x7dea81ed, 0x40270562, 0x9577b3be,
            0xea615f0a);
-  VLOAD_32(v2, 0xa055bbb6, 0x71f9a668, 0x0be640c9, 0x2336ca55, 0xca121638,
+  VLOAD_32(v8, 0xa055bbb6, 0x71f9a668, 0x0be640c9, 0x2336ca55, 0xca121638,
            0xbf234fb5, 0xe7c83142, 0xb7048f12, 0x8eb340e3, 0xef253e93,
            0xffef4a03, 0xdf346833, 0xd0922181, 0xf159ee1d, 0xf86a7c06,
            0xfcb24a2d);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmacc.vv v2, v4, v6, v0.t");
-  VCMP_U32(7, v2, 0xa055bbb6, 0xf2cbc4a8, 0x0be640c9, 0xf69b4268, 0xca121638,
+  asm volatile("vmacc.vv v8, v16, v24, v0.t");
+  VCMP_U32(7, v8, 0xa055bbb6, 0xf2cbc4a8, 0x0be640c9, 0xf69b4268, 0xca121638,
            0xa233b25d, 0xe7c83142, 0xe2b1a595, 0x8eb340e3, 0x95d6b28a,
            0xffef4a03, 0x6338471d, 0xd0922181, 0xabe00fef, 0xf86a7c06,
            0x913705b1);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0x9cffef345b95f00b, 0x85d366e07e4bbc6b, 0xadfda1d2464c6433,
+  VSET(16, e64, m8);
+  VLOAD_64(v24, 0x9cffef345b95f00b, 0x85d366e07e4bbc6b, 0xadfda1d2464c6433,
            0x610bf2c1435b3cf6, 0x8a0c6e4bc950e81f, 0x4296e7147ef94d7a,
            0x27d7ec90ba159756, 0x2a6c87932c3aef86, 0xbfd90c33e58a8fe3,
            0x1114f7672cf625c1, 0x1a7b72dd8ac39fab, 0xdb80f952e5fd2e5b,
            0x6b01c18a3daf288b, 0x69b4b0e4335f26d5, 0x0c059f365ec6d3d5,
            0xc22568276f1dcdd0);
-  VLOAD_64(v4, 0x6dc8e88769e54465, 0xce8cda83d16c3859, 0x1465ee5b6eb0d2b8,
+  VLOAD_64(v16, 0x6dc8e88769e54465, 0xce8cda83d16c3859, 0x1465ee5b6eb0d2b8,
            0x4827a9b40add2507, 0xd24c4005695a64d6, 0xb97c8e41e912f84a,
            0xc8c22e3b3b2e2fa1, 0x26712aa325bd00b6, 0xdf7ad19151df27b5,
            0x68ba6d050ffcba1e, 0x94448979a2b854e6, 0x84bf5d544f97f739,
            0x6d4bfa429e9d6ef0, 0xdb6c54b9a91ab935, 0x1a0051ca72162c5e,
            0xe04b73fdf1b61f9c);
-  VLOAD_64(v2, 0x32a4c1edbbfe5591, 0xf6baf4e747f4a120, 0x3a29727ae38b9b92,
+  VLOAD_64(v8, 0x32a4c1edbbfe5591, 0xf6baf4e747f4a120, 0x3a29727ae38b9b92,
            0xf173f78d09c997e4, 0xaab9d34e4aeaa57a, 0xa8fe3bf12b7c95e8,
            0xc4bd99b066821092, 0x9c2f1daf5fe2db9d, 0xa8b041a876aabcae,
            0xb9a2e6f9ded9a60a, 0x8bdf55954f50101d, 0x704f0e648c11d63f,
            0x0c8ca4d0a6d1a982, 0xa74d01c12ae6aea5, 0x3f2cd5d2e2f5b538,
            0x79803b24efa2caa3);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmacc.vv v2, v4, v6, v0.t");
-  VCMP_U64(8, v2, 0x32a4c1edbbfe5591, 0xad447a1b99a48a53, 0x3a29727ae38b9b92,
+  asm volatile("vmacc.vv v8, v16, v24, v0.t");
+  VCMP_U64(8, v8, 0x32a4c1edbbfe5591, 0xad447a1b99a48a53, 0x3a29727ae38b9b92,
            0x813582af4d75d09e, 0xaab9d34e4aeaa57a, 0x36d90fe4df2f2b2c,
            0xc4bd99b066821092, 0x955c2ac405b724e1, 0xa8b041a876aabcae,
            0x10277404741c4ca8, 0x8bdf55954f50101d, 0x58439c4175d7f582,
@@ -158,62 +158,62 @@ void TEST_CASE2() {
 }
 
 void TEST_CASE3() {
-  VSET(16, e8, m2);
+  VSET(16, e8, m8);
   int64_t scalar = 5;
-  VLOAD_8(v4, 0x60, 0xe3, 0xa0, 0xb7, 0x35, 0x23, 0xa3, 0xf4, 0x5f, 0x6e, 0x07,
+  VLOAD_8(v16, 0x60, 0xe3, 0xa0, 0xb7, 0x35, 0x23, 0xa3, 0xf4, 0x5f, 0x6e, 0x07,
           0x01, 0xe7, 0x51, 0x53, 0x29);
-  VLOAD_8(v2, 0xfb, 0x1b, 0xc0, 0x36, 0xa7, 0xe0, 0xc8, 0x47, 0x57, 0xe0, 0x51,
+  VLOAD_8(v8, 0xfb, 0x1b, 0xc0, 0x36, 0xa7, 0xe0, 0xc8, 0x47, 0x57, 0xe0, 0x51,
           0xaa, 0xd2, 0x93, 0x83, 0xa8);
-  asm volatile("vmacc.vx v2, %[A], v4" ::[A] "r"(scalar));
-  VCMP_U8(9, v2, 0xdb, 0x8a, 0xe0, 0xc9, 0xb0, 0x8f, 0xf7, 0x0b, 0x32, 0x06,
+  asm volatile("vmacc.vx v8, %[A], v16" ::[A] "r"(scalar));
+  VCMP_U8(9, v8, 0xdb, 0x8a, 0xe0, 0xc9, 0xb0, 0x8f, 0xf7, 0x0b, 0x32, 0x06,
           0x74, 0xaf, 0x55, 0x28, 0x22, 0x75);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   scalar = -5383;
-  VLOAD_16(v4, 0x992e, 0x9a07, 0x90c3, 0xf1ce, 0xd53c, 0x8f07, 0x2d2f, 0x5ab1,
+  VLOAD_16(v16, 0x992e, 0x9a07, 0x90c3, 0xf1ce, 0xd53c, 0x8f07, 0x2d2f, 0x5ab1,
            0x0a79, 0x0523, 0x6f34, 0xe5fd, 0xc95a, 0xca1c, 0x36bf, 0x16a1);
-  VLOAD_16(v2, 0x0a9f, 0x7ee0, 0x494e, 0xb6d0, 0x394c, 0xc8e7, 0xc117, 0x8108,
+  VLOAD_16(v8, 0x0a9f, 0x7ee0, 0x494e, 0xb6d0, 0x394c, 0xc8e7, 0xc117, 0x8108,
            0xb1af, 0x9f16, 0x22ab, 0xa244, 0xf1c9, 0xe363, 0x9bed, 0xa06f);
-  asm volatile("vmacc.vx v2, %[A], v4" ::[A] "r"(scalar));
-  VCMP_U16(10, v2, 0x145d, 0xb5af, 0x54f9, 0x342e, 0x78a8, 0x4cb6, 0xa9ce,
+  asm volatile("vmacc.vx v8, %[A], v16" ::[A] "r"(scalar));
+  VCMP_U16(10, v8, 0x145d, 0xb5af, 0x54f9, 0x342e, 0x78a8, 0x4cb6, 0xa9ce,
            0x8131, 0x7b60, 0x9c21, 0xd43f, 0x9759, 0x0e53, 0x109f, 0x71b4,
            0xcd08);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   scalar = 6474219;
-  VLOAD_32(v4, 0x709e784e, 0x8e13e48a, 0xad5df7fd, 0x738c8997, 0x0a0030d0,
+  VLOAD_32(v16, 0x709e784e, 0x8e13e48a, 0xad5df7fd, 0x738c8997, 0x0a0030d0,
            0x7569b952, 0x507fd5c7, 0x5d09af12, 0x0bf1c209, 0x7be6ed49,
            0x842ba667, 0x53360ec0, 0xd85d7415, 0xf20de61f, 0x153e7e16,
            0xec5512e4);
-  VLOAD_32(v2, 0xb2436fad, 0x6b162382, 0xd94eebe7, 0x9c43d906, 0xb80f178d,
+  VLOAD_32(v8, 0xb2436fad, 0x6b162382, 0xd94eebe7, 0x9c43d906, 0xb80f178d,
            0x5cf91d42, 0x7764b8a3, 0x6269f72c, 0xb0dff3a6, 0x838d6893,
            0xa98a861e, 0x758b63de, 0xde488617, 0x371696ab, 0xc3ba8192,
            0x7ca33236);
-  asm volatile("vmacc.vx v2, %[A], v4" ::[A] "r"(scalar));
-  VCMP_U32(11, v2, 0x8e0d1d47, 0xf29d4830, 0xb5213626, 0xb21bb5a3, 0xbc2f367d,
+  asm volatile("vmacc.vx v8, %[A], v16" ::[A] "r"(scalar));
+  VCMP_U32(11, v8, 0x8e0d1d47, 0xf29d4830, 0xb5213626, 0xb21bb5a3, 0xbc2f367d,
            0x18eb9d88, 0x91c53550, 0x69a6ceb2, 0xc09822e9, 0x66c98b96,
            0xf6b125ab, 0xef3fae1e, 0x4c40925e, 0x6b652c20, 0x998385c4,
            0x75d88d82);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
+  /*   VSET(16, e64, m8); */
   /*   scalar = -598189234597999223; */
-  /*   VLOAD_64(v4, 0x2a47beb4fd7729c5, 0x401c187818b15d1e, 0xbbaf5fe50c41f22a,
+  /*   VLOAD_64(v16, 0x2a47beb4fd7729c5, 0x401c187818b15d1e, 0xbbaf5fe50c41f22a,
    */
   /*            0x31eaddea171055a9, 0x609cbc4a78316c29, 0xd7bb8f31d8b59d88, */
   /*            0x97860fd5fba018c0, 0x724cecf178bd2125, 0x866d16f96d3d8b67, */
   /*            0x56153b0315164a5a, 0x6962bde49e3edf3f, 0x9b3f792bfbf5f343, */
   /*            0x64cf433b239e7764, 0x583c3a4ae481fef0, 0x217e2df75fcf0d8d, */
   /*            0x935ac02069fe54ce); */
-  /*   VLOAD_64(v2, 0x0dc8fa1b817237e5, 0xc817934370de904d, 0xb015bdbf0f39ec01,
+  /*   VLOAD_64(v8, 0x0dc8fa1b817237e5, 0xc817934370de904d, 0xb015bdbf0f39ec01,
    */
   /*            0x3c7e70a75643cce5, 0x80c45834a5026c02, 0xcdf1fcd83b8133a0, */
   /*            0x9d31b9b802ae2db1, 0xba7e57975c5febf5, 0x8732f75adf268ddb, */
   /*            0x5ff488a4187bd3f3, 0x6a259fe666091333, 0x5afc4de057de51c4, */
   /*            0x8a479b7e3558e399, 0xbc21e79022996c26, 0xe2c7432cd7e3e81d, */
   /*            0xdab377ddbdfb2df7); */
-  /*   asm volatile("vmacc.vx v2, %[A], v4" ::[A] "r"(scalar)); */
-  /*   VCMP_U64(12, v2, 0x093861b79ac45352, 0xfd3c909decf66b5b,
+  /*   asm volatile("vmacc.vx v8, %[A], v16" ::[A] "r"(scalar)); */
+  /*   VCMP_U64(12, v8, 0x093861b79ac45352, 0xfd3c909decf66b5b,
    * 0x04eb13132ce4267b, */
   /*            0xb258e6b065bbf956, 0x62775181e33422f3, 0xdc0ae0e371686968, */
   /*            0xf8db06270cad2c71, 0x6c3cc52cd1fb49c2, 0x41c19c0ac1b5a2fa, */
@@ -224,57 +224,57 @@ void TEST_CASE3() {
 }
 
 void TEST_CASE4() {
-  VSET(16, e8, m2);
+  VSET(16, e8, m8);
   int64_t scalar = 5;
-  VLOAD_8(v4, 0x60, 0xe3, 0xa0, 0xb7, 0x35, 0x23, 0xa3, 0xf4, 0x5f, 0x6e, 0x07,
+  VLOAD_8(v16, 0x60, 0xe3, 0xa0, 0xb7, 0x35, 0x23, 0xa3, 0xf4, 0x5f, 0x6e, 0x07,
           0x01, 0xe7, 0x51, 0x53, 0x29);
-  VLOAD_8(v2, 0xfb, 0x1b, 0xc0, 0x36, 0xa7, 0xe0, 0xc8, 0x47, 0x57, 0xe0, 0x51,
+  VLOAD_8(v8, 0xfb, 0x1b, 0xc0, 0x36, 0xa7, 0xe0, 0xc8, 0x47, 0x57, 0xe0, 0x51,
           0xaa, 0xd2, 0x93, 0x83, 0xa8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmacc.vx v2, %[A], v4, v0.t" ::[A] "r"(scalar));
-  VCMP_U8(13, v2, 0xfb, 0x8a, 0xc0, 0xc9, 0xa7, 0x8f, 0xc8, 0x0b, 0x57, 0x06,
+  asm volatile("vmacc.vx v8, %[A], v16, v0.t" ::[A] "r"(scalar));
+  VCMP_U8(13, v8, 0xfb, 0x8a, 0xc0, 0xc9, 0xa7, 0x8f, 0xc8, 0x0b, 0x57, 0x06,
           0x51, 0xaf, 0xd2, 0x28, 0x83, 0x75);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   scalar = -5383;
-  VLOAD_16(v4, 0x992e, 0x9a07, 0x90c3, 0xf1ce, 0xd53c, 0x8f07, 0x2d2f, 0x5ab1,
+  VLOAD_16(v16, 0x992e, 0x9a07, 0x90c3, 0xf1ce, 0xd53c, 0x8f07, 0x2d2f, 0x5ab1,
            0x0a79, 0x0523, 0x6f34, 0xe5fd, 0xc95a, 0xca1c, 0x36bf, 0x16a1);
-  VLOAD_16(v2, 0x0a9f, 0x7ee0, 0x494e, 0xb6d0, 0x394c, 0xc8e7, 0xc117, 0x8108,
+  VLOAD_16(v8, 0x0a9f, 0x7ee0, 0x494e, 0xb6d0, 0x394c, 0xc8e7, 0xc117, 0x8108,
            0xb1af, 0x9f16, 0x22ab, 0xa244, 0xf1c9, 0xe363, 0x9bed, 0xa06f);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmacc.vx v2, %[A], v4, v0.t" ::[A] "r"(scalar));
-  VCMP_U16(14, v2, 0x0a9f, 0xb5af, 0x494e, 0x342e, 0x394c, 0x4cb6, 0xc117,
+  asm volatile("vmacc.vx v8, %[A], v16, v0.t" ::[A] "r"(scalar));
+  VCMP_U16(14, v8, 0x0a9f, 0xb5af, 0x494e, 0x342e, 0x394c, 0x4cb6, 0xc117,
            0x8131, 0xb1af, 0x9c21, 0x22ab, 0x9759, 0xf1c9, 0x109f, 0x9bed,
            0xcd08);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   scalar = 6474219;
-  VLOAD_32(v4, 0x709e784e, 0x8e13e48a, 0xad5df7fd, 0x738c8997, 0x0a0030d0,
+  VLOAD_32(v16, 0x709e784e, 0x8e13e48a, 0xad5df7fd, 0x738c8997, 0x0a0030d0,
            0x7569b952, 0x507fd5c7, 0x5d09af12, 0x0bf1c209, 0x7be6ed49,
            0x842ba667, 0x53360ec0, 0xd85d7415, 0xf20de61f, 0x153e7e16,
            0xec5512e4);
-  VLOAD_32(v2, 0xb2436fad, 0x6b162382, 0xd94eebe7, 0x9c43d906, 0xb80f178d,
+  VLOAD_32(v8, 0xb2436fad, 0x6b162382, 0xd94eebe7, 0x9c43d906, 0xb80f178d,
            0x5cf91d42, 0x7764b8a3, 0x6269f72c, 0xb0dff3a6, 0x838d6893,
            0xa98a861e, 0x758b63de, 0xde488617, 0x371696ab, 0xc3ba8192,
            0x7ca33236);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmacc.vx v2, %[A], v4, v0.t" ::[A] "r"(scalar));
-  VCMP_U32(15, v2, 0xb2436fad, 0xf29d4830, 0xd94eebe7, 0xb21bb5a3, 0xb80f178d,
+  asm volatile("vmacc.vx v8, %[A], v16, v0.t" ::[A] "r"(scalar));
+  VCMP_U32(15, v8, 0xb2436fad, 0xf29d4830, 0xd94eebe7, 0xb21bb5a3, 0xb80f178d,
            0x18eb9d88, 0x7764b8a3, 0x69a6ceb2, 0xb0dff3a6, 0x66c98b96,
            0xa98a861e, 0xef3fae1e, 0xde488617, 0x6b652c20, 0xc3ba8192,
            0x75d88d82);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
+  /*   VSET(16, e64, m8); */
   /*   scalar = -598189234597999223; */
-  /*   VLOAD_64(v4, 0x2a47beb4fd7729c5, 0x401c187818b15d1e, 0xbbaf5fe50c41f22a,
+  /*   VLOAD_64(v16, 0x2a47beb4fd7729c5, 0x401c187818b15d1e, 0xbbaf5fe50c41f22a,
    */
   /*            0x31eaddea171055a9, 0x609cbc4a78316c29, 0xd7bb8f31d8b59d88, */
   /*            0x97860fd5fba018c0, 0x724cecf178bd2125, 0x866d16f96d3d8b67, */
   /*            0x56153b0315164a5a, 0x6962bde49e3edf3f, 0x9b3f792bfbf5f343, */
   /*            0x64cf433b239e7764, 0x583c3a4ae481fef0, 0x217e2df75fcf0d8d, */
   /*            0x935ac02069fe54ce); */
-  /*   VLOAD_64(v2, 0x0dc8fa1b817237e5, 0xc817934370de904d, 0xb015bdbf0f39ec01,
+  /*   VLOAD_64(v8, 0x0dc8fa1b817237e5, 0xc817934370de904d, 0xb015bdbf0f39ec01,
    */
   /*            0x3c7e70a75643cce5, 0x80c45834a5026c02, 0xcdf1fcd83b8133a0, */
   /*            0x9d31b9b802ae2db1, 0xba7e57975c5febf5, 0x8732f75adf268ddb, */
@@ -282,8 +282,8 @@ void TEST_CASE4() {
   /*            0x8a479b7e3558e399, 0xbc21e79022996c26, 0xe2c7432cd7e3e81d, */
   /*            0xdab377ddbdfb2df7); */
   /*   VLOAD_8(v0, 0xAA, 0xAA); */
-  /*   asm volatile("vmacc.vx v2, %[A], v4, v0.t" ::[A] "r"(scalar)); */
-  /*   VCMP_U64(16, v2, 0x0dc8fa1b817237e5, 0xfd3c909decf66b5b,
+  /*   asm volatile("vmacc.vx v8, %[A], v16, v0.t" ::[A] "r"(scalar)); */
+  /*   VCMP_U64(16, v8, 0x0dc8fa1b817237e5, 0xfd3c909decf66b5b,
    * 0xb015bdbf0f39ec01, */
   /*            0xb258e6b065bbf956, 0x80c45834a5026c02, 0xdc0ae0e371686968, */
   /*            0x9d31b9b802ae2db1, 0x6c3cc52cd1fb49c2, 0x8732f75adf268ddb, */
diff --git a/sw/riscvTests/isa/rv64uv/vmadd.c b/sw/riscvTests/isa/rv64uv/vmadd.c
index 5241d0b7..dd2e68ee 100644
--- a/sw/riscvTests/isa/rv64uv/vmadd.c
+++ b/sw/riscvTests/isa/rv64uv/vmadd.c
@@ -8,70 +8,70 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 0x21, 0x75, 0x7f, 0x3a, 0x50, 0x6d, 0x3f, 0x3e, 0x74, 0x11, 0x29,
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 0x21, 0x75, 0x7f, 0x3a, 0x50, 0x6d, 0x3f, 0x3e, 0x74, 0x11, 0x29,
           0xea, 0x14, 0xce, 0xb0, 0x37);
-  VLOAD_8(v4, 0xfe, 0xa7, 0x06, 0xaa, 0x35, 0x3c, 0x2c, 0x58, 0xa1, 0xc4, 0x40,
+  VLOAD_8(v16, 0xfe, 0xa7, 0x06, 0xaa, 0x35, 0x3c, 0x2c, 0x58, 0xa1, 0xc4, 0x40,
           0x42, 0x52, 0x40, 0xa8, 0x53);
-  VLOAD_8(v6, 0x30, 0xef, 0xb4, 0x12, 0x6d, 0x3b, 0x2c, 0x5e, 0xf0, 0x25, 0xd7,
+  VLOAD_8(v24, 0x30, 0xef, 0xb4, 0x12, 0x6d, 0x3b, 0x2c, 0x5e, 0xf0, 0x25, 0xd7,
           0x70, 0xc2, 0x62, 0xe0, 0x99);
-  asm volatile("vmadd.vv v2, v4, v6");
-  VCMP_U8(1, v2, 0xee, 0x42, 0xae, 0x96, 0xfd, 0xc7, 0x00, 0xae, 0xe4, 0x29,
+  asm volatile("vmadd.vv v8, v16, v24");
+  VCMP_U8(1, v8, 0xee, 0x42, 0xae, 0x96, 0xfd, 0xc7, 0x00, 0xae, 0xe4, 0x29,
           0x17, 0xc4, 0x2a, 0xe2, 0x60, 0x6e);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 0x1c20, 0x11e4, 0xde38, 0x642f, 0x3eb5, 0xa0af, 0x48e1, 0x5fc4,
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 0x1c20, 0x11e4, 0xde38, 0x642f, 0x3eb5, 0xa0af, 0x48e1, 0x5fc4,
            0x3d2a, 0x67d5, 0x3f07, 0x2889, 0x8812, 0x0bd9, 0x56f4, 0xe068);
-  VLOAD_16(v4, 0x02cc, 0xd99c, 0xdba2, 0xf282, 0x0f99, 0xa219, 0x2dcc, 0x17cc,
+  VLOAD_16(v16, 0x02cc, 0xd99c, 0xdba2, 0xf282, 0x0f99, 0xa219, 0x2dcc, 0x17cc,
            0xe8fb, 0x1e83, 0xed20, 0xbfee, 0xee87, 0x6b0f, 0xf6cf, 0x4cd1);
-  VLOAD_16(v6, 0xe3f0, 0x42db, 0x2fde, 0x1983, 0x910c, 0x853b, 0x82aa, 0x9ac2,
+  VLOAD_16(v24, 0xe3f0, 0x42db, 0x2fde, 0x1983, 0x910c, 0x853b, 0x82aa, 0x9ac2,
            0x4631, 0x1f8b, 0x68c3, 0x6fbc, 0x3b5c, 0xf98b, 0x2db1, 0x8e75);
-  asm volatile("vmadd.vv v2, v4, v6");
-  VCMP_U16(2, v2, 0x8d70, 0x6dcb, 0xb74e, 0x6761, 0xa639, 0xf452, 0x22f6,
+  asm volatile("vmadd.vv v8, v16, v24");
+  VCMP_U16(2, v8, 0x8d70, 0x6dcb, 0xb74e, 0x6761, 0xa639, 0xf452, 0x22f6,
            0x86f2, 0x4e5f, 0x378a, 0xc4a3, 0x561a, 0xb8da, 0x5e42, 0xf4fd,
            0xa35d);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 0x0401c584, 0x69049955, 0x4a71aa0c, 0xc651666f, 0x273fcd5d,
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 0x0401c584, 0x69049955, 0x4a71aa0c, 0xc651666f, 0x273fcd5d,
            0x23ca1d7d, 0x599c994e, 0xb2d8adc5, 0x4710afae, 0x69c61cad,
            0x96ee5026, 0x2c197996, 0xd95da451, 0x3a654fb9, 0xbe990e4b,
            0xc41fd55a);
-  VLOAD_32(v4, 0x39d5b56a, 0xc578a540, 0x51283b5c, 0x07b4ba9d, 0xe5aba5e4,
+  VLOAD_32(v16, 0x39d5b56a, 0xc578a540, 0x51283b5c, 0x07b4ba9d, 0xe5aba5e4,
            0x28720dc8, 0x600fb42b, 0xf2937fa7, 0x4032d36f, 0xc676e3b3,
            0xf1cd5f96, 0x1c14bcbf, 0x7dea81ed, 0x40270562, 0x9577b3be,
            0xea615f0a);
-  VLOAD_32(v6, 0xa055bbb6, 0x71f9a668, 0x0be640c9, 0x2336ca55, 0xca121638,
+  VLOAD_32(v24, 0xa055bbb6, 0x71f9a668, 0x0be640c9, 0x2336ca55, 0xca121638,
            0xbf234fb5, 0xe7c83142, 0xb7048f12, 0x8eb340e3, 0xef253e93,
            0xffef4a03, 0xdf346833, 0xd0922181, 0xf159ee1d, 0xf86a7c06,
            0xfcb24a2d);
-  asm volatile("vmadd.vv v2, v4, v6");
-  VCMP_U32(3, v2, 0x448bd85e, 0xf2cbc4a8, 0x5cd02119, 0xf69b4268, 0x3c60ee0c,
+  asm volatile("vmadd.vv v8, v16, v24");
+  VCMP_U32(3, v8, 0x448bd85e, 0xf2cbc4a8, 0x5cd02119, 0xf69b4268, 0x3c60ee0c,
            0xa233b25d, 0x4c72c95c, 0xe2b1a595, 0xefb7d755, 0x95d6b28a,
            0xd3be5a47, 0x6338471d, 0xfb1a117e, 0xabe00fef, 0xbede88b0,
            0x913705b1);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 0x9cffef345b95f00b, 0x85d366e07e4bbc6b, 0xadfda1d2464c6433,
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 0x9cffef345b95f00b, 0x85d366e07e4bbc6b, 0xadfda1d2464c6433,
            0x610bf2c1435b3cf6, 0x8a0c6e4bc950e81f, 0x4296e7147ef94d7a,
            0x27d7ec90ba159756, 0x2a6c87932c3aef86, 0xbfd90c33e58a8fe3,
            0x1114f7672cf625c1, 0x1a7b72dd8ac39fab, 0xdb80f952e5fd2e5b,
            0x6b01c18a3daf288b, 0x69b4b0e4335f26d5, 0x0c059f365ec6d3d5,
            0xc22568276f1dcdd0);
-  VLOAD_64(v4, 0x6dc8e88769e54465, 0xce8cda83d16c3859, 0x1465ee5b6eb0d2b8,
+  VLOAD_64(v16, 0x6dc8e88769e54465, 0xce8cda83d16c3859, 0x1465ee5b6eb0d2b8,
            0x4827a9b40add2507, 0xd24c4005695a64d6, 0xb97c8e41e912f84a,
            0xc8c22e3b3b2e2fa1, 0x26712aa325bd00b6, 0xdf7ad19151df27b5,
            0x68ba6d050ffcba1e, 0x94448979a2b854e6, 0x84bf5d544f97f739,
            0x6d4bfa429e9d6ef0, 0xdb6c54b9a91ab935, 0x1a0051ca72162c5e,
            0xe04b73fdf1b61f9c);
-  VLOAD_64(v6, 0x32a4c1edbbfe5591, 0xf6baf4e747f4a120, 0x3a29727ae38b9b92,
+  VLOAD_64(v24, 0x32a4c1edbbfe5591, 0xf6baf4e747f4a120, 0x3a29727ae38b9b92,
            0xf173f78d09c997e4, 0xaab9d34e4aeaa57a, 0xa8fe3bf12b7c95e8,
            0xc4bd99b066821092, 0x9c2f1daf5fe2db9d, 0xa8b041a876aabcae,
            0xb9a2e6f9ded9a60a, 0x8bdf55954f50101d, 0x704f0e648c11d63f,
            0x0c8ca4d0a6d1a982, 0xa74d01c12ae6aea5, 0x3f2cd5d2e2f5b538,
            0x79803b24efa2caa3);
-  asm volatile("vmadd.vv v2, v4, v6");
-  VCMP_U64(4, v2, 0xf7c2044aeebff5e8, 0xad447a1b99a48a53, 0x78676efbe1b5763a,
+  asm volatile("vmadd.vv v8, v16, v24");
+  VCMP_U64(4, v8, 0xf7c2044aeebff5e8, 0xad447a1b99a48a53, 0x78676efbe1b5763a,
            0x813582af4d75d09e, 0x483adf8d811ecb64, 0x36d90fe4df2f2b2c,
            0xf833b173685307a8, 0x955c2ac405b724e1, 0xdcf9681f074b0d2d,
            0x10277404741c4ca8, 0x25d9bca0245d9fbf, 0x58439c4175d7f582,
@@ -81,74 +81,74 @@ void TEST_CASE1() {
 }
 
 void TEST_CASE2() {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 0x21, 0x75, 0x7f, 0x3a, 0x50, 0x6d, 0x3f, 0x3e, 0x74, 0x11, 0x29,
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 0x21, 0x75, 0x7f, 0x3a, 0x50, 0x6d, 0x3f, 0x3e, 0x74, 0x11, 0x29,
           0xea, 0x14, 0xce, 0xb0, 0x37);
-  VLOAD_8(v4, 0xfe, 0xa7, 0x06, 0xaa, 0x35, 0x3c, 0x2c, 0x58, 0xa1, 0xc4, 0x40,
+  VLOAD_8(v16, 0xfe, 0xa7, 0x06, 0xaa, 0x35, 0x3c, 0x2c, 0x58, 0xa1, 0xc4, 0x40,
           0x42, 0x52, 0x40, 0xa8, 0x53);
-  VLOAD_8(v6, 0x30, 0xef, 0xb4, 0x12, 0x6d, 0x3b, 0x2c, 0x5e, 0xf0, 0x25, 0xd7,
+  VLOAD_8(v24, 0x30, 0xef, 0xb4, 0x12, 0x6d, 0x3b, 0x2c, 0x5e, 0xf0, 0x25, 0xd7,
           0x70, 0xc2, 0x62, 0xe0, 0x99);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmadd.vv v2, v4, v6, v0.t");
-  VCMP_U8(5, v2, 0x21, 0x42, 0x7f, 0x96, 0x50, 0xc7, 0x3f, 0xae, 0x74, 0x29,
+  asm volatile("vmadd.vv v8, v16, v24, v0.t");
+  VCMP_U8(5, v8, 0x21, 0x42, 0x7f, 0x96, 0x50, 0xc7, 0x3f, 0xae, 0x74, 0x29,
           0x29, 0xc4, 0x14, 0xe2, 0xb0, 0x6e);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 0x1c20, 0x11e4, 0xde38, 0x642f, 0x3eb5, 0xa0af, 0x48e1, 0x5fc4,
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 0x1c20, 0x11e4, 0xde38, 0x642f, 0x3eb5, 0xa0af, 0x48e1, 0x5fc4,
            0x3d2a, 0x67d5, 0x3f07, 0x2889, 0x8812, 0x0bd9, 0x56f4, 0xe068);
-  VLOAD_16(v4, 0x02cc, 0xd99c, 0xdba2, 0xf282, 0x0f99, 0xa219, 0x2dcc, 0x17cc,
+  VLOAD_16(v16, 0x02cc, 0xd99c, 0xdba2, 0xf282, 0x0f99, 0xa219, 0x2dcc, 0x17cc,
            0xe8fb, 0x1e83, 0xed20, 0xbfee, 0xee87, 0x6b0f, 0xf6cf, 0x4cd1);
-  VLOAD_16(v6, 0xe3f0, 0x42db, 0x2fde, 0x1983, 0x910c, 0x853b, 0x82aa, 0x9ac2,
+  VLOAD_16(v24, 0xe3f0, 0x42db, 0x2fde, 0x1983, 0x910c, 0x853b, 0x82aa, 0x9ac2,
            0x4631, 0x1f8b, 0x68c3, 0x6fbc, 0x3b5c, 0xf98b, 0x2db1, 0x8e75);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmadd.vv v2, v4, v6, v0.t");
-  VCMP_U16(6, v2, 0x1c20, 0x6dcb, 0xde38, 0x6761, 0x3eb5, 0xf452, 0x48e1,
+  asm volatile("vmadd.vv v8, v16, v24, v0.t");
+  VCMP_U16(6, v8, 0x1c20, 0x6dcb, 0xde38, 0x6761, 0x3eb5, 0xf452, 0x48e1,
            0x86f2, 0x3d2a, 0x378a, 0x3f07, 0x561a, 0x8812, 0x5e42, 0x56f4,
            0xa35d);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 0x0401c584, 0x69049955, 0x4a71aa0c, 0xc651666f, 0x273fcd5d,
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 0x0401c584, 0x69049955, 0x4a71aa0c, 0xc651666f, 0x273fcd5d,
            0x23ca1d7d, 0x599c994e, 0xb2d8adc5, 0x4710afae, 0x69c61cad,
            0x96ee5026, 0x2c197996, 0xd95da451, 0x3a654fb9, 0xbe990e4b,
            0xc41fd55a);
-  VLOAD_32(v4, 0x39d5b56a, 0xc578a540, 0x51283b5c, 0x07b4ba9d, 0xe5aba5e4,
+  VLOAD_32(v16, 0x39d5b56a, 0xc578a540, 0x51283b5c, 0x07b4ba9d, 0xe5aba5e4,
            0x28720dc8, 0x600fb42b, 0xf2937fa7, 0x4032d36f, 0xc676e3b3,
            0xf1cd5f96, 0x1c14bcbf, 0x7dea81ed, 0x40270562, 0x9577b3be,
            0xea615f0a);
-  VLOAD_32(v6, 0xa055bbb6, 0x71f9a668, 0x0be640c9, 0x2336ca55, 0xca121638,
+  VLOAD_32(v24, 0xa055bbb6, 0x71f9a668, 0x0be640c9, 0x2336ca55, 0xca121638,
            0xbf234fb5, 0xe7c83142, 0xb7048f12, 0x8eb340e3, 0xef253e93,
            0xffef4a03, 0xdf346833, 0xd0922181, 0xf159ee1d, 0xf86a7c06,
            0xfcb24a2d);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmadd.vv v2, v4, v6, v0.t");
-  VCMP_U32(7, v2, 0x0401c584, 0xf2cbc4a8, 0x4a71aa0c, 0xf69b4268, 0x273fcd5d,
+  asm volatile("vmadd.vv v8, v16, v24, v0.t");
+  VCMP_U32(7, v8, 0x0401c584, 0xf2cbc4a8, 0x4a71aa0c, 0xf69b4268, 0x273fcd5d,
            0xa233b25d, 0x599c994e, 0xe2b1a595, 0x4710afae, 0x95d6b28a,
            0x96ee5026, 0x6338471d, 0xd95da451, 0xabe00fef, 0xbe990e4b,
            0x913705b1);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 0x9cffef345b95f00b, 0x85d366e07e4bbc6b, 0xadfda1d2464c6433,
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 0x9cffef345b95f00b, 0x85d366e07e4bbc6b, 0xadfda1d2464c6433,
            0x610bf2c1435b3cf6, 0x8a0c6e4bc950e81f, 0x4296e7147ef94d7a,
            0x27d7ec90ba159756, 0x2a6c87932c3aef86, 0xbfd90c33e58a8fe3,
            0x1114f7672cf625c1, 0x1a7b72dd8ac39fab, 0xdb80f952e5fd2e5b,
            0x6b01c18a3daf288b, 0x69b4b0e4335f26d5, 0x0c059f365ec6d3d5,
            0xc22568276f1dcdd0);
-  VLOAD_64(v4, 0x6dc8e88769e54465, 0xce8cda83d16c3859, 0x1465ee5b6eb0d2b8,
+  VLOAD_64(v16, 0x6dc8e88769e54465, 0xce8cda83d16c3859, 0x1465ee5b6eb0d2b8,
            0x4827a9b40add2507, 0xd24c4005695a64d6, 0xb97c8e41e912f84a,
            0xc8c22e3b3b2e2fa1, 0x26712aa325bd00b6, 0xdf7ad19151df27b5,
            0x68ba6d050ffcba1e, 0x94448979a2b854e6, 0x84bf5d544f97f739,
            0x6d4bfa429e9d6ef0, 0xdb6c54b9a91ab935, 0x1a0051ca72162c5e,
            0xe04b73fdf1b61f9c);
-  VLOAD_64(v6, 0x32a4c1edbbfe5591, 0xf6baf4e747f4a120, 0x3a29727ae38b9b92,
+  VLOAD_64(v24, 0x32a4c1edbbfe5591, 0xf6baf4e747f4a120, 0x3a29727ae38b9b92,
            0xf173f78d09c997e4, 0xaab9d34e4aeaa57a, 0xa8fe3bf12b7c95e8,
            0xc4bd99b066821092, 0x9c2f1daf5fe2db9d, 0xa8b041a876aabcae,
            0xb9a2e6f9ded9a60a, 0x8bdf55954f50101d, 0x704f0e648c11d63f,
            0x0c8ca4d0a6d1a982, 0xa74d01c12ae6aea5, 0x3f2cd5d2e2f5b538,
            0x79803b24efa2caa3);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmadd.vv v2, v4, v6, v0.t");
-  VCMP_U64(8, v2, 0x9cffef345b95f00b, 0xad447a1b99a48a53, 0xadfda1d2464c6433,
+  asm volatile("vmadd.vv v8, v16, v24, v0.t");
+  VCMP_U64(8, v8, 0x9cffef345b95f00b, 0xad447a1b99a48a53, 0xadfda1d2464c6433,
            0x813582af4d75d09e, 0x8a0c6e4bc950e81f, 0x36d90fe4df2f2b2c,
            0x27d7ec90ba159756, 0x955c2ac405b724e1, 0xbfd90c33e58a8fe3,
            0x10277404741c4ca8, 0x1a7b72dd8ac39fab, 0x58439c4175d7f582,
@@ -158,62 +158,62 @@ void TEST_CASE2() {
 }
 
 void TEST_CASE3() {
-  VSET(16, e8, m2);
+  VSET(16, e8, m8);
   int64_t scalar = 5;
-  VLOAD_8(v2, 0x60, 0xe3, 0xa0, 0xb7, 0x35, 0x23, 0xa3, 0xf4, 0x5f, 0x6e, 0x07,
+  VLOAD_8(v8, 0x60, 0xe3, 0xa0, 0xb7, 0x35, 0x23, 0xa3, 0xf4, 0x5f, 0x6e, 0x07,
           0x01, 0xe7, 0x51, 0x53, 0x29);
-  VLOAD_8(v4, 0xfb, 0x1b, 0xc0, 0x36, 0xa7, 0xe0, 0xc8, 0x47, 0x57, 0xe0, 0x51,
+  VLOAD_8(v16, 0xfb, 0x1b, 0xc0, 0x36, 0xa7, 0xe0, 0xc8, 0x47, 0x57, 0xe0, 0x51,
           0xaa, 0xd2, 0x93, 0x83, 0xa8);
-  asm volatile("vmadd.vx v2, %[A], v4" ::[A] "r"(scalar));
-  VCMP_U8(9, v2, 0xdb, 0x8a, 0xe0, 0xc9, 0xb0, 0x8f, 0xf7, 0x0b, 0x32, 0x06,
+  asm volatile("vmadd.vx v8, %[A], v16" ::[A] "r"(scalar));
+  VCMP_U8(9, v8, 0xdb, 0x8a, 0xe0, 0xc9, 0xb0, 0x8f, 0xf7, 0x0b, 0x32, 0x06,
           0x74, 0xaf, 0x55, 0x28, 0x22, 0x75);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   scalar = -5383;
-  VLOAD_16(v2, 0x992e, 0x9a07, 0x90c3, 0xf1ce, 0xd53c, 0x8f07, 0x2d2f, 0x5ab1,
+  VLOAD_16(v8, 0x992e, 0x9a07, 0x90c3, 0xf1ce, 0xd53c, 0x8f07, 0x2d2f, 0x5ab1,
            0x0a79, 0x0523, 0x6f34, 0xe5fd, 0xc95a, 0xca1c, 0x36bf, 0x16a1);
-  VLOAD_16(v4, 0x0a9f, 0x7ee0, 0x494e, 0xb6d0, 0x394c, 0xc8e7, 0xc117, 0x8108,
+  VLOAD_16(v16, 0x0a9f, 0x7ee0, 0x494e, 0xb6d0, 0x394c, 0xc8e7, 0xc117, 0x8108,
            0xb1af, 0x9f16, 0x22ab, 0xa244, 0xf1c9, 0xe363, 0x9bed, 0xa06f);
-  asm volatile("vmadd.vx v2, %[A], v4" ::[A] "r"(scalar));
-  VCMP_U16(10, v2, 0x145d, 0xb5af, 0x54f9, 0x342e, 0x78a8, 0x4cb6, 0xa9ce,
+  asm volatile("vmadd.vx v8, %[A], v16" ::[A] "r"(scalar));
+  VCMP_U16(10, v8, 0x145d, 0xb5af, 0x54f9, 0x342e, 0x78a8, 0x4cb6, 0xa9ce,
            0x8131, 0x7b60, 0x9c21, 0xd43f, 0x9759, 0x0e53, 0x109f, 0x71b4,
            0xcd08);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   scalar = 6474219;
-  VLOAD_32(v2, 0x709e784e, 0x8e13e48a, 0xad5df7fd, 0x738c8997, 0x0a0030d0,
+  VLOAD_32(v8, 0x709e784e, 0x8e13e48a, 0xad5df7fd, 0x738c8997, 0x0a0030d0,
            0x7569b952, 0x507fd5c7, 0x5d09af12, 0x0bf1c209, 0x7be6ed49,
            0x842ba667, 0x53360ec0, 0xd85d7415, 0xf20de61f, 0x153e7e16,
            0xec5512e4);
-  VLOAD_32(v4, 0xb2436fad, 0x6b162382, 0xd94eebe7, 0x9c43d906, 0xb80f178d,
+  VLOAD_32(v16, 0xb2436fad, 0x6b162382, 0xd94eebe7, 0x9c43d906, 0xb80f178d,
            0x5cf91d42, 0x7764b8a3, 0x6269f72c, 0xb0dff3a6, 0x838d6893,
            0xa98a861e, 0x758b63de, 0xde488617, 0x371696ab, 0xc3ba8192,
            0x7ca33236);
-  asm volatile("vmadd.vx v2, %[A], v4" ::[A] "r"(scalar));
-  VCMP_U32(11, v2, 0x8e0d1d47, 0xf29d4830, 0xb5213626, 0xb21bb5a3, 0xbc2f367d,
+  asm volatile("vmadd.vx v8, %[A], v16" ::[A] "r"(scalar));
+  VCMP_U32(11, v8, 0x8e0d1d47, 0xf29d4830, 0xb5213626, 0xb21bb5a3, 0xbc2f367d,
            0x18eb9d88, 0x91c53550, 0x69a6ceb2, 0xc09822e9, 0x66c98b96,
            0xf6b125ab, 0xef3fae1e, 0x4c40925e, 0x6b652c20, 0x998385c4,
            0x75d88d82);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
+  /*   VSET(16, e64, m8); */
   /*   scalar = -598189234597999223; */
-  /*   VLOAD_64(v2, 0x2a47beb4fd7729c5, 0x401c187818b15d1e, 0xbbaf5fe50c41f22a,
+  /*   VLOAD_64(v8, 0x2a47beb4fd7729c5, 0x401c187818b15d1e, 0xbbaf5fe50c41f22a,
    */
   /*            0x31eaddea171055a9, 0x609cbc4a78316c29, 0xd7bb8f31d8b59d88, */
   /*            0x97860fd5fba018c0, 0x724cecf178bd2125, 0x866d16f96d3d8b67, */
   /*            0x56153b0315164a5a, 0x6962bde49e3edf3f, 0x9b3f792bfbf5f343, */
   /*            0x64cf433b239e7764, 0x583c3a4ae481fef0, 0x217e2df75fcf0d8d, */
   /*            0x935ac02069fe54ce); */
-  /*   VLOAD_64(v4, 0x0dc8fa1b817237e5, 0xc817934370de904d, 0xb015bdbf0f39ec01,
+  /*   VLOAD_64(v16, 0x0dc8fa1b817237e5, 0xc817934370de904d, 0xb015bdbf0f39ec01,
    */
   /*            0x3c7e70a75643cce5, 0x80c45834a5026c02, 0xcdf1fcd83b8133a0, */
   /*            0x9d31b9b802ae2db1, 0xba7e57975c5febf5, 0x8732f75adf268ddb, */
   /*            0x5ff488a4187bd3f3, 0x6a259fe666091333, 0x5afc4de057de51c4, */
   /*            0x8a479b7e3558e399, 0xbc21e79022996c26, 0xe2c7432cd7e3e81d, */
   /*            0xdab377ddbdfb2df7); */
-  /*   asm volatile("vmadd.vx v2, %[A], v4" ::[A] "r"(scalar)); */
-  /*   VCMP_U64(12, v2, 0x093861b79ac45352, 0xfd3c909decf66b5b,
+  /*   asm volatile("vmadd.vx v8, %[A], v16" ::[A] "r"(scalar)); */
+  /*   VCMP_U64(12, v8, 0x093861b79ac45352, 0xfd3c909decf66b5b,
    * 0x04eb13132ce4267b, */
   /*            0xb258e6b065bbf956, 0x62775181e33422f3, 0xdc0ae0e371686968, */
   /*            0xf8db06270cad2c71, 0x6c3cc52cd1fb49c2, 0x41c19c0ac1b5a2fa, */
@@ -224,57 +224,57 @@ void TEST_CASE3() {
 }
 
 void TEST_CASE4() {
-  VSET(16, e8, m2);
+  VSET(16, e8, m8);
   int64_t scalar = 5;
-  VLOAD_8(v2, 0x60, 0xe3, 0xa0, 0xb7, 0x35, 0x23, 0xa3, 0xf4, 0x5f, 0x6e, 0x07,
+  VLOAD_8(v8, 0x60, 0xe3, 0xa0, 0xb7, 0x35, 0x23, 0xa3, 0xf4, 0x5f, 0x6e, 0x07,
           0x01, 0xe7, 0x51, 0x53, 0x29);
-  VLOAD_8(v4, 0xfb, 0x1b, 0xc0, 0x36, 0xa7, 0xe0, 0xc8, 0x47, 0x57, 0xe0, 0x51,
+  VLOAD_8(v16, 0xfb, 0x1b, 0xc0, 0x36, 0xa7, 0xe0, 0xc8, 0x47, 0x57, 0xe0, 0x51,
           0xaa, 0xd2, 0x93, 0x83, 0xa8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmadd.vx v2, %[A], v4, v0.t" ::[A] "r"(scalar));
-  VCMP_U8(13, v2, 0x60, 0x8a, 0xa0, 0xc9, 0x35, 0x8f, 0xa3, 0x0b, 0x5f, 0x06,
+  asm volatile("vmadd.vx v8, %[A], v16, v0.t" ::[A] "r"(scalar));
+  VCMP_U8(13, v8, 0x60, 0x8a, 0xa0, 0xc9, 0x35, 0x8f, 0xa3, 0x0b, 0x5f, 0x06,
           0x07, 0xaf, 0xe7, 0x28, 0x53, 0x75);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   scalar = -5383;
-  VLOAD_16(v2, 0x992e, 0x9a07, 0x90c3, 0xf1ce, 0xd53c, 0x8f07, 0x2d2f, 0x5ab1,
+  VLOAD_16(v8, 0x992e, 0x9a07, 0x90c3, 0xf1ce, 0xd53c, 0x8f07, 0x2d2f, 0x5ab1,
            0x0a79, 0x0523, 0x6f34, 0xe5fd, 0xc95a, 0xca1c, 0x36bf, 0x16a1);
-  VLOAD_16(v4, 0x0a9f, 0x7ee0, 0x494e, 0xb6d0, 0x394c, 0xc8e7, 0xc117, 0x8108,
+  VLOAD_16(v16, 0x0a9f, 0x7ee0, 0x494e, 0xb6d0, 0x394c, 0xc8e7, 0xc117, 0x8108,
            0xb1af, 0x9f16, 0x22ab, 0xa244, 0xf1c9, 0xe363, 0x9bed, 0xa06f);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmadd.vx v2, %[A], v4, v0.t" ::[A] "r"(scalar));
-  VCMP_U16(14, v2, 0x992e, 0xb5af, 0x90c3, 0x342e, 0xd53c, 0x4cb6, 0x2d2f,
+  asm volatile("vmadd.vx v8, %[A], v16, v0.t" ::[A] "r"(scalar));
+  VCMP_U16(14, v8, 0x992e, 0xb5af, 0x90c3, 0x342e, 0xd53c, 0x4cb6, 0x2d2f,
            0x8131, 0x0a79, 0x9c21, 0x6f34, 0x9759, 0xc95a, 0x109f, 0x36bf,
            0xcd08);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   scalar = 6474219;
-  VLOAD_32(v2, 0x709e784e, 0x8e13e48a, 0xad5df7fd, 0x738c8997, 0x0a0030d0,
+  VLOAD_32(v8, 0x709e784e, 0x8e13e48a, 0xad5df7fd, 0x738c8997, 0x0a0030d0,
            0x7569b952, 0x507fd5c7, 0x5d09af12, 0x0bf1c209, 0x7be6ed49,
            0x842ba667, 0x53360ec0, 0xd85d7415, 0xf20de61f, 0x153e7e16,
            0xec5512e4);
-  VLOAD_32(v4, 0xb2436fad, 0x6b162382, 0xd94eebe7, 0x9c43d906, 0xb80f178d,
+  VLOAD_32(v16, 0xb2436fad, 0x6b162382, 0xd94eebe7, 0x9c43d906, 0xb80f178d,
            0x5cf91d42, 0x7764b8a3, 0x6269f72c, 0xb0dff3a6, 0x838d6893,
            0xa98a861e, 0x758b63de, 0xde488617, 0x371696ab, 0xc3ba8192,
            0x7ca33236);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vmadd.vx v2, %[A], v4, v0.t" ::[A] "r"(scalar));
-  VCMP_U32(15, v2, 0x709e784e, 0xf29d4830, 0xad5df7fd, 0xb21bb5a3, 0x0a0030d0,
+  asm volatile("vmadd.vx v8, %[A], v16, v0.t" ::[A] "r"(scalar));
+  VCMP_U32(15, v8, 0x709e784e, 0xf29d4830, 0xad5df7fd, 0xb21bb5a3, 0x0a0030d0,
            0x18eb9d88, 0x507fd5c7, 0x69a6ceb2, 0x0bf1c209, 0x66c98b96,
            0x842ba667, 0xef3fae1e, 0xd85d7415, 0x6b652c20, 0x153e7e16,
            0x75d88d82);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
+  /*   VSET(16, e64, m8); */
   /*   scalar = -598189234597999223; */
-  /*   VLOAD_64(v2, 0x2a47beb4fd7729c5, 0x401c187818b15d1e, 0xbbaf5fe50c41f22a,
+  /*   VLOAD_64(v8, 0x2a47beb4fd7729c5, 0x401c187818b15d1e, 0xbbaf5fe50c41f22a,
    */
   /*            0x31eaddea171055a9, 0x609cbc4a78316c29, 0xd7bb8f31d8b59d88, */
   /*            0x97860fd5fba018c0, 0x724cecf178bd2125, 0x866d16f96d3d8b67, */
   /*            0x56153b0315164a5a, 0x6962bde49e3edf3f, 0x9b3f792bfbf5f343, */
   /*            0x64cf433b239e7764, 0x583c3a4ae481fef0, 0x217e2df75fcf0d8d, */
   /*            0x935ac02069fe54ce); */
-  /*   VLOAD_64(v4, 0x0dc8fa1b817237e5, 0xc817934370de904d, 0xb015bdbf0f39ec01,
+  /*   VLOAD_64(v16, 0x0dc8fa1b817237e5, 0xc817934370de904d, 0xb015bdbf0f39ec01,
    */
   /*            0x3c7e70a75643cce5, 0x80c45834a5026c02, 0xcdf1fcd83b8133a0, */
   /*            0x9d31b9b802ae2db1, 0xba7e57975c5febf5, 0x8732f75adf268ddb, */
@@ -282,8 +282,8 @@ void TEST_CASE4() {
   /*            0x8a479b7e3558e399, 0xbc21e79022996c26, 0xe2c7432cd7e3e81d, */
   /*            0xdab377ddbdfb2df7); */
   /*   VLOAD_8(v0, 0xAA, 0xAA); */
-  /*   asm volatile("vmadd.vx v2, %[A], v4, v0.t" ::[A] "r"(scalar)); */
-  /*   VCMP_U64(16, v2, 0x2a47beb4fd7729c5, 0xfd3c909decf66b5b,
+  /*   asm volatile("vmadd.vx v8, %[A], v16, v0.t" ::[A] "r"(scalar)); */
+  /*   VCMP_U64(16, v8, 0x2a47beb4fd7729c5, 0xfd3c909decf66b5b,
    * 0xbbaf5fe50c41f22a, */
   /*            0xb258e6b065bbf956, 0x609cbc4a78316c29, 0xdc0ae0e371686968, */
   /*            0x97860fd5fba018c0, 0x6c3cc52cd1fb49c2, 0x866d16f96d3d8b67, */
diff --git a/sw/riscvTests/isa/rv64uv/vmax.c b/sw/riscvTests/isa/rv64uv/vmax.c
index 945e22be..35b4266c 100644
--- a/sw/riscvTests/isa/rv64uv/vmax.c
+++ b/sw/riscvTests/isa/rv64uv/vmax.c
@@ -8,79 +8,79 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
            2560, -19900, 12345, -80, 2560, -19900);
-  VLOAD_16(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_16(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
-  asm volatile("vmax.vv v2, v4, v6");
-  VCMP_I16(1, v2, 12345, 7000, 2560, 19901, 12345, 7000, 2560, 19901, 12345,
+  asm volatile("vmax.vv v8, v16, v24");
+  VCMP_I16(1, v8, 12345, 7000, 2560, 19901, 12345, 7000, 2560, 19901, 12345,
            7000, 2560, 19901, 12345, 7000, 2560, 19901);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
            2560, -19900, 12345, -80, 2560, -19900);
-  VLOAD_32(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_32(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
-  asm volatile("vmax.vv v2, v4, v6");
-  VCMP_I32(2, v2, 12345, 7000, 2560, 19901, 12345, 7000, 2560, 19901, 12345,
+  asm volatile("vmax.vv v8, v16, v24");
+  VCMP_I32(2, v8, 12345, 7000, 2560, 19901, 12345, 7000, 2560, 19901, 12345,
            7000, 2560, 19901, 12345, 7000, 2560, 19901);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
            2560, -19900, 12345, -80, 2560, -19900);
-  VLOAD_64(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_64(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
-  asm volatile("vmax.vv v2, v4, v6");
-  VCMP_I64(3, v2, 12345, 7000, 2560, 19901, 12345, 7000, 2560, 19901, 12345,
+  asm volatile("vmax.vv v8, v16, v24");
+  VCMP_I64(3, v8, 12345, 7000, 2560, 19901, 12345, 7000, 2560, 19901, 12345,
            7000, 2560, 19901, 12345, 7000, 2560, 19901);
 #endif
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
            2560, -19900, 12345, -80, 2560, -19900);
-  VLOAD_16(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_16(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vmax.vv v2, v4, v6, v0.t");
-  VCMP_I16(4, v2, 0xbeef, 0xbeef, 2560, 19901, 0xbeef, 0xbeef, 2560, 19901,
+  asm volatile("vmax.vv v8, v16, v24, v0.t");
+  VCMP_I16(4, v8, 0xbeef, 0xbeef, 2560, 19901, 0xbeef, 0xbeef, 2560, 19901,
            0xbeef, 0xbeef, 2560, 19901, 0xbeef, 0xbeef, 2560, 19901);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
            2560, -19900, 12345, -80, 2560, -19900);
-  VLOAD_32(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_32(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef);
-  asm volatile("vmax.vv v2, v4, v6, v0.t");
-  VCMP_I32(5, v2, 0xdeadbeef, 0xdeadbeef, 2560, 19901, 0xdeadbeef, 0xdeadbeef,
+  asm volatile("vmax.vv v8, v16, v24, v0.t");
+  VCMP_I32(5, v8, 0xdeadbeef, 0xdeadbeef, 2560, 19901, 0xdeadbeef, 0xdeadbeef,
            2560, 19901, 0xdeadbeef, 0xdeadbeef, 2560, 19901, 0xdeadbeef,
            0xdeadbeef, 2560, 19901);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
            2560, -19900, 12345, -80, 2560, -19900);
-  VLOAD_64(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_64(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef);
-  asm volatile("vmax.vv v2, v4, v6, v0.t");
-  VCMP_I64(6, v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 2560, 19901,
+  asm volatile("vmax.vv v8, v16, v24, v0.t");
+  VCMP_I64(6, v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 2560, 19901,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 2560, 19901,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 2560, 19901,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 2560, 19901);
@@ -90,33 +90,33 @@ void TEST_CASE2(void) {
 void TEST_CASE3(void) {
   const uint64_t scalar = 40;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8,
           -25, 99);
-  asm volatile("vmax.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I8(7, v2, 123, 40, 40, 99, 123, 40, 40, 99, 123, 40, 40, 99, 123, 40, 40,
+  asm volatile("vmax.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I8(7, v8, 123, 40, 40, 99, 123, 40, 40, 99, 123, 40, 40, 99, 123, 40, 40,
           99);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
            12345, -8, -25, 199);
-  asm volatile("vmax.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I16(8, v2, 12345, 40, 40, 199, 12345, 40, 40, 199, 12345, 40, 40, 199,
+  asm volatile("vmax.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I16(8, v8, 12345, 40, 40, 199, 12345, 40, 40, 199, 12345, 40, 40, 199,
            12345, 40, 40, 199);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
            12345, -8, -25, 199);
-  asm volatile("vmax.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I32(9, v2, 12345, 40, 40, 199, 12345, 40, 40, 199, 12345, 40, 40, 199,
+  asm volatile("vmax.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I32(9, v8, 12345, 40, 40, 199, 12345, 40, 40, 199, 12345, 40, 40, 199,
            12345, 40, 40, 199);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
            12345, -8, -25, 199);
-  asm volatile("vmax.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I64(10, v2, 12345, 40, 40, 199, 12345, 40, 40, 199, 12345, 40, 40, 199,
+  asm volatile("vmax.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I64(10, v8, 12345, 40, 40, 199, 12345, 40, 40, 199, 12345, 40, 40, 199,
            12345, 40, 40, 199);
 #endif
 };
@@ -124,52 +124,52 @@ void TEST_CASE3(void) {
 void TEST_CASE4(void) {
   const uint64_t scalar = 40;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8,
           -25, 99);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef, 0xef, 0xef, 0xef, 0xef);
-  asm volatile("vmax.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I8(11, v2, 0xef, 0xef, 40, 99, 0xef, 0xef, 40, 99, 0xef, 0xef, 40, 99,
+  asm volatile("vmax.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I8(11, v8, 0xef, 0xef, 40, 99, 0xef, 0xef, 40, 99, 0xef, 0xef, 40, 99,
           0xef, 0xef, 40, 99);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
            12345, -8, -25, 199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vmax.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I16(12, v2, 0xbeef, 0xbeef, 40, 199, 0xbeef, 0xbeef, 40, 199, 0xbeef,
+  asm volatile("vmax.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I16(12, v8, 0xbeef, 0xbeef, 40, 199, 0xbeef, 0xbeef, 40, 199, 0xbeef,
            0xbeef, 40, 199, 0xbeef, 0xbeef, 40, 199);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
            12345, -8, -25, 199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef);
-  asm volatile("vmax.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I32(13, v2, 0xdeadbeef, 0xdeadbeef, 40, 199, 0xdeadbeef, 0xdeadbeef, 40,
+  asm volatile("vmax.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I32(13, v8, 0xdeadbeef, 0xdeadbeef, 40, 199, 0xdeadbeef, 0xdeadbeef, 40,
            199, 0xdeadbeef, 0xdeadbeef, 40, 199, 0xdeadbeef, 0xdeadbeef, 40,
            199);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
            12345, -8, -25, 199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef);
-  asm volatile("vmax.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I64(14, v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 40, 199,
+  asm volatile("vmax.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I64(14, v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 40, 199,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 40, 199, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 40, 199, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            40, 199);
diff --git a/sw/riscvTests/isa/rv64uv/vmaxu.c b/sw/riscvTests/isa/rv64uv/vmaxu.c
index 2f7c320f..d6204fe9 100644
--- a/sw/riscvTests/isa/rv64uv/vmaxu.c
+++ b/sw/riscvTests/isa/rv64uv/vmaxu.c
@@ -8,79 +8,79 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
            19900, 12345, 80, 2560, 19900);
-  VLOAD_16(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_16(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
-  asm volatile("vmaxu.vv v2, v4, v6");
-  VCMP_U16(1, v2, 12345, 7000, 2560, 19901, 12345, 7000, 2560, 19901, 12345,
+  asm volatile("vmaxu.vv v8, v16, v24");
+  VCMP_U16(1, v8, 12345, 7000, 2560, 19901, 12345, 7000, 2560, 19901, 12345,
            7000, 2560, 19901, 12345, 7000, 2560, 19901);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
            19900, 12345, 80, 2560, 19900);
-  VLOAD_32(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_32(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
-  asm volatile("vmaxu.vv v2, v4, v6");
-  VCMP_U32(2, v2, 12345, 7000, 2560, 19901, 12345, 7000, 2560, 19901, 12345,
+  asm volatile("vmaxu.vv v8, v16, v24");
+  VCMP_U32(2, v8, 12345, 7000, 2560, 19901, 12345, 7000, 2560, 19901, 12345,
            7000, 2560, 19901, 12345, 7000, 2560, 19901);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
            19900, 12345, 80, 2560, 19900);
-  VLOAD_64(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_64(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
-  asm volatile("vmaxu.vv v2, v4, v6");
-  VCMP_U64(3, v2, 12345, 7000, 2560, 19901, 12345, 7000, 2560, 19901, 12345,
+  asm volatile("vmaxu.vv v8, v16, v24");
+  VCMP_U64(3, v8, 12345, 7000, 2560, 19901, 12345, 7000, 2560, 19901, 12345,
            7000, 2560, 19901, 12345, 7000, 2560, 19901);
 #endif
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
            19900, 12345, 80, 2560, 19900);
-  VLOAD_16(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_16(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vmaxu.vv v2, v4, v6, v0.t");
-  VCMP_U16(4, v2, 0xbeef, 0xbeef, 2560, 19901, 0xbeef, 0xbeef, 2560, 19901,
+  asm volatile("vmaxu.vv v8, v16, v24, v0.t");
+  VCMP_U16(4, v8, 0xbeef, 0xbeef, 2560, 19901, 0xbeef, 0xbeef, 2560, 19901,
            0xbeef, 0xbeef, 2560, 19901, 0xbeef, 0xbeef, 2560, 19901);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
            19900, 12345, 80, 2560, 19900);
-  VLOAD_32(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_32(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef);
-  asm volatile("vmaxu.vv v2, v4, v6, v0.t");
-  VCMP_U32(5, v2, 0xdeadbeef, 0xdeadbeef, 2560, 19901, 0xdeadbeef, 0xdeadbeef,
+  asm volatile("vmaxu.vv v8, v16, v24, v0.t");
+  VCMP_U32(5, v8, 0xdeadbeef, 0xdeadbeef, 2560, 19901, 0xdeadbeef, 0xdeadbeef,
            2560, 19901, 0xdeadbeef, 0xdeadbeef, 2560, 19901, 0xdeadbeef,
            0xdeadbeef, 2560, 19901);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
            19900, 12345, 80, 2560, 19900);
-  VLOAD_64(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_64(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef);
-  asm volatile("vmaxu.vv v2, v4, v6, v0.t");
-  VCMP_U64(6, v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 2560, 19901,
+  asm volatile("vmaxu.vv v8, v16, v24, v0.t");
+  VCMP_U64(6, v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 2560, 19901,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 2560, 19901,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 2560, 19901,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 2560, 19901);
@@ -90,33 +90,33 @@ void TEST_CASE2(void) {
 void TEST_CASE3(void) {
   const uint64_t scalar = 40;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25,
           199);
-  asm volatile("vmaxu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(7, v2, 123, 40, 40, 199, 123, 40, 40, 199, 123, 40, 40, 199, 123, 40,
+  asm volatile("vmaxu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(7, v8, 123, 40, 40, 199, 123, 40, 40, 199, 123, 40, 40, 199, 123, 40,
           40, 199);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
            8, 25, 199);
-  asm volatile("vmaxu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(8, v2, 12345, 40, 40, 199, 12345, 40, 40, 199, 12345, 40, 40, 199,
+  asm volatile("vmaxu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(8, v8, 12345, 40, 40, 199, 12345, 40, 40, 199, 12345, 40, 40, 199,
            12345, 40, 40, 199);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
            8, 25, 199);
-  asm volatile("vmaxu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(9, v2, 12345, 40, 40, 199, 12345, 40, 40, 199, 12345, 40, 40, 199,
+  asm volatile("vmaxu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(9, v8, 12345, 40, 40, 199, 12345, 40, 40, 199, 12345, 40, 40, 199,
            12345, 40, 40, 199);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
            8, 25, 199);
-  asm volatile("vmaxu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U64(10, v2, 12345, 40, 40, 199, 12345, 40, 40, 199, 12345, 40, 40, 199,
+  asm volatile("vmaxu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U64(10, v8, 12345, 40, 40, 199, 12345, 40, 40, 199, 12345, 40, 40, 199,
            12345, 40, 40, 199);
 #endif
 };
@@ -124,52 +124,52 @@ void TEST_CASE3(void) {
 void TEST_CASE4(void) {
   const uint64_t scalar = 40;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25,
           199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef, 0xef, 0xef, 0xef, 0xef);
-  asm volatile("vmaxu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U8(11, v2, 0xef, 0xef, 40, 199, 0xef, 0xef, 40, 199, 0xef, 0xef, 40, 199,
+  asm volatile("vmaxu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U8(11, v8, 0xef, 0xef, 40, 199, 0xef, 0xef, 40, 199, 0xef, 0xef, 40, 199,
           0xef, 0xef, 40, 199);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
            8, 25, 199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vmaxu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U16(12, v2, 0xbeef, 0xbeef, 40, 199, 0xbeef, 0xbeef, 40, 199, 0xbeef,
+  asm volatile("vmaxu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U16(12, v8, 0xbeef, 0xbeef, 40, 199, 0xbeef, 0xbeef, 40, 199, 0xbeef,
            0xbeef, 40, 199, 0xbeef, 0xbeef, 40, 199);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
            8, 25, 199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef);
-  asm volatile("vmaxu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U32(13, v2, 0xdeadbeef, 0xdeadbeef, 40, 199, 0xdeadbeef, 0xdeadbeef, 40,
+  asm volatile("vmaxu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U32(13, v8, 0xdeadbeef, 0xdeadbeef, 40, 199, 0xdeadbeef, 0xdeadbeef, 40,
            199, 0xdeadbeef, 0xdeadbeef, 40, 199, 0xdeadbeef, 0xdeadbeef, 40,
            199);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
            8, 25, 199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef);
-  asm volatile("vmaxu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U64(14, v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 40, 199,
+  asm volatile("vmaxu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U64(14, v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 40, 199,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 40, 199, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 40, 199, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            40, 199);
diff --git a/sw/riscvTests/isa/rv64uv/vmin.c b/sw/riscvTests/isa/rv64uv/vmin.c
index 1e29d145..58b3255f 100644
--- a/sw/riscvTests/isa/rv64uv/vmin.c
+++ b/sw/riscvTests/isa/rv64uv/vmin.c
@@ -8,79 +8,79 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
            2560, -19900, 12345, -80, 2560, -19900);
-  VLOAD_16(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_16(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
-  asm volatile("vmin.vv v2, v4, v6");
-  VCMP_I16(1, v2, 50, -80, 400, -19900, 50, -80, 400, -19900, 50, -80, 400,
+  asm volatile("vmin.vv v8, v16, v24");
+  VCMP_I16(1, v8, 50, -80, 400, -19900, 50, -80, 400, -19900, 50, -80, 400,
            -19900, 50, -80, 400, -19900);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
            2560, -19900, 12345, -80, 2560, -19900);
-  VLOAD_32(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_32(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
-  asm volatile("vmin.vv v2, v4, v6");
-  VCMP_I32(2, v2, 50, -80, 400, -19900, 50, -80, 400, -19900, 50, -80, 400,
+  asm volatile("vmin.vv v8, v16, v24");
+  VCMP_I32(2, v8, 50, -80, 400, -19900, 50, -80, 400, -19900, 50, -80, 400,
            -19900, 50, -80, 400, -19900);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
            2560, -19900, 12345, -80, 2560, -19900);
-  VLOAD_64(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_64(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
-  asm volatile("vmin.vv v2, v4, v6");
-  VCMP_I64(3, v2, 50, -80, 400, -19900, 50, -80, 400, -19900, 50, -80, 400,
+  asm volatile("vmin.vv v8, v16, v24");
+  VCMP_I64(3, v8, 50, -80, 400, -19900, 50, -80, 400, -19900, 50, -80, 400,
            -19900, 50, -80, 400, -19900);
 #endif
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
            2560, -19900, 12345, -80, 2560, -19900);
-  VLOAD_16(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_16(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vmin.vv v2, v4, v6, v0.t");
-  VCMP_I16(4, v2, 0xbeef, 0xbeef, 400, -19900, 0xbeef, 0xbeef, 400, -19900,
+  asm volatile("vmin.vv v8, v16, v24, v0.t");
+  VCMP_I16(4, v8, 0xbeef, 0xbeef, 400, -19900, 0xbeef, 0xbeef, 400, -19900,
            0xbeef, 0xbeef, 400, -19900, 0xbeef, 0xbeef, 400, -19900);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
            2560, -19900, 12345, -80, 2560, -19900);
-  VLOAD_32(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_32(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef);
-  asm volatile("vmin.vv v2, v4, v6, v0.t");
-  VCMP_I32(5, v2, 0xdeadbeef, 0xdeadbeef, 400, -19900, 0xdeadbeef, 0xdeadbeef,
+  asm volatile("vmin.vv v8, v16, v24, v0.t");
+  VCMP_I32(5, v8, 0xdeadbeef, 0xdeadbeef, 400, -19900, 0xdeadbeef, 0xdeadbeef,
            400, -19900, 0xdeadbeef, 0xdeadbeef, 400, -19900, 0xdeadbeef,
            0xdeadbeef, 400, -19900);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, -80, 2560, -19900, 12345, -80, 2560, -19900, 12345, -80,
            2560, -19900, 12345, -80, 2560, -19900);
-  VLOAD_64(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_64(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef);
-  asm volatile("vmin.vv v2, v4, v6, v0.t");
-  VCMP_I64(6, v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 400, -19900,
+  asm volatile("vmin.vv v8, v16, v24, v0.t");
+  VCMP_I64(6, v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 400, -19900,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 400, -19900,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 400, -19900,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 400, -19900);
@@ -90,33 +90,33 @@ void TEST_CASE2(void) {
 void TEST_CASE3(void) {
   const uint64_t scalar = 40;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8,
           -25, 99);
-  asm volatile("vmin.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I8(7, v2, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8, -25,
+  asm volatile("vmin.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I8(7, v8, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8, -25,
           40);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
            12345, -8, -25, 199);
-  asm volatile("vmin.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I16(8, v2, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8,
+  asm volatile("vmin.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I16(8, v8, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8,
            -25, 40);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
            12345, -8, -25, 199);
-  asm volatile("vmin.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I32(9, v2, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8,
+  asm volatile("vmin.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I32(9, v8, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8,
            -25, 40);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
            12345, -8, -25, 199);
-  asm volatile("vmin.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I64(10, v2, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8,
+  asm volatile("vmin.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I64(10, v8, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8, -25, 40, 40, -8,
            -25, 40);
 #endif
 };
@@ -124,52 +124,52 @@ void TEST_CASE3(void) {
 void TEST_CASE4(void) {
   const uint64_t scalar = 40;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8, -25, 99, 123, -8,
           -25, 99);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef, 0xef, 0xef, 0xef, 0xef);
-  asm volatile("vmin.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I8(11, v2, 0xef, 0xef, -25, 40, 0xef, 0xef, -25, 40, 0xef, 0xef, -25, 40,
+  asm volatile("vmin.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I8(11, v8, 0xef, 0xef, -25, 40, 0xef, 0xef, -25, 40, 0xef, 0xef, -25, 40,
           0xef, 0xef, -25, 40);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
            12345, -8, -25, 199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vmin.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I16(12, v2, 0xbeef, 0xbeef, -25, 40, 0xbeef, 0xbeef, -25, 40, 0xbeef,
+  asm volatile("vmin.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I16(12, v8, 0xbeef, 0xbeef, -25, 40, 0xbeef, 0xbeef, -25, 40, 0xbeef,
            0xbeef, -25, 40, 0xbeef, 0xbeef, -25, 40);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
            12345, -8, -25, 199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef);
-  asm volatile("vmin.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I32(13, v2, 0xdeadbeef, 0xdeadbeef, -25, 40, 0xdeadbeef, 0xdeadbeef, -25,
+  asm volatile("vmin.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I32(13, v8, 0xdeadbeef, 0xdeadbeef, -25, 40, 0xdeadbeef, 0xdeadbeef, -25,
            40, 0xdeadbeef, 0xdeadbeef, -25, 40, 0xdeadbeef, 0xdeadbeef, -25,
            40);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, -8, -25, 199, 12345, -8, -25, 199, 12345, -8, -25, 199,
            12345, -8, -25, 199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef);
-  asm volatile("vmin.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I64(14, v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, -25, 40,
+  asm volatile("vmin.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I64(14, v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, -25, 40,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, -25, 40, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, -25, 40, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            -25, 40);
diff --git a/sw/riscvTests/isa/rv64uv/vminu.c b/sw/riscvTests/isa/rv64uv/vminu.c
index 8c2e3a94..65be4114 100644
--- a/sw/riscvTests/isa/rv64uv/vminu.c
+++ b/sw/riscvTests/isa/rv64uv/vminu.c
@@ -8,79 +8,79 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
            19900, 12345, 80, 2560, 19900);
-  VLOAD_16(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_16(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
-  asm volatile("vminu.vv v2, v4, v6");
-  VCMP_U16(1, v2, 50, 80, 400, 19900, 50, 80, 400, 19900, 50, 80, 400, 19900,
+  asm volatile("vminu.vv v8, v16, v24");
+  VCMP_U16(1, v8, 50, 80, 400, 19900, 50, 80, 400, 19900, 50, 80, 400, 19900,
            50, 80, 400, 19900);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
            19900, 12345, 80, 2560, 19900);
-  VLOAD_32(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_32(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
-  asm volatile("vminu.vv v2, v4, v6");
-  VCMP_U32(2, v2, 50, 80, 400, 19900, 50, 80, 400, 19900, 50, 80, 400, 19900,
+  asm volatile("vminu.vv v8, v16, v24");
+  VCMP_U32(2, v8, 50, 80, 400, 19900, 50, 80, 400, 19900, 50, 80, 400, 19900,
            50, 80, 400, 19900);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
            19900, 12345, 80, 2560, 19900);
-  VLOAD_64(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_64(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
-  asm volatile("vminu.vv v2, v4, v6");
-  VCMP_U64(3, v2, 50, 80, 400, 19900, 50, 80, 400, 19900, 50, 80, 400, 19900,
+  asm volatile("vminu.vv v8, v16, v24");
+  VCMP_U64(3, v8, 50, 80, 400, 19900, 50, 80, 400, 19900, 50, 80, 400, 19900,
            50, 80, 400, 19900);
 #endif
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
            19900, 12345, 80, 2560, 19900);
-  VLOAD_16(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_16(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vminu.vv v2, v4, v6, v0.t");
-  VCMP_U16(4, v2, 0xbeef, 0xbeef, 400, 19900, 0xbeef, 0xbeef, 400, 19900,
+  asm volatile("vminu.vv v8, v16, v24, v0.t");
+  VCMP_U16(4, v8, 0xbeef, 0xbeef, 400, 19900, 0xbeef, 0xbeef, 400, 19900,
            0xbeef, 0xbeef, 400, 19900, 0xbeef, 0xbeef, 400, 19900);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
            19900, 12345, 80, 2560, 19900);
-  VLOAD_32(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_32(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef);
-  asm volatile("vminu.vv v2, v4, v6, v0.t");
-  VCMP_U32(5, v2, 0xdeadbeef, 0xdeadbeef, 400, 19900, 0xdeadbeef, 0xdeadbeef,
+  asm volatile("vminu.vv v8, v16, v24, v0.t");
+  VCMP_U32(5, v8, 0xdeadbeef, 0xdeadbeef, 400, 19900, 0xdeadbeef, 0xdeadbeef,
            400, 19900, 0xdeadbeef, 0xdeadbeef, 400, 19900, 0xdeadbeef,
            0xdeadbeef, 400, 19900);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, 80, 2560, 19900, 12345, 80, 2560, 19900, 12345, 80, 2560,
            19900, 12345, 80, 2560, 19900);
-  VLOAD_64(v6, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
+  VLOAD_64(v24, 50, 7000, 400, 19901, 50, 7000, 400, 19901, 50, 7000, 400, 19901,
            50, 7000, 400, 19901);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef);
-  asm volatile("vminu.vv v2, v4, v6, v0.t");
-  VCMP_U64(6, v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 400, 19900,
+  asm volatile("vminu.vv v8, v16, v24, v0.t");
+  VCMP_U64(6, v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 400, 19900,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 400, 19900,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 400, 19900,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 400, 19900);
@@ -90,81 +90,81 @@ void TEST_CASE2(void) {
 void TEST_CASE3(void) {
   const uint64_t scalar = 40;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25,
           199);
-  asm volatile("vminu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(7, v2, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40);
+  asm volatile("vminu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(7, v8, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
            8, 25, 199);
-  asm volatile("vminu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(8, v2, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40);
+  asm volatile("vminu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(8, v8, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
            8, 25, 199);
-  asm volatile("vminu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(9, v2, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40);
+  asm volatile("vminu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(9, v8, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
            8, 25, 199);
-  asm volatile("vminu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U64(10, v2, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40);
+  asm volatile("vminu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U64(10, v8, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40, 40, 8, 25, 40);
 #endif
 };
 
 void TEST_CASE4(void) {
   const uint64_t scalar = 40;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25, 199, 123, 8, 25,
           199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef, 0xef, 0xef, 0xef, 0xef);
-  asm volatile("vminu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U8(11, v2, 0xef, 0xef, 25, 40, 0xef, 0xef, 25, 40, 0xef, 0xef, 25, 40,
+  asm volatile("vminu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U8(11, v8, 0xef, 0xef, 25, 40, 0xef, 0xef, 25, 40, 0xef, 0xef, 25, 40,
           0xef, 0xef, 25, 40);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
            8, 25, 199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vminu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U16(12, v2, 0xbeef, 0xbeef, 25, 40, 0xbeef, 0xbeef, 25, 40, 0xbeef,
+  asm volatile("vminu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U16(12, v8, 0xbeef, 0xbeef, 25, 40, 0xbeef, 0xbeef, 25, 40, 0xbeef,
            0xbeef, 25, 40, 0xbeef, 0xbeef, 25, 40);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
            8, 25, 199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef);
-  asm volatile("vminu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U32(13, v2, 0xdeadbeef, 0xdeadbeef, 25, 40, 0xdeadbeef, 0xdeadbeef, 25,
+  asm volatile("vminu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U32(13, v8, 0xdeadbeef, 0xdeadbeef, 25, 40, 0xdeadbeef, 0xdeadbeef, 25,
            40, 0xdeadbeef, 0xdeadbeef, 25, 40, 0xdeadbeef, 0xdeadbeef, 25, 40);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345, 8, 25, 199, 12345,
            8, 25, 199);
   VLOAD_8(v0, 0xCC, 0xCC);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef);
-  asm volatile("vminu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U64(14, v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 25, 40,
+  asm volatile("vminu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U64(14, v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 25, 40,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 25, 40, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 25, 40, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            25, 40);
diff --git a/sw/riscvTests/isa/rv64uv/vmul.c b/sw/riscvTests/isa/rv64uv/vmul.c
index 43937857..32c1cc06 100644
--- a/sw/riscvTests/isa/rv64uv/vmul.c
+++ b/sw/riscvTests/isa/rv64uv/vmul.c
@@ -8,56 +8,56 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0xb3, 0x5d, 0x3d, 0xa4, 0xbf, 0xc7, 0x6b, 0x95, 0xf9, 0x64, 0x52,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0xb3, 0x5d, 0x3d, 0xa4, 0xbf, 0xc7, 0x6b, 0x95, 0xf9, 0x64, 0x52,
           0x57, 0xbc, 0x1f, 0xd5, 0x13);
-  VLOAD_8(v6, 0x46, 0x37, 0xf5, 0x2b, 0x55, 0x05, 0xcb, 0x76, 0x31, 0x30, 0x78,
+  VLOAD_8(v24, 0x46, 0x37, 0xf5, 0x2b, 0x55, 0x05, 0xcb, 0x76, 0x31, 0x30, 0x78,
           0xb3, 0x6a, 0xae, 0x5a, 0xe1);
-  asm volatile("vmul.vv v2, v4, v6");
-  VCMP_I8(1, v2, 0xf2, 0xfb, 0x61, 0x8c, 0x6b, 0xe3, 0xd9, 0xae, 0xa9, 0xc0,
+  asm volatile("vmul.vv v8, v16, v24");
+  VCMP_I8(1, v8, 0xf2, 0xfb, 0x61, 0x8c, 0x6b, 0xe3, 0xd9, 0xae, 0xa9, 0xc0,
           0x70, 0xd5, 0xd8, 0x12, 0xe2, 0xb3);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x8132, 0x94b5, 0x245c, 0xd15d, 0xbfca, 0x18b6, 0xd5ba, 0x9299,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x8132, 0x94b5, 0x245c, 0xd15d, 0xbfca, 0x18b6, 0xd5ba, 0x9299,
            0xccbd, 0x9ad4, 0xce46, 0xfbba, 0x10cc, 0xc463, 0x5298, 0x7b3e);
-  VLOAD_16(v6, 0xede6, 0x010b, 0xa570, 0x21c5, 0xfe5a, 0x5386, 0x16c9, 0x45fb,
+  VLOAD_16(v24, 0xede6, 0x010b, 0xa570, 0x21c5, 0xfe5a, 0x5386, 0x16c9, 0x45fb,
            0x1439, 0x436f, 0x6f56, 0x90f7, 0x77c0, 0x0751, 0x64c3, 0x36e8);
-  asm volatile("vmul.vv v2, v4, v6");
-  VCMP_I16(2, v2, 0x5cec, 0x18c7, 0x3440, 0x1991, 0xd904, 0xf144, 0xcb0a,
+  asm volatile("vmul.vv v8, v16, v24");
+  VCMP_I16(2, v8, 0x5cec, 0x18c7, 0x3440, 0x1991, 0xd904, 0xf144, 0xcb0a,
            0xf903, 0x5a15, 0x9dec, 0xa584, 0x8076, 0x6d00, 0xd853, 0x49c8,
            0xc430);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x9c2bdc58, 0xe3995899, 0xbbbc0eda, 0x0729ff92, 0xa757a2c5,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x9c2bdc58, 0xe3995899, 0xbbbc0eda, 0x0729ff92, 0xa757a2c5,
            0xd5f3a23e, 0x9a295390, 0xb2367b2e, 0xfee5b6a2, 0x07cb59c1,
            0x6bf5cf9a, 0x7d75506b, 0x013c1e90, 0x600f9ca8, 0x6d4d0522,
            0x0a225ff0);
-  VLOAD_32(v6, 0xc51e02f8, 0xae06b334, 0x397b1ec7, 0xc46f34fe, 0x4f9db2ab,
+  VLOAD_32(v24, 0xc51e02f8, 0xae06b334, 0x397b1ec7, 0xc46f34fe, 0x4f9db2ab,
            0x957c2534, 0x70f8e127, 0xa79ebcec, 0x0a542044, 0x20e6ac3e,
            0xd61caed7, 0x6f4e7820, 0x27c56901, 0x0aaf1d61, 0xa95c6f5c,
            0x5b7aedf3);
-  asm volatile("vmul.vv v2, v4, v6");
-  VCMP_I32(3, v2, 0x2c862540, 0x85aefa14, 0xa5ab1776, 0x3be33adc, 0x5487b397,
+  asm volatile("vmul.vv v8, v16, v24");
+  VCMP_I32(3, v8, 0x2c862540, 0x85aefa14, 0xa5ab1776, 0x3be33adc, 0x5487b397,
            0x57f7ea98, 0xc23d4af0, 0x55135668, 0xad00c308, 0x46f368be,
            0x2f640656, 0x91f63560, 0x1e952e90, 0xd18163a8, 0xf71f9638,
            0x79d240d0);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x077de9270ce00632, 0x2dadf4e020f3d47a, 0xb54ca84f9fe0573b,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x077de9270ce00632, 0x2dadf4e020f3d47a, 0xb54ca84f9fe0573b,
            0x7be639dfdb02db6f, 0x61bb44569da93eff, 0xcd7f973ce822182b,
            0x5434a22e7432397c, 0xcaadfd89d8dd1ad5, 0x5474c56d9089d672,
            0x700e415c07b99bf9, 0xb89d409d4323a9c8, 0x68ccc7411db0ab09,
            0xdf4fe3fa4e113e98, 0xa98a2e2575b04c41, 0x26ddf248ccb4a7aa,
            0xdda1822d4972ee47);
-  VLOAD_64(v6, 0xcd2888c8bb07b736, 0xf20013627ac47d4f, 0xc05dbcd989ef329c,
+  VLOAD_64(v24, 0xcd2888c8bb07b736, 0xf20013627ac47d4f, 0xc05dbcd989ef329c,
            0xc272db2ebcf7cfad, 0x8869302db041176d, 0xd3d90968a9ee01c2,
            0x9cdb9f91a3381f51, 0x99ad38b70907ee8d, 0xf7d629b266c67cf1,
            0x706f9b996cdd60f2, 0x4caa2335622bd6a0, 0x94171c9dfbbb186f,
            0x7b6e42290f54ecc6, 0xa545b8670143bfbc, 0x9f430bf94b2805c9,
            0xb45030fc2b4cef12);
-  asm volatile("vmul.vv v2, v4, v6");
-  VCMP_I64(4, v2, 0x90d27e278d0d0c8c, 0x5ea9d3e60b6623a6, 0x6823b3e240d3adf4,
+  asm volatile("vmul.vv v8, v16, v24");
+  VCMP_I64(4, v8, 0x90d27e278d0d0c8c, 0x5ea9d3e60b6623a6, 0x6823b3e240d3adf4,
            0xc0dcea378c760b03, 0x17692726a477bb93, 0x784c7f2ee6e87b96,
            0xd1aae9975ffa343c, 0xfdcd46ca398ccd51, 0x405f01791dce1952,
            0x16063fbe99e7d162, 0xc9d244cddacf4d00, 0x22024848323600e7,
@@ -67,99 +67,99 @@ void TEST_CASE1(void) {
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0xb3, 0x5d, 0x3d, 0xa4, 0xbf, 0xc7, 0x6b, 0x95, 0xf9, 0x64, 0x52,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0xb3, 0x5d, 0x3d, 0xa4, 0xbf, 0xc7, 0x6b, 0x95, 0xf9, 0x64, 0x52,
           0x57, 0xbc, 0x1f, 0xd5, 0x13);
-  VLOAD_8(v6, 0x46, 0x37, 0xf5, 0x2b, 0x55, 0x05, 0xcb, 0x76, 0x31, 0x30, 0x78,
+  VLOAD_8(v24, 0x46, 0x37, 0xf5, 0x2b, 0x55, 0x05, 0xcb, 0x76, 0x31, 0x30, 0x78,
           0xb3, 0x6a, 0xae, 0x5a, 0xe1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmul.vv v2, v4, v6, v0.t");
-  VCMP_I8(5, v2, 0, 0xfb, 0, 0x8c, 0, 0xe3, 0, 0xae, 0, 0xc0, 0, 0xd5, 0, 0x12,
+  VCLEAR(v8);
+  asm volatile("vmul.vv v8, v16, v24, v0.t");
+  VCMP_I8(5, v8, 0, 0xfb, 0, 0x8c, 0, 0xe3, 0, 0xae, 0, 0xc0, 0, 0xd5, 0, 0x12,
           0, 0xb3);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x8132, 0x94b5, 0x245c, 0xd15d, 0xbfca, 0x18b6, 0xd5ba, 0x9299,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x8132, 0x94b5, 0x245c, 0xd15d, 0xbfca, 0x18b6, 0xd5ba, 0x9299,
            0xccbd, 0x9ad4, 0xce46, 0xfbba, 0x10cc, 0xc463, 0x5298, 0x7b3e);
-  VLOAD_16(v6, 0xede6, 0x010b, 0xa570, 0x21c5, 0xfe5a, 0x5386, 0x16c9, 0x45fb,
+  VLOAD_16(v24, 0xede6, 0x010b, 0xa570, 0x21c5, 0xfe5a, 0x5386, 0x16c9, 0x45fb,
            0x1439, 0x436f, 0x6f56, 0x90f7, 0x77c0, 0x0751, 0x64c3, 0x36e8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmul.vv v2, v4, v6, v0.t");
-  VCMP_I16(6, v2, 0, 0x18c7, 0, 0x1991, 0, 0xf144, 0, 0xf903, 0, 0x9dec, 0,
+  VCLEAR(v8);
+  asm volatile("vmul.vv v8, v16, v24, v0.t");
+  VCMP_I16(6, v8, 0, 0x18c7, 0, 0x1991, 0, 0xf144, 0, 0xf903, 0, 0x9dec, 0,
            0x8076, 0, 0xd853, 0, 0xc430);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x9c2bdc58, 0xe3995899, 0xbbbc0eda, 0x0729ff92, 0xa757a2c5,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x9c2bdc58, 0xe3995899, 0xbbbc0eda, 0x0729ff92, 0xa757a2c5,
            0xd5f3a23e, 0x9a295390, 0xb2367b2e, 0xfee5b6a2, 0x07cb59c1,
            0x6bf5cf9a, 0x7d75506b, 0x013c1e90, 0x600f9ca8, 0x6d4d0522,
            0x0a225ff0);
-  VLOAD_32(v6, 0xc51e02f8, 0xae06b334, 0x397b1ec7, 0xc46f34fe, 0x4f9db2ab,
+  VLOAD_32(v24, 0xc51e02f8, 0xae06b334, 0x397b1ec7, 0xc46f34fe, 0x4f9db2ab,
            0x957c2534, 0x70f8e127, 0xa79ebcec, 0x0a542044, 0x20e6ac3e,
            0xd61caed7, 0x6f4e7820, 0x27c56901, 0x0aaf1d61, 0xa95c6f5c,
            0x5b7aedf3);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmul.vv v2, v4, v6, v0.t");
-  VCMP_I32(7, v2, 0, 0x85aefa14, 0, 0x3be33adc, 0, 0x57f7ea98, 0, 0x55135668, 0,
+  VCLEAR(v8);
+  asm volatile("vmul.vv v8, v16, v24, v0.t");
+  VCMP_I32(7, v8, 0, 0x85aefa14, 0, 0x3be33adc, 0, 0x57f7ea98, 0, 0x55135668, 0,
            0x46f368be, 0, 0x91f63560, 0, 0xd18163a8, 0, 0x79d240d0);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x077de9270ce00632, 0x2dadf4e020f3d47a, 0xb54ca84f9fe0573b,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x077de9270ce00632, 0x2dadf4e020f3d47a, 0xb54ca84f9fe0573b,
            0x7be639dfdb02db6f, 0x61bb44569da93eff, 0xcd7f973ce822182b,
            0x5434a22e7432397c, 0xcaadfd89d8dd1ad5, 0x5474c56d9089d672,
            0x700e415c07b99bf9, 0xb89d409d4323a9c8, 0x68ccc7411db0ab09,
            0xdf4fe3fa4e113e98, 0xa98a2e2575b04c41, 0x26ddf248ccb4a7aa,
            0xdda1822d4972ee47);
-  VLOAD_64(v6, 0xcd2888c8bb07b736, 0xf20013627ac47d4f, 0xc05dbcd989ef329c,
+  VLOAD_64(v24, 0xcd2888c8bb07b736, 0xf20013627ac47d4f, 0xc05dbcd989ef329c,
            0xc272db2ebcf7cfad, 0x8869302db041176d, 0xd3d90968a9ee01c2,
            0x9cdb9f91a3381f51, 0x99ad38b70907ee8d, 0xf7d629b266c67cf1,
            0x706f9b996cdd60f2, 0x4caa2335622bd6a0, 0x94171c9dfbbb186f,
            0x7b6e42290f54ecc6, 0xa545b8670143bfbc, 0x9f430bf94b2805c9,
            0xb45030fc2b4cef12);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmul.vv v2, v4, v6, v0.t");
-  VCMP_I64(8, v2, 0, 0x5ea9d3e60b6623a6, 0, 0xc0dcea378c760b03, 0,
+  VCLEAR(v8);
+  asm volatile("vmul.vv v8, v16, v24, v0.t");
+  VCMP_I64(8, v8, 0, 0x5ea9d3e60b6623a6, 0, 0xc0dcea378c760b03, 0,
            0x784c7f2ee6e87b96, 0, 0xfdcd46ca398ccd51, 0, 0x16063fbe99e7d162, 0,
            0x22024848323600e7, 0, 0x566db9e82c5f7ebc, 0, 0xdaab68ca209d09fe);
 #endif
 };
 
 void TEST_CASE3(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x80, 0xb2, 0xb6, 0xd7, 0x4f, 0xbe, 0xee, 0x53, 0xab, 0x57, 0xe4,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x80, 0xb2, 0xb6, 0xd7, 0x4f, 0xbe, 0xee, 0x53, 0xab, 0x57, 0xe4,
           0x28, 0x6a, 0x91, 0x14, 0x4f);
   int64_t scalar = 5;
-  asm volatile("vmul.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I8(9, v2, 0x80, 0x7a, 0x8e, 0x33, 0x8b, 0xb6, 0xa6, 0x9f, 0x57, 0xb3,
+  asm volatile("vmul.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I8(9, v8, 0x80, 0x7a, 0x8e, 0x33, 0x8b, 0xb6, 0xa6, 0x9f, 0x57, 0xb3,
           0x74, 0xc8, 0x12, 0xd5, 0x64, 0x8b);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xbab0, 0x83a5, 0x06b6, 0x22ba, 0x91b8, 0x7720, 0xc2c7, 0x3494,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xbab0, 0x83a5, 0x06b6, 0x22ba, 0x91b8, 0x7720, 0xc2c7, 0x3494,
            0xd281, 0x6d38, 0x378d, 0xa91d, 0xd731, 0xa4c7, 0x4d8f, 0x2422);
   scalar = -5383;
-  asm volatile("vmul.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I16(10, v2, 0x7530, 0xdd7d, 0xe306, 0xcaea, 0xebf8, 0x1e20, 0x598f,
+  asm volatile("vmul.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I16(10, v8, 0x7530, 0xdd7d, 0xe306, 0xcaea, 0xebf8, 0x1e20, 0x598f,
            0x6bf4, 0xa979, 0x6b78, 0xea25, 0xff35, 0x18a9, 0x2b8f, 0x2617,
            0x3912);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x8bb4a8bc, 0x9799b344, 0xcd8c1672, 0xeb2d7c0f, 0x55474d7d,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x8bb4a8bc, 0x9799b344, 0xcd8c1672, 0xeb2d7c0f, 0x55474d7d,
            0x3dae9eaf, 0xc19a3519, 0x6922f03c, 0x42edfa01, 0x1f60b344,
            0x82f31d5e, 0x0faa2e5c, 0x74e95cfa, 0x9fcdae3b, 0xe6c4e0a0,
            0x45549cbc);
   scalar = 6474219;
-  asm volatile("vmul.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I32(11, v2, 0xaf4a8094, 0x77dff36c, 0x44dc1ca6, 0x16e6a8c5, 0xee2546bf,
+  asm volatile("vmul.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I32(11, v8, 0xaf4a8094, 0x77dff36c, 0x44dc1ca6, 0x16e6a8c5, 0xee2546bf,
            0x78e111a5, 0x1fd15ef3, 0xe8a9a314, 0xfe2147eb, 0x5a8cf36c,
            0x5536c34a, 0xbed6ca74, 0x23eca37e, 0xe2314329, 0x6857d2e0,
            0x13b37c94);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
-  /*   VLOAD_64(v4, 0xc238e0a3df21299c, 0xb642655c3ab064d5, 0xd19f84bab77e5602,
+  /*   VSET(16, e64, m8); */
+  /*   VLOAD_64(v16, 0xc238e0a3df21299c, 0xb642655c3ab064d5, 0xd19f84bab77e5602,
    */
   /*            0x4e6e3c114a19f160, 0xfd403cbcc59407a1, 0xef3e81a68ae0e48c, */
   /*            0xd93a7b1ab54d024e, 0x5f7460aa9f4c4920, 0x4c91150cd4b54f60, */
@@ -167,8 +167,8 @@ void TEST_CASE3(void) {
   /*            0xcd0e6874555602d4, 0xb70264bd366ff52f, 0xc0b1fa64cec9368d, */
   /*            0x13e86249a0235941); */
   /*   scalar = -598189234597999223; */
-  /*   asm volatile("vmul.vx v2, v4, %[A]" ::[A] "r"(scalar)); */
-  /*   VCMP_I64(12, v2, 0x61ead1213f09307c, 0x7d03f4c84c5e86fd,
+  /*   asm volatile("vmul.vx v8, v16, %[A]" ::[A] "r"(scalar)); */
+  /*   VCMP_I64(12, v8, 0x61ead1213f09307c, 0x7d03f4c84c5e86fd,
    * 0x4aa0acc4e01fa112, */
   /*            0x77bc957fdeec0c60, 0x762b14c112e60229, 0xbac65562e2366aec, */
   /*            0xcc243dd1e80ab1be, 0xa871135122a1c220, 0x3d0db00992575a60, */
@@ -179,41 +179,41 @@ void TEST_CASE3(void) {
 };
 
 void TEST_CASE4(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x80, 0xb2, 0xb6, 0xd7, 0x4f, 0xbe, 0xee, 0x53, 0xab, 0x57, 0xe4,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x80, 0xb2, 0xb6, 0xd7, 0x4f, 0xbe, 0xee, 0x53, 0xab, 0x57, 0xe4,
           0x28, 0x6a, 0x91, 0x14, 0x4f);
   int64_t scalar = 5;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmul.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I8(13, v2, 0, 0x7a, 0, 0x33, 0, 0xb6, 0, 0x9f, 0, 0xb3, 0, 0xc8, 0, 0xd5,
+  VCLEAR(v8);
+  asm volatile("vmul.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I8(13, v8, 0, 0x7a, 0, 0x33, 0, 0xb6, 0, 0x9f, 0, 0xb3, 0, 0xc8, 0, 0xd5,
           0, 0x8b);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xbab0, 0x83a5, 0x06b6, 0x22ba, 0x91b8, 0x7720, 0xc2c7, 0x3494,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xbab0, 0x83a5, 0x06b6, 0x22ba, 0x91b8, 0x7720, 0xc2c7, 0x3494,
            0xd281, 0x6d38, 0x378d, 0xa91d, 0xd731, 0xa4c7, 0x4d8f, 0x2422);
   scalar = -5383;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmul.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I16(14, v2, 0, 0xdd7d, 0, 0xcaea, 0, 0x1e20, 0, 0x6bf4, 0, 0x6b78, 0,
+  VCLEAR(v8);
+  asm volatile("vmul.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I16(14, v8, 0, 0xdd7d, 0, 0xcaea, 0, 0x1e20, 0, 0x6bf4, 0, 0x6b78, 0,
            0xff35, 0, 0x2b8f, 0, 0x3912);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x8bb4a8bc, 0x9799b344, 0xcd8c1672, 0xeb2d7c0f, 0x55474d7d,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x8bb4a8bc, 0x9799b344, 0xcd8c1672, 0xeb2d7c0f, 0x55474d7d,
            0x3dae9eaf, 0xc19a3519, 0x6922f03c, 0x42edfa01, 0x1f60b344,
            0x82f31d5e, 0x0faa2e5c, 0x74e95cfa, 0x9fcdae3b, 0xe6c4e0a0,
            0x45549cbc);
   scalar = 6474219;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmul.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I32(15, v2, 0, 0x77dff36c, 0, 0x16e6a8c5, 0, 0x78e111a5, 0, 0xe8a9a314,
+  VCLEAR(v8);
+  asm volatile("vmul.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I32(15, v8, 0, 0x77dff36c, 0, 0x16e6a8c5, 0, 0x78e111a5, 0, 0xe8a9a314,
            0, 0x5a8cf36c, 0, 0xbed6ca74, 0, 0xe2314329, 0, 0x13b37c94);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
-  /*   VLOAD_64(v4, 0xc238e0a3df21299c, 0xb642655c3ab064d5, 0xd19f84bab77e5602,
+  /*   VSET(16, e64, m8); */
+  /*   VLOAD_64(v16, 0xc238e0a3df21299c, 0xb642655c3ab064d5, 0xd19f84bab77e5602,
    */
   /*            0x4e6e3c114a19f160, 0xfd403cbcc59407a1, 0xef3e81a68ae0e48c, */
   /*            0xd93a7b1ab54d024e, 0x5f7460aa9f4c4920, 0x4c91150cd4b54f60, */
@@ -222,9 +222,9 @@ void TEST_CASE4(void) {
   /*            0x13e86249a0235941); */
   /*   scalar = -598189234597999223; */
   /*   VLOAD_8(v0, 0xAA, 0xAA); */
-  /*   VCLEAR(v2); */
-  /*   asm volatile("vmul.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar)); */
-  /*   VCMP_I64(16, v2, 0, 0x7d03f4c84c5e86fd, 0, 0x77bc957fdeec0c60, 0, */
+  /*   VCLEAR(v8); */
+  /*   asm volatile("vmul.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar)); */
+  /*   VCMP_I64(16, v8, 0, 0x7d03f4c84c5e86fd, 0, 0x77bc957fdeec0c60, 0, */
   /*            0xbac65562e2366aec, 0, 0xa871135122a1c220, 0,
    * 0x8b07763affcd8fb7, 0, */
   /*            0xd8827c839711c0aa, 0, 0x243fd844e74ed927, 0,
diff --git a/sw/riscvTests/isa/rv64uv/vmulh.c b/sw/riscvTests/isa/rv64uv/vmulh.c
index eda29bd6..869bfef9 100644
--- a/sw/riscvTests/isa/rv64uv/vmulh.c
+++ b/sw/riscvTests/isa/rv64uv/vmulh.c
@@ -8,56 +8,56 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0xc2, 0xf6, 0xad, 0x0f, 0xc6, 0xeb, 0xca, 0xf3, 0xf3, 0xd9, 0xf4,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0xc2, 0xf6, 0xad, 0x0f, 0xc6, 0xeb, 0xca, 0xf3, 0xf3, 0xd9, 0xf4,
           0xf6, 0x27, 0x57, 0x4f, 0xef);
-  VLOAD_8(v6, 0xf9, 0x0c, 0xa8, 0x05, 0x23, 0xff, 0x48, 0x74, 0xd4, 0x6b, 0x5b,
+  VLOAD_8(v24, 0xf9, 0x0c, 0xa8, 0x05, 0x23, 0xff, 0x48, 0x74, 0xd4, 0x6b, 0x5b,
           0x07, 0x8b, 0x2e, 0x9e, 0x5f);
-  asm volatile("vmulh.vv v2, v4, v6");
-  VCMP_I8(1, v2, 0x01, 0xff, 0x1c, 0x00, 0xf8, 0x00, 0xf0, 0xfa, 0x02, 0xef,
+  asm volatile("vmulh.vv v8, v16, v24");
+  VCMP_I8(1, v8, 0x01, 0xff, 0x1c, 0x00, 0xf8, 0x00, 0xf0, 0xfa, 0x02, 0xef,
           0xfb, 0xff, 0xee, 0x0f, 0xe1, 0xf9);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x911a, 0x9f44, 0x3d2a, 0xa2a8, 0x5aae, 0x0231, 0x56fa, 0xb8b8,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x911a, 0x9f44, 0x3d2a, 0xa2a8, 0x5aae, 0x0231, 0x56fa, 0xb8b8,
            0x55df, 0x8a78, 0x413c, 0xeb32, 0x6bc4, 0x3e47, 0x3d79, 0x2c8f);
-  VLOAD_16(v6, 0x89fd, 0x6bb7, 0x4a94, 0x770c, 0x7c87, 0x8b01, 0xbb6a, 0x900d,
+  VLOAD_16(v24, 0x89fd, 0x6bb7, 0x4a94, 0x770c, 0x7c87, 0x8b01, 0xbb6a, 0x900d,
            0xb589, 0x709e, 0xc75d, 0xafa5, 0x4fd5, 0x2d77, 0x8dbf, 0x3a0a);
-  asm volatile("vmulh.vv v2, v4, v6");
-  VCMP_I16(2, v2, 0x331f, 0xd74c, 0x11d1, 0xd497, 0x2c1c, 0xfeff, 0xe8b2,
+  asm volatile("vmulh.vv v8, v16, v24");
+  VCMP_I16(2, v8, 0x331f, 0xd74c, 0x11d1, 0xd497, 0x2c1c, 0xfeff, 0xe8b2,
            0x1f2b, 0xe705, 0xcc4b, 0xf191, 0x0687, 0x219b, 0x0b0f, 0xe490,
            0x0a1a);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xc66253f4, 0x710c314c, 0xa6fe579b, 0xa7947b70, 0xbf94259f,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xc66253f4, 0x710c314c, 0xa6fe579b, 0xa7947b70, 0xbf94259f,
            0x211088fe, 0x64bfd390, 0x1d49c8d8, 0x7a12a08a, 0x190ee9ae,
            0x361172f8, 0x52457515, 0x05d4b17b, 0x7bb6d43b, 0x96270cc7,
            0x62d35f88);
-  VLOAD_32(v6, 0xd14a266e, 0xe4f43ca5, 0x1c067312, 0xa1909d51, 0x35b8d1aa,
+  VLOAD_32(v24, 0xd14a266e, 0xe4f43ca5, 0x1c067312, 0xa1909d51, 0x35b8d1aa,
            0xdcd3e2ea, 0x05cec46d, 0xbe70ebd4, 0xe15e49c5, 0x81be068b,
            0x49fd9ad8, 0x6c2a5abd, 0x26216dd6, 0x9e3188ac, 0x14af13c4,
            0xd98c6d7f);
-  asm volatile("vmulh.vv v2, v4, v6");
-  VCMP_I32(3, v2, 0x0a83425c, 0xf40e8502, 0xf6419389, 0x209df360, 0xf27b2982,
+  asm volatile("vmulh.vv v8, v16, v24");
+  VCMP_I32(3, v8, 0x0a83425c, 0xf40e8502, 0xf6419389, 0x209df360, 0xf27b2982,
            0xfb750aac, 0x02491ecb, 0xf87fe57b, 0xf164b493, 0xf3a433c8,
            0x0fa089bb, 0x22c2e9f3, 0x00de5543, 0xd0bbf2cc, 0xf772a985,
            0xf128024f);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x9def74822cdf1a42, 0x29307e854b225449, 0x071cdf51785d150e,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x9def74822cdf1a42, 0x29307e854b225449, 0x071cdf51785d150e,
            0xe8ced2e9009d363f, 0xa88c741be4e81893, 0x4a7655ec12afe587,
            0x50c5efa017138cb9, 0x88e076b6ef49619d, 0x5745683769adf333,
            0x5b3b01f4b1c4fd42, 0x8a3d55e48864d144, 0x2eac97fae4174cac,
            0xdb8804ccf6f55686, 0xf7bea87bac575241, 0x250ed7ddade1432d,
            0x06ae542295f32453);
-  VLOAD_64(v6, 0xc5c41e47b5f3de5f, 0xa03833fb95a7e7e2, 0x74f0573dba05b058,
+  VLOAD_64(v24, 0xc5c41e47b5f3de5f, 0xa03833fb95a7e7e2, 0x74f0573dba05b058,
            0x687968e9ba2a98ad, 0x29f4aaf3e5e4f2b6, 0x2c40a650d53f6f08,
            0x491da2c816388b78, 0x2822d8207421ec15, 0x5dd8d394b292512a,
            0x4169844eea56920d, 0x97183b6e1e85fd70, 0x224077bf8899614c,
            0x3a9c0520417d4f32, 0xee47b09a33f49fca, 0x3f9f1140fbd02e0a,
            0x6106ad88eabfc3e2);
-  asm volatile("vmulh.vv v2, v4, v6");
-  VCMP_I64(4, v2, 0x164eafe1cab0639c, 0xf096db86d4d06824, 0x033fc2aecddc0dd7,
+  asm volatile("vmulh.vv v8, v16, v24");
+  VCMP_I64(4, v8, 0x164eafe1cab0639c, 0xf096db86d4d06824, 0x033fc2aecddc0dd7,
            0xf68905ef31703000, 0xf1aaea11162383ae, 0x0cdf24ba4cf3be38,
            0x1711cb1d2f008de9, 0xed52dbcaa3de5ca2, 0x1ffe218cf60b6bf9,
            0x174f95d97aff7bf9, 0x3041b22ecc97909a, 0x063ead2a7756c9da,
@@ -67,99 +67,99 @@ void TEST_CASE1(void) {
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0xc2, 0xf6, 0xad, 0x0f, 0xc6, 0xeb, 0xca, 0xf3, 0xf3, 0xd9, 0xf4,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0xc2, 0xf6, 0xad, 0x0f, 0xc6, 0xeb, 0xca, 0xf3, 0xf3, 0xd9, 0xf4,
           0xf6, 0x27, 0x57, 0x4f, 0xef);
-  VLOAD_8(v6, 0xf9, 0x0c, 0xa8, 0x05, 0x23, 0xff, 0x48, 0x74, 0xd4, 0x6b, 0x5b,
+  VLOAD_8(v24, 0xf9, 0x0c, 0xa8, 0x05, 0x23, 0xff, 0x48, 0x74, 0xd4, 0x6b, 0x5b,
           0x07, 0x8b, 0x2e, 0x9e, 0x5f);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulh.vv v2, v4, v6, v0.t");
-  VCMP_I8(5, v2, 0, 0xff, 0, 0x00, 0, 0x00, 0, 0xfa, 0, 0xef, 0, 0xff, 0, 0x0f,
+  VCLEAR(v8);
+  asm volatile("vmulh.vv v8, v16, v24, v0.t");
+  VCMP_I8(5, v8, 0, 0xff, 0, 0x00, 0, 0x00, 0, 0xfa, 0, 0xef, 0, 0xff, 0, 0x0f,
           0, 0xf9);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x911a, 0x9f44, 0x3d2a, 0xa2a8, 0x5aae, 0x0231, 0x56fa, 0xb8b8,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x911a, 0x9f44, 0x3d2a, 0xa2a8, 0x5aae, 0x0231, 0x56fa, 0xb8b8,
            0x55df, 0x8a78, 0x413c, 0xeb32, 0x6bc4, 0x3e47, 0x3d79, 0x2c8f);
-  VLOAD_16(v6, 0x89fd, 0x6bb7, 0x4a94, 0x770c, 0x7c87, 0x8b01, 0xbb6a, 0x900d,
+  VLOAD_16(v24, 0x89fd, 0x6bb7, 0x4a94, 0x770c, 0x7c87, 0x8b01, 0xbb6a, 0x900d,
            0xb589, 0x709e, 0xc75d, 0xafa5, 0x4fd5, 0x2d77, 0x8dbf, 0x3a0a);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulh.vv v2, v4, v6, v0.t");
-  VCMP_I16(6, v2, 0, 0xd74c, 0, 0xd497, 0, 0xfeff, 0, 0x1f2b, 0, 0xcc4b, 0,
+  VCLEAR(v8);
+  asm volatile("vmulh.vv v8, v16, v24, v0.t");
+  VCMP_I16(6, v8, 0, 0xd74c, 0, 0xd497, 0, 0xfeff, 0, 0x1f2b, 0, 0xcc4b, 0,
            0x0687, 0, 0x0b0f, 0, 0x0a1a);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xc66253f4, 0x710c314c, 0xa6fe579b, 0xa7947b70, 0xbf94259f,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xc66253f4, 0x710c314c, 0xa6fe579b, 0xa7947b70, 0xbf94259f,
            0x211088fe, 0x64bfd390, 0x1d49c8d8, 0x7a12a08a, 0x190ee9ae,
            0x361172f8, 0x52457515, 0x05d4b17b, 0x7bb6d43b, 0x96270cc7,
            0x62d35f88);
-  VLOAD_32(v6, 0xd14a266e, 0xe4f43ca5, 0x1c067312, 0xa1909d51, 0x35b8d1aa,
+  VLOAD_32(v24, 0xd14a266e, 0xe4f43ca5, 0x1c067312, 0xa1909d51, 0x35b8d1aa,
            0xdcd3e2ea, 0x05cec46d, 0xbe70ebd4, 0xe15e49c5, 0x81be068b,
            0x49fd9ad8, 0x6c2a5abd, 0x26216dd6, 0x9e3188ac, 0x14af13c4,
            0xd98c6d7f);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulh.vv v2, v4, v6, v0.t");
-  VCMP_I32(7, v2, 0, 0xf40e8502, 0, 0x209df360, 0, 0xfb750aac, 0, 0xf87fe57b, 0,
+  VCLEAR(v8);
+  asm volatile("vmulh.vv v8, v16, v24, v0.t");
+  VCMP_I32(7, v8, 0, 0xf40e8502, 0, 0x209df360, 0, 0xfb750aac, 0, 0xf87fe57b, 0,
            0xf3a433c8, 0, 0x22c2e9f3, 0, 0xd0bbf2cc, 0, 0xf128024f);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x9def74822cdf1a42, 0x29307e854b225449, 0x071cdf51785d150e,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x9def74822cdf1a42, 0x29307e854b225449, 0x071cdf51785d150e,
            0xe8ced2e9009d363f, 0xa88c741be4e81893, 0x4a7655ec12afe587,
            0x50c5efa017138cb9, 0x88e076b6ef49619d, 0x5745683769adf333,
            0x5b3b01f4b1c4fd42, 0x8a3d55e48864d144, 0x2eac97fae4174cac,
            0xdb8804ccf6f55686, 0xf7bea87bac575241, 0x250ed7ddade1432d,
            0x06ae542295f32453);
-  VLOAD_64(v6, 0xc5c41e47b5f3de5f, 0xa03833fb95a7e7e2, 0x74f0573dba05b058,
+  VLOAD_64(v24, 0xc5c41e47b5f3de5f, 0xa03833fb95a7e7e2, 0x74f0573dba05b058,
            0x687968e9ba2a98ad, 0x29f4aaf3e5e4f2b6, 0x2c40a650d53f6f08,
            0x491da2c816388b78, 0x2822d8207421ec15, 0x5dd8d394b292512a,
            0x4169844eea56920d, 0x97183b6e1e85fd70, 0x224077bf8899614c,
            0x3a9c0520417d4f32, 0xee47b09a33f49fca, 0x3f9f1140fbd02e0a,
            0x6106ad88eabfc3e2);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulh.vv v2, v4, v6, v0.t");
-  VCMP_I64(8, v2, 0, 0xf096db86d4d06824, 0, 0xf68905ef31703000, 0,
+  VCLEAR(v8);
+  asm volatile("vmulh.vv v8, v16, v24, v0.t");
+  VCMP_I64(8, v8, 0, 0xf096db86d4d06824, 0, 0xf68905ef31703000, 0,
            0x0cdf24ba4cf3be38, 0, 0xed52dbcaa3de5ca2, 0, 0x174f95d97aff7bf9, 0,
            0x063ead2a7756c9da, 0, 0x0092485623082173, 0, 0x02883a7e75391040);
 #endif
 };
 
 void TEST_CASE3(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x92, 0xce, 0xdd, 0x64, 0x60, 0x29, 0xa6, 0xd5, 0x07, 0x8c, 0x71,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x92, 0xce, 0xdd, 0x64, 0x60, 0x29, 0xa6, 0xd5, 0x07, 0x8c, 0x71,
           0x94, 0x95, 0xf6, 0xd4, 0xbd);
   int64_t scalar = 5;
-  asm volatile("vmulh.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I8(9, v2, 0xfd, 0xff, 0xff, 0x01, 0x01, 0x00, 0xfe, 0xff, 0x00, 0xfd,
+  asm volatile("vmulh.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I8(9, v8, 0xfd, 0xff, 0xff, 0x01, 0x01, 0x00, 0xfe, 0xff, 0x00, 0xfd,
           0x02, 0xfd, 0xfd, 0xff, 0xff, 0xfe);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x3b9b, 0x7758, 0x030f, 0x9f60, 0x13e2, 0x8f0d, 0xfc9d, 0x3922,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x3b9b, 0x7758, 0x030f, 0x9f60, 0x13e2, 0x8f0d, 0xfc9d, 0x3922,
            0x3a43, 0x58b5, 0xb9e9, 0xa4e8, 0x4bac, 0x5636, 0x9f4a, 0xbd52);
   scalar = -5383;
-  asm volatile("vmulh.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I16(10, v2, 0xfb1a, 0xf632, 0xffbf, 0x07ef, 0xfe5d, 0x0947, 0x0047,
+  asm volatile("vmulh.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I16(10, v8, 0xfb1a, 0xf632, 0xffbf, 0x07ef, 0xfe5d, 0x0947, 0x0047,
            0xfb4e, 0xfb36, 0xf8b6, 0x05c1, 0x077b, 0xf9c8, 0xf8eb, 0x07f1,
            0x057a);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x7efca225, 0xdbc0a9ca, 0x0cf02cf8, 0xc19bdc84, 0x7fa3ca90,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x7efca225, 0xdbc0a9ca, 0x0cf02cf8, 0xc19bdc84, 0x7fa3ca90,
            0x3d878c29, 0x15809928, 0x7b0b7421, 0x48b872f5, 0xafbfeab4,
            0xe79dc9ba, 0xe60a8fc0, 0x1fd7e866, 0xed7df17c, 0x0684a7ee,
            0xb2b01a61);
   scalar = 6474219;
-  asm volatile("vmulh.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I32(11, v2, 0x003100de, 0xfff20329, 0x0004fe25, 0xffe7ec74, 0x00314160,
+  asm volatile("vmulh.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I32(11, v8, 0x003100de, 0xfff20329, 0x0004fe25, 0xffe7ec74, 0x00314160,
            0x0017be6b, 0x00084c30, 0x002f7b6f, 0x001c0ff7, 0xffe1082b,
            0xfff6972b, 0xfff5fb91, 0x000c49c4, 0xfff8db9d, 0x000283ec,
            0xffe22a6f);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
-  /*   VLOAD_64(v4, 0x42e9b386e7453715, 0xd6aae3fda4b2f3e8, 0xfcbec1ad7996a0b2,
+  /*   VSET(16, e64, m8); */
+  /*   VLOAD_64(v16, 0x42e9b386e7453715, 0xd6aae3fda4b2f3e8, 0xfcbec1ad7996a0b2,
    */
   /*            0x4fcb68f516b589c9, 0x414b0eeb29c35e62, 0x038c6221829f4241, */
   /*            0xf2c2c11f26e326b0, 0xed9ad0ce4d50a009, 0xc57105a57d435897, */
@@ -167,8 +167,8 @@ void TEST_CASE3(void) {
   /*            0x1d9da4f87df33b54, 0xe347aadb53bdc879, 0x7a39a7269cbae2a7, */
   /*            0x422ed2952e246f26); */
   /*   scalar = -598189234597999223; */
-  /*   asm volatile("vmulh.vx v2, v4, %[A]" ::[A] "r"(scalar)); */
-  /*   VCMP_I64(12, v2, 0xfdd4850b300f6008, 0x01571f899f226d57,
+  /*   asm volatile("vmulh.vx v8, v16, %[A]" ::[A] "r"(scalar)); */
+  /*   VCMP_I64(12, v8, 0xfdd4850b300f6008, 0x01571f899f226d57,
    * 0x001b0534decdc9a2, */
   /*            0xfd6994f8de6e51aa, 0xfde1f73873e6758a, 0xffe28b043b9b8971, */
   /*            0x006de7f819baba3d, 0x0098b57f65f599e1, 0x01e62040839e971b, */
@@ -179,41 +179,41 @@ void TEST_CASE3(void) {
 };
 
 void TEST_CASE4(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x92, 0xce, 0xdd, 0x64, 0x60, 0x29, 0xa6, 0xd5, 0x07, 0x8c, 0x71,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x92, 0xce, 0xdd, 0x64, 0x60, 0x29, 0xa6, 0xd5, 0x07, 0x8c, 0x71,
           0x94, 0x95, 0xf6, 0xd4, 0xbd);
   int64_t scalar = 5;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulh.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I8(13, v2, 0, 0xff, 0, 0x01, 0, 0x00, 0, 0xff, 0, 0xfd, 0, 0xfd, 0, 0xff,
+  VCLEAR(v8);
+  asm volatile("vmulh.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I8(13, v8, 0, 0xff, 0, 0x01, 0, 0x00, 0, 0xff, 0, 0xfd, 0, 0xfd, 0, 0xff,
           0, 0xfe);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x3b9b, 0x7758, 0x030f, 0x9f60, 0x13e2, 0x8f0d, 0xfc9d, 0x3922,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x3b9b, 0x7758, 0x030f, 0x9f60, 0x13e2, 0x8f0d, 0xfc9d, 0x3922,
            0x3a43, 0x58b5, 0xb9e9, 0xa4e8, 0x4bac, 0x5636, 0x9f4a, 0xbd52);
   scalar = -5383;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulh.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I16(14, v2, 0, 0xf632, 0, 0x07ef, 0, 0x0947, 0, 0xfb4e, 0, 0xf8b6, 0,
+  VCLEAR(v8);
+  asm volatile("vmulh.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I16(14, v8, 0, 0xf632, 0, 0x07ef, 0, 0x0947, 0, 0xfb4e, 0, 0xf8b6, 0,
            0x077b, 0, 0xf8eb, 0, 0x057a);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x7efca225, 0xdbc0a9ca, 0x0cf02cf8, 0xc19bdc84, 0x7fa3ca90,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x7efca225, 0xdbc0a9ca, 0x0cf02cf8, 0xc19bdc84, 0x7fa3ca90,
            0x3d878c29, 0x15809928, 0x7b0b7421, 0x48b872f5, 0xafbfeab4,
            0xe79dc9ba, 0xe60a8fc0, 0x1fd7e866, 0xed7df17c, 0x0684a7ee,
            0xb2b01a61);
   scalar = 6474219;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulh.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I32(15, v2, 0, 0xfff20329, 0, 0xffe7ec74, 0, 0x0017be6b, 0, 0x002f7b6f,
+  VCLEAR(v8);
+  asm volatile("vmulh.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I32(15, v8, 0, 0xfff20329, 0, 0xffe7ec74, 0, 0x0017be6b, 0, 0x002f7b6f,
            0, 0xffe1082b, 0, 0xfff5fb91, 0, 0xfff8db9d, 0, 0xffe22a6f);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
-  /*   VLOAD_64(v4, 0x42e9b386e7453715, 0xd6aae3fda4b2f3e8, 0xfcbec1ad7996a0b2,
+  /*   VSET(16, e64, m8); */
+  /*   VLOAD_64(v16, 0x42e9b386e7453715, 0xd6aae3fda4b2f3e8, 0xfcbec1ad7996a0b2,
    */
   /*            0x4fcb68f516b589c9, 0x414b0eeb29c35e62, 0x038c6221829f4241, */
   /*            0xf2c2c11f26e326b0, 0xed9ad0ce4d50a009, 0xc57105a57d435897, */
@@ -222,9 +222,9 @@ void TEST_CASE4(void) {
   /*            0x422ed2952e246f26); */
   /*   scalar = -598189234597999223; */
   /*   VLOAD_8(v0, 0xAA, 0xAA); */
-  /*   VCLEAR(v2); */
-  /*   asm volatile("vmulh.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar)); */
-  /*   VCMP_I64(16, v2, 0, 0x01571f899f226d57, 0, 0xfd6994f8de6e51aa, 0, */
+  /*   VCLEAR(v8); */
+  /*   asm volatile("vmulh.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar)); */
+  /*   VCMP_I64(16, v8, 0, 0x01571f899f226d57, 0, 0xfd6994f8de6e51aa, 0, */
   /*            0xffe28b043b9b8971, 0, 0x0098b57f65f599e1, 0,
    * 0x039b807e6f36fd81, 0, */
   /*            0x0293356120e5cee9, 0, 0x00ee6bb505683322, 0,
diff --git a/sw/riscvTests/isa/rv64uv/vmulhsu.c b/sw/riscvTests/isa/rv64uv/vmulhsu.c
index 482b3e65..c87aaa8b 100644
--- a/sw/riscvTests/isa/rv64uv/vmulhsu.c
+++ b/sw/riscvTests/isa/rv64uv/vmulhsu.c
@@ -8,56 +8,56 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x53, 0x4f, 0xde, 0xea, 0x47, 0x3c, 0x41, 0xf8, 0xd6, 0xd0, 0x93,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x53, 0x4f, 0xde, 0xea, 0x47, 0x3c, 0x41, 0xf8, 0xd6, 0xd0, 0x93,
           0x35, 0xfc, 0x70, 0x33, 0xe4);
-  VLOAD_8(v6, 0xaa, 0x24, 0xaa, 0xde, 0x92, 0x00, 0x7f, 0xe5, 0xb3, 0xf8, 0xa0,
+  VLOAD_8(v24, 0xaa, 0x24, 0xaa, 0xde, 0x92, 0x00, 0x7f, 0xe5, 0xb3, 0xf8, 0xa0,
           0xa8, 0xbb, 0xc6, 0x65, 0x81);
-  asm volatile("vmulhsu.vv v2, v4, v6");
-  VCMP_I8(1, v2, 0x37, 0x0b, 0xe9, 0xec, 0x28, 0x00, 0x20, 0xf8, 0xe2, 0xd1,
+  asm volatile("vmulhsu.vv v8, v16, v24");
+  VCMP_I8(1, v8, 0x37, 0x0b, 0xe9, 0xec, 0x28, 0x00, 0x20, 0xf8, 0xe2, 0xd1,
           0xbb, 0x22, 0xfd, 0x56, 0x14, 0xf1);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0f50, 0x47f9, 0xa4ca, 0xf94d, 0x720c, 0x444c, 0x3681, 0x96bd,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0f50, 0x47f9, 0xa4ca, 0xf94d, 0x720c, 0x444c, 0x3681, 0x96bd,
            0x5d37, 0xd64e, 0xe792, 0xdb64, 0xfaa6, 0xafe6, 0xf4e8, 0xe5ea);
-  VLOAD_16(v6, 0x7784, 0xa42e, 0x499b, 0x0c01, 0x9d2b, 0x600d, 0x2bbd, 0xcb41,
+  VLOAD_16(v24, 0x7784, 0xa42e, 0x499b, 0x0c01, 0x9d2b, 0x600d, 0x2bbd, 0xcb41,
            0xdda1, 0xb5d7, 0xafbc, 0xc74f, 0xab45, 0x986f, 0xf0f2, 0xcf3c);
-  asm volatile("vmulhsu.vv v2, v4, v6");
-  VCMP_I16(2, v2, 0x0726, 0x2e28, 0xe5c6, 0xffaf, 0x4604, 0x199f, 0x094f,
+  asm volatile("vmulhsu.vv v8, v16, v24");
+  VCMP_I16(2, v8, 0x0726, 0x2e28, 0xe5c6, 0xffaf, 0x4604, 0x199f, 0x094f,
            0xac6d, 0x50b3, 0xe262, 0xef3a, 0xe37f, 0xfc6b, 0xd04d, 0xf58f,
            0xeae2);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xeded4bf3, 0xc9e27167, 0x4175509c, 0x80a3ae04, 0x9f1b2c07,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xeded4bf3, 0xc9e27167, 0x4175509c, 0x80a3ae04, 0x9f1b2c07,
            0x87ea397b, 0x862e2800, 0x3cd09f37, 0x9a313d78, 0x596661ee,
            0x31f99717, 0x64e65802, 0xbd567027, 0xf7c459be, 0x57b6d9cd,
            0x94bc3eb4);
-  VLOAD_32(v6, 0xa147b233, 0x19880f3d, 0x8dd8815e, 0xbc318dca, 0x2c436b94,
+  VLOAD_32(v24, 0xa147b233, 0x19880f3d, 0x8dd8815e, 0xbc318dca, 0x2c436b94,
            0x29ba4191, 0x637f89b7, 0xe39d7818, 0xf48ff2d6, 0xb1dc7c7e,
            0xfa5da298, 0x5c1aae36, 0x83e04069, 0xecf36c08, 0x40d2e3a3,
            0xe7468a97);
-  asm volatile("vmulhsu.vv v2, v4, v6");
-  VCMP_I32(3, v2, 0xf49d2cff, 0xfa9a5a26, 0x2444f976, 0xa25f8c94, 0xef3f26f6,
+  asm volatile("vmulhsu.vv v8, v16, v24");
+  VCMP_I32(3, v8, 0xf49d2cff, 0xfa9a5a26, 0x2444f976, 0xa25f8c94, 0xef3f26f6,
            0xec6d24a0, 0xd0a728d5, 0x361265a6, 0x9ebdaf85, 0x3e1cc92b,
            0x30e004f5, 0x244d4baf, 0xdda8d640, 0xf8612ea2, 0x1635f870,
            0x9f184dfb);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x2b1f761d24dcff24, 0x1174fcea60fbf146, 0xaa5068c22e71489d,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x2b1f761d24dcff24, 0x1174fcea60fbf146, 0xaa5068c22e71489d,
            0x422ad458a7cbf321, 0x01e0f752e5d8bb37, 0xe7762162abff4c4c,
            0x36279dbbf009199d, 0x188dda33d835d9e4, 0xa0f5a67450e87d77,
            0xb43066649033e7ac, 0xb47ff6241cc77c2c, 0xfce0bafc1d36b615,
            0x045b90f3b63e0f7f, 0x514e5121be1f02e5, 0x06c9e97573723e47,
            0x406879d908a80b41);
-  VLOAD_64(v6, 0xd50adee8d491db29, 0xc7d423514dd58616, 0x5b22f7a3971e17f9,
+  VLOAD_64(v24, 0xd50adee8d491db29, 0xc7d423514dd58616, 0x5b22f7a3971e17f9,
            0xb9ad8b0339e659cd, 0x5af15755f3954b0f, 0x6b2fb3e49bd48e69,
            0x084244757fba5561, 0xf2d5b41ee89411fa, 0x8585111aaee16c07,
            0xcd1a427644b0ad59, 0x2356738fd6b04f3a, 0x89d936a76f0a518a,
            0x5f2df66443ff24b3, 0x6cbfcf273c43ae6b, 0xabb59d9f05a03eef,
            0xb84832df19fc19b6);
-  asm volatile("vmulhsu.vv v2, v4, v6");
-  VCMP_I64(4, v2, 0x23e3020d5d8e40d8, 0x0da067e42d62fa2a, 0xe17ee107c3fdd97f,
+  asm volatile("vmulhsu.vv v8, v16, v24");
+  VCMP_I64(4, v8, 0x23e3020d5d8e40d8, 0x0da067e42d62fa2a, 0xe17ee107c3fdd97f,
            0x2ffdce53a7ef7aa4, 0x00aadc600f6180bd, 0xf5b9cd660e9f294b,
            0x01bf419feafa3fe5, 0x174a979243e0945b, 0xce6e38c0508aba17,
            0xc342fb3a620dde75, 0xf593ff8eafcca075, 0xfe519de4c807844e,
@@ -67,99 +67,99 @@ void TEST_CASE1(void) {
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x53, 0x4f, 0xde, 0xea, 0x47, 0x3c, 0x41, 0xf8, 0xd6, 0xd0, 0x93,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x53, 0x4f, 0xde, 0xea, 0x47, 0x3c, 0x41, 0xf8, 0xd6, 0xd0, 0x93,
           0x35, 0xfc, 0x70, 0x33, 0xe4);
-  VLOAD_8(v6, 0xaa, 0x24, 0xaa, 0xde, 0x92, 0x00, 0x7f, 0xe5, 0xb3, 0xf8, 0xa0,
+  VLOAD_8(v24, 0xaa, 0x24, 0xaa, 0xde, 0x92, 0x00, 0x7f, 0xe5, 0xb3, 0xf8, 0xa0,
           0xa8, 0xbb, 0xc6, 0x65, 0x81);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhsu.vv v2, v4, v6, v0.t");
-  VCMP_I8(5, v2, 0, 0x0b, 0, 0xec, 0, 0x00, 0, 0xf8, 0, 0xd1, 0, 0x22, 0, 0x56,
+  VCLEAR(v8);
+  asm volatile("vmulhsu.vv v8, v16, v24, v0.t");
+  VCMP_I8(5, v8, 0, 0x0b, 0, 0xec, 0, 0x00, 0, 0xf8, 0, 0xd1, 0, 0x22, 0, 0x56,
           0, 0xf1);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0f50, 0x47f9, 0xa4ca, 0xf94d, 0x720c, 0x444c, 0x3681, 0x96bd,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0f50, 0x47f9, 0xa4ca, 0xf94d, 0x720c, 0x444c, 0x3681, 0x96bd,
            0x5d37, 0xd64e, 0xe792, 0xdb64, 0xfaa6, 0xafe6, 0xf4e8, 0xe5ea);
-  VLOAD_16(v6, 0x7784, 0xa42e, 0x499b, 0x0c01, 0x9d2b, 0x600d, 0x2bbd, 0xcb41,
+  VLOAD_16(v24, 0x7784, 0xa42e, 0x499b, 0x0c01, 0x9d2b, 0x600d, 0x2bbd, 0xcb41,
            0xdda1, 0xb5d7, 0xafbc, 0xc74f, 0xab45, 0x986f, 0xf0f2, 0xcf3c);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhsu.vv v2, v4, v6, v0.t");
-  VCMP_I16(6, v2, 0, 0x2e28, 0, 0xffaf, 0, 0x199f, 0, 0xac6d, 0, 0xe262, 0,
+  VCLEAR(v8);
+  asm volatile("vmulhsu.vv v8, v16, v24, v0.t");
+  VCMP_I16(6, v8, 0, 0x2e28, 0, 0xffaf, 0, 0x199f, 0, 0xac6d, 0, 0xe262, 0,
            0xe37f, 0, 0xd04d, 0, 0xeae2);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xeded4bf3, 0xc9e27167, 0x4175509c, 0x80a3ae04, 0x9f1b2c07,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xeded4bf3, 0xc9e27167, 0x4175509c, 0x80a3ae04, 0x9f1b2c07,
            0x87ea397b, 0x862e2800, 0x3cd09f37, 0x9a313d78, 0x596661ee,
            0x31f99717, 0x64e65802, 0xbd567027, 0xf7c459be, 0x57b6d9cd,
            0x94bc3eb4);
-  VLOAD_32(v6, 0xa147b233, 0x19880f3d, 0x8dd8815e, 0xbc318dca, 0x2c436b94,
+  VLOAD_32(v24, 0xa147b233, 0x19880f3d, 0x8dd8815e, 0xbc318dca, 0x2c436b94,
            0x29ba4191, 0x637f89b7, 0xe39d7818, 0xf48ff2d6, 0xb1dc7c7e,
            0xfa5da298, 0x5c1aae36, 0x83e04069, 0xecf36c08, 0x40d2e3a3,
            0xe7468a97);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhsu.vv v2, v4, v6, v0.t");
-  VCMP_I32(7, v2, 0, 0xfa9a5a26, 0, 0xa25f8c94, 0, 0xec6d24a0, 0, 0x361265a6, 0,
+  VCLEAR(v8);
+  asm volatile("vmulhsu.vv v8, v16, v24, v0.t");
+  VCMP_I32(7, v8, 0, 0xfa9a5a26, 0, 0xa25f8c94, 0, 0xec6d24a0, 0, 0x361265a6, 0,
            0x3e1cc92b, 0, 0x244d4baf, 0, 0xf8612ea2, 0, 0x9f184dfb);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x2b1f761d24dcff24, 0x1174fcea60fbf146, 0xaa5068c22e71489d,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x2b1f761d24dcff24, 0x1174fcea60fbf146, 0xaa5068c22e71489d,
            0x422ad458a7cbf321, 0x01e0f752e5d8bb37, 0xe7762162abff4c4c,
            0x36279dbbf009199d, 0x188dda33d835d9e4, 0xa0f5a67450e87d77,
            0xb43066649033e7ac, 0xb47ff6241cc77c2c, 0xfce0bafc1d36b615,
            0x045b90f3b63e0f7f, 0x514e5121be1f02e5, 0x06c9e97573723e47,
            0x406879d908a80b41);
-  VLOAD_64(v6, 0xd50adee8d491db29, 0xc7d423514dd58616, 0x5b22f7a3971e17f9,
+  VLOAD_64(v24, 0xd50adee8d491db29, 0xc7d423514dd58616, 0x5b22f7a3971e17f9,
            0xb9ad8b0339e659cd, 0x5af15755f3954b0f, 0x6b2fb3e49bd48e69,
            0x084244757fba5561, 0xf2d5b41ee89411fa, 0x8585111aaee16c07,
            0xcd1a427644b0ad59, 0x2356738fd6b04f3a, 0x89d936a76f0a518a,
            0x5f2df66443ff24b3, 0x6cbfcf273c43ae6b, 0xabb59d9f05a03eef,
            0xb84832df19fc19b6);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhsu.vv v2, v4, v6, v0.t");
-  VCMP_I64(8, v2, 0, 0x0da067e42d62fa2a, 0, 0x2ffdce53a7ef7aa4, 0,
+  VCLEAR(v8);
+  asm volatile("vmulhsu.vv v8, v16, v24, v0.t");
+  VCMP_I64(8, v8, 0, 0x0da067e42d62fa2a, 0, 0x2ffdce53a7ef7aa4, 0,
            0xf5b9cd660e9f294b, 0, 0x174a979243e0945b, 0, 0xc342fb3a620dde75, 0,
            0xfe519de4c807844e, 0, 0x2289f5738e0e6d23, 0, 0x2e5d41c2cc9b604f);
 #endif
 };
 
 void TEST_CASE3(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x21, 0x87, 0xa0, 0xa8, 0x6a, 0x6f, 0x6a, 0x6b, 0x74, 0x99, 0x37,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x21, 0x87, 0xa0, 0xa8, 0x6a, 0x6f, 0x6a, 0x6b, 0x74, 0x99, 0x37,
           0xa4, 0xdc, 0x4f, 0xc3, 0x55);
   uint64_t scalar = 5;
-  asm volatile("vmulhsu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I8(9, v2, 0x00, 0xfd, 0xfe, 0xfe, 0x02, 0x02, 0x02, 0x02, 0x02, 0xfd,
+  asm volatile("vmulhsu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I8(9, v8, 0x00, 0xfd, 0xfe, 0xfe, 0x02, 0x02, 0x02, 0x02, 0x02, 0xfd,
           0x01, 0xfe, 0xff, 0x01, 0xfe, 0x01);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x62b8, 0xc1e3, 0xb151, 0x08ce, 0x06c4, 0x1d2f, 0x7448, 0xfcd5,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x62b8, 0xc1e3, 0xb151, 0x08ce, 0x06c4, 0x1d2f, 0x7448, 0xfcd5,
            0x398c, 0xb933, 0x436d, 0x748f, 0x58d9, 0x1cd6, 0x86db, 0x20f2);
   scalar = 816;
-  asm volatile("vmulhsu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I16(10, v2, 0x013a, 0xff3a, 0xff05, 0x001c, 0x0015, 0x005d, 0x0172,
+  asm volatile("vmulhsu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I16(10, v8, 0x013a, 0xff3a, 0xff05, 0x001c, 0x0015, 0x005d, 0x0172,
            0xfff5, 0x00b7, 0xff1e, 0x00d6, 0x0173, 0x011b, 0x005b, 0xfe7d,
            0x0069);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xa7cac3f7, 0xb3894e05, 0xbac8e70b, 0x05479577, 0x19d8bf63,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xa7cac3f7, 0xb3894e05, 0xbac8e70b, 0x05479577, 0x19d8bf63,
            0xb952c1ad, 0x9eaa74c0, 0x9e38d5c8, 0x51c77b3b, 0xa5f44521,
            0x65042faa, 0x8e7e5345, 0x76ae481c, 0x0ab27b6f, 0xa388cf2b,
            0x58218f7f);
   scalar = 7389998;
-  asm volatile("vmulhsu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I32(11, v2, 0xffd92575, 0xffde51c5, 0xffe1831f, 0x00025357, 0x000b6288,
+  asm volatile("vmulhsu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I32(11, v8, 0xffd92575, 0xffde51c5, 0xffe1831f, 0x00025357, 0x000b6288,
            0xffe0de52, 0xffd5205d, 0xffd4ee51, 0x0024059f, 0xffd85637,
            0x002c7ed9, 0xffce00ba, 0x003446bb, 0x0004b63d, 0xffd7455b,
            0x0026d1e0);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
-  /*   VLOAD_64(v4, 0x43c5f863d4be9b51, 0x70b017b4c5d0d11e, 0x9e008a07f48796fe,
+  /*   VSET(16, e64, m8); */
+  /*   VLOAD_64(v16, 0x43c5f863d4be9b51, 0x70b017b4c5d0d11e, 0x9e008a07f48796fe,
    */
   /*            0x6f0fa9a63860308a, 0x07b5d372a7be167c, 0x234be9472899553e, */
   /*            0x25655d82cb668037, 0x959d6233470780ee, 0xf3d683308326232a, */
@@ -167,8 +167,8 @@ void TEST_CASE3(void) {
   /*            0x8382e0c79caa1e6c, 0x0d1593d36c1dc00e, 0x9f8eb889cc8e98c6, */
   /*            0x37411f40369680d2); */
   /*   scalar = 321156886679781445; */
-  /*   asm volatile("vmulhsu.vx v2, v4, %[A]" ::[A] "r"(scalar)); */
-  /*   VCMP_I64(12, v2, 0x012e0fe6705cf26d, 0x01f63e6c65840868,
+  /*   asm volatile("vmulhsu.vx v8, v16, %[A]" ::[A] "r"(scalar)); */
+  /*   VCMP_I64(12, v8, 0x012e0fe6705cf26d, 0x01f63e6c65840868,
    * 0xfe4b3a837bcf749f, */
   /*            0x01eefe6ad67c584e, 0x00225d3cec11ae29, 0x009d50942207fb0e, */
   /*            0x00a6abfb9cc735df, 0xfe25d8c13270b026, 0xffc9cb59c445c91a, */
@@ -179,41 +179,41 @@ void TEST_CASE3(void) {
 };
 
 void TEST_CASE4(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x21, 0x87, 0xa0, 0xa8, 0x6a, 0x6f, 0x6a, 0x6b, 0x74, 0x99, 0x37,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x21, 0x87, 0xa0, 0xa8, 0x6a, 0x6f, 0x6a, 0x6b, 0x74, 0x99, 0x37,
           0xa4, 0xdc, 0x4f, 0xc3, 0x55);
   uint64_t scalar = 5;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhsu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I8(13, v2, 0, 0xfd, 0, 0xfe, 0, 0x02, 0, 0x02, 0, 0xfd, 0, 0xfe, 0, 0x01,
+  VCLEAR(v8);
+  asm volatile("vmulhsu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I8(13, v8, 0, 0xfd, 0, 0xfe, 0, 0x02, 0, 0x02, 0, 0xfd, 0, 0xfe, 0, 0x01,
           0, 0x01);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x62b8, 0xc1e3, 0xb151, 0x08ce, 0x06c4, 0x1d2f, 0x7448, 0xfcd5,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x62b8, 0xc1e3, 0xb151, 0x08ce, 0x06c4, 0x1d2f, 0x7448, 0xfcd5,
            0x398c, 0xb933, 0x436d, 0x748f, 0x58d9, 0x1cd6, 0x86db, 0x20f2);
   scalar = 816;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhsu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I16(14, v2, 0, 0xff3a, 0, 0x001c, 0, 0x005d, 0, 0xfff5, 0, 0xff1e, 0,
+  VCLEAR(v8);
+  asm volatile("vmulhsu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I16(14, v8, 0, 0xff3a, 0, 0x001c, 0, 0x005d, 0, 0xfff5, 0, 0xff1e, 0,
            0x0173, 0, 0x005b, 0, 0x0069);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xa7cac3f7, 0xb3894e05, 0xbac8e70b, 0x05479577, 0x19d8bf63,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xa7cac3f7, 0xb3894e05, 0xbac8e70b, 0x05479577, 0x19d8bf63,
            0xb952c1ad, 0x9eaa74c0, 0x9e38d5c8, 0x51c77b3b, 0xa5f44521,
            0x65042faa, 0x8e7e5345, 0x76ae481c, 0x0ab27b6f, 0xa388cf2b,
            0x58218f7f);
   scalar = 7389998;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhsu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I32(15, v2, 0, 0xffde51c5, 0, 0x00025357, 0, 0xffe0de52, 0, 0xffd4ee51,
+  VCLEAR(v8);
+  asm volatile("vmulhsu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I32(15, v8, 0, 0xffde51c5, 0, 0x00025357, 0, 0xffe0de52, 0, 0xffd4ee51,
            0, 0xffd85637, 0, 0xffce00ba, 0, 0x0004b63d, 0, 0x0026d1e0);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
-  /*   VLOAD_64(v4, 0x43c5f863d4be9b51, 0x70b017b4c5d0d11e, 0x9e008a07f48796fe,
+  /*   VSET(16, e64, m8); */
+  /*   VLOAD_64(v16, 0x43c5f863d4be9b51, 0x70b017b4c5d0d11e, 0x9e008a07f48796fe,
    */
   /*            0x6f0fa9a63860308a, 0x07b5d372a7be167c, 0x234be9472899553e, */
   /*            0x25655d82cb668037, 0x959d6233470780ee, 0xf3d683308326232a, */
@@ -222,9 +222,9 @@ void TEST_CASE4(void) {
   /*            0x37411f40369680d2); */
   /*   scalar = 321156886679781445; */
   /*   VLOAD_8(v0, 0xAA, 0xAA); */
-  /*   VCLEAR(v2); */
-  /*   asm volatile("vmulhsu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar)); */
-  /*   VCMP_I64(16, v2, 0, 0x01f63e6c65840868, 0, 0x01eefe6ad67c584e, 0, */
+  /*   VCLEAR(v8); */
+  /*   asm volatile("vmulhsu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar)); */
+  /*   VCMP_I64(16, v8, 0, 0x01f63e6c65840868, 0, 0x01eefe6ad67c584e, 0, */
   /*            0x009d50942207fb0e, 0, 0xfe25d8c13270b026, 0,
    * 0x02261e05ece3e474, 0, */
   /*            0x004c5c6f8fd9129e, 0, 0x003a50e3baabab1e, 0,
diff --git a/sw/riscvTests/isa/rv64uv/vmulhu.c b/sw/riscvTests/isa/rv64uv/vmulhu.c
index 72864626..424bd372 100644
--- a/sw/riscvTests/isa/rv64uv/vmulhu.c
+++ b/sw/riscvTests/isa/rv64uv/vmulhu.c
@@ -8,56 +8,56 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x3b, 0xb2, 0xd1, 0x3e, 0x39, 0x2c, 0x08, 0xc5, 0xbf, 0x54, 0x6c,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x3b, 0xb2, 0xd1, 0x3e, 0x39, 0x2c, 0x08, 0xc5, 0xbf, 0x54, 0x6c,
           0xde, 0x87, 0xcb, 0x7a, 0x83);
-  VLOAD_8(v6, 0x55, 0xde, 0xf4, 0x14, 0x3c, 0xed, 0x47, 0x1b, 0xca, 0x0b, 0xc4,
+  VLOAD_8(v24, 0x55, 0xde, 0xf4, 0x14, 0x3c, 0xed, 0x47, 0x1b, 0xca, 0x0b, 0xc4,
           0xe3, 0xd8, 0x8f, 0xa0, 0x0d);
-  asm volatile("vmulhu.vv v2, v4, v6");
-  VCMP_U8(1, v2, 0x13, 0x9a, 0xc7, 0x04, 0x0d, 0x28, 0x02, 0x14, 0x96, 0x03,
+  asm volatile("vmulhu.vv v8, v16, v24");
+  VCMP_U8(1, v8, 0x13, 0x9a, 0xc7, 0x04, 0x0d, 0x28, 0x02, 0x14, 0x96, 0x03,
           0x52, 0xc4, 0x71, 0x71, 0x4c, 0x06);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xe6e1, 0x02a1, 0x2911, 0xe3c3, 0xe141, 0x69e6, 0x4133, 0xf783,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xe6e1, 0x02a1, 0x2911, 0xe3c3, 0xe141, 0x69e6, 0x4133, 0xf783,
            0x91ef, 0x1897, 0xf0bb, 0x0e07, 0xb8eb, 0x3f5a, 0x9f5d, 0xa626);
-  VLOAD_16(v6, 0x4fcb, 0x8a38, 0xbaa0, 0x8a97, 0xe409, 0x558e, 0x582b, 0x62b1,
+  VLOAD_16(v24, 0x4fcb, 0x8a38, 0xbaa0, 0x8a97, 0xe409, 0x558e, 0x582b, 0x62b1,
            0xf7bb, 0x181f, 0x2b5a, 0xdf85, 0x44f3, 0x27fe, 0x8412, 0xcda0);
-  asm volatile("vmulhu.vv v2, v4, v6");
-  VCMP_U16(2, v2, 0x47f6, 0x016b, 0x1df0, 0x7b4d, 0xc8a5, 0x2364, 0x1674,
+  asm volatile("vmulhu.vv v8, v16, v24");
+  VCMP_U16(2, v8, 0x47f6, 0x016b, 0x1df0, 0x7b4d, 0xc8a5, 0x2364, 0x1674,
            0x5f6b, 0x8d38, 0x0251, 0x28c4, 0x0c3f, 0x31cd, 0x09e5, 0x5237,
            0x8574);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xf129e694, 0x8dfc72a3, 0xc9911598, 0xd20083ec, 0xe7f36604,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xf129e694, 0x8dfc72a3, 0xc9911598, 0xd20083ec, 0xe7f36604,
            0x1ab510aa, 0xc290b86c, 0xa7e9a02e, 0x5c3f3bb3, 0x70a3dfae,
            0x16baad22, 0x21758cfb, 0x09033e60, 0x8b31075e, 0x6439b7bf,
            0xead33cf0);
-  VLOAD_32(v6, 0x3f2ef56d, 0x12649032, 0x6c0a880b, 0x7cb2477a, 0x41525037,
+  VLOAD_32(v24, 0x3f2ef56d, 0x12649032, 0x6c0a880b, 0x7cb2477a, 0x41525037,
            0x02a39cfa, 0xf7595181, 0x0c230035, 0x86cf9ea9, 0x0f66ddd3,
            0x13351370, 0xbe489ce5, 0x4127f488, 0xe6b5e1b3, 0xc6918270,
            0xccc8626a);
-  asm volatile("vmulhu.vv v2, v4, v6");
-  VCMP_U32(3, v2, 0x3b858c79, 0x0a3386a5, 0x55117fe4, 0x664a7ee4, 0x3b2f618b,
+  asm volatile("vmulhu.vv v8, v16, v24");
+  VCMP_U32(3, v8, 0x3b858c79, 0x0a3386a5, 0x55117fe4, 0x664a7ee4, 0x3b2f618b,
            0x00467bcb, 0xbbfd8432, 0x07f5e895, 0x3093e98c, 0x06c6dd00,
            0x01b49139, 0x18debc33, 0x024b3af0, 0x7d70f100, 0x4dbd9bdf,
            0xbbd823dc);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x4aee1e4f9775ff4b, 0x045a804c3d3e7dc0, 0x1a2f38060efcd306,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x4aee1e4f9775ff4b, 0x045a804c3d3e7dc0, 0x1a2f38060efcd306,
            0x34e09e5173ee6301, 0xd1f03c2e38769683, 0x1b1f454816d4ed10,
            0xed4a4f231da4abb3, 0xc87b025e6da277dc, 0x8da43ddf6feb6aae,
            0x7dcf10ced634db74, 0x736fd9583bc2de91, 0xa66de0036d350cbc,
            0x40bf5ec7afca9ec2, 0x5bb552a7b134ba79, 0x6ae5d02d7c121603,
            0x8a7621ad8d6f104a);
-  VLOAD_64(v6, 0x8f2c0088bea2739e, 0x4ed8c54dad60d3cb, 0x51e715e5cf56b2e6,
+  VLOAD_64(v24, 0x8f2c0088bea2739e, 0x4ed8c54dad60d3cb, 0x51e715e5cf56b2e6,
            0xa1b1262536ea3c57, 0x67f334468e5cde4f, 0x8ae5618164bd63fd,
            0x2f8be93c1d7807c3, 0x0444a9f4ccff2a2c, 0x6cac5e35bf847d59,
            0x1d92c5117b87a392, 0x124597d21d757a4e, 0x4ec5a9fb5b8a6591,
            0xb5b4189dd6080734, 0xf75ddacea0effff6, 0x5c3cb19fbc1c7580,
            0xff93a562f06d3641);
-  asm volatile("vmulhu.vv v2, v4, v6");
-  VCMP_U64(4, v2, 0x29e7e403b1955330, 0x015742ce71e2c757, 0x08609392d9402e03,
+  asm volatile("vmulhu.vv v8, v16, v24");
+  VCMP_U64(4, v8, 0x29e7e403b1955330, 0x015742ce71e2c757, 0x08609392d9402e03,
            0x2165dabfb788d03d, 0x553f1a1e61409141, 0x0eb728a66479b5fb,
            0x2c125410c5448322, 0x0357b1cf05241ad9, 0x3c20a893e10635bb,
            0x0e8895d7f39e953c, 0x083d3ee38137c9b0, 0x3335fb506009220b,
@@ -67,99 +67,99 @@ void TEST_CASE1(void) {
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x3b, 0xb2, 0xd1, 0x3e, 0x39, 0x2c, 0x08, 0xc5, 0xbf, 0x54, 0x6c,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x3b, 0xb2, 0xd1, 0x3e, 0x39, 0x2c, 0x08, 0xc5, 0xbf, 0x54, 0x6c,
           0xde, 0x87, 0xcb, 0x7a, 0x83);
-  VLOAD_8(v6, 0x55, 0xde, 0xf4, 0x14, 0x3c, 0xed, 0x47, 0x1b, 0xca, 0x0b, 0xc4,
+  VLOAD_8(v24, 0x55, 0xde, 0xf4, 0x14, 0x3c, 0xed, 0x47, 0x1b, 0xca, 0x0b, 0xc4,
           0xe3, 0xd8, 0x8f, 0xa0, 0x0d);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhu.vv v2, v4, v6, v0.t");
-  VCMP_U8(5, v2, 0, 0x9a, 0, 0x04, 0, 0x28, 0, 0x14, 0, 0x03, 0, 0xc4, 0, 0x71,
+  VCLEAR(v8);
+  asm volatile("vmulhu.vv v8, v16, v24, v0.t");
+  VCMP_U8(5, v8, 0, 0x9a, 0, 0x04, 0, 0x28, 0, 0x14, 0, 0x03, 0, 0xc4, 0, 0x71,
           0, 0x06);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xe6e1, 0x02a1, 0x2911, 0xe3c3, 0xe141, 0x69e6, 0x4133, 0xf783,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xe6e1, 0x02a1, 0x2911, 0xe3c3, 0xe141, 0x69e6, 0x4133, 0xf783,
            0x91ef, 0x1897, 0xf0bb, 0x0e07, 0xb8eb, 0x3f5a, 0x9f5d, 0xa626);
-  VLOAD_16(v6, 0x4fcb, 0x8a38, 0xbaa0, 0x8a97, 0xe409, 0x558e, 0x582b, 0x62b1,
+  VLOAD_16(v24, 0x4fcb, 0x8a38, 0xbaa0, 0x8a97, 0xe409, 0x558e, 0x582b, 0x62b1,
            0xf7bb, 0x181f, 0x2b5a, 0xdf85, 0x44f3, 0x27fe, 0x8412, 0xcda0);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhu.vv v2, v4, v6, v0.t");
-  VCMP_U16(6, v2, 0, 0x016b, 0, 0x7b4d, 0, 0x2364, 0, 0x5f6b, 0, 0x0251, 0,
+  VCLEAR(v8);
+  asm volatile("vmulhu.vv v8, v16, v24, v0.t");
+  VCMP_U16(6, v8, 0, 0x016b, 0, 0x7b4d, 0, 0x2364, 0, 0x5f6b, 0, 0x0251, 0,
            0x0c3f, 0, 0x09e5, 0, 0x8574);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xf129e694, 0x8dfc72a3, 0xc9911598, 0xd20083ec, 0xe7f36604,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xf129e694, 0x8dfc72a3, 0xc9911598, 0xd20083ec, 0xe7f36604,
            0x1ab510aa, 0xc290b86c, 0xa7e9a02e, 0x5c3f3bb3, 0x70a3dfae,
            0x16baad22, 0x21758cfb, 0x09033e60, 0x8b31075e, 0x6439b7bf,
            0xead33cf0);
-  VLOAD_32(v6, 0x3f2ef56d, 0x12649032, 0x6c0a880b, 0x7cb2477a, 0x41525037,
+  VLOAD_32(v24, 0x3f2ef56d, 0x12649032, 0x6c0a880b, 0x7cb2477a, 0x41525037,
            0x02a39cfa, 0xf7595181, 0x0c230035, 0x86cf9ea9, 0x0f66ddd3,
            0x13351370, 0xbe489ce5, 0x4127f488, 0xe6b5e1b3, 0xc6918270,
            0xccc8626a);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhu.vv v2, v4, v6, v0.t");
-  VCMP_U32(7, v2, 0, 0x0a3386a5, 0, 0x664a7ee4, 0, 0x00467bcb, 0, 0x07f5e895, 0,
+  VCLEAR(v8);
+  asm volatile("vmulhu.vv v8, v16, v24, v0.t");
+  VCMP_U32(7, v8, 0, 0x0a3386a5, 0, 0x664a7ee4, 0, 0x00467bcb, 0, 0x07f5e895, 0,
            0x06c6dd00, 0, 0x18debc33, 0, 0x7d70f100, 0, 0xbbd823dc);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x4aee1e4f9775ff4b, 0x045a804c3d3e7dc0, 0x1a2f38060efcd306,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x4aee1e4f9775ff4b, 0x045a804c3d3e7dc0, 0x1a2f38060efcd306,
            0x34e09e5173ee6301, 0xd1f03c2e38769683, 0x1b1f454816d4ed10,
            0xed4a4f231da4abb3, 0xc87b025e6da277dc, 0x8da43ddf6feb6aae,
            0x7dcf10ced634db74, 0x736fd9583bc2de91, 0xa66de0036d350cbc,
            0x40bf5ec7afca9ec2, 0x5bb552a7b134ba79, 0x6ae5d02d7c121603,
            0x8a7621ad8d6f104a);
-  VLOAD_64(v6, 0x8f2c0088bea2739e, 0x4ed8c54dad60d3cb, 0x51e715e5cf56b2e6,
+  VLOAD_64(v24, 0x8f2c0088bea2739e, 0x4ed8c54dad60d3cb, 0x51e715e5cf56b2e6,
            0xa1b1262536ea3c57, 0x67f334468e5cde4f, 0x8ae5618164bd63fd,
            0x2f8be93c1d7807c3, 0x0444a9f4ccff2a2c, 0x6cac5e35bf847d59,
            0x1d92c5117b87a392, 0x124597d21d757a4e, 0x4ec5a9fb5b8a6591,
            0xb5b4189dd6080734, 0xf75ddacea0effff6, 0x5c3cb19fbc1c7580,
            0xff93a562f06d3641);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhu.vv v2, v4, v6, v0.t");
-  VCMP_U64(8, v2, 0, 0x015742ce71e2c757, 0, 0x2165dabfb788d03d, 0,
+  VCLEAR(v8);
+  asm volatile("vmulhu.vv v8, v16, v24, v0.t");
+  VCMP_U64(8, v8, 0, 0x015742ce71e2c757, 0, 0x2165dabfb788d03d, 0,
            0x0eb728a66479b5fb, 0, 0x0357b1cf05241ad9, 0, 0x0e8895d7f39e953c, 0,
            0x3335fb506009220b, 0, 0x589d920140d7dd8c, 0, 0x8a3b86d4dd8169cf);
 #endif
 };
 
 void TEST_CASE3(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x5c, 0x3c, 0x86, 0x65, 0x41, 0x38, 0x20, 0x9e, 0x88, 0x28, 0x19,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x5c, 0x3c, 0x86, 0x65, 0x41, 0x38, 0x20, 0x9e, 0x88, 0x28, 0x19,
           0xc2, 0x5f, 0xa3, 0x7c, 0xca);
   uint64_t scalar = 5;
-  asm volatile("vmulhu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(9, v2, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x00, 0x03, 0x02, 0x00,
+  asm volatile("vmulhu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(9, v8, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x00, 0x03, 0x02, 0x00,
           0x00, 0x03, 0x01, 0x03, 0x02, 0x03);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x4e7f, 0xfe41, 0x1346, 0x6c1a, 0x38ce, 0x5fa7, 0x5e39, 0xf7a2,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x4e7f, 0xfe41, 0x1346, 0x6c1a, 0x38ce, 0x5fa7, 0x5e39, 0xf7a2,
            0x61aa, 0x0a3a, 0xfe0a, 0x30f1, 0x5852, 0xbb6b, 0x42f7, 0x58d9);
   scalar = 816;
-  asm volatile("vmulhu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(10, v2, 0x00fa, 0x032a, 0x003d, 0x0158, 0x00b5, 0x0130, 0x012c,
+  asm volatile("vmulhu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(10, v8, 0x00fa, 0x032a, 0x003d, 0x0158, 0x00b5, 0x0130, 0x012c,
            0x0315, 0x0137, 0x0020, 0x0329, 0x009c, 0x0119, 0x0255, 0x00d5,
            0x011b);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x15c6221c, 0x0d704417, 0x3d90ffd1, 0x4e168273, 0xc3bd5e20,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x15c6221c, 0x0d704417, 0x3d90ffd1, 0x4e168273, 0xc3bd5e20,
            0xd75f62df, 0x3002ed42, 0x74269b1d, 0xc77bc0dd, 0x36f2552d,
            0x71b5888c, 0x02eb291b, 0x790cb3b1, 0xa3cf03c4, 0x8f90730a,
            0xf41b555a);
   scalar = 7389998;
-  asm volatile("vmulhu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(11, v2, 0x00099748, 0x0005eb5c, 0x001b1e60, 0x00226562, 0x00563815,
+  asm volatile("vmulhu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(11, v8, 0x00099748, 0x0005eb5c, 0x001b1e60, 0x00226562, 0x00563815,
            0x005eddef, 0x001525e2, 0x00332972, 0x0057de3b, 0x001833e9,
            0x0032161d, 0x0001491b, 0x003551d9, 0x00482775, 0x003f3ca7,
            0x006b8612);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
-  /*   VLOAD_64(v4, 0x96304201a90be11f, 0x11654d4226322e4b, 0xe16e5cf2c1183b63,
+  /*   VSET(16, e64, m8); */
+  /*   VLOAD_64(v16, 0x96304201a90be11f, 0x11654d4226322e4b, 0xe16e5cf2c1183b63,
    */
   /*            0x447b5f4710764817, 0xb62589a3d309672c, 0x5ddec2e6716fd0d3, */
   /*            0xf31034a096a6d0fa, 0x9cb4dca46ce577f7, 0x30cf2e2dc6773d82, */
@@ -167,8 +167,8 @@ void TEST_CASE3(void) {
   /*            0x0c0c54042a20ddc8, 0xf309bda968a3a583, 0x550697570a1e9645, */
   /*            0x5beaf5933973231f); */
   /*   scalar = 321156886679781445; */
-  /*   asm volatile("vmulhu.vx v2, v4, %[A]" ::[A] "r"(scalar)); */
-  /*   VCMP_U64(12, v2, 0x029d61da2f470da8, 0x004d882170361dd2,
+  /*   asm volatile("vmulhu.vx v8, v16, %[A]" ::[A] "r"(scalar)); */
+  /*   VCMP_U64(12, v8, 0x029d61da2f470da8, 0x004d882170361dd2,
    * 0x03ecbc09716942cd, */
   /*            0x013138661b0ea1a1, 0x032bd162449d3f20, 0x01a25fd52874e6a2, */
   /*            0x043b51fe85cf352c, 0x02ba6ebb77802a7c, 0x00d98a5bba81dc57, */
@@ -179,41 +179,41 @@ void TEST_CASE3(void) {
 };
 
 void TEST_CASE4(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x5c, 0x3c, 0x86, 0x65, 0x41, 0x38, 0x20, 0x9e, 0x88, 0x28, 0x19,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x5c, 0x3c, 0x86, 0x65, 0x41, 0x38, 0x20, 0x9e, 0x88, 0x28, 0x19,
           0xc2, 0x5f, 0xa3, 0x7c, 0xca);
   uint64_t scalar = 5;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U8(13, v2, 0, 0x01, 0, 0x01, 0, 0x01, 0, 0x03, 0, 0x00, 0, 0x03, 0, 0x03,
+  VCLEAR(v8);
+  asm volatile("vmulhu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U8(13, v8, 0, 0x01, 0, 0x01, 0, 0x01, 0, 0x03, 0, 0x00, 0, 0x03, 0, 0x03,
           0, 0x03);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x4e7f, 0xfe41, 0x1346, 0x6c1a, 0x38ce, 0x5fa7, 0x5e39, 0xf7a2,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x4e7f, 0xfe41, 0x1346, 0x6c1a, 0x38ce, 0x5fa7, 0x5e39, 0xf7a2,
            0x61aa, 0x0a3a, 0xfe0a, 0x30f1, 0x5852, 0xbb6b, 0x42f7, 0x58d9);
   scalar = 816;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U16(14, v2, 0, 0x032a, 0, 0x0158, 0, 0x0130, 0, 0x0315, 0, 0x0020, 0,
+  VCLEAR(v8);
+  asm volatile("vmulhu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U16(14, v8, 0, 0x032a, 0, 0x0158, 0, 0x0130, 0, 0x0315, 0, 0x0020, 0,
            0x009c, 0, 0x0255, 0, 0x011b);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x15c6221c, 0x0d704417, 0x3d90ffd1, 0x4e168273, 0xc3bd5e20,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x15c6221c, 0x0d704417, 0x3d90ffd1, 0x4e168273, 0xc3bd5e20,
            0xd75f62df, 0x3002ed42, 0x74269b1d, 0xc77bc0dd, 0x36f2552d,
            0x71b5888c, 0x02eb291b, 0x790cb3b1, 0xa3cf03c4, 0x8f90730a,
            0xf41b555a);
   scalar = 7389998;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vmulhu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U32(15, v2, 0, 0x0005eb5c, 0, 0x00226562, 0, 0x005eddef, 0, 0x00332972,
+  VCLEAR(v8);
+  asm volatile("vmulhu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U32(15, v8, 0, 0x0005eb5c, 0, 0x00226562, 0, 0x005eddef, 0, 0x00332972,
            0, 0x001833e9, 0, 0x0001491b, 0, 0x00482775, 0, 0x006b8612);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
-  /*   VLOAD_64(v4, 0x96304201a90be11f, 0x11654d4226322e4b, 0xe16e5cf2c1183b63,
+  /*   VSET(16, e64, m8); */
+  /*   VLOAD_64(v16, 0x96304201a90be11f, 0x11654d4226322e4b, 0xe16e5cf2c1183b63,
    */
   /*            0x447b5f4710764817, 0xb62589a3d309672c, 0x5ddec2e6716fd0d3, */
   /*            0xf31034a096a6d0fa, 0x9cb4dca46ce577f7, 0x30cf2e2dc6773d82, */
@@ -222,9 +222,9 @@ void TEST_CASE4(void) {
   /*            0x5beaf5933973231f); */
   /*   scalar = 321156886679781445; */
   /*   VLOAD_8(v0, 0xAA, 0xAA); */
-  /*   VCLEAR(v2); */
-  /*   asm volatile("vmulhu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar)); */
-  /*   VCMP_U64(16, v2, 0, 0x004d882170361dd2, 0, 0x013138661b0ea1a1, 0, */
+  /*   VCLEAR(v8); */
+  /*   asm volatile("vmulhu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar)); */
+  /*   VCMP_U64(16, v8, 0, 0x004d882170361dd2, 0, 0x013138661b0ea1a1, 0, */
   /*            0x01a25fd52874e6a2, 0, 0x02ba6ebb77802a7c, 0,
    * 0x01b10a47f99f8c44, 0, */
   /*            0x010e20461059ad6b, 0, 0x043b352e6dc32a00, 0,
diff --git a/sw/riscvTests/isa/rv64uv/vmv.c b/sw/riscvTests/isa/rv64uv/vmv.c
index 63fe2337..094767c0 100644
--- a/sw/riscvTests/isa/rv64uv/vmv.c
+++ b/sw/riscvTests/isa/rv64uv/vmv.c
@@ -8,60 +8,60 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vmv.v.v v6, v2");
-  VCMP_U8(1, v6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vmv.v.v v16, v8");
+  VCMP_U8(1, v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v4, 8, 7, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1);
-  asm volatile("vmv.v.v v6, v2");
-  VCMP_U16(2, v6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vmv.v.v v16, v8");
+  VCMP_U16(2, v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v4, 8, 7, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1);
-  asm volatile("vmv.v.v v6, v2");
-  VCMP_U32(3, v6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vmv.v.v v16, v8");
+  VCMP_U32(3, v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v4, 8, 7, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1);
-  asm volatile("vmv.v.v v6, v2");
-  VCMP_U64(4, v6, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vmv.v.v v16, v8");
+  VCMP_U64(4, v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 #endif
 }
 
 void TEST_CASE2() {
   const uint32_t scalar = 0xdeadbeef;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vmv.v.x v6, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(5, v6, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vmv.v.x v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(5, v16, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef, 0xef, 0xef, 0xef, 0xef, 0xef);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vmv.v.x v6, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(6, v6, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vmv.v.x v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(6, v16, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vmv.v.x v6, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(7, v6, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vmv.v.x v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(7, v16, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vmv.v.x v6, %[A]" ::[A] "r"(scalar));
-  VCMP_U64(8, v6, 0xffffffffdeadbeef, 0xffffffffdeadbeef, 0xffffffffdeadbeef,
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vmv.v.x v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U64(8, v16, 0xffffffffdeadbeef, 0xffffffffdeadbeef, 0xffffffffdeadbeef,
            0xffffffffdeadbeef, 0xffffffffdeadbeef, 0xffffffffdeadbeef,
            0xffffffffdeadbeef, 0xffffffffdeadbeef, 0xffffffffdeadbeef,
            0xffffffffdeadbeef, 0xffffffffdeadbeef, 0xffffffffdeadbeef,
@@ -71,29 +71,29 @@ void TEST_CASE2() {
 }
 
 void TEST_CASE3() {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vmv.v.i v6, -9");
-  VCMP_U8(9, v6, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9,
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vmv.v.i v16, -9");
+  VCMP_U8(9, v16, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9,
           -9);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vmv.v.i v6, -10");
-  VCMP_U16(10, v6, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10,
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vmv.v.i v16, -10");
+  VCMP_U16(10, v16, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10,
            -10, -10, -10, -10);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vmv.v.i v6, -11");
-  VCMP_U32(11, v6, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11,
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vmv.v.i v16, -11");
+  VCMP_U32(11, v16, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11,
            -11, -11, -11, -11);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vmv.v.i v6, -12");
-  VCMP_U64(12, v6, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12,
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vmv.v.i v16, -12");
+  VCMP_U64(12, v16, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12,
            -12, -12, -12, -12);
 #endif
 }
diff --git a/sw/riscvTests/isa/rv64uv/vnmsac.c b/sw/riscvTests/isa/rv64uv/vnmsac.c
index d6e30e59..be9a4c41 100644
--- a/sw/riscvTests/isa/rv64uv/vnmsac.c
+++ b/sw/riscvTests/isa/rv64uv/vnmsac.c
@@ -8,70 +8,70 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(16, e8, m2);
-  VLOAD_8(v6, 0x41, 0x5b, 0xd0, 0x04, 0xc4, 0x7a, 0x91, 0xd1, 0x7b, 0x09, 0x85,
+  VSET(16, e8, m8);
+  VLOAD_8(v24, 0x41, 0x5b, 0xd0, 0x04, 0xc4, 0x7a, 0x91, 0xd1, 0x7b, 0x09, 0x85,
           0x59, 0x2b, 0xe3, 0x33, 0xb9);
-  VLOAD_8(v4, 0xc5, 0x4d, 0xad, 0x35, 0x81, 0x18, 0x48, 0x50, 0xe7, 0x95, 0x7b,
+  VLOAD_8(v16, 0xc5, 0x4d, 0xad, 0x35, 0x81, 0x18, 0x48, 0x50, 0xe7, 0x95, 0x7b,
           0x18, 0xe6, 0x44, 0x57, 0xaf);
-  VLOAD_8(v2, 0x53, 0x13, 0x2c, 0xd8, 0x4a, 0xc3, 0xa3, 0xd7, 0x7e, 0x1f, 0x4c,
+  VLOAD_8(v8, 0x53, 0x13, 0x2c, 0xd8, 0x4a, 0xc3, 0xa3, 0xd7, 0x7e, 0x1f, 0x4c,
           0x4e, 0x2e, 0x7d, 0x13, 0x5a);
-  asm volatile("vnmsac.vv v2, v4, v6");
-  VCMP_U8(1, v2, 0x4e, 0xb4, 0x9c, 0x04, 0x86, 0x53, 0xdb, 0x87, 0x81, 0xe2,
+  asm volatile("vnmsac.vv v8, v16, v24");
+  VCMP_U8(1, v8, 0x4e, 0xb4, 0x9c, 0x04, 0x86, 0x53, 0xdb, 0x87, 0x81, 0xe2,
           0x65, 0xf6, 0x8c, 0x31, 0xbe, 0xe3);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x9904, 0x5982, 0xa6cb, 0x73a1, 0x227e, 0xc8f6, 0x3eeb, 0xb010,
+  VSET(16, e16, m8);
+  VLOAD_16(v24, 0x9904, 0x5982, 0xa6cb, 0x73a1, 0x227e, 0xc8f6, 0x3eeb, 0xb010,
            0x14a1, 0xef2d, 0x3376, 0x371a, 0x4fc8, 0xbcca, 0xccd7, 0x9097);
-  VLOAD_16(v4, 0xb2dd, 0x9ca4, 0x72fe, 0xecab, 0x9909, 0xe1b0, 0x1769, 0x6759,
+  VLOAD_16(v16, 0xb2dd, 0x9ca4, 0x72fe, 0xecab, 0x9909, 0xe1b0, 0x1769, 0x6759,
            0x9500, 0x3aae, 0x0637, 0xeadc, 0x7523, 0xa53c, 0xecc7, 0xaccc);
-  VLOAD_16(v2, 0xb917, 0x6a27, 0x0f0c, 0x04a2, 0xe0b6, 0x9fb1, 0x5c69, 0x21e2,
+  VLOAD_16(v8, 0xb917, 0x6a27, 0x0f0c, 0x04a2, 0xe0b6, 0x9fb1, 0x5c69, 0x21e2,
            0x3588, 0x8d19, 0x65d9, 0x6458, 0xfbff, 0xf949, 0x34a4, 0x0710);
-  asm volatile("vnmsac.vv v2, v4, v6");
-  VCMP_U16(2, v2, 0xd8a3, 0xdadf, 0x2ba2, 0x5c17, 0x5c48, 0x4091, 0x7106,
+  asm volatile("vnmsac.vv v8, v16, v24");
+  VCMP_U16(2, v8, 0xd8a3, 0xdadf, 0x2ba2, 0x5c17, 0x5c48, 0x4091, 0x7106,
            0x7c52, 0x8088, 0xca83, 0x937f, 0x4600, 0xaba7, 0x87f1, 0xc583,
            0x5abc);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0xe6f4ff60, 0xbf6a38db, 0x30f2ea92, 0x1763619e, 0x815c1c28,
+  VSET(16, e32, m8);
+  VLOAD_32(v24, 0xe6f4ff60, 0xbf6a38db, 0x30f2ea92, 0x1763619e, 0x815c1c28,
            0x5f1b57db, 0xdb2cdc06, 0xab577f4a, 0x214746ac, 0xd3a08c15,
            0x35887ce9, 0x9d5a0f65, 0x76adea2b, 0x91b7f299, 0x6e2977fe,
            0xdcbcb1d7);
-  VLOAD_32(v4, 0x885c8baa, 0xbe200324, 0x9eaa49d7, 0x4e208dde, 0x802bbe9f,
+  VLOAD_32(v16, 0x885c8baa, 0xbe200324, 0x9eaa49d7, 0x4e208dde, 0x802bbe9f,
            0x7633680e, 0xf1a79717, 0xe62e371e, 0x0fc25b48, 0x11067f38,
            0xc654ccb4, 0x6702a66c, 0x7a0b229d, 0x25c2b688, 0x82b68b3d,
            0x4224aa5e);
-  VLOAD_32(v2, 0x3a582428, 0x61c55f94, 0xb445799b, 0xcca5a657, 0x51a7fe9e,
+  VLOAD_32(v8, 0x3a582428, 0x61c55f94, 0xb445799b, 0xcca5a657, 0x51a7fe9e,
            0x0840b4f8, 0xfb0a701b, 0x1b5361d7, 0xd10c9064, 0xa899d63d,
            0xbb1779fd, 0x1b35390c, 0xd04c0f6c, 0xd8c9db62, 0x90a09dc8,
            0x463438b4);
-  asm volatile("vnmsac.vv v2, v4, v6");
-  VCMP_U32(3, v2, 0x0e7d6e68, 0x92cacfc8, 0x726ad6fd, 0x6ff2f953, 0xe1d4d1c6,
+  asm volatile("vnmsac.vv v8, v16, v24");
+  VCMP_U32(3, v8, 0x0e7d6e68, 0x92cacfc8, 0x726ad6fd, 0x6ff2f953, 0xe1d4d1c6,
            0x466feefe, 0xa6512191, 0xdf6d912b, 0x7c898c04, 0x0a7ec6a5,
            0x2121fa29, 0x91713c70, 0x60b0bd0d, 0xb3a6341a, 0x82041c42,
            0x7a9625c2);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0xb8d79a755b98580a, 0xceefb8be6deb3a3d, 0x670688aed7c97cdd,
+  VSET(16, e64, m8);
+  VLOAD_64(v24, 0xb8d79a755b98580a, 0xceefb8be6deb3a3d, 0x670688aed7c97cdd,
            0x0ced1db5e1b7da8f, 0x58993c2ae4a62e89, 0x864439a0768dce1b,
            0x7882d6539128d119, 0xfe6469348911945b, 0x6da189493780c328,
            0xf8c4931b61dc54dc, 0xd5ac914ccbf735f0, 0xba0a5bf3b2b528d1,
            0x74d814e6ebcebe81, 0xfc44af3a74cfee8c, 0xea0cb63d1bf7d5dc,
            0xbe98c841d80bd077);
-  VLOAD_64(v4, 0x5517b401c8fbd5ec, 0x021c52c329edd200, 0xff61d899305d1423,
+  VLOAD_64(v16, 0x5517b401c8fbd5ec, 0x021c52c329edd200, 0xff61d899305d1423,
            0xd886035fdcfe3186, 0x694b857cb1cc3bc3, 0x52376b9a996e1925,
            0x5785c45d41ec230d, 0x950f08c23f6da73d, 0xe5dc4e9a35834719,
            0x9a08d0e965e96a19, 0xb80c2107151bdcf6, 0xd0612e4d4bc314b7,
            0xdfb23a142b750482, 0xedc5e4b79881bdaf, 0x72c493d9df55bf13,
            0xfd4b1328b8f7773a);
-  VLOAD_64(v2, 0xc265b2d19ad92bbb, 0x81a4ef527fc2e042, 0xe490f5981f64a313,
+  VLOAD_64(v8, 0xc265b2d19ad92bbb, 0x81a4ef527fc2e042, 0xe490f5981f64a313,
            0xf12edb410132b013, 0xc475df4b52276fe9, 0x069e283bf74ca195,
            0x8dd5189f3a66f166, 0x297726422e620380, 0x7b74d167bd1b22fd,
            0x08e88e9642656a52, 0x0ab0c3f0f7ddeb66, 0x00b155918c8646c0,
            0x84d4df4b2a3768c7, 0xc31234734867ae09, 0x79320b8da693a84e,
            0x30727b2d1bccd396);
-  asm volatile("vnmsac.vv v2, v4, v6");
-  VCMP_U64(4, v2, 0x231a763b4759b083, 0x68b16397da83d642, 0x7081592414ce4cdc,
+  asm volatile("vnmsac.vv v8, v16, v24");
+  VCMP_U64(4, v8, 0x231a763b4759b083, 0x68b16397da83d642, 0x7081592414ce4cdc,
            0x084dc189ec3eea39, 0x72cb55f70cac6a8e, 0xc713321c491334ae,
            0xa21580bb2ab1e821, 0x3d84da5e7dab4cd1, 0x735a758175effc15,
            0x91e8df24708208d6, 0x5133f0cd25a5d6c6, 0x2f1a889653a2c559,
@@ -81,74 +81,74 @@ void TEST_CASE1() {
 }
 
 void TEST_CASE2() {
-  VSET(16, e8, m2);
-  VLOAD_8(v6, 0x41, 0x5b, 0xd0, 0x04, 0xc4, 0x7a, 0x91, 0xd1, 0x7b, 0x09, 0x85,
+  VSET(16, e8, m8);
+  VLOAD_8(v24, 0x41, 0x5b, 0xd0, 0x04, 0xc4, 0x7a, 0x91, 0xd1, 0x7b, 0x09, 0x85,
           0x59, 0x2b, 0xe3, 0x33, 0xb9);
-  VLOAD_8(v4, 0xc5, 0x4d, 0xad, 0x35, 0x81, 0x18, 0x48, 0x50, 0xe7, 0x95, 0x7b,
+  VLOAD_8(v16, 0xc5, 0x4d, 0xad, 0x35, 0x81, 0x18, 0x48, 0x50, 0xe7, 0x95, 0x7b,
           0x18, 0xe6, 0x44, 0x57, 0xaf);
-  VLOAD_8(v2, 0x53, 0x13, 0x2c, 0xd8, 0x4a, 0xc3, 0xa3, 0xd7, 0x7e, 0x1f, 0x4c,
+  VLOAD_8(v8, 0x53, 0x13, 0x2c, 0xd8, 0x4a, 0xc3, 0xa3, 0xd7, 0x7e, 0x1f, 0x4c,
           0x4e, 0x2e, 0x7d, 0x13, 0x5a);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsac.vv v2, v4, v6, v0.t");
-  VCMP_U8(5, v2, 0x53, 0xb4, 0x2c, 0x04, 0x4a, 0x53, 0xa3, 0x87, 0x7e, 0xe2,
+  asm volatile("vnmsac.vv v8, v16, v24, v0.t");
+  VCMP_U8(5, v8, 0x53, 0xb4, 0x2c, 0x04, 0x4a, 0x53, 0xa3, 0x87, 0x7e, 0xe2,
           0x4c, 0xf6, 0x2e, 0x31, 0x13, 0xe3);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x9904, 0x5982, 0xa6cb, 0x73a1, 0x227e, 0xc8f6, 0x3eeb, 0xb010,
+  VSET(16, e16, m8);
+  VLOAD_16(v24, 0x9904, 0x5982, 0xa6cb, 0x73a1, 0x227e, 0xc8f6, 0x3eeb, 0xb010,
            0x14a1, 0xef2d, 0x3376, 0x371a, 0x4fc8, 0xbcca, 0xccd7, 0x9097);
-  VLOAD_16(v4, 0xb2dd, 0x9ca4, 0x72fe, 0xecab, 0x9909, 0xe1b0, 0x1769, 0x6759,
+  VLOAD_16(v16, 0xb2dd, 0x9ca4, 0x72fe, 0xecab, 0x9909, 0xe1b0, 0x1769, 0x6759,
            0x9500, 0x3aae, 0x0637, 0xeadc, 0x7523, 0xa53c, 0xecc7, 0xaccc);
-  VLOAD_16(v2, 0xb917, 0x6a27, 0x0f0c, 0x04a2, 0xe0b6, 0x9fb1, 0x5c69, 0x21e2,
+  VLOAD_16(v8, 0xb917, 0x6a27, 0x0f0c, 0x04a2, 0xe0b6, 0x9fb1, 0x5c69, 0x21e2,
            0x3588, 0x8d19, 0x65d9, 0x6458, 0xfbff, 0xf949, 0x34a4, 0x0710);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsac.vv v2, v4, v6, v0.t");
-  VCMP_U16(6, v2, 0xb917, 0xdadf, 0x0f0c, 0x5c17, 0xe0b6, 0x4091, 0x5c69,
+  asm volatile("vnmsac.vv v8, v16, v24, v0.t");
+  VCMP_U16(6, v8, 0xb917, 0xdadf, 0x0f0c, 0x5c17, 0xe0b6, 0x4091, 0x5c69,
            0x7c52, 0x3588, 0xca83, 0x65d9, 0x4600, 0xfbff, 0x87f1, 0x34a4,
            0x5abc);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0xe6f4ff60, 0xbf6a38db, 0x30f2ea92, 0x1763619e, 0x815c1c28,
+  VSET(16, e32, m8);
+  VLOAD_32(v24, 0xe6f4ff60, 0xbf6a38db, 0x30f2ea92, 0x1763619e, 0x815c1c28,
            0x5f1b57db, 0xdb2cdc06, 0xab577f4a, 0x214746ac, 0xd3a08c15,
            0x35887ce9, 0x9d5a0f65, 0x76adea2b, 0x91b7f299, 0x6e2977fe,
            0xdcbcb1d7);
-  VLOAD_32(v4, 0x885c8baa, 0xbe200324, 0x9eaa49d7, 0x4e208dde, 0x802bbe9f,
+  VLOAD_32(v16, 0x885c8baa, 0xbe200324, 0x9eaa49d7, 0x4e208dde, 0x802bbe9f,
            0x7633680e, 0xf1a79717, 0xe62e371e, 0x0fc25b48, 0x11067f38,
            0xc654ccb4, 0x6702a66c, 0x7a0b229d, 0x25c2b688, 0x82b68b3d,
            0x4224aa5e);
-  VLOAD_32(v2, 0x3a582428, 0x61c55f94, 0xb445799b, 0xcca5a657, 0x51a7fe9e,
+  VLOAD_32(v8, 0x3a582428, 0x61c55f94, 0xb445799b, 0xcca5a657, 0x51a7fe9e,
            0x0840b4f8, 0xfb0a701b, 0x1b5361d7, 0xd10c9064, 0xa899d63d,
            0xbb1779fd, 0x1b35390c, 0xd04c0f6c, 0xd8c9db62, 0x90a09dc8,
            0x463438b4);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsac.vv v2, v4, v6, v0.t");
-  VCMP_U32(7, v2, 0x3a582428, 0x92cacfc8, 0xb445799b, 0x6ff2f953, 0x51a7fe9e,
+  asm volatile("vnmsac.vv v8, v16, v24, v0.t");
+  VCMP_U32(7, v8, 0x3a582428, 0x92cacfc8, 0xb445799b, 0x6ff2f953, 0x51a7fe9e,
            0x466feefe, 0xfb0a701b, 0xdf6d912b, 0xd10c9064, 0x0a7ec6a5,
            0xbb1779fd, 0x91713c70, 0xd04c0f6c, 0xb3a6341a, 0x90a09dc8,
            0x7a9625c2);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0xb8d79a755b98580a, 0xceefb8be6deb3a3d, 0x670688aed7c97cdd,
+  VSET(16, e64, m8);
+  VLOAD_64(v24, 0xb8d79a755b98580a, 0xceefb8be6deb3a3d, 0x670688aed7c97cdd,
            0x0ced1db5e1b7da8f, 0x58993c2ae4a62e89, 0x864439a0768dce1b,
            0x7882d6539128d119, 0xfe6469348911945b, 0x6da189493780c328,
            0xf8c4931b61dc54dc, 0xd5ac914ccbf735f0, 0xba0a5bf3b2b528d1,
            0x74d814e6ebcebe81, 0xfc44af3a74cfee8c, 0xea0cb63d1bf7d5dc,
            0xbe98c841d80bd077);
-  VLOAD_64(v4, 0x5517b401c8fbd5ec, 0x021c52c329edd200, 0xff61d899305d1423,
+  VLOAD_64(v16, 0x5517b401c8fbd5ec, 0x021c52c329edd200, 0xff61d899305d1423,
            0xd886035fdcfe3186, 0x694b857cb1cc3bc3, 0x52376b9a996e1925,
            0x5785c45d41ec230d, 0x950f08c23f6da73d, 0xe5dc4e9a35834719,
            0x9a08d0e965e96a19, 0xb80c2107151bdcf6, 0xd0612e4d4bc314b7,
            0xdfb23a142b750482, 0xedc5e4b79881bdaf, 0x72c493d9df55bf13,
            0xfd4b1328b8f7773a);
-  VLOAD_64(v2, 0xc265b2d19ad92bbb, 0x81a4ef527fc2e042, 0xe490f5981f64a313,
+  VLOAD_64(v8, 0xc265b2d19ad92bbb, 0x81a4ef527fc2e042, 0xe490f5981f64a313,
            0xf12edb410132b013, 0xc475df4b52276fe9, 0x069e283bf74ca195,
            0x8dd5189f3a66f166, 0x297726422e620380, 0x7b74d167bd1b22fd,
            0x08e88e9642656a52, 0x0ab0c3f0f7ddeb66, 0x00b155918c8646c0,
            0x84d4df4b2a3768c7, 0xc31234734867ae09, 0x79320b8da693a84e,
            0x30727b2d1bccd396);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsac.vv v2, v4, v6, v0.t");
-  VCMP_U64(8, v2, 0xc265b2d19ad92bbb, 0x68b16397da83d642, 0xe490f5981f64a313,
+  asm volatile("vnmsac.vv v8, v16, v24, v0.t");
+  VCMP_U64(8, v8, 0xc265b2d19ad92bbb, 0x68b16397da83d642, 0xe490f5981f64a313,
            0x084dc189ec3eea39, 0xc475df4b52276fe9, 0xc713321c491334ae,
            0x8dd5189f3a66f166, 0x3d84da5e7dab4cd1, 0x7b74d167bd1b22fd,
            0x91e8df24708208d6, 0x0ab0c3f0f7ddeb66, 0x2f1a889653a2c559,
@@ -158,62 +158,62 @@ void TEST_CASE2() {
 }
 
 void TEST_CASE3() {
-  VSET(16, e8, m2);
+  VSET(16, e8, m8);
   int64_t scalar = 5;
-  VLOAD_8(v6, 0x5e, 0xf5, 0xa9, 0x0b, 0x14, 0x3c, 0x84, 0x22, 0xd7, 0xb6, 0x5c,
+  VLOAD_8(v24, 0x5e, 0xf5, 0xa9, 0x0b, 0x14, 0x3c, 0x84, 0x22, 0xd7, 0xb6, 0x5c,
           0x90, 0xa2, 0x67, 0x3d, 0xf5);
-  VLOAD_8(v2, 0xfa, 0xd9, 0x2a, 0xe2, 0xe7, 0x1f, 0x8c, 0xbd, 0x40, 0x5d, 0x50,
+  VLOAD_8(v8, 0xfa, 0xd9, 0x2a, 0xe2, 0xe7, 0x1f, 0x8c, 0xbd, 0x40, 0x5d, 0x50,
           0x1f, 0xe0, 0xdd, 0x1f, 0xd7);
-  asm volatile("vnmsac.vx v2, %[A], v6" ::[A] "r"(scalar));
-  VCMP_U8(9, v2, 0x24, 0x10, 0xdd, 0xab, 0x83, 0xf3, 0xf8, 0x13, 0x0d, 0xcf,
+  asm volatile("vnmsac.vx v8, %[A], v24" ::[A] "r"(scalar));
+  VCMP_U8(9, v8, 0x24, 0x10, 0xdd, 0xab, 0x83, 0xf3, 0xf8, 0x13, 0x0d, 0xcf,
           0x84, 0x4f, 0xb6, 0xda, 0xee, 0x0e);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   scalar = -5383;
-  VLOAD_16(v6, 0xfe80, 0x3910, 0x5313, 0xefef, 0xecfc, 0x7983, 0xcc0d, 0x731f,
+  VLOAD_16(v24, 0xfe80, 0x3910, 0x5313, 0xefef, 0xecfc, 0x7983, 0xcc0d, 0x731f,
            0xf384, 0xfde3, 0x9cd1, 0xf20b, 0xa41b, 0x949a, 0x5886, 0xa1a9);
-  VLOAD_16(v2, 0xe886, 0xf1f9, 0x1857, 0xd0bb, 0x522e, 0x2de0, 0xa6c2, 0xd624,
+  VLOAD_16(v8, 0xe886, 0xf1f9, 0x1857, 0xd0bb, 0x522e, 0x2de0, 0xa6c2, 0xd624,
            0xd024, 0x40a2, 0xdd99, 0xd517, 0xf00a, 0xae8d, 0x79a5, 0x519d);
-  asm volatile("vnmsac.vx v2, %[A], v6" ::[A] "r"(scalar));
-  VCMP_U16(10, v2, 0x5e06, 0xd169, 0xecdc, 0xfb44, 0x7912, 0x3f75, 0x4c1d,
+  asm volatile("vnmsac.vx v8, %[A], v24" ::[A] "r"(scalar));
+  VCMP_U16(10, v8, 0x5e06, 0xd169, 0xecdc, 0xfb44, 0x7912, 0x3f75, 0x4c1d,
            0x86fd, 0x4cc0, 0xd0d7, 0x4c50, 0x5a64, 0xa3c7, 0x60c3, 0xe34f,
            0x9a3c);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   scalar = 6474219;
-  VLOAD_32(v6, 0x48da7aac, 0x54e98600, 0xf49f26e5, 0x338e8406, 0x40ca82f5,
+  VLOAD_32(v24, 0x48da7aac, 0x54e98600, 0xf49f26e5, 0x338e8406, 0x40ca82f5,
            0x75d0b8f6, 0x38c88af2, 0x96bb5c03, 0x6f61c0a9, 0x3626dd69,
            0x31aba619, 0x7d974a55, 0xbc63c280, 0x502334bf, 0x9451b955,
            0x6a8bae19);
-  VLOAD_32(v2, 0xcbd8537e, 0x36928a6c, 0x60cf8444, 0xa19ea650, 0x8f2a8694,
+  VLOAD_32(v8, 0xcbd8537e, 0x36928a6c, 0x60cf8444, 0xa19ea650, 0x8f2a8694,
            0x050956bf, 0x1ef799f5, 0x43c0f327, 0x4bfd5a25, 0x7be439e4,
            0xed89a52a, 0x2bbf028d, 0x872392b9, 0x0ad55495, 0x865c7264,
            0xfcce4b64);
-  asm volatile("vnmsac.vx v2, %[A], v6" ::[A] "r"(scalar));
-  VCMP_U32(11, v2, 0x6b20ab9a, 0x9dfe886c, 0xf983030d, 0xddd6bece, 0xf2a7f2ad,
+  asm volatile("vnmsac.vx v8, %[A], v24" ::[A] "r"(scalar));
+  VCMP_U32(11, v8, 0x6b20ab9a, 0x9dfe886c, 0xf983030d, 0xddd6bece, 0xf2a7f2ad,
            0x2f0a66ed, 0x59240bcf, 0x915f2166, 0x8c4ace02, 0x802d8981,
            0xf9fc8b37, 0xa3f70986, 0xced98739, 0xa4fbf240, 0x4249945d,
            0xdd51d971);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
+  /*   VSET(16, e64, m8); */
   /*   scalar = -598189234597999223; */
-  /*   VLOAD_64(v6, 0x93adc14539897782, 0xa8d5d41c19b1455a, 0x55e01165195d2d9b,
+  /*   VLOAD_64(v24, 0x93adc14539897782, 0xa8d5d41c19b1455a, 0x55e01165195d2d9b,
    */
   /*            0xe81a26a17fef30f2, 0x33a71ede19aec0aa, 0x49598be14c5bc1cd, */
   /*            0x1c27bde3f488bfc6, 0x4188f9b8611e5d90, 0xd53289cca28a3b6b, */
   /*            0x3b435e1078e3bee9, 0x5e3f4c08c869abf4, 0x3c004920e9c39fb6, */
   /*            0x4b42a451b264b153, 0x110a6db11a7c2801, 0x7c0f358ac41d49fa, */
   /*            0x6e8c6ae4d14bd1a5); */
-  /*   VLOAD_64(v2, 0x3b0c6a3a651beecc, 0xb612caa033bc9bca, 0xda94340ac428ca78,
+  /*   VLOAD_64(v8, 0x3b0c6a3a651beecc, 0xb612caa033bc9bca, 0xda94340ac428ca78,
    */
   /*            0xf774b16ef94a22ea, 0x87df3c47c8113e43, 0x38487d57a064f677, */
   /*            0x358706b57ce6d6c7, 0xda111b3ac946811c, 0xe9ffed5b39f1ea1d, */
   /*            0x3c7e5a675c779870, 0x5d2ea63ac910e42e, 0xb3e832dbe2332203, */
   /*            0x05d366b426005f47, 0x00b3b58815a860d8, 0x023bbf8109263e1d, */
   /*            0x5fbc2f647d6c1153); */
-  /*   asm volatile("vnmsac.vx v2, %[A], v6" ::[A] "r"(scalar)); */
-  /*   VCMP_U64(12, v2, 0x60dd7609c833e03a, 0x79abe3a30a816ca0,
+  /*   asm volatile("vnmsac.vx v8, %[A], v24" ::[A] "r"(scalar)); */
+  /*   VCMP_U64(12, v8, 0x60dd7609c833e03a, 0x79abe3a30a816ca0,
    * 0x983ca4c97f204385, */
   /*            0x59a9303f04932768, 0x59c29659b4d00149, 0x59a15b1bb66f16c2, */
   /*            0x37b0445a8ebaa7d1, 0x65e0c3ab56fa1f0c, 0x94a740971b1d6eda, */
@@ -224,57 +224,57 @@ void TEST_CASE3() {
 }
 
 void TEST_CASE4() {
-  VSET(16, e8, m2);
+  VSET(16, e8, m8);
   int64_t scalar = 5;
-  VLOAD_8(v6, 0x5e, 0xf5, 0xa9, 0x0b, 0x14, 0x3c, 0x84, 0x22, 0xd7, 0xb6, 0x5c,
+  VLOAD_8(v24, 0x5e, 0xf5, 0xa9, 0x0b, 0x14, 0x3c, 0x84, 0x22, 0xd7, 0xb6, 0x5c,
           0x90, 0xa2, 0x67, 0x3d, 0xf5);
-  VLOAD_8(v2, 0xfa, 0xd9, 0x2a, 0xe2, 0xe7, 0x1f, 0x8c, 0xbd, 0x40, 0x5d, 0x50,
+  VLOAD_8(v8, 0xfa, 0xd9, 0x2a, 0xe2, 0xe7, 0x1f, 0x8c, 0xbd, 0x40, 0x5d, 0x50,
           0x1f, 0xe0, 0xdd, 0x1f, 0xd7);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsac.vx v2, %[A], v6, v0.t" ::[A] "r"(scalar));
-  VCMP_U8(13, v2, 0xfa, 0x10, 0x2a, 0xab, 0xe7, 0xf3, 0x8c, 0x13, 0x40, 0xcf,
+  asm volatile("vnmsac.vx v8, %[A], v24, v0.t" ::[A] "r"(scalar));
+  VCMP_U8(13, v8, 0xfa, 0x10, 0x2a, 0xab, 0xe7, 0xf3, 0x8c, 0x13, 0x40, 0xcf,
           0x50, 0x4f, 0xe0, 0xda, 0x1f, 0x0e);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   scalar = -5383;
-  VLOAD_16(v6, 0xfe80, 0x3910, 0x5313, 0xefef, 0xecfc, 0x7983, 0xcc0d, 0x731f,
+  VLOAD_16(v24, 0xfe80, 0x3910, 0x5313, 0xefef, 0xecfc, 0x7983, 0xcc0d, 0x731f,
            0xf384, 0xfde3, 0x9cd1, 0xf20b, 0xa41b, 0x949a, 0x5886, 0xa1a9);
-  VLOAD_16(v2, 0xe886, 0xf1f9, 0x1857, 0xd0bb, 0x522e, 0x2de0, 0xa6c2, 0xd624,
+  VLOAD_16(v8, 0xe886, 0xf1f9, 0x1857, 0xd0bb, 0x522e, 0x2de0, 0xa6c2, 0xd624,
            0xd024, 0x40a2, 0xdd99, 0xd517, 0xf00a, 0xae8d, 0x79a5, 0x519d);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsac.vx v2, %[A], v6, v0.t" ::[A] "r"(scalar));
-  VCMP_U16(14, v2, 0xe886, 0xd169, 0x1857, 0xfb44, 0x522e, 0x3f75, 0xa6c2,
+  asm volatile("vnmsac.vx v8, %[A], v24, v0.t" ::[A] "r"(scalar));
+  VCMP_U16(14, v8, 0xe886, 0xd169, 0x1857, 0xfb44, 0x522e, 0x3f75, 0xa6c2,
            0x86fd, 0xd024, 0xd0d7, 0xdd99, 0x5a64, 0xf00a, 0x60c3, 0x79a5,
            0x9a3c);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   scalar = 6474219;
-  VLOAD_32(v6, 0x48da7aac, 0x54e98600, 0xf49f26e5, 0x338e8406, 0x40ca82f5,
+  VLOAD_32(v24, 0x48da7aac, 0x54e98600, 0xf49f26e5, 0x338e8406, 0x40ca82f5,
            0x75d0b8f6, 0x38c88af2, 0x96bb5c03, 0x6f61c0a9, 0x3626dd69,
            0x31aba619, 0x7d974a55, 0xbc63c280, 0x502334bf, 0x9451b955,
            0x6a8bae19);
-  VLOAD_32(v2, 0xcbd8537e, 0x36928a6c, 0x60cf8444, 0xa19ea650, 0x8f2a8694,
+  VLOAD_32(v8, 0xcbd8537e, 0x36928a6c, 0x60cf8444, 0xa19ea650, 0x8f2a8694,
            0x050956bf, 0x1ef799f5, 0x43c0f327, 0x4bfd5a25, 0x7be439e4,
            0xed89a52a, 0x2bbf028d, 0x872392b9, 0x0ad55495, 0x865c7264,
            0xfcce4b64);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsac.vx v2, %[A], v6, v0.t" ::[A] "r"(scalar));
-  VCMP_U32(15, v2, 0xcbd8537e, 0x9dfe886c, 0x60cf8444, 0xddd6bece, 0x8f2a8694,
+  asm volatile("vnmsac.vx v8, %[A], v24, v0.t" ::[A] "r"(scalar));
+  VCMP_U32(15, v8, 0xcbd8537e, 0x9dfe886c, 0x60cf8444, 0xddd6bece, 0x8f2a8694,
            0x2f0a66ed, 0x1ef799f5, 0x915f2166, 0x4bfd5a25, 0x802d8981,
            0xed89a52a, 0xa3f70986, 0x872392b9, 0xa4fbf240, 0x865c7264,
            0xdd51d971);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
+  /*   VSET(16, e64, m8); */
   /*   scalar = -598189234597999223; */
-  /*   VLOAD_64(v6, 0x93adc14539897782, 0xa8d5d41c19b1455a, 0x55e01165195d2d9b,
+  /*   VLOAD_64(v24, 0x93adc14539897782, 0xa8d5d41c19b1455a, 0x55e01165195d2d9b,
    */
   /*            0xe81a26a17fef30f2, 0x33a71ede19aec0aa, 0x49598be14c5bc1cd, */
   /*            0x1c27bde3f488bfc6, 0x4188f9b8611e5d90, 0xd53289cca28a3b6b, */
   /*            0x3b435e1078e3bee9, 0x5e3f4c08c869abf4, 0x3c004920e9c39fb6, */
   /*            0x4b42a451b264b153, 0x110a6db11a7c2801, 0x7c0f358ac41d49fa, */
   /*            0x6e8c6ae4d14bd1a5); */
-  /*   VLOAD_64(v2, 0x3b0c6a3a651beecc, 0xb612caa033bc9bca, 0xda94340ac428ca78,
+  /*   VLOAD_64(v8, 0x3b0c6a3a651beecc, 0xb612caa033bc9bca, 0xda94340ac428ca78,
    */
   /*            0xf774b16ef94a22ea, 0x87df3c47c8113e43, 0x38487d57a064f677, */
   /*            0x358706b57ce6d6c7, 0xda111b3ac946811c, 0xe9ffed5b39f1ea1d, */
@@ -282,8 +282,8 @@ void TEST_CASE4() {
   /*            0x05d366b426005f47, 0x00b3b58815a860d8, 0x023bbf8109263e1d, */
   /*            0x5fbc2f647d6c1153); */
   /*   VLOAD_8(v0, 0xAA, 0xAA); */
-  /*   asm volatile("vnmsac.vx v2, %[A], v6, v0.t" ::[A] "r"(scalar)); */
-  /*   VCMP_U64(16, v2, 0x3b0c6a3a651beecc, 0x79abe3a30a816ca0,
+  /*   asm volatile("vnmsac.vx v8, %[A], v24, v0.t" ::[A] "r"(scalar)); */
+  /*   VCMP_U64(16, v8, 0x3b0c6a3a651beecc, 0x79abe3a30a816ca0,
    * 0xda94340ac428ca78, */
   /*            0x59a9303f04932768, 0x87df3c47c8113e43, 0x59a15b1bb66f16c2, */
   /*            0x358706b57ce6d6c7, 0x65e0c3ab56fa1f0c, 0xe9ffed5b39f1ea1d, */
diff --git a/sw/riscvTests/isa/rv64uv/vnmsub.c b/sw/riscvTests/isa/rv64uv/vnmsub.c
index c0dd0a1f..cd1cbc72 100644
--- a/sw/riscvTests/isa/rv64uv/vnmsub.c
+++ b/sw/riscvTests/isa/rv64uv/vnmsub.c
@@ -8,70 +8,70 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 0x41, 0x5b, 0xd0, 0x04, 0xc4, 0x7a, 0x91, 0xd1, 0x7b, 0x09, 0x85,
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 0x41, 0x5b, 0xd0, 0x04, 0xc4, 0x7a, 0x91, 0xd1, 0x7b, 0x09, 0x85,
           0x59, 0x2b, 0xe3, 0x33, 0xb9);
-  VLOAD_8(v4, 0xc5, 0x4d, 0xad, 0x35, 0x81, 0x18, 0x48, 0x50, 0xe7, 0x95, 0x7b,
+  VLOAD_8(v16, 0xc5, 0x4d, 0xad, 0x35, 0x81, 0x18, 0x48, 0x50, 0xe7, 0x95, 0x7b,
           0x18, 0xe6, 0x44, 0x57, 0xaf);
-  VLOAD_8(v6, 0x53, 0x13, 0x2c, 0xd8, 0x4a, 0xc3, 0xa3, 0xd7, 0x7e, 0x1f, 0x4c,
+  VLOAD_8(v24, 0x53, 0x13, 0x2c, 0xd8, 0x4a, 0xc3, 0xa3, 0xd7, 0x7e, 0x1f, 0x4c,
           0x4e, 0x2e, 0x7d, 0x13, 0x5a);
-  asm volatile("vnmsub.vv v2, v4, v6");
-  VCMP_U8(1, v2, 0x4e, 0xb4, 0x9c, 0x04, 0x86, 0x53, 0xdb, 0x87, 0x81, 0xe2,
+  asm volatile("vnmsub.vv v8, v16, v24");
+  VCMP_U8(1, v8, 0x4e, 0xb4, 0x9c, 0x04, 0x86, 0x53, 0xdb, 0x87, 0x81, 0xe2,
           0x65, 0xf6, 0x8c, 0x31, 0xbe, 0xe3);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 0x9904, 0x5982, 0xa6cb, 0x73a1, 0x227e, 0xc8f6, 0x3eeb, 0xb010,
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 0x9904, 0x5982, 0xa6cb, 0x73a1, 0x227e, 0xc8f6, 0x3eeb, 0xb010,
            0x14a1, 0xef2d, 0x3376, 0x371a, 0x4fc8, 0xbcca, 0xccd7, 0x9097);
-  VLOAD_16(v4, 0xb2dd, 0x9ca4, 0x72fe, 0xecab, 0x9909, 0xe1b0, 0x1769, 0x6759,
+  VLOAD_16(v16, 0xb2dd, 0x9ca4, 0x72fe, 0xecab, 0x9909, 0xe1b0, 0x1769, 0x6759,
            0x9500, 0x3aae, 0x0637, 0xeadc, 0x7523, 0xa53c, 0xecc7, 0xaccc);
-  VLOAD_16(v6, 0xb917, 0x6a27, 0x0f0c, 0x04a2, 0xe0b6, 0x9fb1, 0x5c69, 0x21e2,
+  VLOAD_16(v24, 0xb917, 0x6a27, 0x0f0c, 0x04a2, 0xe0b6, 0x9fb1, 0x5c69, 0x21e2,
            0x3588, 0x8d19, 0x65d9, 0x6458, 0xfbff, 0xf949, 0x34a4, 0x0710);
-  asm volatile("vnmsub.vv v2, v4, v6");
-  VCMP_U16(2, v2, 0xd8a3, 0xdadf, 0x2ba2, 0x5c17, 0x5c48, 0x4091, 0x7106,
+  asm volatile("vnmsub.vv v8, v16, v24");
+  VCMP_U16(2, v8, 0xd8a3, 0xdadf, 0x2ba2, 0x5c17, 0x5c48, 0x4091, 0x7106,
            0x7c52, 0x8088, 0xca83, 0x937f, 0x4600, 0xaba7, 0x87f1, 0xc583,
            0x5abc);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 0xe6f4ff60, 0xbf6a38db, 0x30f2ea92, 0x1763619e, 0x815c1c28,
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 0xe6f4ff60, 0xbf6a38db, 0x30f2ea92, 0x1763619e, 0x815c1c28,
            0x5f1b57db, 0xdb2cdc06, 0xab577f4a, 0x214746ac, 0xd3a08c15,
            0x35887ce9, 0x9d5a0f65, 0x76adea2b, 0x91b7f299, 0x6e2977fe,
            0xdcbcb1d7);
-  VLOAD_32(v4, 0x885c8baa, 0xbe200324, 0x9eaa49d7, 0x4e208dde, 0x802bbe9f,
+  VLOAD_32(v16, 0x885c8baa, 0xbe200324, 0x9eaa49d7, 0x4e208dde, 0x802bbe9f,
            0x7633680e, 0xf1a79717, 0xe62e371e, 0x0fc25b48, 0x11067f38,
            0xc654ccb4, 0x6702a66c, 0x7a0b229d, 0x25c2b688, 0x82b68b3d,
            0x4224aa5e);
-  VLOAD_32(v6, 0x3a582428, 0x61c55f94, 0xb445799b, 0xcca5a657, 0x51a7fe9e,
+  VLOAD_32(v24, 0x3a582428, 0x61c55f94, 0xb445799b, 0xcca5a657, 0x51a7fe9e,
            0x0840b4f8, 0xfb0a701b, 0x1b5361d7, 0xd10c9064, 0xa899d63d,
            0xbb1779fd, 0x1b35390c, 0xd04c0f6c, 0xd8c9db62, 0x90a09dc8,
            0x463438b4);
-  asm volatile("vnmsub.vv v2, v4, v6");
-  VCMP_U32(3, v2, 0x0e7d6e68, 0x92cacfc8, 0x726ad6fd, 0x6ff2f953, 0xe1d4d1c6,
+  asm volatile("vnmsub.vv v8, v16, v24");
+  VCMP_U32(3, v8, 0x0e7d6e68, 0x92cacfc8, 0x726ad6fd, 0x6ff2f953, 0xe1d4d1c6,
            0x466feefe, 0xa6512191, 0xdf6d912b, 0x7c898c04, 0x0a7ec6a5,
            0x2121fa29, 0x91713c70, 0x60b0bd0d, 0xb3a6341a, 0x82041c42,
            0x7a9625c2);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 0xb8d79a755b98580a, 0xceefb8be6deb3a3d, 0x670688aed7c97cdd,
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 0xb8d79a755b98580a, 0xceefb8be6deb3a3d, 0x670688aed7c97cdd,
            0x0ced1db5e1b7da8f, 0x58993c2ae4a62e89, 0x864439a0768dce1b,
            0x7882d6539128d119, 0xfe6469348911945b, 0x6da189493780c328,
            0xf8c4931b61dc54dc, 0xd5ac914ccbf735f0, 0xba0a5bf3b2b528d1,
            0x74d814e6ebcebe81, 0xfc44af3a74cfee8c, 0xea0cb63d1bf7d5dc,
            0xbe98c841d80bd077);
-  VLOAD_64(v4, 0x5517b401c8fbd5ec, 0x021c52c329edd200, 0xff61d899305d1423,
+  VLOAD_64(v16, 0x5517b401c8fbd5ec, 0x021c52c329edd200, 0xff61d899305d1423,
            0xd886035fdcfe3186, 0x694b857cb1cc3bc3, 0x52376b9a996e1925,
            0x5785c45d41ec230d, 0x950f08c23f6da73d, 0xe5dc4e9a35834719,
            0x9a08d0e965e96a19, 0xb80c2107151bdcf6, 0xd0612e4d4bc314b7,
            0xdfb23a142b750482, 0xedc5e4b79881bdaf, 0x72c493d9df55bf13,
            0xfd4b1328b8f7773a);
-  VLOAD_64(v6, 0xc265b2d19ad92bbb, 0x81a4ef527fc2e042, 0xe490f5981f64a313,
+  VLOAD_64(v24, 0xc265b2d19ad92bbb, 0x81a4ef527fc2e042, 0xe490f5981f64a313,
            0xf12edb410132b013, 0xc475df4b52276fe9, 0x069e283bf74ca195,
            0x8dd5189f3a66f166, 0x297726422e620380, 0x7b74d167bd1b22fd,
            0x08e88e9642656a52, 0x0ab0c3f0f7ddeb66, 0x00b155918c8646c0,
            0x84d4df4b2a3768c7, 0xc31234734867ae09, 0x79320b8da693a84e,
            0x30727b2d1bccd396);
-  asm volatile("vnmsub.vv v2, v4, v6");
-  VCMP_U64(4, v2, 0x231a763b4759b083, 0x68b16397da83d642, 0x7081592414ce4cdc,
+  asm volatile("vnmsub.vv v8, v16, v24");
+  VCMP_U64(4, v8, 0x231a763b4759b083, 0x68b16397da83d642, 0x7081592414ce4cdc,
            0x084dc189ec3eea39, 0x72cb55f70cac6a8e, 0xc713321c491334ae,
            0xa21580bb2ab1e821, 0x3d84da5e7dab4cd1, 0x735a758175effc15,
            0x91e8df24708208d6, 0x5133f0cd25a5d6c6, 0x2f1a889653a2c559,
@@ -81,74 +81,74 @@ void TEST_CASE1() {
 }
 
 void TEST_CASE2() {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 0x41, 0x5b, 0xd0, 0x04, 0xc4, 0x7a, 0x91, 0xd1, 0x7b, 0x09, 0x85,
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 0x41, 0x5b, 0xd0, 0x04, 0xc4, 0x7a, 0x91, 0xd1, 0x7b, 0x09, 0x85,
           0x59, 0x2b, 0xe3, 0x33, 0xb9);
-  VLOAD_8(v4, 0xc5, 0x4d, 0xad, 0x35, 0x81, 0x18, 0x48, 0x50, 0xe7, 0x95, 0x7b,
+  VLOAD_8(v16, 0xc5, 0x4d, 0xad, 0x35, 0x81, 0x18, 0x48, 0x50, 0xe7, 0x95, 0x7b,
           0x18, 0xe6, 0x44, 0x57, 0xaf);
-  VLOAD_8(v6, 0x53, 0x13, 0x2c, 0xd8, 0x4a, 0xc3, 0xa3, 0xd7, 0x7e, 0x1f, 0x4c,
+  VLOAD_8(v24, 0x53, 0x13, 0x2c, 0xd8, 0x4a, 0xc3, 0xa3, 0xd7, 0x7e, 0x1f, 0x4c,
           0x4e, 0x2e, 0x7d, 0x13, 0x5a);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsub.vv v2, v4, v6, v0.t");
-  VCMP_U8(5, v2, 0x41, 0xb4, 0xd0, 0x04, 0xc4, 0x53, 0x91, 0x87, 0x7b, 0xe2,
+  asm volatile("vnmsub.vv v8, v16, v24, v0.t");
+  VCMP_U8(5, v8, 0x41, 0xb4, 0xd0, 0x04, 0xc4, 0x53, 0x91, 0x87, 0x7b, 0xe2,
           0x85, 0xf6, 0x2b, 0x31, 0x33, 0xe3);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 0x9904, 0x5982, 0xa6cb, 0x73a1, 0x227e, 0xc8f6, 0x3eeb, 0xb010,
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 0x9904, 0x5982, 0xa6cb, 0x73a1, 0x227e, 0xc8f6, 0x3eeb, 0xb010,
            0x14a1, 0xef2d, 0x3376, 0x371a, 0x4fc8, 0xbcca, 0xccd7, 0x9097);
-  VLOAD_16(v4, 0xb2dd, 0x9ca4, 0x72fe, 0xecab, 0x9909, 0xe1b0, 0x1769, 0x6759,
+  VLOAD_16(v16, 0xb2dd, 0x9ca4, 0x72fe, 0xecab, 0x9909, 0xe1b0, 0x1769, 0x6759,
            0x9500, 0x3aae, 0x0637, 0xeadc, 0x7523, 0xa53c, 0xecc7, 0xaccc);
-  VLOAD_16(v6, 0xb917, 0x6a27, 0x0f0c, 0x04a2, 0xe0b6, 0x9fb1, 0x5c69, 0x21e2,
+  VLOAD_16(v24, 0xb917, 0x6a27, 0x0f0c, 0x04a2, 0xe0b6, 0x9fb1, 0x5c69, 0x21e2,
            0x3588, 0x8d19, 0x65d9, 0x6458, 0xfbff, 0xf949, 0x34a4, 0x0710);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsub.vv v2, v4, v6, v0.t");
-  VCMP_U16(6, v2, 0x9904, 0xdadf, 0xa6cb, 0x5c17, 0x227e, 0x4091, 0x3eeb,
+  asm volatile("vnmsub.vv v8, v16, v24, v0.t");
+  VCMP_U16(6, v8, 0x9904, 0xdadf, 0xa6cb, 0x5c17, 0x227e, 0x4091, 0x3eeb,
            0x7c52, 0x14a1, 0xca83, 0x3376, 0x4600, 0x4fc8, 0x87f1, 0xccd7,
            0x5abc);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 0xe6f4ff60, 0xbf6a38db, 0x30f2ea92, 0x1763619e, 0x815c1c28,
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 0xe6f4ff60, 0xbf6a38db, 0x30f2ea92, 0x1763619e, 0x815c1c28,
            0x5f1b57db, 0xdb2cdc06, 0xab577f4a, 0x214746ac, 0xd3a08c15,
            0x35887ce9, 0x9d5a0f65, 0x76adea2b, 0x91b7f299, 0x6e2977fe,
            0xdcbcb1d7);
-  VLOAD_32(v4, 0x885c8baa, 0xbe200324, 0x9eaa49d7, 0x4e208dde, 0x802bbe9f,
+  VLOAD_32(v16, 0x885c8baa, 0xbe200324, 0x9eaa49d7, 0x4e208dde, 0x802bbe9f,
            0x7633680e, 0xf1a79717, 0xe62e371e, 0x0fc25b48, 0x11067f38,
            0xc654ccb4, 0x6702a66c, 0x7a0b229d, 0x25c2b688, 0x82b68b3d,
            0x4224aa5e);
-  VLOAD_32(v6, 0x3a582428, 0x61c55f94, 0xb445799b, 0xcca5a657, 0x51a7fe9e,
+  VLOAD_32(v24, 0x3a582428, 0x61c55f94, 0xb445799b, 0xcca5a657, 0x51a7fe9e,
            0x0840b4f8, 0xfb0a701b, 0x1b5361d7, 0xd10c9064, 0xa899d63d,
            0xbb1779fd, 0x1b35390c, 0xd04c0f6c, 0xd8c9db62, 0x90a09dc8,
            0x463438b4);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsub.vv v2, v4, v6, v0.t");
-  VCMP_U32(7, v2, 0xe6f4ff60, 0x92cacfc8, 0x30f2ea92, 0x6ff2f953, 0x815c1c28,
+  asm volatile("vnmsub.vv v8, v16, v24, v0.t");
+  VCMP_U32(7, v8, 0xe6f4ff60, 0x92cacfc8, 0x30f2ea92, 0x6ff2f953, 0x815c1c28,
            0x466feefe, 0xdb2cdc06, 0xdf6d912b, 0x214746ac, 0x0a7ec6a5,
            0x35887ce9, 0x91713c70, 0x76adea2b, 0xb3a6341a, 0x6e2977fe,
            0x7a9625c2);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 0xb8d79a755b98580a, 0xceefb8be6deb3a3d, 0x670688aed7c97cdd,
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 0xb8d79a755b98580a, 0xceefb8be6deb3a3d, 0x670688aed7c97cdd,
            0x0ced1db5e1b7da8f, 0x58993c2ae4a62e89, 0x864439a0768dce1b,
            0x7882d6539128d119, 0xfe6469348911945b, 0x6da189493780c328,
            0xf8c4931b61dc54dc, 0xd5ac914ccbf735f0, 0xba0a5bf3b2b528d1,
            0x74d814e6ebcebe81, 0xfc44af3a74cfee8c, 0xea0cb63d1bf7d5dc,
            0xbe98c841d80bd077);
-  VLOAD_64(v4, 0x5517b401c8fbd5ec, 0x021c52c329edd200, 0xff61d899305d1423,
+  VLOAD_64(v16, 0x5517b401c8fbd5ec, 0x021c52c329edd200, 0xff61d899305d1423,
            0xd886035fdcfe3186, 0x694b857cb1cc3bc3, 0x52376b9a996e1925,
            0x5785c45d41ec230d, 0x950f08c23f6da73d, 0xe5dc4e9a35834719,
            0x9a08d0e965e96a19, 0xb80c2107151bdcf6, 0xd0612e4d4bc314b7,
            0xdfb23a142b750482, 0xedc5e4b79881bdaf, 0x72c493d9df55bf13,
            0xfd4b1328b8f7773a);
-  VLOAD_64(v6, 0xc265b2d19ad92bbb, 0x81a4ef527fc2e042, 0xe490f5981f64a313,
+  VLOAD_64(v24, 0xc265b2d19ad92bbb, 0x81a4ef527fc2e042, 0xe490f5981f64a313,
            0xf12edb410132b013, 0xc475df4b52276fe9, 0x069e283bf74ca195,
            0x8dd5189f3a66f166, 0x297726422e620380, 0x7b74d167bd1b22fd,
            0x08e88e9642656a52, 0x0ab0c3f0f7ddeb66, 0x00b155918c8646c0,
            0x84d4df4b2a3768c7, 0xc31234734867ae09, 0x79320b8da693a84e,
            0x30727b2d1bccd396);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsub.vv v2, v4, v6, v0.t");
-  VCMP_U64(8, v2, 0xb8d79a755b98580a, 0x68b16397da83d642, 0x670688aed7c97cdd,
+  asm volatile("vnmsub.vv v8, v16, v24, v0.t");
+  VCMP_U64(8, v8, 0xb8d79a755b98580a, 0x68b16397da83d642, 0x670688aed7c97cdd,
            0x084dc189ec3eea39, 0x58993c2ae4a62e89, 0xc713321c491334ae,
            0x7882d6539128d119, 0x3d84da5e7dab4cd1, 0x6da189493780c328,
            0x91e8df24708208d6, 0xd5ac914ccbf735f0, 0x2f1a889653a2c559,
@@ -158,62 +158,62 @@ void TEST_CASE2() {
 }
 
 void TEST_CASE3() {
-  VSET(16, e8, m2);
+  VSET(16, e8, m8);
   int64_t scalar = 5;
-  VLOAD_8(v2, 0x5e, 0xf5, 0xa9, 0x0b, 0x14, 0x3c, 0x84, 0x22, 0xd7, 0xb6, 0x5c,
+  VLOAD_8(v8, 0x5e, 0xf5, 0xa9, 0x0b, 0x14, 0x3c, 0x84, 0x22, 0xd7, 0xb6, 0x5c,
           0x90, 0xa2, 0x67, 0x3d, 0xf5);
-  VLOAD_8(v6, 0xfa, 0xd9, 0x2a, 0xe2, 0xe7, 0x1f, 0x8c, 0xbd, 0x40, 0x5d, 0x50,
+  VLOAD_8(v24, 0xfa, 0xd9, 0x2a, 0xe2, 0xe7, 0x1f, 0x8c, 0xbd, 0x40, 0x5d, 0x50,
           0x1f, 0xe0, 0xdd, 0x1f, 0xd7);
-  asm volatile("vnmsub.vx v2, %[A], v6" ::[A] "r"(scalar));
-  VCMP_U8(9, v2, 0x24, 0x10, 0xdd, 0xab, 0x83, 0xf3, 0xf8, 0x13, 0x0d, 0xcf,
+  asm volatile("vnmsub.vx v8, %[A], v24" ::[A] "r"(scalar));
+  VCMP_U8(9, v8, 0x24, 0x10, 0xdd, 0xab, 0x83, 0xf3, 0xf8, 0x13, 0x0d, 0xcf,
           0x84, 0x4f, 0xb6, 0xda, 0xee, 0x0e);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   scalar = -5383;
-  VLOAD_16(v2, 0xfe80, 0x3910, 0x5313, 0xefef, 0xecfc, 0x7983, 0xcc0d, 0x731f,
+  VLOAD_16(v8, 0xfe80, 0x3910, 0x5313, 0xefef, 0xecfc, 0x7983, 0xcc0d, 0x731f,
            0xf384, 0xfde3, 0x9cd1, 0xf20b, 0xa41b, 0x949a, 0x5886, 0xa1a9);
-  VLOAD_16(v6, 0xe886, 0xf1f9, 0x1857, 0xd0bb, 0x522e, 0x2de0, 0xa6c2, 0xd624,
+  VLOAD_16(v24, 0xe886, 0xf1f9, 0x1857, 0xd0bb, 0x522e, 0x2de0, 0xa6c2, 0xd624,
            0xd024, 0x40a2, 0xdd99, 0xd517, 0xf00a, 0xae8d, 0x79a5, 0x519d);
-  asm volatile("vnmsub.vx v2, %[A], v6" ::[A] "r"(scalar));
-  VCMP_U16(10, v2, 0x5e06, 0xd169, 0xecdc, 0xfb44, 0x7912, 0x3f75, 0x4c1d,
+  asm volatile("vnmsub.vx v8, %[A], v24" ::[A] "r"(scalar));
+  VCMP_U16(10, v8, 0x5e06, 0xd169, 0xecdc, 0xfb44, 0x7912, 0x3f75, 0x4c1d,
            0x86fd, 0x4cc0, 0xd0d7, 0x4c50, 0x5a64, 0xa3c7, 0x60c3, 0xe34f,
            0x9a3c);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   scalar = 6474219;
-  VLOAD_32(v2, 0x48da7aac, 0x54e98600, 0xf49f26e5, 0x338e8406, 0x40ca82f5,
+  VLOAD_32(v8, 0x48da7aac, 0x54e98600, 0xf49f26e5, 0x338e8406, 0x40ca82f5,
            0x75d0b8f6, 0x38c88af2, 0x96bb5c03, 0x6f61c0a9, 0x3626dd69,
            0x31aba619, 0x7d974a55, 0xbc63c280, 0x502334bf, 0x9451b955,
            0x6a8bae19);
-  VLOAD_32(v6, 0xcbd8537e, 0x36928a6c, 0x60cf8444, 0xa19ea650, 0x8f2a8694,
+  VLOAD_32(v24, 0xcbd8537e, 0x36928a6c, 0x60cf8444, 0xa19ea650, 0x8f2a8694,
            0x050956bf, 0x1ef799f5, 0x43c0f327, 0x4bfd5a25, 0x7be439e4,
            0xed89a52a, 0x2bbf028d, 0x872392b9, 0x0ad55495, 0x865c7264,
            0xfcce4b64);
-  asm volatile("vnmsub.vx v2, %[A], v6" ::[A] "r"(scalar));
-  VCMP_U32(11, v2, 0x6b20ab9a, 0x9dfe886c, 0xf983030d, 0xddd6bece, 0xf2a7f2ad,
+  asm volatile("vnmsub.vx v8, %[A], v24" ::[A] "r"(scalar));
+  VCMP_U32(11, v8, 0x6b20ab9a, 0x9dfe886c, 0xf983030d, 0xddd6bece, 0xf2a7f2ad,
            0x2f0a66ed, 0x59240bcf, 0x915f2166, 0x8c4ace02, 0x802d8981,
            0xf9fc8b37, 0xa3f70986, 0xced98739, 0xa4fbf240, 0x4249945d,
            0xdd51d971);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
+  /*   VSET(16, e64, m8); */
   /*   scalar = -598189234597999223; */
-  /*   VLOAD_64(v2, 0x93adc14539897782, 0xa8d5d41c19b1455a, 0x55e01165195d2d9b,
+  /*   VLOAD_64(v8, 0x93adc14539897782, 0xa8d5d41c19b1455a, 0x55e01165195d2d9b,
    */
   /*            0xe81a26a17fef30f2, 0x33a71ede19aec0aa, 0x49598be14c5bc1cd, */
   /*            0x1c27bde3f488bfc6, 0x4188f9b8611e5d90, 0xd53289cca28a3b6b, */
   /*            0x3b435e1078e3bee9, 0x5e3f4c08c869abf4, 0x3c004920e9c39fb6, */
   /*            0x4b42a451b264b153, 0x110a6db11a7c2801, 0x7c0f358ac41d49fa, */
   /*            0x6e8c6ae4d14bd1a5); */
-  /*   VLOAD_64(v6, 0x3b0c6a3a651beecc, 0xb612caa033bc9bca, 0xda94340ac428ca78,
+  /*   VLOAD_64(v24, 0x3b0c6a3a651beecc, 0xb612caa033bc9bca, 0xda94340ac428ca78,
    */
   /*            0xf774b16ef94a22ea, 0x87df3c47c8113e43, 0x38487d57a064f677, */
   /*            0x358706b57ce6d6c7, 0xda111b3ac946811c, 0xe9ffed5b39f1ea1d, */
   /*            0x3c7e5a675c779870, 0x5d2ea63ac910e42e, 0xb3e832dbe2332203, */
   /*            0x05d366b426005f47, 0x00b3b58815a860d8, 0x023bbf8109263e1d, */
   /*            0x5fbc2f647d6c1153); */
-  /*   asm volatile("vnmsub.vx v2, %[A], v6" ::[A] "r"(scalar)); */
-  /*   VCMP_U64(12, v2, 0x60dd7609c833e03a, 0x79abe3a30a816ca0,
+  /*   asm volatile("vnmsub.vx v8, %[A], v24" ::[A] "r"(scalar)); */
+  /*   VCMP_U64(12, v8, 0x60dd7609c833e03a, 0x79abe3a30a816ca0,
    * 0x983ca4c97f204385, */
   /*            0x59a9303f04932768, 0x59c29659b4d00149, 0x59a15b1bb66f16c2, */
   /*            0x37b0445a8ebaa7d1, 0x65e0c3ab56fa1f0c, 0x94a740971b1d6eda, */
@@ -224,57 +224,57 @@ void TEST_CASE3() {
 }
 
 void TEST_CASE4() {
-  VSET(16, e8, m2);
+  VSET(16, e8, m8);
   int64_t scalar = 5;
-  VLOAD_8(v2, 0x5e, 0xf5, 0xa9, 0x0b, 0x14, 0x3c, 0x84, 0x22, 0xd7, 0xb6, 0x5c,
+  VLOAD_8(v8, 0x5e, 0xf5, 0xa9, 0x0b, 0x14, 0x3c, 0x84, 0x22, 0xd7, 0xb6, 0x5c,
           0x90, 0xa2, 0x67, 0x3d, 0xf5);
-  VLOAD_8(v6, 0xfa, 0xd9, 0x2a, 0xe2, 0xe7, 0x1f, 0x8c, 0xbd, 0x40, 0x5d, 0x50,
+  VLOAD_8(v24, 0xfa, 0xd9, 0x2a, 0xe2, 0xe7, 0x1f, 0x8c, 0xbd, 0x40, 0x5d, 0x50,
           0x1f, 0xe0, 0xdd, 0x1f, 0xd7);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsub.vx v2, %[A], v6, v0.t" ::[A] "r"(scalar));
-  VCMP_U8(13, v2, 0x5e, 0x10, 0xa9, 0xab, 0x14, 0xf3, 0x84, 0x13, 0xd7, 0xcf,
+  asm volatile("vnmsub.vx v8, %[A], v24, v0.t" ::[A] "r"(scalar));
+  VCMP_U8(13, v8, 0x5e, 0x10, 0xa9, 0xab, 0x14, 0xf3, 0x84, 0x13, 0xd7, 0xcf,
           0x5c, 0x4f, 0xa2, 0xda, 0x3d, 0x0e);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   scalar = -5383;
-  VLOAD_16(v2, 0xfe80, 0x3910, 0x5313, 0xefef, 0xecfc, 0x7983, 0xcc0d, 0x731f,
+  VLOAD_16(v8, 0xfe80, 0x3910, 0x5313, 0xefef, 0xecfc, 0x7983, 0xcc0d, 0x731f,
            0xf384, 0xfde3, 0x9cd1, 0xf20b, 0xa41b, 0x949a, 0x5886, 0xa1a9);
-  VLOAD_16(v6, 0xe886, 0xf1f9, 0x1857, 0xd0bb, 0x522e, 0x2de0, 0xa6c2, 0xd624,
+  VLOAD_16(v24, 0xe886, 0xf1f9, 0x1857, 0xd0bb, 0x522e, 0x2de0, 0xa6c2, 0xd624,
            0xd024, 0x40a2, 0xdd99, 0xd517, 0xf00a, 0xae8d, 0x79a5, 0x519d);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsub.vx v2, %[A], v6, v0.t" ::[A] "r"(scalar));
-  VCMP_U16(14, v2, 0xfe80, 0xd169, 0x5313, 0xfb44, 0xecfc, 0x3f75, 0xcc0d,
+  asm volatile("vnmsub.vx v8, %[A], v24, v0.t" ::[A] "r"(scalar));
+  VCMP_U16(14, v8, 0xfe80, 0xd169, 0x5313, 0xfb44, 0xecfc, 0x3f75, 0xcc0d,
            0x86fd, 0xf384, 0xd0d7, 0x9cd1, 0x5a64, 0xa41b, 0x60c3, 0x5886,
            0x9a3c);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   scalar = 6474219;
-  VLOAD_32(v2, 0x48da7aac, 0x54e98600, 0xf49f26e5, 0x338e8406, 0x40ca82f5,
+  VLOAD_32(v8, 0x48da7aac, 0x54e98600, 0xf49f26e5, 0x338e8406, 0x40ca82f5,
            0x75d0b8f6, 0x38c88af2, 0x96bb5c03, 0x6f61c0a9, 0x3626dd69,
            0x31aba619, 0x7d974a55, 0xbc63c280, 0x502334bf, 0x9451b955,
            0x6a8bae19);
-  VLOAD_32(v6, 0xcbd8537e, 0x36928a6c, 0x60cf8444, 0xa19ea650, 0x8f2a8694,
+  VLOAD_32(v24, 0xcbd8537e, 0x36928a6c, 0x60cf8444, 0xa19ea650, 0x8f2a8694,
            0x050956bf, 0x1ef799f5, 0x43c0f327, 0x4bfd5a25, 0x7be439e4,
            0xed89a52a, 0x2bbf028d, 0x872392b9, 0x0ad55495, 0x865c7264,
            0xfcce4b64);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vnmsub.vx v2, %[A], v6, v0.t" ::[A] "r"(scalar));
-  VCMP_U32(15, v2, 0x48da7aac, 0x9dfe886c, 0xf49f26e5, 0xddd6bece, 0x40ca82f5,
+  asm volatile("vnmsub.vx v8, %[A], v24, v0.t" ::[A] "r"(scalar));
+  VCMP_U32(15, v8, 0x48da7aac, 0x9dfe886c, 0xf49f26e5, 0xddd6bece, 0x40ca82f5,
            0x2f0a66ed, 0x38c88af2, 0x915f2166, 0x6f61c0a9, 0x802d8981,
            0x31aba619, 0xa3f70986, 0xbc63c280, 0xa4fbf240, 0x9451b955,
            0xdd51d971);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
+  /*   VSET(16, e64, m8); */
   /*   scalar = -598189234597999223; */
-  /*   VLOAD_64(v2, 0x93adc14539897782, 0xa8d5d41c19b1455a, 0x55e01165195d2d9b,
+  /*   VLOAD_64(v8, 0x93adc14539897782, 0xa8d5d41c19b1455a, 0x55e01165195d2d9b,
    */
   /*            0xe81a26a17fef30f2, 0x33a71ede19aec0aa, 0x49598be14c5bc1cd, */
   /*            0x1c27bde3f488bfc6, 0x4188f9b8611e5d90, 0xd53289cca28a3b6b, */
   /*            0x3b435e1078e3bee9, 0x5e3f4c08c869abf4, 0x3c004920e9c39fb6, */
   /*            0x4b42a451b264b153, 0x110a6db11a7c2801, 0x7c0f358ac41d49fa, */
   /*            0x6e8c6ae4d14bd1a5); */
-  /*   VLOAD_64(v6, 0x3b0c6a3a651beecc, 0xb612caa033bc9bca, 0xda94340ac428ca78,
+  /*   VLOAD_64(v24, 0x3b0c6a3a651beecc, 0xb612caa033bc9bca, 0xda94340ac428ca78,
    */
   /*            0xf774b16ef94a22ea, 0x87df3c47c8113e43, 0x38487d57a064f677, */
   /*            0x358706b57ce6d6c7, 0xda111b3ac946811c, 0xe9ffed5b39f1ea1d, */
@@ -282,8 +282,8 @@ void TEST_CASE4() {
   /*            0x05d366b426005f47, 0x00b3b58815a860d8, 0x023bbf8109263e1d, */
   /*            0x5fbc2f647d6c1153); */
   /*   VLOAD_8(v0, 0xAA, 0xAA); */
-  /*   asm volatile("vnmsub.vx v2, %[A], v6, v0.t" ::[A] "r"(scalar)); */
-  /*   VCMP_U64(16, v2, 0x93adc14539897782, 0x79abe3a30a816ca0,
+  /*   asm volatile("vnmsub.vx v8, %[A], v24, v0.t" ::[A] "r"(scalar)); */
+  /*   VCMP_U64(16, v8, 0x93adc14539897782, 0x79abe3a30a816ca0,
    * 0x55e01165195d2d9b, */
   /*            0x59a9303f04932768, 0x33a71ede19aec0aa, 0x59a15b1bb66f16c2, */
   /*            0x1c27bde3f488bfc6, 0x65e0c3ab56fa1f0c, 0xd53289cca28a3b6b, */
diff --git a/sw/riscvTests/isa/rv64uv/vor.c b/sw/riscvTests/isa/rv64uv/vor.c
index b1a5b12a..be95164e 100644
--- a/sw/riscvTests/isa/rv64uv/vor.c
+++ b/sw/riscvTests/isa/rv64uv/vor.c
@@ -8,48 +8,48 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
-  VLOAD_8(v6, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03,
+  VLOAD_8(v24, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03,
           0xf0);
-  asm volatile("vor.vv v2, v4, v6");
-  VCMP_U8(1, v2, 0xff, 0x03, 0xf0, 0xff, 0x03, 0xf0, 0xff, 0x03, 0xf0, 0xff,
+  asm volatile("vor.vv v8, v16, v24");
+  VCMP_U8(1, v8, 0xff, 0x03, 0xf0, 0xff, 0x03, 0xf0, 0xff, 0x03, 0xf0, 0xff,
           0x03, 0xf0);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
-  VLOAD_16(v6, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003,
+  VLOAD_16(v24, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003,
            0xf0f0, 0xff00, 0x0003, 0xf0f0);
-  asm volatile("vor.vv v2, v4, v6");
-  VCMP_U16(2, v2, 0xffff, 0x0003, 0xf0f0, 0xffff, 0x0003, 0xf0f0, 0xffff,
+  asm volatile("vor.vv v8, v16, v24");
+  VCMP_U16(2, v8, 0xffff, 0x0003, 0xf0f0, 0xffff, 0x0003, 0xf0f0, 0xffff,
            0x0003, 0xf0f0, 0xffff, 0x0003, 0xf0f0);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
-  VLOAD_32(v6, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000, 0x00000003,
+  VLOAD_32(v24, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000, 0x00000003,
            0xf0f0f0f0, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000,
            0x00000003, 0xf0f0f0f0);
-  asm volatile("vor.vv v2, v4, v6");
-  VCMP_U32(3, v2, 0xffffffff, 0x00000003, 0xf0f0f0f0, 0xffffffff, 0x00000003,
+  asm volatile("vor.vv v8, v16, v24");
+  VCMP_U32(3, v8, 0xffffffff, 0x00000003, 0xf0f0f0f0, 0xffffffff, 0x00000003,
            0xf0f0f0f0, 0xffffffff, 0x00000003, 0xf0f0f0f0, 0xffffffff,
            0x00000003, 0xf0f0f0f0);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
-  VLOAD_64(v6, 0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
+  VLOAD_64(v24, 0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0);
-  asm volatile("vor.vv v2, v4, v6");
-  VCMP_U64(4, v2, 0xffffffffffffffff, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
+  asm volatile("vor.vv v8, v16, v24");
+  VCMP_U64(4, v8, 0xffffffffffffffff, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0);
@@ -57,63 +57,63 @@ void TEST_CASE1() {
 }
 
 void TEST_CASE2() {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
-  VLOAD_8(v6, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03,
+  VLOAD_8(v24, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03,
           0xf0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef);
-  asm volatile("vor.vv v2, v4, v6, v0.t");
-  VCMP_U8(5, v2, 0xff, 0xef, 0xf0, 0xff, 0xef, 0xf0, 0xff, 0xef, 0xf0, 0xff,
+  asm volatile("vor.vv v8, v16, v24, v0.t");
+  VCMP_U8(5, v8, 0xff, 0xef, 0xf0, 0xff, 0xef, 0xf0, 0xff, 0xef, 0xf0, 0xff,
           0xef, 0xf0);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
-  VLOAD_16(v6, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003,
+  VLOAD_16(v24, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003,
            0xf0f0, 0xff00, 0x0003, 0xf0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vor.vv v2, v4, v6, v0.t");
-  VCMP_U16(6, v2, 0xffff, 0xbeef, 0xf0f0, 0xffff, 0xbeef, 0xf0f0, 0xffff,
+  asm volatile("vor.vv v8, v16, v24, v0.t");
+  VCMP_U16(6, v8, 0xffff, 0xbeef, 0xf0f0, 0xffff, 0xbeef, 0xf0f0, 0xffff,
            0xbeef, 0xf0f0, 0xffff, 0xbeef, 0xf0f0);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
-  VLOAD_32(v6, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000, 0x00000003,
+  VLOAD_32(v24, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000, 0x00000003,
            0xf0f0f0f0, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000,
            0x00000003, 0xf0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef);
-  asm volatile("vor.vv v2, v4, v6, v0.t");
-  VCMP_U32(7, v2, 0xffffffff, 0xdeadbeef, 0xf0f0f0f0, 0xffffffff, 0xdeadbeef,
+  asm volatile("vor.vv v8, v16, v24, v0.t");
+  VCMP_U32(7, v8, 0xffffffff, 0xdeadbeef, 0xf0f0f0f0, 0xffffffff, 0xdeadbeef,
            0xf0f0f0f0, 0xffffffff, 0xdeadbeef, 0xf0f0f0f0, 0xffffffff,
            0xdeadbeef, 0xf0f0f0f0);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
-  VLOAD_64(v6, 0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
+  VLOAD_64(v24, 0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef);
-  asm volatile("vor.vv v2, v4, v6, v0.t");
-  VCMP_U64(8, v2, 0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0f0,
+  asm volatile("vor.vv v8, v16, v24, v0.t");
+  VCMP_U64(8, v8, 0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0f0);
@@ -123,37 +123,37 @@ void TEST_CASE2() {
 void TEST_CASE3() {
   const uint32_t scalar = 0x0ff00ff0;
 
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
-  asm volatile("vor.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(9, v2, 0xff, 0xf1, 0xf0, 0xff, 0xf1, 0xf0, 0xff, 0xf1, 0xf0, 0xff,
+  asm volatile("vor.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(9, v8, 0xff, 0xf1, 0xf0, 0xff, 0xf1, 0xf0, 0xff, 0xf1, 0xf0, 0xff,
           0xf1, 0xf0);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
-  asm volatile("vor.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(10, v2, 0xffff, 0x0ff1, 0xfff0, 0xffff, 0x0ff1, 0xfff0, 0xffff,
+  asm volatile("vor.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(10, v8, 0xffff, 0x0ff1, 0xfff0, 0xffff, 0x0ff1, 0xfff0, 0xffff,
            0x0ff1, 0xfff0, 0xffff, 0x0ff1, 0xfff0);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
-  asm volatile("vor.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(11, v2, 0xffffffff, 0x0ff00ff1, 0xfff0fff0, 0xffffffff, 0x0ff00ff1,
+  asm volatile("vor.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(11, v8, 0xffffffff, 0x0ff00ff1, 0xfff0fff0, 0xffffffff, 0x0ff00ff1,
            0xfff0fff0, 0xffffffff, 0x0ff00ff1, 0xfff0fff0, 0xffffffff,
            0x0ff00ff1, 0xfff0fff0);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
-  asm volatile("vor.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U64(12, v2, 0xffffffffffffffff, 0x000000000ff00ff1, 0xf0f0f0f0fff0fff0,
+  asm volatile("vor.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U64(12, v8, 0xffffffffffffffff, 0x000000000ff00ff1, 0xf0f0f0f0fff0fff0,
            0xffffffffffffffff, 0x000000000ff00ff1, 0xf0f0f0f0fff0fff0,
            0xffffffffffffffff, 0x000000000ff00ff1, 0xf0f0f0f0fff0fff0,
            0xffffffffffffffff, 0x000000000ff00ff1, 0xf0f0f0f0fff0fff0);
@@ -163,52 +163,52 @@ void TEST_CASE3() {
 void TEST_CASE4() {
   const uint32_t scalar = 0x0ff00ff0;
 
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef);
-  asm volatile("vor.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U8(13, v2, 0xff, 0xef, 0xf0, 0xff, 0xef, 0xf0, 0xff, 0xef, 0xf0, 0xff,
+  asm volatile("vor.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U8(13, v8, 0xff, 0xef, 0xf0, 0xff, 0xef, 0xf0, 0xff, 0xef, 0xf0, 0xff,
           0xef, 0xf0);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vor.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U16(14, v2, 0xffff, 0xbeef, 0xfff0, 0xffff, 0xbeef, 0xfff0, 0xffff,
+  asm volatile("vor.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U16(14, v8, 0xffff, 0xbeef, 0xfff0, 0xffff, 0xbeef, 0xfff0, 0xffff,
            0xbeef, 0xfff0, 0xffff, 0xbeef, 0xfff0);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef);
-  asm volatile("vor.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U32(15, v2, 0xffffffff, 0xdeadbeef, 0xfff0fff0, 0xffffffff, 0xdeadbeef,
+  asm volatile("vor.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U32(15, v8, 0xffffffff, 0xdeadbeef, 0xfff0fff0, 0xffffffff, 0xdeadbeef,
            0xfff0fff0, 0xffffffff, 0xdeadbeef, 0xfff0fff0, 0xffffffff,
            0xdeadbeef, 0xfff0fff0);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef);
-  asm volatile("vor.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U64(16, v2, 0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0fff0fff0,
+  asm volatile("vor.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U64(16, v8, 0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0fff0fff0,
            0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0fff0fff0,
            0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0fff0fff0,
            0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0fff0fff0);
@@ -216,37 +216,37 @@ void TEST_CASE4() {
 }
 
 void TEST_CASE5() {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
-  asm volatile("vor.vi v2, v4, 15");
-  VCMP_U8(17, v2, 0xff, 0x0f, 0xff, 0xff, 0x0f, 0xff, 0xff, 0x0f, 0xff, 0xff,
+  asm volatile("vor.vi v8, v16, 15");
+  VCMP_U8(17, v8, 0xff, 0x0f, 0xff, 0xff, 0x0f, 0xff, 0xff, 0x0f, 0xff, 0xff,
           0x0f, 0xff);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
-  asm volatile("vor.vi v2, v4, 15");
-  VCMP_U16(18, v2, 0xffff, 0x000f, 0xf0ff, 0xffff, 0x000f, 0xf0ff, 0xffff,
+  asm volatile("vor.vi v8, v16, 15");
+  VCMP_U16(18, v8, 0xffff, 0x000f, 0xf0ff, 0xffff, 0x000f, 0xf0ff, 0xffff,
            0x000f, 0xf0ff, 0xffff, 0x000f, 0xf0ff);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
-  asm volatile("vor.vi v2, v4, 15");
-  VCMP_U32(19, v2, 0xffffffff, 0x0000000f, 0xf0f0f0ff, 0xffffffff, 0x0000000f,
+  asm volatile("vor.vi v8, v16, 15");
+  VCMP_U32(19, v8, 0xffffffff, 0x0000000f, 0xf0f0f0ff, 0xffffffff, 0x0000000f,
            0xf0f0f0ff, 0xffffffff, 0x0000000f, 0xf0f0f0ff, 0xffffffff,
            0x0000000f, 0xf0f0f0ff);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
-  asm volatile("vor.vi v2, v4, 15");
-  VCMP_U64(20, v2, 0xffffffffffffffff, 0x000000000000000f, 0xf0f0f0f0f0f0f0ff,
+  asm volatile("vor.vi v8, v16, 15");
+  VCMP_U64(20, v8, 0xffffffffffffffff, 0x000000000000000f, 0xf0f0f0f0f0f0f0ff,
            0xffffffffffffffff, 0x000000000000000f, 0xf0f0f0f0f0f0f0ff,
            0xffffffffffffffff, 0x000000000000000f, 0xf0f0f0f0f0f0f0ff,
            0xffffffffffffffff, 0x000000000000000f, 0xf0f0f0f0f0f0f0ff);
@@ -254,52 +254,52 @@ void TEST_CASE5() {
 }
 
 void TEST_CASE6() {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef);
-  asm volatile("vor.vi v2, v4, 15, v0.t");
-  VCMP_U8(21, v2, 0xff, 0xef, 0xff, 0xff, 0xef, 0xff, 0xff, 0xef, 0xff, 0xff,
+  asm volatile("vor.vi v8, v16, 15, v0.t");
+  VCMP_U8(21, v8, 0xff, 0xef, 0xff, 0xff, 0xef, 0xff, 0xff, 0xef, 0xff, 0xff,
           0xef, 0xff);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vor.vi v2, v4, 15, v0.t");
-  VCMP_U16(22, v2, 0xffff, 0xbeef, 0xf0ff, 0xffff, 0xbeef, 0xf0ff, 0xffff,
+  asm volatile("vor.vi v8, v16, 15, v0.t");
+  VCMP_U16(22, v8, 0xffff, 0xbeef, 0xf0ff, 0xffff, 0xbeef, 0xf0ff, 0xffff,
            0xbeef, 0xf0ff, 0xffff, 0xbeef, 0xf0ff);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef);
-  asm volatile("vor.vi v2, v4, 15, v0.t");
-  VCMP_U32(23, v2, 0xffffffff, 0xdeadbeef, 0xf0f0f0ff, 0xffffffff, 0xdeadbeef,
+  asm volatile("vor.vi v8, v16, 15, v0.t");
+  VCMP_U32(23, v8, 0xffffffff, 0xdeadbeef, 0xf0f0f0ff, 0xffffffff, 0xdeadbeef,
            0xf0f0f0ff, 0xffffffff, 0xdeadbeef, 0xf0f0f0ff, 0xffffffff,
            0xdeadbeef, 0xf0f0f0ff);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef);
-  asm volatile("vor.vi v2, v4, 15, v0.t");
-  VCMP_U64(24, v2, 0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0ff,
+  asm volatile("vor.vi v8, v16, 15, v0.t");
+  VCMP_U64(24, v8, 0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0ff,
            0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0ff,
            0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0ff,
            0xffffffffffffffff, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0ff);
diff --git a/sw/riscvTests/isa/rv64uv/vredand.c b/sw/riscvTests/isa/rv64uv/vredand.c
index 34b7fab4..a354b18d 100644
--- a/sw/riscvTests/isa/rv64uv/vredand.c
+++ b/sw/riscvTests/isa/rv64uv/vredand.c
@@ -8,81 +8,81 @@
 
 // Naive test
 void TEST_CASE1(void) {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0xf1, 0xf0, 0xff, 0xf1, 0xf0, 0xff, 0xf1, 0xf0, 0xff, 0xf1,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0xf1, 0xf0, 0xff, 0xf1, 0xf0, 0xff, 0xf1, 0xf0, 0xff, 0xf1,
           0xf0);
   VLOAD_8(v8, 0xf0);
-  asm volatile("vredand.vs v12, v4, v8");
-  VCMP_U8(1, v12, 0xf0);
+  asm volatile("vredand.vs v24, v16, v8");
+  VCMP_U8(1, v24, 0xf0);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0301, 0xf1f0, 0xffff, 0x0101, 0xf7f0, 0xffff, 0x0701,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0301, 0xf1f0, 0xffff, 0x0101, 0xf7f0, 0xffff, 0x0701,
            0xfff0, 0xffff, 0x0101, 0xf1f0);
   VLOAD_16(v8, 0xefff);
-  asm volatile("vredand.vs v12, v4, v8");
-  VCMP_U16(2, v12, 0x0100);
+  asm volatile("vredand.vs v24, v16, v8");
+  VCMP_U16(2, v24, 0x0100);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x100ff001, 0xf0f0f0f0, 0xffffffff, 0x100ff001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x100ff001, 0xf0f0f0f0, 0xffffffff, 0x100ff001,
            0xf0f0f0f0, 0xffffffff, 0x100ff001, 0xf0f0f0f0, 0xffffffff,
            0x100ff001, 0xf0f0f0f0);
   VLOAD_32(v8, 0x00f010f0);
-  asm volatile("vredand.vs v12, v4, v8");
-  VCMP_U32(3, v12, 0x00001000);
+  asm volatile("vredand.vs v24, v16, v8");
+  VCMP_U32(3, v24, 0x00001000);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x1000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x1000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x1000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x1000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x1000000000000001, 0xf0f0f0f0f0f0f0f0);
   VLOAD_64(v8, 0xfffffffffffffff7);
-  asm volatile("vredand.vs v12, v4, v8");
-  VCMP_U64(4, v12, 0x1000000000000000);
+  asm volatile("vredand.vs v24, v16, v8");
+  VCMP_U64(4, v24, 0x1000000000000000);
 #endif
 }
 
 // Masked naive test
 void TEST_CASE2(void) {
-  VSET(12, e8, m2);
+  VSET(12, e8, m8);
   VLOAD_8(v0, 0xf7, 0xff);
-  VLOAD_8(v4, 0xff, 0xf1, 0xff, 0x00, 0xf1, 0xf0, 0xff, 0xf1, 0xf0, 0xff, 0xf1,
+  VLOAD_8(v16, 0xff, 0xf1, 0xff, 0x00, 0xf1, 0xf0, 0xff, 0xf1, 0xf0, 0xff, 0xf1,
           0xf0);
   VLOAD_8(v8, 0xf0);
-  VLOAD_8(v12, 1);
-  asm volatile("vredand.vs v12, v4, v8, v0.t");
-  VCMP_U8(5, v12, 0xf0);
+  VLOAD_8(v24, 1);
+  asm volatile("vredand.vs v24, v16, v8, v0.t");
+  VCMP_U8(5, v24, 0xf0);
 
-  VSET(12, e16, m2);
+  VSET(12, e16, m8);
   VLOAD_8(v0, 0x00, 0x08);
-  VLOAD_16(v4, 0xffff, 0x0301, 0xf1f0, 0xffff, 0x0101, 0xf7f0, 0xffff, 0x9701,
+  VLOAD_16(v16, 0xffff, 0x0301, 0xf1f0, 0xffff, 0x0101, 0xf7f0, 0xffff, 0x9701,
            0xfff0, 0xffff, 0x0101, 0xf1f0);
   VLOAD_16(v8, 0xefff);
-  VLOAD_16(v12, 1);
-  asm volatile("vredand.vs v12, v4, v8, v0.t");
-  VCMP_U16(6, v12, 0xe1f0);
+  VLOAD_16(v24, 1);
+  asm volatile("vredand.vs v24, v16, v8, v0.t");
+  VCMP_U16(6, v24, 0xe1f0);
 
-  VSET(12, e32, m2);
+  VSET(12, e32, m8);
   VLOAD_8(v0, 0xfe, 0xff);
-  VLOAD_32(v4, 0x00000000, 0x100ff001, 0xf0f0f0f0, 0xffffffff, 0x100ff001,
+  VLOAD_32(v16, 0x00000000, 0x100ff001, 0xf0f0f0f0, 0xffffffff, 0x100ff001,
            0xf0f0f0f0, 0xffffffff, 0x100ff001, 0xf0f0f0f0, 0xffffffff,
            0x100ff001, 0xf0f0f0f0);
   VLOAD_32(v8, 0x00f010f0);
-  VLOAD_32(v12, 1);
-  asm volatile("vredand.vs v12, v4, v8, v0.t");
-  VCMP_U32(7, v12, 0x00001000);
+  VLOAD_32(v24, 1);
+  asm volatile("vredand.vs v24, v16, v8, v0.t");
+  VCMP_U32(7, v24, 0x00001000);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
+  VSET(12, e64, m8);
   VLOAD_8(v0, 0xaa, 0x55);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x1000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VLOAD_64(v16, 0xffffffffffffffff, 0x1000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x1000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x1000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x1000000000000001, 0xf0f0f0f0f0f0f0f0);
   VLOAD_64(v8, 0xfffffffffffffff7);
-  VLOAD_64(v12, 1);
-  asm volatile("vredand.vs v12, v4, v8, v0.t");
-  VCMP_U64(8, v12, 0x1000000000000000);
+  VLOAD_64(v24, 1);
+  asm volatile("vredand.vs v24, v16, v8, v0.t");
+  VCMP_U64(8, v24, 0x1000000000000000);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vredmax.c b/sw/riscvTests/isa/rv64uv/vredmax.c
index 94a7c60b..0b6953d6 100644
--- a/sw/riscvTests/isa/rv64uv/vredmax.c
+++ b/sw/riscvTests/isa/rv64uv/vredmax.c
@@ -8,67 +8,67 @@
 
 // Naive test
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, -7, 8, 1, 9, 3, 4, 5, -6, 7, 8);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, -7, 8, 1, 9, 3, 4, 5, -6, 7, 8);
   VLOAD_8(v8, -1);
-  asm volatile("vredmax.vs v12, v4, v8");
-  VCMP_U8(1, v12, 9);
+  asm volatile("vredmax.vs v24, v16, v8");
+  VCMP_U8(1, v24, 9);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, -1, 2, -3, 4, 5, 6, 7, 8, 1, 2, 3, -4, 5, 6, 7, 8);
+  VSET(16, e16, m8);
+  VLOAD_16(v16, -1, 2, -3, 4, 5, 6, 7, 8, 1, 2, 3, -4, 5, 6, 7, 8);
   VLOAD_16(v8, 9);
-  asm volatile("vredmax.vs v12, v4, v8");
-  VCMP_U16(2, v12, 9);
+  asm volatile("vredmax.vs v24, v16, v8");
+  VCMP_U16(2, v24, 9);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 9, 2, 3, -4, 5, 6, 7, 8, 1, 2, 3, 4, -5, 6, 7, 8);
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 9, 2, 3, -4, 5, 6, 7, 8, 1, 2, 3, 4, -5, 6, 7, 8);
   VLOAD_32(v8, 1);
-  asm volatile("vredmax.vs v12, v4, v8");
-  VCMP_U32(3, v12, 9);
+  asm volatile("vredmax.vs v24, v16, v8");
+  VCMP_U32(3, v24, 9);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, -1, 2, 3, -4, 5, 6, 7, 9, 1, 2, 3, 4, 5, 6, 7, -8);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, -1, 2, 3, -4, 5, 6, 7, 9, 1, 2, 3, 4, 5, 6, 7, -8);
   VLOAD_64(v8, -1);
-  asm volatile("vredmax.vs v12, v4, v8");
-  VCMP_U64(4, v12, 9);
+  asm volatile("vredmax.vs v24, v16, v8");
+  VCMP_U64(4, v24, 9);
 #endif
 }
 
 // Masked naive test
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
+  VSET(16, e8, m8);
   VLOAD_8(v0, 0x03, 0x00);
-  VLOAD_8(v4, -1, 2, 3, -4, 5, 6, 7, 9, 1, -2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v16, -1, 2, 3, -4, 5, 6, 7, 9, 1, -2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 1);
-  VLOAD_8(v12, 1);
-  asm volatile("vredmax.vs v12, v4, v8, v0.t");
-  VCMP_U8(5, v12, 2);
+  VLOAD_8(v24, 1);
+  asm volatile("vredmax.vs v24, v16, v8, v0.t");
+  VCMP_U8(5, v24, 2);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   VLOAD_8(v0, 0x00, 0xc0);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, -7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, -7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, 9);
-  VLOAD_16(v12, 1);
-  asm volatile("vredmax.vs v12, v4, v8, v0.t");
-  VCMP_U16(6, v12, 9);
+  VLOAD_16(v24, 1);
+  asm volatile("vredmax.vs v24, v16, v8, v0.t");
+  VCMP_U16(6, v24, 9);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   VLOAD_8(v0, 0x00, 0xc0);
-  VLOAD_32(v4, -1, 2, 3, 4, 5, 6, 7, -8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v16, -1, 2, 3, 4, 5, 6, 7, -8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, 1);
-  VLOAD_32(v12, 1);
-  asm volatile("vredmax.vs v12, v4, v8, v0.t");
-  VCMP_U32(7, v12, 8);
+  VLOAD_32(v24, 1);
+  asm volatile("vredmax.vs v24, v16, v8, v0.t");
+  VCMP_U32(7, v24, 8);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   VLOAD_8(v0, 0xaa, 0x55);
-  VLOAD_64(v4, 1, -2, 3, 4, 5, 6, -7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v16, 1, -2, 3, 4, 5, 6, -7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, 4);
-  VLOAD_64(v12, 1);
-  asm volatile("vredmax.vs v12, v4, v8, v0.t");
-  VCMP_U64(8, v12, 8);
+  VLOAD_64(v24, 1);
+  asm volatile("vredmax.vs v24, v16, v8, v0.t");
+  VCMP_U64(8, v24, 8);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vredmaxu.c b/sw/riscvTests/isa/rv64uv/vredmaxu.c
index 8b545cb4..1e38a098 100644
--- a/sw/riscvTests/isa/rv64uv/vredmaxu.c
+++ b/sw/riscvTests/isa/rv64uv/vredmaxu.c
@@ -8,96 +8,96 @@
 
 // Naive test
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 9, 3, 4, 5, 6, 7, 8);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 9, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 1);
-  asm volatile("vredmaxu.vs v12, v4, v8");
-  VCMP_U8(1, v12, 9);
+  asm volatile("vredmaxu.vs v24, v16, v8");
+  VCMP_U8(1, v24, 9);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, 9);
-  asm volatile("vredmaxu.vs v12, v4, v8");
-  VCMP_U16(2, v12, 9);
+  asm volatile("vredmaxu.vs v24, v16, v8");
+  VCMP_U16(2, v24, 9);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 9, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 9, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, 1);
-  asm volatile("vredmaxu.vs v12, v4, v8");
-  VCMP_U32(3, v12, 9);
+  asm volatile("vredmaxu.vs v24, v16, v8");
+  VCMP_U32(3, v24, 9);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 9, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 9, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, 1);
-  asm volatile("vredmaxu.vs v12, v4, v8");
-  VCMP_U64(4, v12, 9);
+  asm volatile("vredmaxu.vs v24, v16, v8");
+  VCMP_U64(4, v24, 9);
 #endif
 }
 
 // Masked naive test
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
+  VSET(16, e8, m8);
   VLOAD_8(v0, 0x03, 0x00);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 9, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 9, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 1);
-  VLOAD_8(v12, 1);
-  asm volatile("vredmaxu.vs v12, v4, v8, v0.t");
-  VCMP_U8(5, v12, 2);
+  VLOAD_8(v24, 1);
+  asm volatile("vredmaxu.vs v24, v16, v8, v0.t");
+  VCMP_U8(5, v24, 2);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   VLOAD_8(v0, 0x00, 0xc0);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, 9);
-  VLOAD_16(v12, 1);
-  asm volatile("vredmaxu.vs v12, v4, v8, v0.t");
-  VCMP_U16(6, v12, 9);
+  VLOAD_16(v24, 1);
+  asm volatile("vredmaxu.vs v24, v16, v8, v0.t");
+  VCMP_U16(6, v24, 9);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   VLOAD_8(v0, 0x00, 0xc0);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, 1);
-  VLOAD_32(v12, 1);
-  asm volatile("vredmaxu.vs v12, v4, v8, v0.t");
-  VCMP_U32(7, v12, 8);
+  VLOAD_32(v24, 1);
+  asm volatile("vredmaxu.vs v24, v16, v8, v0.t");
+  VCMP_U32(7, v24, 8);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   VLOAD_8(v0, 0xaa, 0x55);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, 4);
-  VLOAD_64(v12, 1);
-  asm volatile("vredmaxu.vs v12, v4, v8, v0.t");
-  VCMP_U64(8, v12, 8);
+  VLOAD_64(v24, 1);
+  asm volatile("vredmaxu.vs v24, v16, v8, v0.t");
+  VCMP_U64(8, v24, 8);
 #endif
 }
 
 // Naive test with negative values
 void TEST_CASE3(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 9, -3, 4, 5, 6, 7, 8);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 9, -3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 1);
-  asm volatile("vredmaxu.vs v12, v4, v8");
-  VCMP_U8(9, v12, -3);
+  asm volatile("vredmaxu.vs v24, v16, v8");
+  VCMP_U8(9, v24, -3);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, -9);
-  asm volatile("vredmaxu.vs v12, v4, v8");
-  VCMP_U16(10, v12, -9);
+  asm volatile("vredmaxu.vs v24, v16, v8");
+  VCMP_U16(10, v24, -9);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 9, 2, 3, 4, -5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 9, 2, 3, 4, -5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, 1);
-  asm volatile("vredmaxu.vs v12, v4, v8");
-  VCMP_U32(11, v12, -5);
+  asm volatile("vredmaxu.vs v24, v16, v8");
+  VCMP_U32(11, v24, -5);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 1, 2, 3, -4, 5, 6, 7, 9, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 1, 2, 3, -4, 5, 6, 7, 9, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, -1);
-  asm volatile("vredmaxu.vs v12, v4, v8");
-  VCMP_U64(12, v12, -1);
+  asm volatile("vredmaxu.vs v24, v16, v8");
+  VCMP_U64(12, v24, -1);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vredmin.c b/sw/riscvTests/isa/rv64uv/vredmin.c
index 67148a54..758cf2b0 100644
--- a/sw/riscvTests/isa/rv64uv/vredmin.c
+++ b/sw/riscvTests/isa/rv64uv/vredmin.c
@@ -8,67 +8,67 @@
 
 // Naive test
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 0, 1, 9, 3, 4, 5, 6, 7, 8);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 0, 1, 9, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 1);
-  asm volatile("vredmin.vs v12, v4, v8");
-  VCMP_U8(1, v12, 0);
+  asm volatile("vredmin.vs v24, v16, v8");
+  VCMP_U8(1, v24, 0);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 1, 2, -3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 1, 2, -3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, 0);
-  asm volatile("vredmin.vs v12, v4, v8");
-  VCMP_U16(2, v12, -3);
+  asm volatile("vredmin.vs v24, v16, v8");
+  VCMP_U16(2, v24, -3);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 9, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 9, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, -1);
-  asm volatile("vredmin.vs v12, v4, v8");
-  VCMP_U32(3, v12, -1);
+  asm volatile("vredmin.vs v24, v16, v8");
+  VCMP_U32(3, v24, -1);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, -1, 2, 3, 4, 5, -6, 7, -9, -1, -2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, -1, 2, 3, 4, 5, -6, 7, -9, -1, -2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, -1);
-  asm volatile("vredmin.vs v12, v4, v8");
-  VCMP_U64(4, v12, -9);
+  asm volatile("vredmin.vs v24, v16, v8");
+  VCMP_U64(4, v24, -9);
 #endif
 }
 
 // Masked naive test
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
+  VSET(16, e8, m8);
   VLOAD_8(v0, 0x03, 0x00);
-  VLOAD_8(v4, 1, -2, 3, 4, 5, 6, 7, 9, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v16, 1, -2, 3, 4, 5, 6, 7, 9, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 1);
-  VLOAD_8(v12, 1);
-  asm volatile("vredmin.vs v12, v4, v8, v0.t");
-  VCMP_U8(5, v12, -2);
+  VLOAD_8(v24, 1);
+  asm volatile("vredmin.vs v24, v16, v8, v0.t");
+  VCMP_U8(5, v24, -2);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   VLOAD_8(v0, 0x00, 0xc0);
-  VLOAD_16(v4, -1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v16, -1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, 3);
-  VLOAD_16(v12, 1);
-  asm volatile("vredmin.vs v12, v4, v8, v0.t");
-  VCMP_U16(6, v12, 3);
+  VLOAD_16(v24, 1);
+  asm volatile("vredmin.vs v24, v16, v8, v0.t");
+  VCMP_U16(6, v24, 3);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   VLOAD_8(v0, 0x00, 0xc0);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, 8);
-  VLOAD_32(v12, 1);
-  asm volatile("vredmin.vs v12, v4, v8, v0.t");
-  VCMP_U32(7, v12, 7);
+  VLOAD_32(v24, 1);
+  asm volatile("vredmin.vs v24, v16, v8, v0.t");
+  VCMP_U32(7, v24, 7);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   VLOAD_8(v0, 0xaa, 0x55);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, 4);
-  VLOAD_64(v12, 1);
-  asm volatile("vredmin.vs v12, v4, v8, v0.t");
-  VCMP_U64(8, v12, 1);
+  VLOAD_64(v24, 1);
+  asm volatile("vredmin.vs v24, v16, v8, v0.t");
+  VCMP_U64(8, v24, 1);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vredminu.c b/sw/riscvTests/isa/rv64uv/vredminu.c
index 0fedc3e6..f33fb52e 100644
--- a/sw/riscvTests/isa/rv64uv/vredminu.c
+++ b/sw/riscvTests/isa/rv64uv/vredminu.c
@@ -8,67 +8,67 @@
 
 // Naive test
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 0, 1, 9, 3, 4, 5, 6, 7, 8);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 0, 1, 9, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 1);
-  asm volatile("vredminu.vs v12, v4, v8");
-  VCMP_U8(1, v12, 0);
+  asm volatile("vredminu.vs v24, v16, v8");
+  VCMP_U8(1, v24, 0);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 1, 2, -3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 1, 2, -3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, 0);
-  asm volatile("vredminu.vs v12, v4, v8");
-  VCMP_U16(2, v12, 0);
+  asm volatile("vredminu.vs v24, v16, v8");
+  VCMP_U16(2, v24, 0);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 9, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 9, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, -1);
-  asm volatile("vredminu.vs v12, v4, v8");
-  VCMP_U32(3, v12, 1);
+  asm volatile("vredminu.vs v24, v16, v8");
+  VCMP_U32(3, v24, 1);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, -1, 2, 3, 4, 5, -6, 7, -9, -1, -2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, -1, 2, 3, 4, 5, -6, 7, -9, -1, -2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, -1);
-  asm volatile("vredminu.vs v12, v4, v8");
-  VCMP_U64(4, v12, 2);
+  asm volatile("vredminu.vs v24, v16, v8");
+  VCMP_U64(4, v24, 2);
 #endif
 }
 
 // Masked naive test
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
+  VSET(16, e8, m8);
   VLOAD_8(v0, 0x03, 0x00);
-  VLOAD_8(v4, 1, -2, 3, 4, 5, 6, 7, 9, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v16, 1, -2, 3, 4, 5, 6, 7, 9, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 1);
-  VLOAD_8(v12, 1);
-  asm volatile("vredminu.vs v12, v4, v8, v0.t");
-  VCMP_U8(5, v12, 1);
+  VLOAD_8(v24, 1);
+  asm volatile("vredminu.vs v24, v16, v8, v0.t");
+  VCMP_U8(5, v24, 1);
 
-  VSET(16, e16, m2);
+  VSET(16, e16, m8);
   VLOAD_8(v0, 0x00, 0xc0);
-  VLOAD_16(v4, -1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v16, -1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, 3);
-  VLOAD_16(v12, 1);
-  asm volatile("vredminu.vs v12, v4, v8, v0.t");
-  VCMP_U16(6, v12, 3);
+  VLOAD_16(v24, 1);
+  asm volatile("vredminu.vs v24, v16, v8, v0.t");
+  VCMP_U16(6, v24, 3);
 
-  VSET(16, e32, m2);
+  VSET(16, e32, m8);
   VLOAD_8(v0, 0x00, 0xc0);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, 8);
-  VLOAD_32(v12, 1);
-  asm volatile("vredminu.vs v12, v4, v8, v0.t");
-  VCMP_U32(7, v12, 7);
+  VLOAD_32(v24, 1);
+  asm volatile("vredminu.vs v24, v16, v8, v0.t");
+  VCMP_U32(7, v24, 7);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
+  VSET(16, e64, m8);
   VLOAD_8(v0, 0xaa, 0x55);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, 4);
-  VLOAD_64(v12, 1);
-  asm volatile("vredminu.vs v12, v4, v8, v0.t");
-  VCMP_U64(8, v12, 1);
+  VLOAD_64(v24, 1);
+  asm volatile("vredminu.vs v24, v16, v8, v0.t");
+  VCMP_U64(8, v24, 1);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vredor.c b/sw/riscvTests/isa/rv64uv/vredor.c
index 886b28fa..decc6719 100644
--- a/sw/riscvTests/isa/rv64uv/vredor.c
+++ b/sw/riscvTests/isa/rv64uv/vredor.c
@@ -8,81 +8,81 @@
 
 // Naive test
 void TEST_CASE1(void) {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01,
           0x00);
   VLOAD_8(v8, 0x10);
-  asm volatile("vredor.vs v12, v4, v8");
-  VCMP_U8(1, v12, 0x11);
+  asm volatile("vredor.vs v24, v16, v8");
+  VCMP_U8(1, v24, 0x11);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0x0000, 0x0301, 0x0100, 0x0000, 0x0101, 0x0700, 0x0000, 0x0701,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0x0000, 0x0301, 0x0100, 0x0000, 0x0101, 0x0700, 0x0000, 0x0701,
            0x0000, 0x0000, 0x0101, 0x0100);
   VLOAD_16(v8, 0xe000);
-  asm volatile("vredor.vs v12, v4, v8");
-  VCMP_U16(2, v12, 0xe701);
+  asm volatile("vredor.vs v24, v16, v8");
+  VCMP_U16(2, v24, 0xe701);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0x00000000, 0x10000001, 0x00000000, 0x00000000, 0x10000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0x00000000, 0x10000001, 0x00000000, 0x00000000, 0x10000001,
            0x00000000, 0x00000000, 0x10000001, 0x00000000, 0x00000000,
            0x10000001, 0x00000000);
   VLOAD_32(v8, 0x00001000);
-  asm volatile("vredor.vs v12, v4, v8");
-  VCMP_U32(3, v12, 0x10001001);
+  asm volatile("vredor.vs v24, v16, v8");
+  VCMP_U32(3, v24, 0x10001001);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0x0000000000000000, 0x1000000000000001, 0x0000000000000000,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0x0000000000000000, 0x1000000000000001, 0x0000000000000000,
            0x0000000000000000, 0x1000000000000001, 0x0000000000000000,
            0x0000000000000000, 0x1000000000000001, 0x0000000000000000,
            0x0000000000000000, 0x1000000000000001, 0x0000000000000000);
   VLOAD_64(v8, 0x0000000000000007);
-  asm volatile("vredor.vs v12, v4, v8");
-  VCMP_U64(4, v12, 0x1000000000000007);
+  asm volatile("vredor.vs v24, v16, v8");
+  VCMP_U64(4, v24, 0x1000000000000007);
 #endif
 }
 
 // Masked naive test
 void TEST_CASE2(void) {
-  VSET(12, e8, m2);
+  VSET(12, e8, m8);
   VLOAD_8(v0, 0x07, 0x00);
-  VLOAD_8(v4, 0x00, 0x01, 0x00, 0xff, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01,
+  VLOAD_8(v16, 0x00, 0x01, 0x00, 0xff, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01,
           0x00);
   VLOAD_8(v8, 0x00);
-  VLOAD_8(v12, 1);
-  asm volatile("vredor.vs v12, v4, v8, v0.t");
-  VCMP_U8(5, v12, 0x01);
+  VLOAD_8(v24, 1);
+  asm volatile("vredor.vs v24, v16, v8, v0.t");
+  VCMP_U8(5, v24, 0x01);
 
-  VSET(12, e16, m2);
+  VSET(12, e16, m8);
   VLOAD_8(v0, 0x00, 0x08);
-  VLOAD_16(v4, 0x0f00, 0x0301, 0x0100, 0x0000, 0x0101, 0x0700, 0x0000, 0x9701,
+  VLOAD_16(v16, 0x0f00, 0x0301, 0x0100, 0x0000, 0x0101, 0x0700, 0x0000, 0x9701,
            0x0000, 0x0000, 0x0101, 0x0100);
   VLOAD_16(v8, 0xe000);
-  VLOAD_16(v12, 1);
-  asm volatile("vredor.vs v12, v4, v8, v0.t");
-  VCMP_U16(6, v12, 0xe100);
+  VLOAD_16(v24, 1);
+  asm volatile("vredor.vs v24, v16, v8, v0.t");
+  VCMP_U16(6, v24, 0xe100);
 
-  VSET(12, e32, m2);
+  VSET(12, e32, m8);
   VLOAD_8(v0, 0x0e, 0x00);
-  VLOAD_32(v4, 0xf0000fff, 0x10000001, 0x00000000, 0x00000000, 0x10000001,
+  VLOAD_32(v16, 0xf0000fff, 0x10000001, 0x00000000, 0x00000000, 0x10000001,
            0x00000000, 0x00000000, 0x10000001, 0x00000000, 0x00000000,
            0x10000001, 0x00000000);
   VLOAD_32(v8, 0x00001000);
-  VLOAD_32(v12, 1);
-  asm volatile("vredor.vs v12, v4, v8, v0.t");
-  VCMP_U32(7, v12, 0x10001001);
+  VLOAD_32(v24, 1);
+  asm volatile("vredor.vs v24, v16, v8, v0.t");
+  VCMP_U32(7, v24, 0x10001001);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
+  VSET(12, e64, m8);
   VLOAD_8(v0, 0xaa, 0x55);
-  VLOAD_64(v4, 0x0000000000000000, 0x1000000000000001, 0x0000f00000000000,
+  VLOAD_64(v16, 0x0000000000000000, 0x1000000000000001, 0x0000f00000000000,
            0x0000000000000000, 0x1000000000000001, 0x0000000000000000,
            0x0000000000000000, 0x1000000000000001, 0x0000000000000000,
            0x0000000000000000, 0x1000000000000001, 0x0000000000000000);
   VLOAD_64(v8, 0x0000000000000007);
-  VLOAD_64(v12, 1);
-  asm volatile("vredor.vs v12, v4, v8, v0.t");
-  VCMP_U64(8, v12, 0x1000000000000007);
+  VLOAD_64(v24, 1);
+  asm volatile("vredor.vs v24, v16, v8, v0.t");
+  VCMP_U64(8, v24, 0x1000000000000007);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vredsum.c b/sw/riscvTests/isa/rv64uv/vredsum.c
index 8b4c9860..4d515878 100644
--- a/sw/riscvTests/isa/rv64uv/vredsum.c
+++ b/sw/riscvTests/isa/rv64uv/vredsum.c
@@ -9,29 +9,29 @@
 // Naive test
 void TEST_CASE1(void) {
   VSET(16, e8, m4);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 1);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U8(1, v12, 73);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U8(1, v24, 73);
 
   VSET(16, e16, m4);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, 1);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U16(2, v12, 73);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U16(2, v24, 73);
 
   VSET(16, e32, m4);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, 1);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U32(3, v12, 73);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U32(3, v24, 73);
 
 #if ELEN == 64
   VSET(16, e64, m4);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, 1);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U64(4, v12, 73);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U64(4, v24, 73);
 #endif
 }
 
@@ -39,109 +39,109 @@ void TEST_CASE1(void) {
 void TEST_CASE2(void) {
   VSET(16, e8, m4);
   VLOAD_8(v0, 0xaa, 0x55);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 1);
-  VLOAD_8(v12, 1);
-  asm volatile("vredsum.vs v12, v4, v8, v0.t");
-  VCMP_U8(5, v12, 37);
+  VLOAD_8(v24, 1);
+  asm volatile("vredsum.vs v24, v16, v8, v0.t");
+  VCMP_U8(5, v24, 37);
 
   VSET(16, e16, m4);
   VLOAD_8(v0, 0xaa, 0x55);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, 1);
-  VLOAD_16(v12, 1);
-  asm volatile("vredsum.vs v12, v4, v8, v0.t");
-  VCMP_U16(6, v12, 37);
+  VLOAD_16(v24, 1);
+  asm volatile("vredsum.vs v24, v16, v8, v0.t");
+  VCMP_U16(6, v24, 37);
 
   VSET(16, e32, m4);
   VLOAD_8(v0, 0xaa, 0x55);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, 1);
-  VLOAD_32(v12, 1);
-  asm volatile("vredsum.vs v12, v4, v8, v0.t");
-  VCMP_U32(7, v12, 37);
+  VLOAD_32(v24, 1);
+  asm volatile("vredsum.vs v24, v16, v8, v0.t");
+  VCMP_U32(7, v24, 37);
 
 #if ELEN == 64
   VSET(16, e64, m4);
   VLOAD_8(v0, 0xaa, 0x55);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, 1);
-  VLOAD_64(v12, 1);
-  asm volatile("vredsum.vs v12, v4, v8, v0.t");
-  VCMP_U64(8, v12, 37);
+  VLOAD_64(v24, 1);
+  asm volatile("vredsum.vs v24, v16, v8, v0.t");
+  VCMP_U64(8, v24, 37);
 #endif
 }
 
 // Are we respecting the undisturbed tail policy?
 void TEST_CASE3(void) {
   VSET(16, e8, m4);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_8(v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U8(9, v12, 73, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U8(9, v24, 73, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 
   VSET(16, e16, m4);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_16(v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U16(10, v12, 73, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U16(10, v24, 73, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 
   VSET(16, e32, m4);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_32(v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U32(11, v12, 73, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U32(11, v24, 73, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 
 #if ELEN == 64
   VSET(16, e64, m4);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_64(v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U64(12, v12, 73, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U64(12, v24, 73, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 #endif
 }
 
 // Odd number of elements, undisturbed policy
 void TEST_CASE4(void) {
   VSET(15, e8, m4);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_8(v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U8(13, v12, 65, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U8(13, v24, 65, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 
   VSET(1, e16, m4);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_16(v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U16(14, v12, 2, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U16(14, v24, 2, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 
   VSET(3, e32, m4);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_32(v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U32(15, v12, 7, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U32(15, v24, 7, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 
 #if ELEN == 64
   VSET(7, e64, m4);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_64(v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U64(16, v12, 29, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U64(16, v24, 29, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 
   VSET(15, e64, m4);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_64(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_64(v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vredsum.vs v12, v4, v8");
-  VCMP_U64(17, v12, 65, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_64(v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vredsum.vs v24, v16, v8");
+  VCMP_U64(17, v24, 65, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 #endif
 }
 
@@ -149,28 +149,28 @@ void TEST_CASE4(void) {
 void TEST_CASE5(void) {
   VSET(15, e8, m4);
   VLOAD_8(v0, 0x00, 0x40);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v8, 100, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_8(v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vredsum.vs v12, v4, v8, v0.t");
-  VCMP_U8(18, v12, 107, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_8(v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vredsum.vs v24, v16, v8, v0.t");
+  VCMP_U8(18, v24, 107, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 
   VSET(1, e16, m4);
   VLOAD_8(v0, 0xaa, 0x55);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_16(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_16(v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vredsum.vs v12, v4, v8, v0.t");
-  VCMP_U16(19, v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_16(v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vredsum.vs v24, v16, v8, v0.t");
+  VCMP_U16(19, v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 
 #if ELEN == 64
   VSET(3, e32, m4);
   VLOAD_8(v0, 0xaa, 0x55);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_32(v8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  VLOAD_32(v12, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vredsum.vs v12, v4, v8, v0.t");
-  VCMP_U32(20, v12, 3, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VLOAD_32(v24, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vredsum.vs v24, v16, v8, v0.t");
+  VCMP_U32(20, v24, 3, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vredxor.c b/sw/riscvTests/isa/rv64uv/vredxor.c
index 89b80e9b..514dd13d 100644
--- a/sw/riscvTests/isa/rv64uv/vredxor.c
+++ b/sw/riscvTests/isa/rv64uv/vredxor.c
@@ -8,31 +8,31 @@
 
 // Naive test
 void TEST_CASE1(void) {
-  VSET(4, e8, m2);
-  VLOAD_8(v4, 0x00, 0x01, 0x01, 0x00);
+  VSET(4, e8, m8);
+  VLOAD_8(v16, 0x00, 0x01, 0x01, 0x00);
   VLOAD_8(v8, 0x11);
-  asm volatile("vredxor.vs v12, v4, v8");
-  VCMP_U8(1, v12, 0x11);
+  asm volatile("vredxor.vs v24, v16, v8");
+  VCMP_U8(1, v24, 0x11);
 
-  VSET(4, e16, m2);
-  VLOAD_16(v4, 0x8000, 0x0301, 0x0101, 0x0001);
+  VSET(4, e16, m8);
+  VLOAD_16(v16, 0x8000, 0x0301, 0x0101, 0x0001);
   VLOAD_16(v8, 0xe001);
-  asm volatile("vredxor.vs v12, v4, v8");
-  VCMP_U16(2, v12, 0x6200);
+  asm volatile("vredxor.vs v24, v16, v8");
+  VCMP_U16(2, v24, 0x6200);
 
-  VSET(4, e32, m2);
-  VLOAD_32(v4, 0x00000001, 0x10000001, 0x00000000, 0x00000000);
+  VSET(4, e32, m8);
+  VLOAD_32(v16, 0x00000001, 0x10000001, 0x00000000, 0x00000000);
   VLOAD_32(v8, 0x00001000);
-  asm volatile("vredxor.vs v12, v4, v8");
-  VCMP_U32(3, v12, 0x10001000);
+  asm volatile("vredxor.vs v24, v16, v8");
+  VCMP_U32(3, v24, 0x10001000);
 
 #if ELEN == 64
-  VSET(4, e64, m2);
-  VLOAD_64(v4, 0x0000000000000000, 0x1000000000000001, 0x0000000000000000,
+  VSET(4, e64, m8);
+  VLOAD_64(v16, 0x0000000000000000, 0x1000000000000001, 0x0000000000000000,
            0x0000000000000000);
   VLOAD_64(v8, 0x0000000000000007);
-  asm volatile("vredxor.vs v12, v4, v8");
-  VCMP_U64(4, v12, 0x1000000000000006);
+  asm volatile("vredxor.vs v24, v16, v8");
+  VCMP_U64(4, v24, 0x1000000000000006);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vrem.c b/sw/riscvTests/isa/rv64uv/vrem.c
index ac36af5f..dbba3fcc 100644
--- a/sw/riscvTests/isa/rv64uv/vrem.c
+++ b/sw/riscvTests/isa/rv64uv/vrem.c
@@ -8,56 +8,56 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x9b, 0x28, 0xec, 0x86, 0x26, 0x85, 0xf7, 0x33, 0x46, 0x37, 0x2c,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x9b, 0x28, 0xec, 0x86, 0x26, 0x85, 0xf7, 0x33, 0x46, 0x37, 0x2c,
           0x0c, 0x8e, 0xae, 0xa1, 0x93);
-  VLOAD_8(v6, 0x84, 0x5e, 0x3b, 0xdf, 0x10, 0xfc, 0x05, 0xcf, 0x42, 0xbe, 0x23,
+  VLOAD_8(v24, 0x84, 0x5e, 0x3b, 0xdf, 0x10, 0xfc, 0x05, 0xcf, 0x42, 0xbe, 0x23,
           0xdb, 0x37, 0x78, 0xe2, 0x85);
-  asm volatile("vrem.vv v2, v4, v6");
-  VCMP_I8(1, v2, 0x9b, 0x28, 0xec, 0xe9, 0x06, 0xfd, 0xfc, 0x02, 0x04, 0x37,
+  asm volatile("vrem.vv v8, v16, v24");
+  VCMP_I8(1, v8, 0x9b, 0x28, 0xec, 0xe9, 0x06, 0xfd, 0xfc, 0x02, 0x04, 0x37,
           0x09, 0x0c, 0xfc, 0xae, 0xfb, 0x93);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xb58f, 0xa184, 0xdcf9, 0xd084, 0xbbc6, 0xcf0e, 0xbbd4, 0xa20c,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xb58f, 0xa184, 0xdcf9, 0xd084, 0xbbc6, 0xcf0e, 0xbbd4, 0xa20c,
            0xe04c, 0xd954, 0xda74, 0xa394, 0x207a, 0x8975, 0xddd3, 0x897d);
-  VLOAD_16(v6, 0x4534, 0xafd7, 0xf703, 0x92c2, 0x97e3, 0xd85a, 0x1540, 0x8c5c,
+  VLOAD_16(v24, 0x4534, 0xafd7, 0xf703, 0x92c2, 0x97e3, 0xd85a, 0x1540, 0x8c5c,
            0x4a71, 0x43a7, 0xe65d, 0x2bdc, 0x497b, 0x6aa0, 0x6071, 0xf431);
-  asm volatile("vrem.vv v2, v4, v6");
-  VCMP_I16(2, v2, 0xfac3, 0xf1ad, 0xf7f0, 0xd084, 0xbbc6, 0xf6b4, 0xfb94,
+  asm volatile("vrem.vv v8, v16, v24");
+  VCMP_I16(2, v8, 0xfac3, 0xf1ad, 0xf7f0, 0xd084, 0xbbc6, 0xf6b4, 0xfb94,
            0xa20c, 0xe04c, 0xd954, 0xf417, 0xfb4c, 0x207a, 0xf415, 0xddd3,
            0xff93);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x620db972, 0x60b1f870, 0x7d1badcf, 0x90a85eb6, 0xca41954b,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x620db972, 0x60b1f870, 0x7d1badcf, 0x90a85eb6, 0xca41954b,
            0x10dc3772, 0xf7749e82, 0x027ed4d3, 0xdcb6a562, 0xa979baf0,
            0xb480c184, 0x979555c6, 0x3f894108, 0x803bd362, 0x9038beec,
            0x22d7ca24);
-  VLOAD_32(v6, 0xb9b52c0c, 0x30b52d8c, 0x832f89ea, 0x95181d9c, 0x85a6a24f,
+  VLOAD_32(v24, 0xb9b52c0c, 0x30b52d8c, 0x832f89ea, 0x95181d9c, 0x85a6a24f,
            0x2f2c64a7, 0xebe4120c, 0x83852646, 0xfb1857b5, 0x25400571,
            0xab2d7393, 0xddb87ac8, 0x01149cdf, 0x62b2c8dc, 0xaed39563,
            0x41ec046e);
-  asm volatile("vrem.vv v2, v4, v6");
-  VCMP_I32(3, v2, 0x1bc2e57e, 0x2ffccae4, 0x004b37b9, 0xfb90411a, 0xca41954b,
+  asm volatile("vrem.vv v8, v16, v24");
+  VCMP_I32(3, v8, 0x1bc2e57e, 0x2ffccae4, 0x004b37b9, 0xfb90411a, 0xca41954b,
            0x10dc3772, 0xf7749e82, 0x027ed4d3, 0xff0c3f6f, 0xf3f9c5d2,
            0xb480c184, 0xfe6be56e, 0x00ddb682, 0xe2ee9c3e, 0xe1652989,
            0x22d7ca24);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x9fc0a4e82116b913, 0xbd1a679edd2667e1, 0x559913931b91caf2,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x9fc0a4e82116b913, 0xbd1a679edd2667e1, 0x559913931b91caf2,
            0xecfe6fb53a8b043d, 0xd8a48a111d080e66, 0x7baccec6b5a29e3e,
            0x8746dc00d1d7ff0b, 0x467babd497d4931b, 0x6f7f3e669faa900c,
            0x36e81d34c3ee3445, 0x99bcc4a480c648c5, 0xc8ae527a2cc4d908,
            0xce3b4c1da847fe6a, 0x3709710bc016c1fc, 0x81471426bbe09e45,
            0x0f0389282729456f);
-  VLOAD_64(v6, 0xf2473f877dd9c3df, 0xd2471da7c8ff8466, 0x7e93451b38765d03,
+  VLOAD_64(v24, 0xf2473f877dd9c3df, 0xd2471da7c8ff8466, 0x7e93451b38765d03,
            0xf7e905f27777369f, 0x73cbef014fd0f311, 0x4c3e4fc36800b443,
            0x4c283e06a5067444, 0xdc8295e57f30e905, 0x08207a363067024e,
            0x42aba773f21efc47, 0x5f00e9093d50b50f, 0x5ff0dcd41bf799fa,
            0xe8c1d1110518742a, 0x34fe1a3555bf07f0, 0xd1bce4800f79700f,
            0xff00f7d87b2c7068);
-  asm volatile("vrem.vv v2, v4, v6");
-  VCMP_I64(4, v2, 0xffcde833b0225dfa, 0xead349f71426e37b, 0x559913931b91caf2,
+  asm volatile("vrem.vv v8, v16, v24");
+  VCMP_I64(4, v8, 0xffcde833b0225dfa, 0xead349f71426e37b, 0x559913931b91caf2,
            0xfd2c63d04b9c96ff, 0xd8a48a111d080e66, 0x2f6e7f034da1e9fb,
            0xd36f1a0776de734f, 0x22fe41ba17057c20, 0x05d909a62a6f7216,
            0x36e81d34c3ee3445, 0xf8bdadadbe16fdd4, 0xc8ae527a2cc4d908,
@@ -67,99 +67,99 @@ void TEST_CASE1(void) {
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x9b, 0x28, 0xec, 0x86, 0x26, 0x85, 0xf7, 0x33, 0x46, 0x37, 0x2c,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x9b, 0x28, 0xec, 0x86, 0x26, 0x85, 0xf7, 0x33, 0x46, 0x37, 0x2c,
           0x0c, 0x8e, 0xae, 0xa1, 0x93);
-  VLOAD_8(v6, 0x84, 0x5e, 0x3b, 0xdf, 0x10, 0xfc, 0x05, 0xcf, 0x42, 0xbe, 0x23,
+  VLOAD_8(v24, 0x84, 0x5e, 0x3b, 0xdf, 0x10, 0xfc, 0x05, 0xcf, 0x42, 0xbe, 0x23,
           0xdb, 0x37, 0x78, 0xe2, 0x85);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vrem.vv v2, v4, v6, v0.t");
-  VCMP_I8(5, v2, 0, 0x28, 0, 0xe9, 0, 0xfd, 0, 0x02, 0, 0x37, 0, 0x0c, 0, 0xae,
+  VCLEAR(v8);
+  asm volatile("vrem.vv v8, v16, v24, v0.t");
+  VCMP_I8(5, v8, 0, 0x28, 0, 0xe9, 0, 0xfd, 0, 0x02, 0, 0x37, 0, 0x0c, 0, 0xae,
           0, 0x93);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xb58f, 0xa184, 0xdcf9, 0xd084, 0xbbc6, 0xcf0e, 0xbbd4, 0xa20c,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xb58f, 0xa184, 0xdcf9, 0xd084, 0xbbc6, 0xcf0e, 0xbbd4, 0xa20c,
            0xe04c, 0xd954, 0xda74, 0xa394, 0x207a, 0x8975, 0xddd3, 0x897d);
-  VLOAD_16(v6, 0x4534, 0xafd7, 0xf703, 0x92c2, 0x97e3, 0xd85a, 0x1540, 0x8c5c,
+  VLOAD_16(v24, 0x4534, 0xafd7, 0xf703, 0x92c2, 0x97e3, 0xd85a, 0x1540, 0x8c5c,
            0x4a71, 0x43a7, 0xe65d, 0x2bdc, 0x497b, 0x6aa0, 0x6071, 0xf431);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vrem.vv v2, v4, v6, v0.t");
-  VCMP_I16(6, v2, 0, 0xf1ad, 0, 0xd084, 0, 0xf6b4, 0, 0xa20c, 0, 0xd954, 0,
+  VCLEAR(v8);
+  asm volatile("vrem.vv v8, v16, v24, v0.t");
+  VCMP_I16(6, v8, 0, 0xf1ad, 0, 0xd084, 0, 0xf6b4, 0, 0xa20c, 0, 0xd954, 0,
            0xfb4c, 0, 0xf415, 0, 0xff93);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x620db972, 0x60b1f870, 0x7d1badcf, 0x90a85eb6, 0xca41954b,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x620db972, 0x60b1f870, 0x7d1badcf, 0x90a85eb6, 0xca41954b,
            0x10dc3772, 0xf7749e82, 0x027ed4d3, 0xdcb6a562, 0xa979baf0,
            0xb480c184, 0x979555c6, 0x3f894108, 0x803bd362, 0x9038beec,
            0x22d7ca24);
-  VLOAD_32(v6, 0xb9b52c0c, 0x30b52d8c, 0x832f89ea, 0x95181d9c, 0x85a6a24f,
+  VLOAD_32(v24, 0xb9b52c0c, 0x30b52d8c, 0x832f89ea, 0x95181d9c, 0x85a6a24f,
            0x2f2c64a7, 0xebe4120c, 0x83852646, 0xfb1857b5, 0x25400571,
            0xab2d7393, 0xddb87ac8, 0x01149cdf, 0x62b2c8dc, 0xaed39563,
            0x41ec046e);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vrem.vv v2, v4, v6, v0.t");
-  VCMP_I32(7, v2, 0, 0x2ffccae4, 0, 0xfb90411a, 0, 0x10dc3772, 0, 0x027ed4d3, 0,
+  VCLEAR(v8);
+  asm volatile("vrem.vv v8, v16, v24, v0.t");
+  VCMP_I32(7, v8, 0, 0x2ffccae4, 0, 0xfb90411a, 0, 0x10dc3772, 0, 0x027ed4d3, 0,
            0xf3f9c5d2, 0, 0xfe6be56e, 0, 0xe2ee9c3e, 0, 0x22d7ca24);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x9fc0a4e82116b913, 0xbd1a679edd2667e1, 0x559913931b91caf2,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x9fc0a4e82116b913, 0xbd1a679edd2667e1, 0x559913931b91caf2,
            0xecfe6fb53a8b043d, 0xd8a48a111d080e66, 0x7baccec6b5a29e3e,
            0x8746dc00d1d7ff0b, 0x467babd497d4931b, 0x6f7f3e669faa900c,
            0x36e81d34c3ee3445, 0x99bcc4a480c648c5, 0xc8ae527a2cc4d908,
            0xce3b4c1da847fe6a, 0x3709710bc016c1fc, 0x81471426bbe09e45,
            0x0f0389282729456f);
-  VLOAD_64(v6, 0xf2473f877dd9c3df, 0xd2471da7c8ff8466, 0x7e93451b38765d03,
+  VLOAD_64(v24, 0xf2473f877dd9c3df, 0xd2471da7c8ff8466, 0x7e93451b38765d03,
            0xf7e905f27777369f, 0x73cbef014fd0f311, 0x4c3e4fc36800b443,
            0x4c283e06a5067444, 0xdc8295e57f30e905, 0x08207a363067024e,
            0x42aba773f21efc47, 0x5f00e9093d50b50f, 0x5ff0dcd41bf799fa,
            0xe8c1d1110518742a, 0x34fe1a3555bf07f0, 0xd1bce4800f79700f,
            0xff00f7d87b2c7068);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vrem.vv v2, v4, v6, v0.t");
-  VCMP_I64(8, v2, 0, 0xead349f71426e37b, 0, 0xfd2c63d04b9c96ff, 0,
+  VCLEAR(v8);
+  asm volatile("vrem.vv v8, v16, v24, v0.t");
+  VCMP_I64(8, v8, 0, 0xead349f71426e37b, 0, 0xfd2c63d04b9c96ff, 0,
            0x2f6e7f034da1e9fb, 0, 0x22fe41ba17057c20, 0, 0x36e81d34c3ee3445, 0,
            0xc8ae527a2cc4d908, 0, 0x020b56d66a57ba0c, 0, 0x00120ed75ec3db87);
 #endif
 };
 
 void TEST_CASE3(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x5b, 0x3b, 0xc4, 0x95, 0x41, 0x71, 0x9b, 0x67, 0x84, 0x2e, 0x0a,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x5b, 0x3b, 0xc4, 0x95, 0x41, 0x71, 0x9b, 0x67, 0x84, 0x2e, 0x0a,
           0x2a, 0xb2, 0x57, 0xe5, 0x6c);
   int64_t scalar = 5;
-  asm volatile("vrem.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I8(9, v2, 0x01, 0x04, 0x00, 0xfe, 0x00, 0x03, 0xff, 0x03, 0xfc, 0x01,
+  asm volatile("vrem.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I8(9, v8, 0x01, 0x04, 0x00, 0xfe, 0x00, 0x03, 0xff, 0x03, 0xfc, 0x01,
           0x00, 0x02, 0xfd, 0x02, 0xfe, 0x03);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xc670, 0x8f3b, 0x200f, 0x52ea, 0xfdce, 0xcf06, 0x57f1, 0x1936,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xc670, 0x8f3b, 0x200f, 0x52ea, 0xfdce, 0xcf06, 0x57f1, 0x1936,
            0xb6ec, 0x69e8, 0x0abf, 0x441e, 0xa420, 0x396c, 0xe7c9, 0xa464);
   scalar = -538;
-  asm volatile("vrem.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I16(10, v2, 0xff2e, 0xfe9d, 0x0089, 0x00f4, 0xffe8, 0xff5c, 0x01c7,
+  asm volatile("vrem.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I16(10, v8, 0xff2e, 0xfe9d, 0x0089, 0x00f4, 0xffe8, 0xff5c, 0x01c7,
            0x0218, 0xfe60, 0x00d4, 0x003d, 0x00de, 0xfe7e, 0x00ae, 0xfee7,
            0xfec2);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xf937dbf9, 0x6d855b59, 0x3bd09126, 0xaed11886, 0x6eb6f4bd,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xf937dbf9, 0x6d855b59, 0x3bd09126, 0xaed11886, 0x6eb6f4bd,
            0x5c639253, 0xca0f2abf, 0x57fec97b, 0x39496099, 0x8bfcdd58,
            0x0f19f6e2, 0x2070c8d4, 0x8c689324, 0x2eecd9d7, 0xe2907e94,
            0xb6cc2d44);
   scalar = 649;
-  asm volatile("vrem.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I32(11, v2, 0xfffffee4, 0x00000116, 0x00000160, 0xffffffef, 0x00000217,
+  asm volatile("vrem.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I32(11, v8, 0xfffffee4, 0x00000116, 0x00000160, 0xffffffef, 0x00000217,
            0x00000275, 0xfffffea6, 0x000000a9, 0x000000e4, 0xfffffe09,
            0x00000272, 0x0000023c, 0xffffff79, 0x000000ce, 0xffffffb3,
            0xfffffe0e);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
-  /*   VLOAD_64(v4, 0x94236504e03e6525, 0x8d219d7afe5b2fb0, 0xc65a0b252860ab73,
+  /*   VSET(16, e64, m8); */
+  /*   VLOAD_64(v16, 0x94236504e03e6525, 0x8d219d7afe5b2fb0, 0xc65a0b252860ab73,
    */
   /*            0x2ca68636bacbc0bb, 0x275575f3e3fea940, 0x8f546251aaad354a, */
   /*            0xb1462969035e0fa7, 0x5c9cdc19273ce111, 0x25a8487741ee75db, */
@@ -167,8 +167,8 @@ void TEST_CASE3(void) {
   /*            0xb308a4fe0dcbb2f3, 0xf2fa735abc2db4d0, 0xc73c476461ac3f28, */
   /*            0xb2830c2607bfffcc); */
   /*   scalar = -59223; */
-  /*   asm volatile("vrem.vx v2, v4, %[A]" ::[A] "r"(scalar)); */
-  /*   VCMP_I64(12, v2, 0xffffffffffff299e, 0xffffffffffff1f8a,
+  /*   asm volatile("vrem.vx v8, v16, %[A]" ::[A] "r"(scalar)); */
+  /*   VCMP_I64(12, v8, 0xffffffffffff299e, 0xffffffffffff1f8a,
    * 0xffffffffffff57aa, */
   /*            0x000000000000cc8c, 0x000000000000416e, 0xffffffffffffcecd, */
   /*            0xffffffffffff7e24, 0x000000000000397b, 0x000000000000bb50, */
@@ -179,41 +179,41 @@ void TEST_CASE3(void) {
 };
 
 void TEST_CASE4(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x5b, 0x3b, 0xc4, 0x95, 0x41, 0x71, 0x9b, 0x67, 0x84, 0x2e, 0x0a,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x5b, 0x3b, 0xc4, 0x95, 0x41, 0x71, 0x9b, 0x67, 0x84, 0x2e, 0x0a,
           0x2a, 0xb2, 0x57, 0xe5, 0x6c);
   int64_t scalar = 5;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vrem.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I8(13, v2, 0, 0x04, 0, 0xfe, 0, 0x03, 0, 0x03, 0, 0x01, 0, 0x02, 0, 0x02,
+  VCLEAR(v8);
+  asm volatile("vrem.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I8(13, v8, 0, 0x04, 0, 0xfe, 0, 0x03, 0, 0x03, 0, 0x01, 0, 0x02, 0, 0x02,
           0, 0x03);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xc670, 0x8f3b, 0x200f, 0x52ea, 0xfdce, 0xcf06, 0x57f1, 0x1936,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xc670, 0x8f3b, 0x200f, 0x52ea, 0xfdce, 0xcf06, 0x57f1, 0x1936,
            0xb6ec, 0x69e8, 0x0abf, 0x441e, 0xa420, 0x396c, 0xe7c9, 0xa464);
   scalar = -538;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vrem.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I16(14, v2, 0, 0xfe9d, 0, 0x00f4, 0, 0xff5c, 0, 0x0218, 0, 0x00d4, 0,
+  VCLEAR(v8);
+  asm volatile("vrem.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I16(14, v8, 0, 0xfe9d, 0, 0x00f4, 0, 0xff5c, 0, 0x0218, 0, 0x00d4, 0,
            0x00de, 0, 0x00ae, 0, 0xfec2);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0xf937dbf9, 0x6d855b59, 0x3bd09126, 0xaed11886, 0x6eb6f4bd,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0xf937dbf9, 0x6d855b59, 0x3bd09126, 0xaed11886, 0x6eb6f4bd,
            0x5c639253, 0xca0f2abf, 0x57fec97b, 0x39496099, 0x8bfcdd58,
            0x0f19f6e2, 0x2070c8d4, 0x8c689324, 0x2eecd9d7, 0xe2907e94,
            0xb6cc2d44);
   scalar = 649;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vrem.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I32(15, v2, 0, 0x00000116, 0, 0xffffffef, 0, 0x00000275, 0, 0x000000a9,
+  VCLEAR(v8);
+  asm volatile("vrem.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I32(15, v8, 0, 0x00000116, 0, 0xffffffef, 0, 0x00000275, 0, 0x000000a9,
            0, 0xfffffe09, 0, 0x0000023c, 0, 0x000000ce, 0, 0xfffffe0e);
 
   /* #if ELEN == 64 */
-  /*   VSET(16, e64, m2); */
-  /*   VLOAD_64(v4, 0x94236504e03e6525, 0x8d219d7afe5b2fb0, 0xc65a0b252860ab73,
+  /*   VSET(16, e64, m8); */
+  /*   VLOAD_64(v16, 0x94236504e03e6525, 0x8d219d7afe5b2fb0, 0xc65a0b252860ab73,
    */
   /*            0x2ca68636bacbc0bb, 0x275575f3e3fea940, 0x8f546251aaad354a, */
   /*            0xb1462969035e0fa7, 0x5c9cdc19273ce111, 0x25a8487741ee75db, */
@@ -222,9 +222,9 @@ void TEST_CASE4(void) {
   /*            0xb2830c2607bfffcc); */
   /*   scalar = -59223; */
   /*   VLOAD_8(v0, 0xAA, 0xAA); */
-  /*   VCLEAR(v2); */
-  /*   asm volatile("vrem.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar)); */
-  /*   VCMP_I64(16, v2, 0, 0xffffffffffff1f8a, 0, 0x000000000000cc8c, 0, */
+  /*   VCLEAR(v8); */
+  /*   asm volatile("vrem.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar)); */
+  /*   VCMP_I64(16, v8, 0, 0xffffffffffff1f8a, 0, 0x000000000000cc8c, 0, */
   /*            0xffffffffffffcecd, 0, 0x000000000000397b, 0,
    * 0x0000000000006b00, 0, */
   /*            0xffffffffffff9a21, 0, 0xffffffffffffca84, 0,
diff --git a/sw/riscvTests/isa/rv64uv/vremu.c b/sw/riscvTests/isa/rv64uv/vremu.c
index 42080aa6..fc71fd64 100644
--- a/sw/riscvTests/isa/rv64uv/vremu.c
+++ b/sw/riscvTests/isa/rv64uv/vremu.c
@@ -8,56 +8,56 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x11, 0xd2, 0x6a, 0xcc, 0x14, 0xe4, 0x2c, 0x7f, 0xd2, 0x6b, 0x34,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x11, 0xd2, 0x6a, 0xcc, 0x14, 0xe4, 0x2c, 0x7f, 0xd2, 0x6b, 0x34,
           0x5c, 0x75, 0xdd, 0x0c, 0x42);
-  VLOAD_8(v6, 0x77, 0xb2, 0xd1, 0x95, 0x6f, 0xbe, 0x0d, 0x5a, 0x93, 0x02, 0xaf,
+  VLOAD_8(v24, 0x77, 0xb2, 0xd1, 0x95, 0x6f, 0xbe, 0x0d, 0x5a, 0x93, 0x02, 0xaf,
           0xfd, 0x94, 0xe0, 0xb7, 0xe6);
-  asm volatile("vremu.vv v2, v4, v6");
-  VCMP_I8(1, v2, 0x11, 0x20, 0x6a, 0x37, 0x14, 0x26, 0x05, 0x25, 0x3f, 0x01,
+  asm volatile("vremu.vv v8, v16, v24");
+  VCMP_I8(1, v8, 0x11, 0x20, 0x6a, 0x37, 0x14, 0x26, 0x05, 0x25, 0x3f, 0x01,
           0x34, 0x5c, 0x75, 0xdd, 0x0c, 0x42);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xf77a, 0x54d7, 0xe527, 0xe28f, 0x53ed, 0x9301, 0xde4f, 0xcb17,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xf77a, 0x54d7, 0xe527, 0xe28f, 0x53ed, 0x9301, 0xde4f, 0xcb17,
            0xae43, 0x9e4a, 0xa0c2, 0xdf31, 0xb66f, 0x286d, 0x1d15, 0x0480);
-  VLOAD_16(v6, 0x5bfa, 0x0571, 0x8a43, 0x6350, 0xb962, 0x71fc, 0x0b54, 0x1e8b,
+  VLOAD_16(v24, 0x5bfa, 0x0571, 0x8a43, 0x6350, 0xb962, 0x71fc, 0x0b54, 0x1e8b,
            0x6c25, 0x9c0d, 0x5950, 0x1887, 0xbc18, 0x628e, 0x6561, 0x407f);
-  asm volatile("vremu.vv v2, v4, v6");
-  VCMP_I16(2, v2, 0x3f86, 0x0338, 0x5ae4, 0x1bef, 0x53ed, 0x2105, 0x0713,
+  asm volatile("vremu.vv v8, v16, v24");
+  VCMP_I16(2, v8, 0x3f86, 0x0338, 0x5ae4, 0x1bef, 0x53ed, 0x2105, 0x0713,
            0x13d5, 0x421e, 0x023d, 0x4772, 0x0272, 0xb66f, 0x286d, 0x1d15,
            0x0480);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x647d8841, 0xf9e0aabf, 0xea4aa122, 0xd6178d3e, 0x64a7afe5,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x647d8841, 0xf9e0aabf, 0xea4aa122, 0xd6178d3e, 0x64a7afe5,
            0xe0350cba, 0xc72768ec, 0x9f977a31, 0x5e1c2ac4, 0xcd44b950,
            0x39dc32f4, 0x1dc82ea3, 0xd1cf125f, 0xc677269c, 0x6405ec5b,
            0x653a05ee);
-  VLOAD_32(v6, 0x89828d99, 0x5c7c7db0, 0x2911efb6, 0x1f6982ff, 0x564e4bd4,
+  VLOAD_32(v24, 0x89828d99, 0x5c7c7db0, 0x2911efb6, 0x1f6982ff, 0x564e4bd4,
            0xc4576bff, 0x8e998104, 0x4a23ba44, 0x994b4630, 0x017ee935,
            0xa38c7dae, 0x893dfb15, 0x4969125f, 0x9a951d27, 0x09b6017f,
            0x5a0a7906);
-  asm volatile("vremu.vv v2, v4, v6");
-  VCMP_I32(3, v2, 0x647d8841, 0x40e7af5f, 0x1cf0f294, 0x199e7b44, 0x0e596411,
+  asm volatile("vremu.vv v8, v16, v24");
+  VCMP_I32(3, v8, 0x647d8841, 0x40e7af5f, 0x1cf0f294, 0x199e7b44, 0x0e596411,
            0x1bdda0bb, 0x388de7e8, 0x0b5005a9, 0x5e1c2ac4, 0x0059ebf3,
            0x39dc32f4, 0x1dc82ea3, 0x3efceda1, 0x2be20975, 0x02e9dd65,
            0x0b2f8ce8);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x09ab27501ccac4a6, 0x97eb5bf189b39a0e, 0x26f588069b0858c4,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x09ab27501ccac4a6, 0x97eb5bf189b39a0e, 0x26f588069b0858c4,
            0x9a251c274a394df3, 0x54b3587602f8d9d2, 0xc3cc623deda95ca7,
            0x118c4335397980bf, 0xc3e2d283cb39133d, 0x71837e24114813fc,
            0x85a1f65867438a09, 0x80f01e0588afc9a0, 0x60e89a1e5a43d9f5,
            0x93a87cf6308ad888, 0xca3976f49ac6a681, 0xcfc7c8f225b47766,
            0xeaa4ce2cf507b527);
-  VLOAD_64(v6, 0x9fed81c550326301, 0x445bb7ac18d0eaa1, 0x040f8ff58f5adf72,
+  VLOAD_64(v24, 0x9fed81c550326301, 0x445bb7ac18d0eaa1, 0x040f8ff58f5adf72,
            0xafc4ff6b8eb4d201, 0xfba36cabfc3fb4a0, 0x9c3ed271bf173d29,
            0xe8b7e325c9ff594b, 0x05169e56693600d7, 0x08e72c4bb62ad267,
            0xbd9677ee996d5fa5, 0x900295e8502a9817, 0x39e0bfa9927679a8,
            0xdd0ca7797d532524, 0x6f8f78c47ddee88a, 0x2f40f7661cca9eee,
            0x8e4a3b2358129e92);
-  asm volatile("vremu.vv v2, v4, v6");
-  VCMP_I64(4, v2, 0x09ab27501ccac4a6, 0x0f33ec995811c4cc, 0x0269786490d67dc2,
+  asm volatile("vremu.vv v8, v16, v24");
+  VCMP_I64(4, v8, 0x09ab27501ccac4a6, 0x0f33ec995811c4cc, 0x0269786490d67dc2,
            0x9a251c274a394df3, 0x54b3587602f8d9d2, 0x278d8fcc2e921f7e,
            0x118c4335397980bf, 0x028751b02d34f353, 0x06ad6a9787463728,
            0x85a1f65867438a09, 0x80f01e0588afc9a0, 0x2707da74c7cd604d,
@@ -67,107 +67,107 @@ void TEST_CASE1(void) {
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x11, 0xd2, 0x6a, 0xcc, 0x14, 0xe4, 0x2c, 0x7f, 0xd2, 0x6b, 0x34,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x11, 0xd2, 0x6a, 0xcc, 0x14, 0xe4, 0x2c, 0x7f, 0xd2, 0x6b, 0x34,
           0x5c, 0x75, 0xdd, 0x0c, 0x42);
-  VLOAD_8(v6, 0x77, 0xb2, 0xd1, 0x95, 0x6f, 0xbe, 0x0d, 0x5a, 0x93, 0x02, 0xaf,
+  VLOAD_8(v24, 0x77, 0xb2, 0xd1, 0x95, 0x6f, 0xbe, 0x0d, 0x5a, 0x93, 0x02, 0xaf,
           0xfd, 0x94, 0xe0, 0xb7, 0xe6);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vremu.vv v2, v4, v6, v0.t");
-  VCMP_I8(5, v2, 0, 0x20, 0, 0x37, 0, 0x26, 0, 0x25, 0, 0x01, 0, 0x5c, 0, 0xdd,
+  VCLEAR(v8);
+  asm volatile("vremu.vv v8, v16, v24, v0.t");
+  VCMP_I8(5, v8, 0, 0x20, 0, 0x37, 0, 0x26, 0, 0x25, 0, 0x01, 0, 0x5c, 0, 0xdd,
           0, 0x42);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xf77a, 0x54d7, 0xe527, 0xe28f, 0x53ed, 0x9301, 0xde4f, 0xcb17,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xf77a, 0x54d7, 0xe527, 0xe28f, 0x53ed, 0x9301, 0xde4f, 0xcb17,
            0xae43, 0x9e4a, 0xa0c2, 0xdf31, 0xb66f, 0x286d, 0x1d15, 0x0480);
-  VLOAD_16(v6, 0x5bfa, 0x0571, 0x8a43, 0x6350, 0xb962, 0x71fc, 0x0b54, 0x1e8b,
+  VLOAD_16(v24, 0x5bfa, 0x0571, 0x8a43, 0x6350, 0xb962, 0x71fc, 0x0b54, 0x1e8b,
            0x6c25, 0x9c0d, 0x5950, 0x1887, 0xbc18, 0x628e, 0x6561, 0x407f);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vremu.vv v2, v4, v6, v0.t");
-  VCMP_I16(6, v2, 0, 0x0338, 0, 0x1bef, 0, 0x2105, 0, 0x13d5, 0, 0x023d, 0,
+  VCLEAR(v8);
+  asm volatile("vremu.vv v8, v16, v24, v0.t");
+  VCMP_I16(6, v8, 0, 0x0338, 0, 0x1bef, 0, 0x2105, 0, 0x13d5, 0, 0x023d, 0,
            0x0272, 0, 0x286d, 0, 0x0480);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x647d8841, 0xf9e0aabf, 0xea4aa122, 0xd6178d3e, 0x64a7afe5,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x647d8841, 0xf9e0aabf, 0xea4aa122, 0xd6178d3e, 0x64a7afe5,
            0xe0350cba, 0xc72768ec, 0x9f977a31, 0x5e1c2ac4, 0xcd44b950,
            0x39dc32f4, 0x1dc82ea3, 0xd1cf125f, 0xc677269c, 0x6405ec5b,
            0x653a05ee);
-  VLOAD_32(v6, 0x89828d99, 0x5c7c7db0, 0x2911efb6, 0x1f6982ff, 0x564e4bd4,
+  VLOAD_32(v24, 0x89828d99, 0x5c7c7db0, 0x2911efb6, 0x1f6982ff, 0x564e4bd4,
            0xc4576bff, 0x8e998104, 0x4a23ba44, 0x994b4630, 0x017ee935,
            0xa38c7dae, 0x893dfb15, 0x4969125f, 0x9a951d27, 0x09b6017f,
            0x5a0a7906);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vremu.vv v2, v4, v6, v0.t");
-  VCMP_I32(7, v2, 0, 0x40e7af5f, 0, 0x199e7b44, 0, 0x1bdda0bb, 0, 0x0b5005a9, 0,
+  VCLEAR(v8);
+  asm volatile("vremu.vv v8, v16, v24, v0.t");
+  VCMP_I32(7, v8, 0, 0x40e7af5f, 0, 0x199e7b44, 0, 0x1bdda0bb, 0, 0x0b5005a9, 0,
            0x0059ebf3, 0, 0x1dc82ea3, 0, 0x2be20975, 0, 0x0b2f8ce8);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x09ab27501ccac4a6, 0x97eb5bf189b39a0e, 0x26f588069b0858c4,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x09ab27501ccac4a6, 0x97eb5bf189b39a0e, 0x26f588069b0858c4,
            0x9a251c274a394df3, 0x54b3587602f8d9d2, 0xc3cc623deda95ca7,
            0x118c4335397980bf, 0xc3e2d283cb39133d, 0x71837e24114813fc,
            0x85a1f65867438a09, 0x80f01e0588afc9a0, 0x60e89a1e5a43d9f5,
            0x93a87cf6308ad888, 0xca3976f49ac6a681, 0xcfc7c8f225b47766,
            0xeaa4ce2cf507b527);
-  VLOAD_64(v6, 0x9fed81c550326301, 0x445bb7ac18d0eaa1, 0x040f8ff58f5adf72,
+  VLOAD_64(v24, 0x9fed81c550326301, 0x445bb7ac18d0eaa1, 0x040f8ff58f5adf72,
            0xafc4ff6b8eb4d201, 0xfba36cabfc3fb4a0, 0x9c3ed271bf173d29,
            0xe8b7e325c9ff594b, 0x05169e56693600d7, 0x08e72c4bb62ad267,
            0xbd9677ee996d5fa5, 0x900295e8502a9817, 0x39e0bfa9927679a8,
            0xdd0ca7797d532524, 0x6f8f78c47ddee88a, 0x2f40f7661cca9eee,
            0x8e4a3b2358129e92);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vremu.vv v2, v4, v6, v0.t");
-  VCMP_I64(8, v2, 0, 0x0f33ec995811c4cc, 0, 0x9a251c274a394df3, 0,
+  VCLEAR(v8);
+  asm volatile("vremu.vv v8, v16, v24, v0.t");
+  VCMP_I64(8, v8, 0, 0x0f33ec995811c4cc, 0, 0x9a251c274a394df3, 0,
            0x278d8fcc2e921f7e, 0, 0x028751b02d34f353, 0, 0x85a1f65867438a09, 0,
            0x2707da74c7cd604d, 0, 0x5aa9fe301ce7bdf7, 0, 0x5c5a93099cf51695);
 #endif
 };
 
 void TEST_CASE3(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x98, 0x1a, 0xbe, 0x48, 0x7c, 0xd9, 0x5e, 0x58, 0x2e, 0x46, 0x0c,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x98, 0x1a, 0xbe, 0x48, 0x7c, 0xd9, 0x5e, 0x58, 0x2e, 0x46, 0x0c,
           0x24, 0xc5, 0x2b, 0x37, 0xbe);
   uint64_t scalar = 5;
-  asm volatile("vremu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I8(9, v2, 0x02, 0x01, 0x00, 0x02, 0x04, 0x02, 0x04, 0x03, 0x01, 0x00,
+  asm volatile("vremu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I8(9, v8, 0x02, 0x01, 0x00, 0x02, 0x04, 0x02, 0x04, 0x03, 0x01, 0x00,
           0x02, 0x01, 0x02, 0x03, 0x00, 0x00);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xf11f, 0xb8cd, 0xb686, 0xc226, 0xc35a, 0xd724, 0x03f1, 0xcf10,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xf11f, 0xb8cd, 0xb686, 0xc226, 0xc35a, 0xd724, 0x03f1, 0xcf10,
            0xbae0, 0x9f01, 0x1d0f, 0xf53c, 0x5461, 0x341e, 0x9ae7, 0x032b);
   scalar = 538;
-  asm volatile("vremu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I16(10, v2, 0x018b, 0x01f7, 0x01ca, 0x00ce, 0x0202, 0x00c8, 0x01d7,
+  asm volatile("vremu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I16(10, v8, 0x018b, 0x01f7, 0x01ca, 0x00ce, 0x0202, 0x00c8, 0x01d7,
            0x011c, 0x01f0, 0x0163, 0x01bd, 0x0174, 0x0051, 0x01ae, 0x017d,
            0x0111);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x9c36da54, 0x1b1dea93, 0x80be8651, 0x03a23fcf, 0x26973d17,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x9c36da54, 0x1b1dea93, 0x80be8651, 0x03a23fcf, 0x26973d17,
            0x521f01df, 0x09e8f77a, 0x5b231aa2, 0xd4bea1df, 0x529b4f34,
            0x800a5d88, 0xe7b02512, 0xf7954032, 0x48652b8c, 0x8b14b883,
            0x121a9b8b);
   scalar = 649;
-  asm volatile("vremu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I32(11, v2, 0x00000039, 0x00000141, 0x0000020b, 0x0000015f, 0x0000008a,
+  asm volatile("vremu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I32(11, v8, 0x00000039, 0x00000141, 0x0000020b, 0x0000015f, 0x0000008a,
            0x00000199, 0x00000214, 0x0000006c, 0x0000025d, 0x000001a6,
            0x000000d2, 0x00000168, 0x000001e6, 0x00000266, 0x00000188,
            0x00000159);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x1882c5f4b911b949, 0x6ca37133428ed155, 0xbacb9408aa8251bf,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x1882c5f4b911b949, 0x6ca37133428ed155, 0xbacb9408aa8251bf,
            0x62d79deed97681f5, 0x56258335e007492c, 0x2428afa90a14fa61,
            0xd62824119c3084c6, 0xef97986ae9ea2da7, 0xfc28c84e37024f10,
            0x1f475f820dec67e1, 0x9c180cfef468c050, 0x4be017933813e27e,
            0xafd2b5edb83df693, 0xddd4766a628d4c30, 0xa1f4d0f48a6ac917,
            0x827a07db9e6a8897);
   scalar = 9223;
-  asm volatile("vremu.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_I64(12, v2, 0x000000000000167d, 0x00000000000015f2, 0x00000000000019be,
+  asm volatile("vremu.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_I64(12, v8, 0x000000000000167d, 0x00000000000015f2, 0x00000000000019be,
            0x00000000000003fd, 0x00000000000010ce, 0x0000000000001863,
            0x0000000000000750, 0x0000000000000062, 0x0000000000002237,
            0x00000000000002bc, 0x0000000000000061, 0x0000000000001b82,
@@ -177,41 +177,41 @@ void TEST_CASE3(void) {
 };
 
 void TEST_CASE4(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x98, 0x1a, 0xbe, 0x48, 0x7c, 0xd9, 0x5e, 0x58, 0x2e, 0x46, 0x0c,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x98, 0x1a, 0xbe, 0x48, 0x7c, 0xd9, 0x5e, 0x58, 0x2e, 0x46, 0x0c,
           0x24, 0xc5, 0x2b, 0x37, 0xbe);
   uint64_t scalar = 5;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vremu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I8(13, v2, 0, 0x01, 0, 0x02, 0, 0x02, 0, 0x03, 0, 0x00, 0, 0x01, 0, 0x03,
+  VCLEAR(v8);
+  asm volatile("vremu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I8(13, v8, 0, 0x01, 0, 0x02, 0, 0x02, 0, 0x03, 0, 0x00, 0, 0x01, 0, 0x03,
           0, 0x00);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0xf11f, 0xb8cd, 0xb686, 0xc226, 0xc35a, 0xd724, 0x03f1, 0xcf10,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0xf11f, 0xb8cd, 0xb686, 0xc226, 0xc35a, 0xd724, 0x03f1, 0xcf10,
            0xbae0, 0x9f01, 0x1d0f, 0xf53c, 0x5461, 0x341e, 0x9ae7, 0x032b);
   scalar = 538;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vremu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I16(14, v2, 0, 0x01f7, 0, 0x00ce, 0, 0x00c8, 0, 0x011c, 0, 0x0163, 0,
+  VCLEAR(v8);
+  asm volatile("vremu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I16(14, v8, 0, 0x01f7, 0, 0x00ce, 0, 0x00c8, 0, 0x011c, 0, 0x0163, 0,
            0x0174, 0, 0x01ae, 0, 0x0111);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x9c36da54, 0x1b1dea93, 0x80be8651, 0x03a23fcf, 0x26973d17,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x9c36da54, 0x1b1dea93, 0x80be8651, 0x03a23fcf, 0x26973d17,
            0x521f01df, 0x09e8f77a, 0x5b231aa2, 0xd4bea1df, 0x529b4f34,
            0x800a5d88, 0xe7b02512, 0xf7954032, 0x48652b8c, 0x8b14b883,
            0x121a9b8b);
   scalar = 649;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vremu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I32(15, v2, 0, 0x00000141, 0, 0x0000015f, 0, 0x00000199, 0, 0x0000006c,
+  VCLEAR(v8);
+  asm volatile("vremu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I32(15, v8, 0, 0x00000141, 0, 0x0000015f, 0, 0x00000199, 0, 0x0000006c,
            0, 0x000001a6, 0, 0x00000168, 0, 0x00000266, 0, 0x00000159);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x1882c5f4b911b949, 0x6ca37133428ed155, 0xbacb9408aa8251bf,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x1882c5f4b911b949, 0x6ca37133428ed155, 0xbacb9408aa8251bf,
            0x62d79deed97681f5, 0x56258335e007492c, 0x2428afa90a14fa61,
            0xd62824119c3084c6, 0xef97986ae9ea2da7, 0xfc28c84e37024f10,
            0x1f475f820dec67e1, 0x9c180cfef468c050, 0x4be017933813e27e,
@@ -219,9 +219,9 @@ void TEST_CASE4(void) {
            0x827a07db9e6a8897);
   scalar = 9223;
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v2);
-  asm volatile("vremu.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_I64(16, v2, 0, 0x00000000000015f2, 0, 0x00000000000003fd, 0,
+  VCLEAR(v8);
+  asm volatile("vremu.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_I64(16, v8, 0, 0x00000000000015f2, 0, 0x00000000000003fd, 0,
            0x0000000000001863, 0, 0x0000000000000062, 0, 0x00000000000002bc, 0,
            0x0000000000001b82, 0, 0x0000000000000fb7, 0, 0x0000000000000545);
 #endif
diff --git a/sw/riscvTests/isa/rv64uv/vrsub.c b/sw/riscvTests/isa/rv64uv/vrsub.c
index cdefddb3..25fd0e6e 100644
--- a/sw/riscvTests/isa/rv64uv/vrsub.c
+++ b/sw/riscvTests/isa/rv64uv/vrsub.c
@@ -8,91 +8,91 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  asm volatile("vrsub.vi v6, v2, 10");
-  VCMP_U8(1, v6, 5, 0, -5, -10, -15, -20, -25, -30, 5, 0, -5, -10, -15, -20,
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  asm volatile("vrsub.vi v24, v8, 10");
+  VCMP_U8(1, v24, 5, 0, -5, -10, -15, -20, -25, -30, 5, 0, -5, -10, -15, -20,
           -25, -30);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  asm volatile("vrsub.vi v6, v2, 10");
-  VCMP_U16(2, v6, 5, 0, -5, -10, -15, -20, -25, -30, 5, 0, -5, -10, -15, -20,
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  asm volatile("vrsub.vi v24, v8, 10");
+  VCMP_U16(2, v24, 5, 0, -5, -10, -15, -20, -25, -30, 5, 0, -5, -10, -15, -20,
            -25, -30);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  asm volatile("vrsub.vi v6, v2, 10");
-  VCMP_U32(3, v6, 5, 0, -5, -10, -15, -20, -25, -30, 5, 0, -5, -10, -15, -20,
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  asm volatile("vrsub.vi v24, v8, 10");
+  VCMP_U32(3, v24, 5, 0, -5, -10, -15, -20, -25, -30, 5, 0, -5, -10, -15, -20,
            -25, -30);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  asm volatile("vrsub.vi v6, v2, 10");
-  VCMP_U64(4, v6, 5, 0, -5, -10, -15, -20, -25, -30, 5, 0, -5, -10, -15, -20,
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  asm volatile("vrsub.vi v24, v8, 10");
+  VCMP_U64(4, v24, 5, 0, -5, -10, -15, -20, -25, -30, 5, 0, -5, -10, -15, -20,
            -25, -30);
 #endif
 }
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
   VLOAD_8(v0, 0x33, 0x33);
-  VCLEAR(v6);
-  asm volatile("vrsub.vi v6, v2, 10, v0.t");
-  VCMP_U8(5, v6, 5, 0, 0, 0, -15, -20, 0, 0, 5, 0, 0, 0, -15, -20, 0, 0);
+  VCLEAR(v24);
+  asm volatile("vrsub.vi v24, v8, 10, v0.t");
+  VCMP_U8(5, v24, 5, 0, 0, 0, -15, -20, 0, 0, 5, 0, 0, 0, -15, -20, 0, 0);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
   VLOAD_8(v0, 0x33, 0x33);
-  VCLEAR(v6);
-  asm volatile("vrsub.vi v6, v2, 10, v0.t");
-  VCMP_U16(6, v6, 5, 0, 0, 0, -15, -20, 0, 0, 5, 0, 0, 0, -15, -20, 0, 0);
+  VCLEAR(v24);
+  asm volatile("vrsub.vi v24, v8, 10, v0.t");
+  VCMP_U16(6, v24, 5, 0, 0, 0, -15, -20, 0, 0, 5, 0, 0, 0, -15, -20, 0, 0);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
   VLOAD_8(v0, 0x33, 0x33);
-  VCLEAR(v6);
-  asm volatile("vrsub.vi v6, v2, 10, v0.t");
-  VCMP_U32(7, v6, 5, 0, 0, 0, -15, -20, 0, 0, 5, 0, 0, 0, -15, -20, 0, 0);
+  VCLEAR(v24);
+  asm volatile("vrsub.vi v24, v8, 10, v0.t");
+  VCMP_U32(7, v24, 5, 0, 0, 0, -15, -20, 0, 0, 5, 0, 0, 0, -15, -20, 0, 0);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
   VLOAD_8(v0, 0x33, 0x33);
-  VCLEAR(v6);
-  asm volatile("vrsub.vi v6, v2, 10, v0.t");
-  VCMP_U64(8, v6, 5, 0, 0, 0, -15, -20, 0, 0, 5, 0, 0, 0, -15, -20, 0, 0);
+  VCLEAR(v24);
+  asm volatile("vrsub.vi v24, v8, 10, v0.t");
+  VCMP_U64(8, v24, 5, 0, 0, 0, -15, -20, 0, 0, 5, 0, 0, 0, -15, -20, 0, 0);
 #endif
 }
 
 void TEST_CASE3(void) {
   const uint64_t scalar = 25;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  asm volatile("vrsub.vx v6, v2, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(9, v6, 20, 15, 10, 5, 0, -5, -10, -15, 20, 15, 10, 5, 0, -5, -10,
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  asm volatile("vrsub.vx v24, v8, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(9, v24, 20, 15, 10, 5, 0, -5, -10, -15, 20, 15, 10, 5, 0, -5, -10,
           -15);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  asm volatile("vrsub.vx v6, v2, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(10, v6, 20, 15, 10, 5, 0, -5, -10, -15, 20, 15, 10, 5, 0, -5, -10,
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  asm volatile("vrsub.vx v24, v8, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(10, v24, 20, 15, 10, 5, 0, -5, -10, -15, 20, 15, 10, 5, 0, -5, -10,
            -15);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  asm volatile("vrsub.vx v6, v2, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(11, v6, 20, 15, 10, 5, 0, -5, -10, -15, 20, 15, 10, 5, 0, -5, -10,
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  asm volatile("vrsub.vx v24, v8, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(11, v24, 20, 15, 10, 5, 0, -5, -10, -15, 20, 15, 10, 5, 0, -5, -10,
            -15);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  asm volatile("vrsub.vx v6, v2, %[A]" ::[A] "r"(scalar));
-  VCMP_U64(12, v6, 20, 15, 10, 5, 0, -5, -10, -15, 20, 15, 10, 5, 0, -5, -10,
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  asm volatile("vrsub.vx v24, v8, %[A]" ::[A] "r"(scalar));
+  VCMP_U64(12, v24, 20, 15, 10, 5, 0, -5, -10, -15, 20, 15, 10, 5, 0, -5, -10,
            -15);
 #endif
 }
@@ -100,34 +100,34 @@ void TEST_CASE3(void) {
 void TEST_CASE4(void) {
   const uint64_t scalar = 25;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
   VLOAD_8(v0, 0x33, 0x33);
-  VCLEAR(v6);
-  asm volatile("vrsub.vx v6, v2, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U8(13, v6, 20, 15, 0, 0, 0, -5, 0, 0, 20, 15, 0, 0, 0, -5, 0, 0);
+  VCLEAR(v24);
+  asm volatile("vrsub.vx v24, v8, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U8(13, v24, 20, 15, 0, 0, 0, -5, 0, 0, 20, 15, 0, 0, 0, -5, 0, 0);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
   VLOAD_8(v0, 0x33, 0x33);
-  VCLEAR(v6);
-  asm volatile("vrsub.vx v6, v2, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U16(14, v6, 20, 15, 0, 0, 0, -5, 0, 0, 20, 15, 0, 0, 0, -5, 0, 0);
+  VCLEAR(v24);
+  asm volatile("vrsub.vx v24, v8, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U16(14, v24, 20, 15, 0, 0, 0, -5, 0, 0, 20, 15, 0, 0, 0, -5, 0, 0);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
   VLOAD_8(v0, 0x33, 0x33);
-  VCLEAR(v6);
-  asm volatile("vrsub.vx v6, v2, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U32(15, v6, 20, 15, 0, 0, 0, -5, 0, 0, 20, 15, 0, 0, 0, -5, 0, 0);
+  VCLEAR(v24);
+  asm volatile("vrsub.vx v24, v8, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U32(15, v24, 20, 15, 0, 0, 0, -5, 0, 0, 20, 15, 0, 0, 0, -5, 0, 0);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
   VLOAD_8(v0, 0x33, 0x33);
-  VCLEAR(v6);
-  asm volatile("vrsub.vx v6, v2, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U64(16, v6, 20, 15, 0, 0, 0, -5, 0, 0, 20, 15, 0, 0, 0, -5, 0, 0);
+  VCLEAR(v24);
+  asm volatile("vrsub.vx v24, v8, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U64(16, v24, 20, 15, 0, 0, 0, -5, 0, 0, 20, 15, 0, 0, 0, -5, 0, 0);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vslide1down.c b/sw/riscvTests/isa/rv64uv/vslide1down.c
index ac37d7ae..91b5b38a 100644
--- a/sw/riscvTests/isa/rv64uv/vslide1down.c
+++ b/sw/riscvTests/isa/rv64uv/vslide1down.c
@@ -10,88 +10,88 @@
 void TEST_CASE1() {
   uint64_t scalar = 99;
 
-  VSET(32, e8, m4);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+  VSET(32, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
           20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e8, m4);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_8(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslide1down.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(1, v2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 99);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_8(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslide1down.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(1, v8, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 99);
 
-  VSET(32, e16, m4);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+  VSET(32, e16, m8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e16, m4);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_16(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslide1down.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(2, v2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 99);
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_16(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslide1down.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(2, v8, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 99);
 
-  VSET(32, e32, m4);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+  VSET(32, e32, m8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e32, m4);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_32(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslide1down.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(3, v2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 99);
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_32(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslide1down.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(3, v8, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 99);
 
 #if ELEN == 64
-  VSET(32, e64, m4);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+  VSET(32, e64, m8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e64, m4);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_64(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslide1down.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U64(4, v2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 99);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_64(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslide1down.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U64(4, v8, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 99);
 #endif
 }
 
 void TEST_CASE2() {
   uint64_t scalar = 99;
 
-  VSET(32, e8, m4);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+  VSET(32, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
           20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e8, m4);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_8(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_8(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vslide1down.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U8(5, v2, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15, -1, 99);
+  asm volatile("vslide1down.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U8(5, v8, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15, -1, 99);
 
-  VSET(32, e16, m4);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+  VSET(32, e16, m8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e16, m4);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_16(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_16(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0x55, 0x55);
-  asm volatile("vslide1down.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U16(6, v2, 2, -1, 4, -1, 6, -1, 8, -1, 10, -1, 12, -1, 14, -1, 16, -1);
+  asm volatile("vslide1down.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U16(6, v8, 2, -1, 4, -1, 6, -1, 8, -1, 10, -1, 12, -1, 14, -1, 16, -1);
 
-  VSET(32, e32, m4);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+  VSET(32, e32, m8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e32, m4);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_32(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_32(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vslide1down.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U32(7, v2, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15, -1, 99);
+  asm volatile("vslide1down.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U32(7, v8, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15, -1, 99);
 
 #if ELEN == 64
-  VSET(32, e64, m4);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+  VSET(32, e64, m8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e64, m4);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_64(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_64(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0x55, 0x55);
-  asm volatile("vslide1down.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U64(8, v2, 2, -1, 4, -1, 6, -1, 8, -1, 10, -1, 12, -1, 14, -1, 16, -1);
+  asm volatile("vslide1down.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U64(8, v8, 2, -1, 4, -1, 6, -1, 8, -1, 10, -1, 12, -1, 14, -1, 16, -1);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vslide1up.c b/sw/riscvTests/isa/rv64uv/vslide1up.c
index c9422b9b..ffe48221 100644
--- a/sw/riscvTests/isa/rv64uv/vslide1up.c
+++ b/sw/riscvTests/isa/rv64uv/vslide1up.c
@@ -10,64 +10,64 @@
 void TEST_CASE1() {
   uint64_t scalar = 99;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_8(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslide1up.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(1, v2, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_8(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslide1up.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(1, v8, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_16(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslide1up.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(2, v2, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_16(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslide1up.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(2, v8, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_32(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslide1up.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(3, v2, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_32(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslide1up.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(3, v8, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_64(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslide1up.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U64(4, v2, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_64(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslide1up.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U64(4, v8, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
 #endif
 }
 
 void TEST_CASE2() {
   uint64_t scalar = 99;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_8(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_8(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vslide1up.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U8(5, v2, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15);
+  asm volatile("vslide1up.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U8(5, v8, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_16(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_16(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0x55, 0x55);
-  asm volatile("vslide1up.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U16(6, v2, 99, -1, 2, -1, 4, -1, 6, -1, 8, -1, 10, -1, 12, -1, 14, -1);
+  asm volatile("vslide1up.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U16(6, v8, 99, -1, 2, -1, 4, -1, 6, -1, 8, -1, 10, -1, 12, -1, 14, -1);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_32(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_32(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vslide1up.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U32(7, v2, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15);
+  asm volatile("vslide1up.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U32(7, v8, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_64(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_64(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0x55, 0x55);
-  asm volatile("vslide1up.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U64(8, v2, 99, -1, 2, -1, 4, -1, 6, -1, 8, -1, 10, -1, 12, -1, 14, -1);
+  asm volatile("vslide1up.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U64(8, v8, 99, -1, 2, -1, 4, -1, 6, -1, 8, -1, 10, -1, 12, -1, 14, -1);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vslidedown.c b/sw/riscvTests/isa/rv64uv/vslidedown.c
index 832886be..092e8ea3 100644
--- a/sw/riscvTests/isa/rv64uv/vslidedown.c
+++ b/sw/riscvTests/isa/rv64uv/vslidedown.c
@@ -8,35 +8,35 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(32, e8, m4);
+  VSET(32, e8, m8);
   VLOAD_8(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
           20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e8, m4);
+  VSET(16, e8, m8);
   VLOAD_8(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   asm volatile("vslidedown.vi v8, v0, 3");
   VCMP_U8(1, v8, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19);
 
-  VSET(32, e16, m4);
+  VSET(32, e16, m8);
   VLOAD_16(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e16, m4);
+  VSET(16, e16, m8);
   VLOAD_16(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   asm volatile("vslidedown.vi v8, v0, 4");
   VCMP_U16(2, v8, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
 
-  VSET(32, e32, m4);
+  VSET(32, e32, m8);
   VLOAD_32(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e32, m4);
+  VSET(16, e32, m8);
   VLOAD_32(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   asm volatile("vslidedown.vi v8, v0, 5");
   VCMP_U32(3, v8, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21);
 
 #if ELEN == 64
-  VSET(32, e64, m4);
+  VSET(32, e64, m8);
   VLOAD_64(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e64, m4);
+  VSET(16, e64, m8);
   VLOAD_64(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   asm volatile("vslidedown.vi v8, v0, 6");
   VCMP_U64(4, v8, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22);
@@ -44,36 +44,36 @@ void TEST_CASE1() {
 }
 
 void TEST_CASE2() {
-  VSET(32, e8, m4);
+  VSET(32, e8, m8);
   VLOAD_8(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
           20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e8, m4);
+  VSET(16, e8, m8);
   VLOAD_8(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
   asm volatile("vslidedown.vi v8, v0, 3, v0.t");
   VCMP_U8(5, v8, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15, -1, 17, -1, 19);
 
-  VSET(32, e16, m4);
+  VSET(32, e16, m8);
   VLOAD_16(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e16, m4);
+  VSET(16, e16, m8);
   VLOAD_16(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   asm volatile("vslidedown.vi v8, v0, 4, v0.t");
   VCMP_U16(6, v8, -1, 6, -1, 8, -1, 10, -1, 12, -1, 14, -1, 16, -1, 18, -1, 20);
 
-  VSET(32, e32, m4);
+  VSET(32, e32, m8);
   VLOAD_32(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e32, m4);
+  VSET(16, e32, m8);
   VLOAD_32(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   asm volatile("vslidedown.vi v8, v0, 5, v0.t");
   VCMP_U32(7, v8, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15, -1, 17, -1, 19, -1, 21);
 
 #if ELEN == 64
-  VSET(32, e64, m4);
+  VSET(32, e64, m8);
   VLOAD_64(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e64, m4);
+  VSET(16, e64, m8);
   VLOAD_64(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   asm volatile("vslidedown.vi v8, v0, 6, v0.t");
   VCMP_U64(8, v8, -1, 8, -1, 10, -1, 12, -1, 14, -1, 16, -1, 18, -1, 20, -1,
@@ -84,35 +84,35 @@ void TEST_CASE2() {
 void TEST_CASE3() {
   uint64_t scalar = 3;
 
-  VSET(32, e8, m4);
+  VSET(32, e8, m8);
   VLOAD_8(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
           20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e8, m4);
+  VSET(16, e8, m8);
   VLOAD_8(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   asm volatile("vslidedown.vx v8, v0, %[A]" ::[A] "r"(scalar));
   VCMP_U8(9, v8, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19);
 
-  VSET(32, e16, m4);
+  VSET(32, e16, m8);
   VLOAD_16(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e16, m4);
+  VSET(16, e16, m8);
   VLOAD_16(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   asm volatile("vslidedown.vx v8, v0, %[A]" ::[A] "r"(scalar));
   VCMP_U16(10, v8, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19);
 
-  VSET(32, e32, m4);
+  VSET(32, e32, m8);
   VLOAD_32(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e32, m4);
+  VSET(16, e32, m8);
   VLOAD_32(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   asm volatile("vslidedown.vx v8, v0, %[A]" ::[A] "r"(scalar));
   VCMP_U32(11, v8, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19);
 
 #if ELEN == 64
-  VSET(32, e64, m4);
+  VSET(32, e64, m8);
   VLOAD_64(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e64, m4);
+  VSET(16, e64, m8);
   VLOAD_64(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   asm volatile("vslidedown.vx v8, v0, %[A]" ::[A] "r"(scalar));
   VCMP_U64(12, v8, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19);
@@ -122,38 +122,38 @@ void TEST_CASE3() {
 void TEST_CASE4() {
   uint64_t scalar = 3;
 
-  VSET(32, e8, m4);
+  VSET(32, e8, m8);
   VLOAD_8(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
           20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e8, m4);
+  VSET(16, e8, m8);
   VLOAD_8(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
   asm volatile("vslidedown.vx v8, v0, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U8(13, v8, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15, -1, 17, -1, 19);
 
-  VSET(32, e16, m4);
+  VSET(32, e16, m8);
   VLOAD_16(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e16, m4);
+  VSET(16, e16, m8);
   VLOAD_16(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
   asm volatile("vslidedown.vx v8, v0, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U16(14, v8, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15, -1, 17, -1, 19);
 
-  VSET(32, e32, m4);
+  VSET(32, e32, m8);
   VLOAD_32(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e32, m4);
+  VSET(16, e32, m8);
   VLOAD_32(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
   asm volatile("vslidedown.vx v8, v0, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U32(15, v8, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13, -1, 15, -1, 17, -1, 19);
 
 #if ELEN == 64
-  VSET(32, e64, m4);
+  VSET(32, e64, m8);
   VLOAD_64(v0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
-  VSET(16, e64, m4);
+  VSET(16, e64, m8);
   VLOAD_64(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
   asm volatile("vslidedown.vx v8, v0, %[A], v0.t" ::[A] "r"(scalar));
diff --git a/sw/riscvTests/isa/rv64uv/vslideup.c b/sw/riscvTests/isa/rv64uv/vslideup.c
index 9393b30b..e37dff71 100644
--- a/sw/riscvTests/isa/rv64uv/vslideup.c
+++ b/sw/riscvTests/isa/rv64uv/vslideup.c
@@ -8,123 +8,123 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_8(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslideup.vi v2, v4, 3");
-  VCMP_U8(1, v2, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
-
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_16(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslideup.vi v2, v4, 4");
-  VCMP_U16(2, v2, -1, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
-
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_32(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslideup.vi v2, v4, 5");
-  VCMP_U32(3, v2, -1, -1, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_8(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslideup.vi v8, v16, 3");
+  VCMP_U8(1, v8, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
+
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_16(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslideup.vi v8, v16, 4");
+  VCMP_U16(2, v8, -1, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
+
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_32(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslideup.vi v8, v16, 5");
+  VCMP_U32(3, v8, -1, -1, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_64(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslideup.vi v2, v4, 6");
-  VCMP_U64(4, v2, -1, -1, -1, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_64(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslideup.vi v8, v16, 6");
+  VCMP_U64(4, v8, -1, -1, -1, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 #endif
 }
 
 void TEST_CASE2() {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_8(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_8(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vslideup.vi v2, v4, 3, v0.t");
-  VCMP_U8(5, v2, -1, -1, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13);
+  asm volatile("vslideup.vi v8, v16, 3, v0.t");
+  VCMP_U8(5, v8, -1, -1, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_16(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslideup.vi v2, v4, 4, v0.t");
-  VCMP_U16(6, v2, -1, -1, -1, -1, -1, 2, -1, 4, -1, 6, -1, 8, -1, 10, -1, 12);
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_16(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslideup.vi v8, v16, 4, v0.t");
+  VCMP_U16(6, v8, -1, -1, -1, -1, -1, 2, -1, 4, -1, 6, -1, 8, -1, 10, -1, 12);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_32(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslideup.vi v2, v4, 5, v0.t");
-  VCMP_U32(7, v2, -1, -1, -1, -1, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11);
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_32(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslideup.vi v8, v16, 5, v0.t");
+  VCMP_U32(7, v8, -1, -1, -1, -1, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_64(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslideup.vi v2, v4, 6, v0.t");
-  VCMP_U64(8, v2, -1, -1, -1, -1, -1, -1, -1, 2, -1, 4, -1, 6, -1, 8, -1, 10);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_64(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslideup.vi v8, v16, 6, v0.t");
+  VCMP_U64(8, v8, -1, -1, -1, -1, -1, -1, -1, 2, -1, 4, -1, 6, -1, 8, -1, 10);
 #endif
 }
 
 void TEST_CASE3() {
   uint64_t scalar = 3;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_8(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslideup.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(9, v2, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_8(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslideup.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(9, v8, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_16(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslideup.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(10, v2, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_16(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslideup.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(10, v8, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_32(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslideup.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(11, v2, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_32(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslideup.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(11, v8, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_64(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
-  asm volatile("vslideup.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U64(12, v2, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_64(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  asm volatile("vslideup.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U64(12, v8, -1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
 #endif
 }
 
 void TEST_CASE4() {
   uint64_t scalar = 3;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_8(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_8(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vslideup.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U8(13, v2, -1, -1, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13);
+  asm volatile("vslideup.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U8(13, v8, -1, -1, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_16(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_16(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vslideup.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U16(14, v2, -1, -1, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13);
+  asm volatile("vslideup.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U16(14, v8, -1, -1, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_32(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_32(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vslideup.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U32(15, v2, -1, -1, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13);
+  asm volatile("vslideup.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U32(15, v8, -1, -1, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
-  VLOAD_64(v2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+  VLOAD_64(v8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vslideup.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U64(16, v2, -1, -1, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13);
+  asm volatile("vslideup.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U64(16, v8, -1, -1, -1, 1, -1, 3, -1, 5, -1, 7, -1, 9, -1, 11, -1, 13);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vsll.c b/sw/riscvTests/isa/rv64uv/vsll.c
index d29efa13..3150b6e0 100644
--- a/sw/riscvTests/isa/rv64uv/vsll.c
+++ b/sw/riscvTests/isa/rv64uv/vsll.c
@@ -8,45 +8,45 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
           0x01, 0x01, 0x01, 0x01, 0x01);
-  VLOAD_8(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
-  asm volatile("vsll.vv v8, v4, v6");
+  VLOAD_8(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  asm volatile("vsll.vv v8, v16, v24");
   VCMP_U8(1, v8, 0x01, 0x02, 0x04, 0x08, 0x80, 0x80, 0x80, 0x01, 0x01, 0x02,
           0x04, 0x08, 0x80, 0x80, 0x80, 0x01);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
            0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001);
-  VLOAD_16(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
-  asm volatile("vsll.vv v8, v4, v6");
+  VLOAD_16(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  asm volatile("vsll.vv v8, v16, v24");
   VCMP_U16(2, v8, 0x0001, 0x0002, 0x0004, 0x0008, 0x0080, 0x8000, 0x8000,
            0x0001, 0x0001, 0x0002, 0x0004, 0x0008, 0x0080, 0x8000, 0x8000,
            0x0001);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
            0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
            0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
            0x00000001);
-  VLOAD_32(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
-  asm volatile("vsll.vv v8, v4, v6");
+  VLOAD_32(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  asm volatile("vsll.vv v8, v16, v24");
   VCMP_U32(3, v8, 0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000080,
            0x00008000, 0x80000000, 0x00000001, 0x00000001, 0x00000002,
            0x00000004, 0x00000008, 0x00000080, 0x00008000, 0x80000000,
            0x00000001);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000001, 0x0000000000000001, 0x0000000000000001,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000001, 0x0000000000000001, 0x0000000000000001,
            0x0000000000000001, 0x0000000000000001, 0x0000000000000001,
            0x0000000000000001, 0x0000000000000001, 0x0000000000000001,
            0x0000000000000001, 0x0000000000000001, 0x0000000000000001,
            0x0000000000000001, 0x0000000000000001, 0x0000000000000001,
            0x0000000000000001);
-  VLOAD_64(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
-  asm volatile("vsll.vv v8, v4, v6");
+  VLOAD_64(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  asm volatile("vsll.vv v8, v16, v24");
   VCMP_U64(4, v8, 0x000000000000001, 0x0000000000000002, 0x0000000000000004,
            0x0000000000000008, 0x0000000000000080, 0x0000000000008000,
            0x0000000080000000, 0x0000000100000000, 0x0000000000000001,
@@ -57,53 +57,53 @@ void TEST_CASE1(void) {
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
           0x01, 0x01, 0x01, 0x01, 0x01);
-  VLOAD_8(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  VLOAD_8(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsll.vv v8, v4, v6, v0.t");
+  asm volatile("vsll.vv v8, v16, v24, v0.t");
   VCMP_U8(5, v8, 0x00, 0x02, 0x00, 0x08, 0x00, 0x80, 0x00, 0x01, 0x00, 0x02,
           0x00, 0x08, 0x00, 0x80, 0x00, 0x01);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
            0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001);
-  VLOAD_16(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  VLOAD_16(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsll.vv v8, v4, v6, v0.t");
+  asm volatile("vsll.vv v8, v16, v24, v0.t");
   VCMP_U16(6, v8, 0x0000, 0x0002, 0x0000, 0x0008, 0x0000, 0x8000, 0x0000,
            0x0001, 0x0000, 0x0002, 0x0000, 0x0008, 0x0000, 0x8000, 0x0000,
            0x0001);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
            0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
            0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000001,
            0x00000001);
-  VLOAD_32(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  VLOAD_32(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsll.vv v8, v4, v6, v0.t");
+  asm volatile("vsll.vv v8, v16, v24, v0.t");
   VCMP_U32(7, v8, 0x00000000, 0x00000002, 0x00000000, 0x00000008, 0x00000000,
            0x00008000, 0x00000000, 0x00000001, 0x00000000, 0x00000002,
            0x00000000, 0x00000008, 0x00000000, 0x00008000, 0x00000000,
            0x00000001);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000001, 0x0000000000000001, 0x0000000000000001,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000001, 0x0000000000000001, 0x0000000000000001,
            0x0000000000000001, 0x0000000000000001, 0x0000000000000001,
            0x0000000000000001, 0x0000000000000001, 0x0000000000000001,
            0x0000000000000001, 0x0000000000000001, 0x0000000000000001,
            0x0000000000000001, 0x0000000000000001, 0x0000000000000001,
            0x0000000000000001);
-  VLOAD_64(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  VLOAD_64(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsll.vv v8, v4, v6, v0.t");
+  asm volatile("vsll.vv v8, v16, v24, v0.t");
   VCMP_U64(8, v8, 0x000000000000000, 0x0000000000000002, 0x0000000000000000,
            0x0000000000000008, 0x0000000000000000, 0x0000000000008000,
            0x0000000000000000, 0x0000000100000000, 0x0000000000000000,
@@ -116,41 +116,41 @@ void TEST_CASE2(void) {
 void TEST_CASE3(void) {
   const uint64_t scalar = 2;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xF8, 0xF9, 0xFA,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xF8, 0xF9, 0xFA,
           0xFB, 0xFC, 0xFD, 0xFE, 0xFF);
-  asm volatile("vsll.vx v8, v4, %[A]" ::[A] "r"(scalar));
+  asm volatile("vsll.vx v8, v16, %[A]" ::[A] "r"(scalar));
   VCMP_U8(9, v8, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4,
           0xE8, 0xEC, 0xF0, 0xF4, 0xF8, 0xFC);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
            0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0x00FF);
-  asm volatile("vsll.vx v8, v4, %[A]" ::[A] "r"(scalar));
+  asm volatile("vsll.vx v8, v16, %[A]" ::[A] "r"(scalar));
   VCMP_U16(10, v8, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C,
            0x0020, 0xFFE0, 0xFFE4, 0xFFE8, 0xFFEC, 0xFFF0, 0xFFF4, 0xFFF8,
            0x03FC);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005,
            0x00000006, 0x00000007, 0x00000008, 0xFFFFFFF8, 0xFFFFFFF9,
            0xFFFFFFFA, 0xFFFFFFFB, 0xFFFFFFFC, 0xFFFFFFFD, 0xFFFFFFFE,
            0x000000FF);
-  asm volatile("vsll.vx v8, v4, %[A]" ::[A] "r"(scalar));
+  asm volatile("vsll.vx v8, v16, %[A]" ::[A] "r"(scalar));
   VCMP_U32(11, v8, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
            0x00000018, 0x0000001C, 0x00000020, 0xFFFFFFE0, 0xFFFFFFE4,
            0xFFFFFFE8, 0xFFFFFFEC, 0xFFFFFFF0, 0xFFFFFFF4, 0xFFFFFFF8,
            0x000003FC);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
            0x0000000000000004, 0x0000000000000005, 0x0000000000000006,
            0x0000000000000007, 0x0000000000000008, 0xFFFFFFFFFFFFFFF8,
            0xFFFFFFFFFFFFFFF9, 0xFFFFFFFFFFFFFFFA, 0xFFFFFFFFFFFFFFFB,
            0xFFFFFFFFFFFFFFFC, 0xFFFFFFFFFFFFFFFD, 0xFFFFFFFFFFFFFFFE,
            0x00000000000000FF);
-  asm volatile("vsll.vx v8, v4, %[A]" ::[A] "r"(scalar));
+  asm volatile("vsll.vx v8, v16, %[A]" ::[A] "r"(scalar));
   VCMP_U64(12, v8, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
            0x0000000000000010, 0x0000000000000014, 0x0000000000000018,
            0x000000000000001C, 0x0000000000000020, 0xFFFFFFFFFFFFFFE0,
@@ -163,41 +163,41 @@ void TEST_CASE3(void) {
 void TEST_CASE4(void) {
   const uint64_t scalar = 2;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xF8, 0xF9, 0xFA,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xF8, 0xF9, 0xFA,
           0xFB, 0xFC, 0xFD, 0xFE, 0xFF);
   VCLEAR(v8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vsll.vx v8, v4, %[A], v0.t" ::[A] "r"(scalar));
+  asm volatile("vsll.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U8(13, v8, 0x00, 0x08, 0x00, 0x10, 0x00, 0x18, 0x00, 0x20, 0x00, 0xE4,
           0x00, 0xEC, 0x00, 0xF4, 0x00, 0xFC);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
            0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0x00FF);
   VCLEAR(v8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vsll.vx v8, v4, %[A], v0.t" ::[A] "r"(scalar));
+  asm volatile("vsll.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U16(14, v8, 0x0000, 0x0008, 0x0000, 0x0010, 0x0000, 0x0018, 0x0000,
            0x0020, 0x0000, 0xFFE4, 0x0000, 0xFFEC, 0x0000, 0xFFF4, 0x0000,
            0x03FC);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005,
            0x00000006, 0x00000007, 0x00000008, 0xFFFFFFF8, 0xFFFFFFF9,
            0xFFFFFFFA, 0xFFFFFFFB, 0xFFFFFFFC, 0xFFFFFFFD, 0xFFFFFFFE,
            0x000000FF);
   VCLEAR(v8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vsll.vx v8, v4, %[A], v0.t" ::[A] "r"(scalar));
+  asm volatile("vsll.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U32(15, v8, 0x00000000, 0x00000008, 0x00000000, 0x00000010, 0x00000000,
            0x00000018, 0x00000000, 0x00000020, 0x00000000, 0xFFFFFFE4,
            0x00000000, 0xFFFFFFEC, 0x00000000, 0xFFFFFFF4, 0x00000000,
            0x000003FC);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
            0x0000000000000004, 0x0000000000000005, 0x0000000000000006,
            0x0000000000000007, 0x0000000000000008, 0xFFFFFFFFFFFFFFF8,
            0xFFFFFFFFFFFFFFF9, 0xFFFFFFFFFFFFFFFA, 0xFFFFFFFFFFFFFFFB,
@@ -205,7 +205,7 @@ void TEST_CASE4(void) {
            0x00000000000000FF);
   VCLEAR(v8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vsll.vx v8, v4, %[A], v0.t" ::[A] "r"(scalar));
+  asm volatile("vsll.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U64(16, v8, 0x0000000000000000, 0x0000000000000008, 0x0000000000000000,
            0x0000000000000010, 0x0000000000000000, 0x0000000000000018,
            0x0000000000000000, 0x0000000000000020, 0x0000000000000000,
@@ -216,41 +216,41 @@ void TEST_CASE4(void) {
 };
 
 void TEST_CASE5(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xF8, 0xF9, 0xFA,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xF8, 0xF9, 0xFA,
           0xFB, 0xFC, 0xFD, 0xFE, 0xFF);
-  asm volatile("vsll.vi v8, v4, 2");
+  asm volatile("vsll.vi v8, v16, 2");
   VCMP_U8(17, v8, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4,
           0xE8, 0xEC, 0xF0, 0xF4, 0xF8, 0xFC);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
            0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0x00FF);
-  asm volatile("vsll.vi v8, v4, 2");
+  asm volatile("vsll.vi v8, v16, 2");
   VCMP_U16(18, v8, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C,
            0x0020, 0xFFE0, 0xFFE4, 0xFFE8, 0xFFEC, 0xFFF0, 0xFFF4, 0xFFF8,
            0x03FC);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005,
            0x00000006, 0x00000007, 0x00000008, 0xFFFFFFF8, 0xFFFFFFF9,
            0xFFFFFFFA, 0xFFFFFFFB, 0xFFFFFFFC, 0xFFFFFFFD, 0xFFFFFFFE,
            0x000000FF);
-  asm volatile("vsll.vi v8, v4, 2");
+  asm volatile("vsll.vi v8, v16, 2");
   VCMP_U32(19, v8, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
            0x00000018, 0x0000001C, 0x00000020, 0xFFFFFFE0, 0xFFFFFFE4,
            0xFFFFFFE8, 0xFFFFFFEC, 0xFFFFFFF0, 0xFFFFFFF4, 0xFFFFFFF8,
            0x000003FC);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
            0x0000000000000004, 0x0000000000000005, 0x0000000000000006,
            0x0000000000000007, 0x0000000000000008, 0xFFFFFFFFFFFFFFF8,
            0xFFFFFFFFFFFFFFF9, 0xFFFFFFFFFFFFFFFA, 0xFFFFFFFFFFFFFFFB,
            0xFFFFFFFFFFFFFFFC, 0xFFFFFFFFFFFFFFFD, 0xFFFFFFFFFFFFFFFE,
            0x00000000000000FF);
-  asm volatile("vsll.vi v8, v4, 2");
+  asm volatile("vsll.vi v8, v16, 2");
   VCMP_U64(20, v8, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
            0x0000000000000010, 0x0000000000000014, 0x0000000000000018,
            0x000000000000001C, 0x0000000000000020, 0xFFFFFFFFFFFFFFE0,
@@ -261,41 +261,41 @@ void TEST_CASE5(void) {
 };
 
 void TEST_CASE6(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xF8, 0xF9, 0xFA,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xF8, 0xF9, 0xFA,
           0xFB, 0xFC, 0xFD, 0xFE, 0xFF);
   VCLEAR(v8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vsll.vi v8, v4, 2, v0.t");
+  asm volatile("vsll.vi v8, v16, 2, v0.t");
   VCMP_U8(21, v8, 0x00, 0x08, 0x00, 0x10, 0x00, 0x18, 0x00, 0x20, 0x00, 0xE4,
           0x00, 0xEC, 0x00, 0xF4, 0x00, 0xFC);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
            0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0x00FF);
   VCLEAR(v8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vsll.vi v8, v4, 2, v0.t");
+  asm volatile("vsll.vi v8, v16, 2, v0.t");
   VCMP_U16(22, v8, 0x0000, 0x0008, 0x0000, 0x0010, 0x0000, 0x0018, 0x0000,
            0x0020, 0x0000, 0xFFE4, 0x0000, 0xFFEC, 0x0000, 0xFFF4, 0x0000,
            0x03FC);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005,
            0x00000006, 0x00000007, 0x00000008, 0xFFFFFFF8, 0xFFFFFFF9,
            0xFFFFFFFA, 0xFFFFFFFB, 0xFFFFFFFC, 0xFFFFFFFD, 0xFFFFFFFE,
            0x000000FF);
   VCLEAR(v8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vsll.vi v8, v4, 2, v0.t");
+  asm volatile("vsll.vi v8, v16, 2, v0.t");
   VCMP_U32(23, v8, 0x00000000, 0x00000008, 0x00000000, 0x00000010, 0x00000000,
            0x00000018, 0x00000000, 0x00000020, 0x00000000, 0xFFFFFFE4,
            0x00000000, 0xFFFFFFEC, 0x00000000, 0xFFFFFFF4, 0x00000000,
            0x000003FC);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
            0x0000000000000004, 0x0000000000000005, 0x0000000000000006,
            0x0000000000000007, 0x0000000000000008, 0xFFFFFFFFFFFFFFF8,
            0xFFFFFFFFFFFFFFF9, 0xFFFFFFFFFFFFFFFA, 0xFFFFFFFFFFFFFFFB,
@@ -303,7 +303,7 @@ void TEST_CASE6(void) {
            0x00000000000000FF);
   VCLEAR(v8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vsll.vi v8, v4, 2, v0.t");
+  asm volatile("vsll.vi v8, v16, 2, v0.t");
   VCMP_U64(24, v8, 0x0000000000000000, 0x0000000000000008, 0x0000000000000000,
            0x0000000000000010, 0x0000000000000000, 0x0000000000000018,
            0x0000000000000000, 0x0000000000000020, 0x0000000000000000,
diff --git a/sw/riscvTests/isa/rv64uv/vsra.c b/sw/riscvTests/isa/rv64uv/vsra.c
index fe5a091f..4901555f 100644
--- a/sw/riscvTests/isa/rv64uv/vsra.c
+++ b/sw/riscvTests/isa/rv64uv/vsra.c
@@ -8,45 +8,45 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
           0x80, 0x80, 0x80, 0x80, 0x80);
-  VLOAD_8(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
-  asm volatile("vsra.vv v8, v4, v6");
+  VLOAD_8(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  asm volatile("vsra.vv v8, v16, v24");
   VCMP_U8(1, v8, 0x80, 0xC0, 0xE0, 0xF0, 0xFF, 0xFF, 0xFF, 0x80, 0x80, 0xC0,
           0xE0, 0xF0, 0xFF, 0xFF, 0xFF, 0x80);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
            0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000);
-  VLOAD_16(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
-  asm volatile("vsra.vv v8, v4, v6");
+  VLOAD_16(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  asm volatile("vsra.vv v8, v16, v24");
   VCMP_U16(2, v8, 0x8000, 0xC000, 0xE000, 0xF000, 0xFF00, 0xFFFF, 0xFFFF,
            0x8000, 0x8000, 0xC000, 0xE000, 0xF000, 0xFF00, 0xFFFF, 0xFFFF,
            0x8000);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
            0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
            0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
            0x80000000);
-  VLOAD_32(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
-  asm volatile("vsra.vv v8, v4, v6");
+  VLOAD_32(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  asm volatile("vsra.vv v8, v16, v24");
   VCMP_U32(3, v8, 0x80000000, 0xC0000000, 0xE0000000, 0xF0000000, 0xFF000000,
            0xFFFF0000, 0xFFFFFFFF, 0x80000000, 0x80000000, 0xC0000000,
            0xE0000000, 0xF0000000, 0xFF000000, 0xFFFF0000, 0xFFFFFFFF,
            0x80000000);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000);
-  VLOAD_64(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
-  asm volatile("vsra.vv v8, v4, v6");
+  VLOAD_64(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  asm volatile("vsra.vv v8, v16, v24");
   VCMP_U64(4, v8, 0x8000000000000000, 0xC000000000000000, 0xE000000000000000,
            0xF000000000000000, 0xFF00000000000000, 0xFFFF000000000000,
            0xFFFFFFFF00000000, 0xFFFFFFFF80000000, 0x8000000000000000,
@@ -57,53 +57,53 @@ void TEST_CASE1(void) {
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
           0x80, 0x80, 0x80, 0x80, 0x80);
-  VLOAD_8(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  VLOAD_8(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsra.vv v8, v4, v6, v0.t");
+  asm volatile("vsra.vv v8, v16, v24, v0.t");
   VCMP_U8(5, v8, 0x00, 0xC0, 0x00, 0xF0, 0x00, 0xFF, 0x00, 0x80, 0x00, 0xC0,
           0x00, 0xF0, 0x00, 0xFF, 0x00, 0x80);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
            0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000);
-  VLOAD_16(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  VLOAD_16(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsra.vv v8, v4, v6, v0.t");
+  asm volatile("vsra.vv v8, v16, v24, v0.t");
   VCMP_U16(6, v8, 0x0000, 0xC000, 0x0000, 0xF000, 0x0000, 0xFFFF, 0x0000,
            0x8000, 0x0000, 0xC000, 0x0000, 0xF000, 0x0000, 0xFFFF, 0x0000,
            0x8000);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
            0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
            0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
            0x80000000);
-  VLOAD_32(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  VLOAD_32(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsra.vv v8, v4, v6, v0.t");
+  asm volatile("vsra.vv v8, v16, v24, v0.t");
   VCMP_U32(7, v8, 0x00000000, 0xC0000000, 0x00000000, 0xF0000000, 0x00000000,
            0xFFFF0000, 0x00000000, 0x80000000, 0x00000000, 0xC0000000,
            0x00000000, 0xF0000000, 0x00000000, 0xFFFF0000, 0x00000000,
            0x80000000);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000);
-  VLOAD_64(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  VLOAD_64(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsra.vv v8, v4, v6, v0.t");
+  asm volatile("vsra.vv v8, v16, v24, v0.t");
   VCMP_U64(8, v8, 0x0000000000000000, 0xC000000000000000, 0x0000000000000000,
            0xF000000000000000, 0x0000000000000000, 0xFFFF000000000000,
            0x0000000000000000, 0xFFFFFFFF80000000, 0x0000000000000000,
@@ -116,41 +116,41 @@ void TEST_CASE2(void) {
 void TEST_CASE3(void) {
   const uint64_t scalar = 2;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
           0xEC, 0xF0, 0xF4, 0xF8, 0xFC);
-  asm volatile("vsra.vx v8, v4, %[A]" ::[A] "r"(scalar));
+  asm volatile("vsra.vx v8, v16, %[A]" ::[A] "r"(scalar));
   VCMP_U8(9, v8, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xF8, 0xF9,
           0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
            0xFFE0, 0xFFE4, 0xFFE8, 0xFFEC, 0xFFF0, 0xFFF4, 0xFFF8, 0xFFFC);
-  asm volatile("vsra.vx v8, v4, %[A]" ::[A] "r"(scalar));
+  asm volatile("vsra.vx v8, v16, %[A]" ::[A] "r"(scalar));
   VCMP_U16(10, v8, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
            0x0008, 0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE,
            0xFFFF);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
            0x00000018, 0x0000001C, 0x00000020, 0xFFFFFFE0, 0xFFFFFFE4,
            0xFFFFFFE8, 0xFFFFFFEC, 0xFFFFFFF0, 0xFFFFFFF4, 0xFFFFFFF8,
            0xFFFFFFFC);
-  asm volatile("vsra.vx v8, v4, %[A]" ::[A] "r"(scalar));
+  asm volatile("vsra.vx v8, v16, %[A]" ::[A] "r"(scalar));
   VCMP_U32(11, v8, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005,
            0x00000006, 0x00000007, 0x00000008, 0xFFFFFFF8, 0xFFFFFFF9,
            0xFFFFFFFA, 0xFFFFFFFB, 0xFFFFFFFC, 0xFFFFFFFD, 0xFFFFFFFE,
            0xFFFFFFFF);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
            0x0000000000000010, 0x0000000000000014, 0x0000000000000018,
            0x000000000000001C, 0x0000000000000020, 0xFFFFFFFFFFFFFFE0,
            0xFFFFFFFFFFFFFFE4, 0xFFFFFFFFFFFFFFE8, 0xFFFFFFFFFFFFFFEC,
            0xFFFFFFFFFFFFFFF0, 0xFFFFFFFFFFFFFFF4, 0xFFFFFFFFFFFFFFF8,
            0xFFFFFFFFFFFFFFFC);
-  asm volatile("vsra.vx v8, v4, %[A]" ::[A] "r"(scalar));
+  asm volatile("vsra.vx v8, v16, %[A]" ::[A] "r"(scalar));
   VCMP_U64(12, v8, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
            0x0000000000000004, 0x0000000000000005, 0x0000000000000006,
            0x0000000000000007, 0x0000000000000008, 0xFFFFFFFFFFFFFFF8,
@@ -163,41 +163,41 @@ void TEST_CASE3(void) {
 void TEST_CASE4(void) {
   const uint64_t scalar = 2;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
           0xEC, 0xF0, 0xF4, 0xF8, 0xFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsra.vx v8, v4, %[A], v0.t" ::[A] "r"(scalar));
+  asm volatile("vsra.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U8(13, v8, 0x00, 0x02, 0x00, 0x04, 0x00, 0x06, 0x00, 0x08, 0x00, 0xF9,
           0x00, 0xFB, 0x00, 0xFD, 0x00, 0xFF);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
            0xFFE0, 0xFFE4, 0xFFE8, 0xFFEC, 0xFFF0, 0xFFF4, 0xFFF8, 0xFFFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsra.vx v8, v4, %[A], v0.t" ::[A] "r"(scalar));
+  asm volatile("vsra.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U16(14, v8, 0x0000, 0x0002, 0x0000, 0x0004, 0x0000, 0x0006, 0x0000,
            0x0008, 0x0000, 0xFFF9, 0x0000, 0xFFFB, 0x0000, 0xFFFD, 0x0000,
            0xFFFF);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
            0x00000018, 0x0000001C, 0x00000020, 0xFFFFFFE0, 0xFFFFFFE4,
            0xFFFFFFE8, 0xFFFFFFEC, 0xFFFFFFF0, 0xFFFFFFF4, 0xFFFFFFF8,
            0xFFFFFFFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsra.vx v8, v4, %[A], v0.t" ::[A] "r"(scalar));
+  asm volatile("vsra.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U32(15, v8, 0x00000000, 0x00000002, 0x00000000, 0x00000004, 0x00000000,
            0x00000006, 0x00000000, 0x00000008, 0x00000000, 0xFFFFFFF9,
            0x00000000, 0xFFFFFFFB, 0x00000000, 0xFFFFFFFD, 0x00000000,
            0xFFFFFFFF);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
            0x0000000000000010, 0x0000000000000014, 0x0000000000000018,
            0x000000000000001C, 0x0000000000000020, 0xFFFFFFFFFFFFFFE0,
            0xFFFFFFFFFFFFFFE4, 0xFFFFFFFFFFFFFFE8, 0xFFFFFFFFFFFFFFEC,
@@ -205,7 +205,7 @@ void TEST_CASE4(void) {
            0xFFFFFFFFFFFFFFFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsra.vx v8, v4, %[A], v0.t" ::[A] "r"(scalar));
+  asm volatile("vsra.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U64(16, v8, 0x0000000000000000, 0x0000000000000002, 0x0000000000000000,
            0x0000000000000004, 0x0000000000000000, 0x0000000000000006,
            0x0000000000000000, 0x0000000000000008, 0x0000000000000000,
@@ -216,41 +216,41 @@ void TEST_CASE4(void) {
 };
 
 void TEST_CASE5(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
           0xEC, 0xF0, 0xF4, 0xF8, 0xFC);
-  asm volatile("vsra.vi v8, v4, 2");
+  asm volatile("vsra.vi v8, v16, 2");
   VCMP_U8(17, v8, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0xF8, 0xF9,
           0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
            0xFFE0, 0xFFE4, 0xFFE8, 0xFFEC, 0xFFF0, 0xFFF4, 0xFFF8, 0xFFFC);
-  asm volatile("vsra.vi v8, v4, 2");
+  asm volatile("vsra.vi v8, v16, 2");
   VCMP_U16(18, v8, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
            0x0008, 0xFFF8, 0xFFF9, 0xFFFA, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE,
            0xFFFF);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
            0x00000018, 0x0000001C, 0x00000020, 0xFFFFFFE0, 0xFFFFFFE4,
            0xFFFFFFE8, 0xFFFFFFEC, 0xFFFFFFF0, 0xFFFFFFF4, 0xFFFFFFF8,
            0xFFFFFFFC);
-  asm volatile("vsra.vi v8, v4, 2");
+  asm volatile("vsra.vi v8, v16, 2");
   VCMP_U32(19, v8, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005,
            0x00000006, 0x00000007, 0x00000008, 0xFFFFFFF8, 0xFFFFFFF9,
            0xFFFFFFFA, 0xFFFFFFFB, 0xFFFFFFFC, 0xFFFFFFFD, 0xFFFFFFFE,
            0xFFFFFFFF);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
            0x0000000000000010, 0x0000000000000014, 0x0000000000000018,
            0x000000000000001C, 0x0000000000000020, 0xFFFFFFFFFFFFFFE0,
            0xFFFFFFFFFFFFFFE4, 0xFFFFFFFFFFFFFFE8, 0xFFFFFFFFFFFFFFEC,
            0xFFFFFFFFFFFFFFF0, 0xFFFFFFFFFFFFFFF4, 0xFFFFFFFFFFFFFFF8,
            0xFFFFFFFFFFFFFFFC);
-  asm volatile("vsra.vi v8, v4, 2");
+  asm volatile("vsra.vi v8, v16, 2");
   VCMP_U64(20, v8, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
            0x0000000000000004, 0x0000000000000005, 0x0000000000000006,
            0x0000000000000007, 0x0000000000000008, 0xFFFFFFFFFFFFFFF8,
@@ -261,41 +261,41 @@ void TEST_CASE5(void) {
 };
 
 void TEST_CASE6(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
           0xEC, 0xF0, 0xF4, 0xF8, 0xFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsra.vi v8, v4, 2, v0.t");
+  asm volatile("vsra.vi v8, v16, 2, v0.t");
   VCMP_U8(21, v8, 0x00, 0x02, 0x00, 0x04, 0x00, 0x06, 0x00, 0x08, 0x00, 0xF9,
           0x00, 0xFB, 0x00, 0xFD, 0x00, 0xFF);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
            0xFFE0, 0xFFE4, 0xFFE8, 0xFFEC, 0xFFF0, 0xFFF4, 0xFFF8, 0xFFFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsra.vi v8, v4, 2, v0.t");
+  asm volatile("vsra.vi v8, v16, 2, v0.t");
   VCMP_U16(22, v8, 0x0000, 0x0002, 0x0000, 0x0004, 0x0000, 0x0006, 0x0000,
            0x0008, 0x0000, 0xFFF9, 0x0000, 0xFFFB, 0x0000, 0xFFFD, 0x0000,
            0xFFFF);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
            0x00000018, 0x0000001C, 0x00000020, 0xFFFFFFE0, 0xFFFFFFE4,
            0xFFFFFFE8, 0xFFFFFFEC, 0xFFFFFFF0, 0xFFFFFFF4, 0xFFFFFFF8,
            0xFFFFFFFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsra.vi v8, v4, 2, v0.t");
+  asm volatile("vsra.vi v8, v16, 2, v0.t");
   VCMP_U32(23, v8, 0x00000000, 0x00000002, 0x00000000, 0x00000004, 0x00000000,
            0x00000006, 0x00000000, 0x00000008, 0x00000000, 0xFFFFFFF9,
            0x00000000, 0xFFFFFFFB, 0x00000000, 0xFFFFFFFD, 0x00000000,
            0xFFFFFFFF);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
            0x0000000000000010, 0x0000000000000014, 0x0000000000000018,
            0x000000000000001C, 0x0000000000000020, 0xFFFFFFFFFFFFFFE0,
            0xFFFFFFFFFFFFFFE4, 0xFFFFFFFFFFFFFFE8, 0xFFFFFFFFFFFFFFEC,
@@ -303,7 +303,7 @@ void TEST_CASE6(void) {
            0xFFFFFFFFFFFFFFFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsra.vi v8, v4, 2, v0.t");
+  asm volatile("vsra.vi v8, v16, 2, v0.t");
   VCMP_U64(24, v8, 0x0000000000000000, 0x0000000000000002, 0x0000000000000000,
            0x0000000000000004, 0x0000000000000000, 0x0000000000000006,
            0x0000000000000000, 0x0000000000000008, 0x0000000000000000,
diff --git a/sw/riscvTests/isa/rv64uv/vsrl.c b/sw/riscvTests/isa/rv64uv/vsrl.c
index 12654982..8beafca1 100644
--- a/sw/riscvTests/isa/rv64uv/vsrl.c
+++ b/sw/riscvTests/isa/rv64uv/vsrl.c
@@ -8,45 +8,45 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
           0x80, 0x80, 0x80, 0x80, 0x80);
-  VLOAD_8(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
-  asm volatile("vsrl.vv v8, v4, v6");
+  VLOAD_8(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  asm volatile("vsrl.vv v8, v16, v24");
   VCMP_U8(1, v8, 0x80, 0x40, 0x20, 0x10, 0x01, 0x01, 0x01, 0x80, 0x80, 0x40,
           0x20, 0x10, 0x01, 0x01, 0x01, 0x80);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
            0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000);
-  VLOAD_16(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
-  asm volatile("vsrl.vv v8, v4, v6");
+  VLOAD_16(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  asm volatile("vsrl.vv v8, v16, v24");
   VCMP_U16(2, v8, 0x8000, 0x4000, 0x2000, 0x1000, 0x0100, 0x0001, 0x0001,
            0x8000, 0x8000, 0x4000, 0x2000, 0x1000, 0x0100, 0x0001, 0x0001,
            0x8000);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
            0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
            0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
            0x80000000);
-  VLOAD_32(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
-  asm volatile("vsrl.vv v8, v4, v6");
+  VLOAD_32(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  asm volatile("vsrl.vv v8, v16, v24");
   VCMP_U32(3, v8, 0x80000000, 0x40000000, 0x20000000, 0x10000000, 0x01000000,
            0x00010000, 0x00000001, 0x80000000, 0x80000000, 0x40000000,
            0x20000000, 0x10000000, 0x01000000, 0x00010000, 0x00000001,
            0x80000000);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000);
-  VLOAD_64(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
-  asm volatile("vsrl.vv v8, v4, v6");
+  VLOAD_64(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  asm volatile("vsrl.vv v8, v16, v24");
   VCMP_U64(4, v8, 0x8000000000000000, 0x4000000000000000, 0x2000000000000000,
            0x1000000000000000, 0x0100000000000000, 0x0001000000000000,
            0x0000000100000000, 0x0000000080000000, 0x8000000000000000,
@@ -57,53 +57,53 @@ void TEST_CASE1(void) {
 };
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
           0x80, 0x80, 0x80, 0x80, 0x80);
-  VLOAD_8(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  VLOAD_8(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsrl.vv v8, v4, v6, v0.t");
+  asm volatile("vsrl.vv v8, v16, v24, v0.t");
   VCMP_U8(5, v8, 0x00, 0x40, 0x00, 0x10, 0x00, 0x01, 0x00, 0x80, 0x00, 0x40,
           0x00, 0x10, 0x00, 0x01, 0x00, 0x80);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000,
            0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000);
-  VLOAD_16(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  VLOAD_16(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsrl.vv v8, v4, v6, v0.t");
+  asm volatile("vsrl.vv v8, v16, v24, v0.t");
   VCMP_U16(6, v8, 0x0000, 0x4000, 0x0000, 0x1000, 0x0000, 0x0001, 0x0000,
            0x8000, 0x0000, 0x4000, 0x0000, 0x1000, 0x0000, 0x0001, 0x0000,
            0x8000);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
            0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
            0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
            0x80000000);
-  VLOAD_32(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  VLOAD_32(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsrl.vv v8, v4, v6, v0.t");
+  asm volatile("vsrl.vv v8, v16, v24, v0.t");
   VCMP_U32(7, v8, 0x00000000, 0x40000000, 0x00000000, 0x10000000, 0x00000000,
            0x00010000, 0x00000000, 0x80000000, 0x00000000, 0x40000000,
            0x00000000, 0x10000000, 0x00000000, 0x00010000, 0x00000000,
            0x80000000);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000, 0x8000000000000000, 0x8000000000000000,
            0x8000000000000000);
-  VLOAD_64(v6, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
+  VLOAD_64(v24, 0, 1, 2, 3, 7, 15, 31, 32, 0, 1, 2, 3, 7, 15, 31, 32);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsrl.vv v8, v4, v6, v0.t");
+  asm volatile("vsrl.vv v8, v16, v24, v0.t");
   VCMP_U64(8, v8, 0x0000000000000000, 0x4000000000000000, 0x0000000000000000,
            0x1000000000000000, 0x0000000000000000, 0x0001000000000000,
            0x0000000000000000, 0x0000000080000000, 0x0000000000000000,
@@ -116,41 +116,41 @@ void TEST_CASE2(void) {
 void TEST_CASE3(void) {
   const uint64_t scalar = 2;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
           0xEC, 0xF0, 0xF4, 0xF8, 0xFC);
-  asm volatile("vsrl.vx v8, v4, %[A]" ::[A] "r"(scalar));
+  asm volatile("vsrl.vx v8, v16, %[A]" ::[A] "r"(scalar));
   VCMP_U8(9, v8, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x38, 0x39,
           0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
            0xFFE0, 0xFFE4, 0xFFE8, 0xFFEC, 0xFFF0, 0xFFF4, 0xFFF8, 0xFFFC);
-  asm volatile("vsrl.vx v8, v4, %[A]" ::[A] "r"(scalar));
+  asm volatile("vsrl.vx v8, v16, %[A]" ::[A] "r"(scalar));
   VCMP_U16(10, v8, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
            0x0008, 0x3FF8, 0x3FF9, 0x3FFA, 0x3FFB, 0x3FFC, 0x3FFD, 0x3FFE,
            0x3FFF);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
            0x00000018, 0x0000001C, 0x00000020, 0xFFFFFFE0, 0xFFFFFFE4,
            0xFFFFFFE8, 0xFFFFFFEC, 0xFFFFFFF0, 0xFFFFFFF4, 0xFFFFFFF8,
            0xFFFFFFFC);
-  asm volatile("vsrl.vx v8, v4, %[A]" ::[A] "r"(scalar));
+  asm volatile("vsrl.vx v8, v16, %[A]" ::[A] "r"(scalar));
   VCMP_U32(11, v8, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005,
            0x00000006, 0x00000007, 0x00000008, 0x3FFFFFF8, 0x3FFFFFF9,
            0x3FFFFFFA, 0x3FFFFFFB, 0x3FFFFFFC, 0x3FFFFFFD, 0x3FFFFFFE,
            0x3FFFFFFF);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
            0x0000000000000010, 0x0000000000000014, 0x0000000000000018,
            0x000000000000001C, 0x0000000000000020, 0xFFFFFFFFFFFFFFE0,
            0xFFFFFFFFFFFFFFE4, 0xFFFFFFFFFFFFFFE8, 0xFFFFFFFFFFFFFFEC,
            0xFFFFFFFFFFFFFFF0, 0xFFFFFFFFFFFFFFF4, 0xFFFFFFFFFFFFFFF8,
            0xFFFFFFFFFFFFFFFC);
-  asm volatile("vsrl.vx v8, v4, %[A]" ::[A] "r"(scalar));
+  asm volatile("vsrl.vx v8, v16, %[A]" ::[A] "r"(scalar));
   VCMP_U64(12, v8, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
            0x0000000000000004, 0x0000000000000005, 0x0000000000000006,
            0x0000000000000007, 0x0000000000000008, 0x3FFFFFFFFFFFFFF8,
@@ -163,41 +163,41 @@ void TEST_CASE3(void) {
 void TEST_CASE4(void) {
   const uint64_t scalar = 2;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
           0xEC, 0xF0, 0xF4, 0xF8, 0xFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsrl.vx v8, v4, %[A], v0.t" ::[A] "r"(scalar));
+  asm volatile("vsrl.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U8(13, v8, 0x00, 0x02, 0x00, 0x04, 0x00, 0x06, 0x00, 0x08, 0x00, 0x39,
           0x00, 0x3B, 0x00, 0x3D, 0x00, 0x3F);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
            0xFFE0, 0xFFE4, 0xFFE8, 0xFFEC, 0xFFF0, 0xFFF4, 0xFFF8, 0xFFFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsrl.vx v8, v4, %[A], v0.t" ::[A] "r"(scalar));
+  asm volatile("vsrl.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U16(14, v8, 0x0000, 0x0002, 0x0000, 0x0004, 0x0000, 0x0006, 0x0000,
            0x0008, 0x0000, 0x3FF9, 0x0000, 0x3FFB, 0x0000, 0x3FFD, 0x0000,
            0x3FFF);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
            0x00000018, 0x0000001C, 0x00000020, 0xFFFFFFE0, 0xFFFFFFE4,
            0xFFFFFFE8, 0xFFFFFFEC, 0xFFFFFFF0, 0xFFFFFFF4, 0xFFFFFFF8,
            0xFFFFFFFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsrl.vx v8, v4, %[A], v0.t" ::[A] "r"(scalar));
+  asm volatile("vsrl.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U32(15, v8, 0x00000000, 0x00000002, 0x00000000, 0x00000004, 0x00000000,
            0x00000006, 0x00000000, 0x00000008, 0x00000000, 0x3FFFFFF9,
            0x00000000, 0x3FFFFFFB, 0x00000000, 0x3FFFFFFD, 0x00000000,
            0x3FFFFFFF);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
            0x0000000000000010, 0x0000000000000014, 0x0000000000000018,
            0x000000000000001C, 0x0000000000000020, 0xFFFFFFFFFFFFFFE0,
            0xFFFFFFFFFFFFFFE4, 0xFFFFFFFFFFFFFFE8, 0xFFFFFFFFFFFFFFEC,
@@ -205,7 +205,7 @@ void TEST_CASE4(void) {
            0xFFFFFFFFFFFFFFFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsrl.vx v8, v4, %[A], v0.t" ::[A] "r"(scalar));
+  asm volatile("vsrl.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
   VCMP_U64(16, v8, 0x0000000000000000, 0x0000000000000002, 0x0000000000000000,
            0x0000000000000004, 0x0000000000000000, 0x0000000000000006,
            0x0000000000000000, 0x0000000000000008, 0x0000000000000000,
@@ -216,41 +216,41 @@ void TEST_CASE4(void) {
 };
 
 void TEST_CASE5(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
           0xEC, 0xF0, 0xF4, 0xF8, 0xFC);
-  asm volatile("vsrl.vi v8, v4, 2");
+  asm volatile("vsrl.vi v8, v16, 2");
   VCMP_U8(17, v8, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x38, 0x39,
           0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
            0xFFE0, 0xFFE4, 0xFFE8, 0xFFEC, 0xFFF0, 0xFFF4, 0xFFF8, 0xFFFC);
-  asm volatile("vsrl.vi v8, v4, 2");
+  asm volatile("vsrl.vi v8, v16, 2");
   VCMP_U16(18, v8, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
            0x0008, 0x3FF8, 0x3FF9, 0x3FFA, 0x3FFB, 0x3FFC, 0x3FFD, 0x3FFE,
            0x3FFF);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
            0x00000018, 0x0000001C, 0x00000020, 0xFFFFFFE0, 0xFFFFFFE4,
            0xFFFFFFE8, 0xFFFFFFEC, 0xFFFFFFF0, 0xFFFFFFF4, 0xFFFFFFF8,
            0xFFFFFFFC);
-  asm volatile("vsrl.vi v8, v4, 2");
+  asm volatile("vsrl.vi v8, v16, 2");
   VCMP_U32(19, v8, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005,
            0x00000006, 0x00000007, 0x00000008, 0x3FFFFFF8, 0x3FFFFFF9,
            0x3FFFFFFA, 0x3FFFFFFB, 0x3FFFFFFC, 0x3FFFFFFD, 0x3FFFFFFE,
            0x3FFFFFFF);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
            0x0000000000000010, 0x0000000000000014, 0x0000000000000018,
            0x000000000000001C, 0x0000000000000020, 0xFFFFFFFFFFFFFFE0,
            0xFFFFFFFFFFFFFFE4, 0xFFFFFFFFFFFFFFE8, 0xFFFFFFFFFFFFFFEC,
            0xFFFFFFFFFFFFFFF0, 0xFFFFFFFFFFFFFFF4, 0xFFFFFFFFFFFFFFF8,
            0xFFFFFFFFFFFFFFFC);
-  asm volatile("vsrl.vi v8, v4, 2");
+  asm volatile("vsrl.vi v8, v16, 2");
   VCMP_U64(20, v8, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003,
            0x0000000000000004, 0x0000000000000005, 0x0000000000000006,
            0x0000000000000007, 0x0000000000000008, 0x3FFFFFFFFFFFFFF8,
@@ -261,41 +261,41 @@ void TEST_CASE5(void) {
 };
 
 void TEST_CASE6(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v4, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
+  VSET(16, e8, m8);
+  VLOAD_8(v16, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, 0x20, 0xE0, 0xE4, 0xE8,
           0xEC, 0xF0, 0xF4, 0xF8, 0xFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsrl.vi v8, v4, 2, v0.t");
+  asm volatile("vsrl.vi v8, v16, 2, v0.t");
   VCMP_U8(21, v8, 0x00, 0x02, 0x00, 0x04, 0x00, 0x06, 0x00, 0x08, 0x00, 0x39,
           0x00, 0x3B, 0x00, 0x3D, 0x00, 0x3F);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v4, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
+  VSET(16, e16, m8);
+  VLOAD_16(v16, 0x0004, 0x0008, 0x000C, 0x0010, 0x0014, 0x0018, 0x001C, 0x0020,
            0xFFE0, 0xFFE4, 0xFFE8, 0xFFEC, 0xFFF0, 0xFFF4, 0xFFF8, 0xFFFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsrl.vi v8, v4, 2, v0.t");
+  asm volatile("vsrl.vi v8, v16, 2, v0.t");
   VCMP_U16(22, v8, 0x0000, 0x0002, 0x0000, 0x0004, 0x0000, 0x0006, 0x0000,
            0x0008, 0x0000, 0x3FF9, 0x0000, 0x3FFB, 0x0000, 0x3FFD, 0x0000,
            0x3FFF);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v4, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
+  VSET(16, e32, m8);
+  VLOAD_32(v16, 0x00000004, 0x00000008, 0x0000000C, 0x00000010, 0x00000014,
            0x00000018, 0x0000001C, 0x00000020, 0xFFFFFFE0, 0xFFFFFFE4,
            0xFFFFFFE8, 0xFFFFFFEC, 0xFFFFFFF0, 0xFFFFFFF4, 0xFFFFFFF8,
            0xFFFFFFFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsrl.vi v8, v4, 2, v0.t");
+  asm volatile("vsrl.vi v8, v16, 2, v0.t");
   VCMP_U32(23, v8, 0x00000000, 0x00000002, 0x00000000, 0x00000004, 0x00000000,
            0x00000006, 0x00000000, 0x00000008, 0x00000000, 0x3FFFFFF9,
            0x00000000, 0x3FFFFFFB, 0x00000000, 0x3FFFFFFD, 0x00000000,
            0x3FFFFFFF);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v4, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
+  VSET(16, e64, m8);
+  VLOAD_64(v16, 0x0000000000000004, 0x0000000000000008, 0x000000000000000C,
            0x0000000000000010, 0x0000000000000014, 0x0000000000000018,
            0x000000000000001C, 0x0000000000000020, 0xFFFFFFFFFFFFFFE0,
            0xFFFFFFFFFFFFFFE4, 0xFFFFFFFFFFFFFFE8, 0xFFFFFFFFFFFFFFEC,
@@ -303,7 +303,7 @@ void TEST_CASE6(void) {
            0xFFFFFFFFFFFFFFFC);
   VLOAD_8(v0, 0xAA, 0xAA);
   VCLEAR(v8);
-  asm volatile("vsrl.vi v8, v4, 2, v0.t");
+  asm volatile("vsrl.vi v8, v16, 2, v0.t");
   VCMP_U64(24, v8, 0x0000000000000000, 0x0000000000000002, 0x0000000000000000,
            0x0000000000000004, 0x0000000000000000, 0x0000000000000006,
            0x0000000000000000, 0x0000000000000008, 0x0000000000000000,
diff --git a/sw/riscvTests/isa/rv64uv/vsub.c b/sw/riscvTests/isa/rv64uv/vsub.c
index 32a74668..177910fd 100644
--- a/sw/riscvTests/isa/rv64uv/vsub.c
+++ b/sw/riscvTests/isa/rv64uv/vsub.c
@@ -8,126 +8,126 @@
 #include "vector_macros.h"
 
 void TEST_CASE1(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vsub.vv v6, v2, v4");
-  VCMP_U8(1, v6, 4, 8, 12, 16, 20, 24, 28, 32, 4, 8, 12, 16, 20, 24, 28, 32);
-
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vsub.vv v6, v2, v4");
-  VCMP_U16(2, v6, 4, 8, 12, 16, 20, 24, 28, 32, 4, 8, 12, 16, 20, 24, 28, 32);
-
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vsub.vv v6, v2, v4");
-  VCMP_U32(3, v6, 4, 8, 12, 16, 20, 24, 28, 32, 4, 8, 12, 16, 20, 24, 28, 32);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vsub.vv v24, v8, v16");
+  VCMP_U8(1, v24, 4, 8, 12, 16, 20, 24, 28, 32, 4, 8, 12, 16, 20, 24, 28, 32);
+
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vsub.vv v24, v8, v16");
+  VCMP_U16(2, v24, 4, 8, 12, 16, 20, 24, 28, 32, 4, 8, 12, 16, 20, 24, 28, 32);
+
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vsub.vv v24, v8, v16");
+  VCMP_U32(3, v24, 4, 8, 12, 16, 20, 24, 28, 32, 4, 8, 12, 16, 20, 24, 28, 32);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
-  asm volatile("vsub.vv v6, v2, v4");
-  VCMP_U64(4, v6, 4, 8, 12, 16, 20, 24, 28, 32, 4, 8, 12, 16, 20, 24, 28, 32);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  asm volatile("vsub.vv v24, v8, v16");
+  VCMP_U64(4, v24, 4, 8, 12, 16, 20, 24, 28, 32, 4, 8, 12, 16, 20, 24, 28, 32);
 #endif
 }
 
 void TEST_CASE2(void) {
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  VLOAD_8(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VLOAD_8(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vsub.vv v6, v2, v4, v0.t");
-  VCMP_U8(5, v6, 0, 8, 0, 16, 0, 24, 0, 32, 0, 8, 0, 16, 0, 24, 0, 32);
+  VCLEAR(v24);
+  asm volatile("vsub.vv v24, v8, v16, v0.t");
+  VCMP_U8(5, v24, 0, 8, 0, 16, 0, 24, 0, 32, 0, 8, 0, 16, 0, 24, 0, 32);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  VLOAD_16(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VLOAD_16(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vsub.vv v6, v2, v4, v0.t");
-  VCMP_U16(6, v6, 0, 8, 0, 16, 0, 24, 0, 32, 0, 8, 0, 16, 0, 24, 0, 32);
+  VCLEAR(v24);
+  asm volatile("vsub.vv v24, v8, v16, v0.t");
+  VCMP_U16(6, v24, 0, 8, 0, 16, 0, 24, 0, 32, 0, 8, 0, 16, 0, 24, 0, 32);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  VLOAD_32(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VLOAD_32(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vsub.vv v6, v2, v4, v0.t");
-  VCMP_U32(7, v6, 0, 8, 0, 16, 0, 24, 0, 32, 0, 8, 0, 16, 0, 24, 0, 32);
+  VCLEAR(v24);
+  asm volatile("vsub.vv v24, v8, v16, v0.t");
+  VCMP_U32(7, v24, 0, 8, 0, 16, 0, 24, 0, 32, 0, 8, 0, 16, 0, 24, 0, 32);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  VLOAD_64(v4, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VLOAD_64(v16, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vsub.vv v6, v2, v4, v0.t");
-  VCMP_U64(8, v6, 0, 8, 0, 16, 0, 24, 0, 32, 0, 8, 0, 16, 0, 24, 0, 32);
+  VCLEAR(v24);
+  asm volatile("vsub.vv v24, v8, v16, v0.t");
+  VCMP_U64(8, v24, 0, 8, 0, 16, 0, 24, 0, 32, 0, 8, 0, 16, 0, 24, 0, 32);
 #endif
 }
 
 void TEST_CASE3(void) {
   const uint64_t scalar = 5;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  asm volatile("vsub.vx v6, v2, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(9, v6, 0, 5, 10, 15, 20, 25, 30, 35, 0, 5, 10, 15, 20, 25, 30, 35);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  asm volatile("vsub.vx v24, v8, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(9, v24, 0, 5, 10, 15, 20, 25, 30, 35, 0, 5, 10, 15, 20, 25, 30, 35);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  asm volatile("vsub.vx v6, v2, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(10, v6, 0, 5, 10, 15, 20, 25, 30, 35, 0, 5, 10, 15, 20, 25, 30, 35);
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  asm volatile("vsub.vx v24, v8, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(10, v24, 0, 5, 10, 15, 20, 25, 30, 35, 0, 5, 10, 15, 20, 25, 30, 35);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  asm volatile("vsub.vx v6, v2, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(11, v6, 0, 5, 10, 15, 20, 25, 30, 35, 0, 5, 10, 15, 20, 25, 30, 35);
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  asm volatile("vsub.vx v24, v8, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(11, v24, 0, 5, 10, 15, 20, 25, 30, 35, 0, 5, 10, 15, 20, 25, 30, 35);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
-  asm volatile("vsub.vx v6, v2, %[A]" ::[A] "r"(scalar));
-  VCMP_U64(12, v6, 0, 5, 10, 15, 20, 25, 30, 35, 0, 5, 10, 15, 20, 25, 30, 35);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  asm volatile("vsub.vx v24, v8, %[A]" ::[A] "r"(scalar));
+  VCMP_U64(12, v24, 0, 5, 10, 15, 20, 25, 30, 35, 0, 5, 10, 15, 20, 25, 30, 35);
 #endif
 }
 
 void TEST_CASE4(void) {
   const uint64_t scalar = 5;
 
-  VSET(16, e8, m2);
-  VLOAD_8(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VSET(16, e8, m8);
+  VLOAD_8(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vsub.vx v6, v2, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U8(13, v6, 0, 5, 0, 15, 0, 25, 0, 35, 0, 5, 0, 15, 0, 25, 0, 35);
+  VCLEAR(v24);
+  asm volatile("vsub.vx v24, v8, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U8(13, v24, 0, 5, 0, 15, 0, 25, 0, 35, 0, 5, 0, 15, 0, 25, 0, 35);
 
-  VSET(16, e16, m2);
-  VLOAD_16(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VSET(16, e16, m8);
+  VLOAD_16(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vsub.vx v6, v2, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U16(14, v6, 0, 5, 0, 15, 0, 25, 0, 35, 0, 5, 0, 15, 0, 25, 0, 35);
+  VCLEAR(v24);
+  asm volatile("vsub.vx v24, v8, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U16(14, v24, 0, 5, 0, 15, 0, 25, 0, 35, 0, 5, 0, 15, 0, 25, 0, 35);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VSET(16, e32, m8);
+  VLOAD_32(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vsub.vx v6, v2, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U32(15, v6, 0, 5, 0, 15, 0, 25, 0, 35, 0, 5, 0, 15, 0, 25, 0, 35);
+  VCLEAR(v24);
+  asm volatile("vsub.vx v24, v8, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U32(15, v24, 0, 5, 0, 15, 0, 25, 0, 35, 0, 5, 0, 15, 0, 25, 0, 35);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v2, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
+  VSET(16, e64, m8);
+  VLOAD_64(v8, 5, 10, 15, 20, 25, 30, 35, 40, 5, 10, 15, 20, 25, 30, 35, 40);
   VLOAD_8(v0, 0xAA, 0xAA);
-  VCLEAR(v6);
-  asm volatile("vsub.vx v6, v2, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U64(16, v6, 0, 5, 0, 15, 0, 25, 0, 35, 0, 5, 0, 15, 0, 25, 0, 35);
+  VCLEAR(v24);
+  asm volatile("vsub.vx v24, v8, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U64(16, v24, 0, 5, 0, 15, 0, 25, 0, 35, 0, 5, 0, 15, 0, 25, 0, 35);
 #endif
 }
 
diff --git a/sw/riscvTests/isa/rv64uv/vwmacc.c b/sw/riscvTests/isa/rv64uv/vwmacc.c
index 3517d1a6..d1118af8 100644
--- a/sw/riscvTests/isa/rv64uv/vwmacc.c
+++ b/sw/riscvTests/isa/rv64uv/vwmacc.c
@@ -8,46 +8,46 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x460f, 0x1c3e, 0xa322, 0xa7de, 0xd343, 0xa068, 0xf7a8, 0x3a62,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0x460f, 0x1c3e, 0xa322, 0xa7de, 0xd343, 0xa068, 0xf7a8, 0x3a62,
            0x3f7f, 0x0ae0, 0x0e38, 0x57fe, 0xdc97, 0x61e5, 0xe3f4, 0xb1bd);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   VLOAD_8(v4, 0x19, 0x87, 0x46, 0xf5, 0x3d, 0x66, 0xd7, 0xcf, 0x9f, 0x73, 0x35,
           0x92, 0xb4, 0xc4, 0xdb, 0x1a);
   VLOAD_8(v8, 0xd0, 0x62, 0xb7, 0xd9, 0x39, 0xdf, 0x3e, 0x3d, 0xa2, 0xbb, 0xf1,
           0xba, 0xe2, 0xd7, 0x51, 0x5d);
-  asm volatile("vwmacc.vv v6, v4, v8");
-  VSET(16, e16, m2);
-  VCMP_I16(1, v6, 0x415f, 0xedec, 0x8f2c, 0xa98b, 0xe0d8, 0x9342, 0xedba,
+  asm volatile("vwmacc.vv v16, v4, v8");
+  VSET(16, e16, m4);
+  VCMP_I16(1, v16, 0x415f, 0xedec, 0x8f2c, 0xa98b, 0xe0d8, 0x9342, 0xedba,
            0x2eb5, 0x631d, 0xebe1, 0x0b1d, 0x7612, 0xe57f, 0x6b81, 0xd83f,
            0xbb2f);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0x1d5e4130, 0x9a736c84, 0xe2c407c1, 0x62baf7c8, 0xc157159f,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0x1d5e4130, 0x9a736c84, 0xe2c407c1, 0x62baf7c8, 0xc157159f,
            0x6cea275d, 0x0c385a3e, 0xf8f640d1, 0x484e89df, 0xb7720e91,
            0x17a7a4cf, 0x9cba6dac, 0x177e67d2, 0x491950da, 0x5b48691f,
            0x03289e10);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   VLOAD_16(v4, 0x6930, 0x239f, 0x2214, 0x555e, 0x9868, 0x02e7, 0x784f, 0x8c32,
            0xe8d1, 0xe941, 0xaaaf, 0x4833, 0xc773, 0x6156, 0xdad9, 0x02a5);
   VLOAD_16(v8, 0xe798, 0x1fe5, 0xca4f, 0xb93c, 0xafe4, 0x5641, 0x4848, 0x82a3,
            0x6065, 0x1385, 0x5a53, 0x3318, 0xd488, 0xb1cf, 0x5142, 0x0277);
-  asm volatile("vwmacc.vv v6, v4, v8");
-  VSET(16, e32, m2);
-  VCMP_I32(2, v6, 0x135705b0, 0x9ee38abf, 0xdb9e53ed, 0x4b21e7d0, 0xe1c1ea3f,
+  asm volatile("vwmacc.vv v16, v4, v8");
+  VSET(16, e32, m4);
+  VCMP_I32(2, v16, 0x135705b0, 0x9ee38abf, 0xdb9e53ed, 0x4b21e7d0, 0xe1c1ea3f,
            0x6de47e04, 0x2e306876, 0x31abe8a7, 0x3f93c454, 0xb5b61056,
            0xf98d818c, 0xab235b74, 0x211898ea, 0x2b5e7b64, 0x4f7d7e11,
            0x032f22c3);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0x37abc1433be408eb, 0xb3af312be2d38e09, 0x3a99dc46913b03d2,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0x37abc1433be408eb, 0xb3af312be2d38e09, 0x3a99dc46913b03d2,
            0xb2cca27c11815d4d, 0x456749124aaf479a, 0xc11d5ef0eaa5ee72,
            0x1e6a624541e03978, 0x36ce0e391abb8a91, 0x552a61c1f7116723,
            0x621ae1e17b7074c2, 0x4c3f1888b5df72b9, 0xde3961024df8c2cf,
            0x37cd59f214853904, 0xe76372440eb37d3d, 0x0f0ff8cee2000142,
            0x061e905b827b9818);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   VLOAD_32(v4, 0xb5c0475b, 0xda0c4af7, 0xa939123e, 0xb7261aa3, 0x510b75c1,
            0x7d5e66d9, 0x3b263bb7, 0xc35c07a0, 0x03b0bb28, 0xba423d88,
            0xb4ddeabb, 0x97b1e0ce, 0x01d07d01, 0x16174f78, 0x40c6b24f,
@@ -56,9 +56,9 @@ void TEST_CASE1() {
            0x5fc79836, 0x6597295d, 0x737b18f1, 0x8cb86656, 0x044f320e,
            0x2a881643, 0x2e1a8f59, 0xfdc331d1, 0xca03d155, 0x0a51ebfe,
            0xcac2c353);
-  asm volatile("vwmacc.vv v6, v4, v8");
-  VSET(16, e64, m2);
-  VCMP_I64(3, v6, 0x27987c3defb2dc09, 0xc2652748b5903b7c, 0x5fb1b6348769c35c,
+  asm volatile("vwmacc.vv v16, v4, v8");
+  VSET(16, e64, m4);
+  VCMP_I64(3, v16, 0x27987c3defb2dc09, 0xc2652748b5903b7c, 0x5fb1b6348769c35c,
            0xc1e76e2cf6217c56, 0x4cc871cf26ba35d4, 0xf0052607e34f7838,
            0x35e364f04a4539f3, 0x1b733cf52ef5b831, 0x5380f57403c23693,
            0x60ee57a5b80c6232, 0x3fc390677f77f3aa, 0xcb708510404efc6d,
@@ -68,48 +68,48 @@ void TEST_CASE1() {
 }
 
 void TEST_CASE2() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x460f, 0x1c3e, 0xa322, 0xa7de, 0xd343, 0xa068, 0xf7a8, 0x3a62,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0x460f, 0x1c3e, 0xa322, 0xa7de, 0xd343, 0xa068, 0xf7a8, 0x3a62,
            0x3f7f, 0x0ae0, 0x0e38, 0x57fe, 0xdc97, 0x61e5, 0xe3f4, 0xb1bd);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   VLOAD_8(v4, 0x19, 0x87, 0x46, 0xf5, 0x3d, 0x66, 0xd7, 0xcf, 0x9f, 0x73, 0x35,
           0x92, 0xb4, 0xc4, 0xdb, 0x1a);
   VLOAD_8(v8, 0xd0, 0x62, 0xb7, 0xd9, 0x39, 0xdf, 0x3e, 0x3d, 0xa2, 0xbb, 0xf1,
           0xba, 0xe2, 0xd7, 0x51, 0x5d);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmacc.vv v6, v4, v8, v0.t");
-  VSET(16, e16, m2);
-  VCMP_I16(4, v6, 0x460f, 0xedec, 0xa322, 0xa98b, 0xd343, 0x9342, 0xf7a8,
+  asm volatile("vwmacc.vv v16, v4, v8, v0.t");
+  VSET(16, e16, m4);
+  VCMP_I16(4, v16, 0x460f, 0xedec, 0xa322, 0xa98b, 0xd343, 0x9342, 0xf7a8,
            0x2eb5, 0x3f7f, 0xebe1, 0x0e38, 0x7612, 0xdc97, 0x6b81, 0xe3f4,
            0xbb2f);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0x1d5e4130, 0x9a736c84, 0xe2c407c1, 0x62baf7c8, 0xc157159f,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0x1d5e4130, 0x9a736c84, 0xe2c407c1, 0x62baf7c8, 0xc157159f,
            0x6cea275d, 0x0c385a3e, 0xf8f640d1, 0x484e89df, 0xb7720e91,
            0x17a7a4cf, 0x9cba6dac, 0x177e67d2, 0x491950da, 0x5b48691f,
            0x03289e10);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   VLOAD_16(v4, 0x6930, 0x239f, 0x2214, 0x555e, 0x9868, 0x02e7, 0x784f, 0x8c32,
            0xe8d1, 0xe941, 0xaaaf, 0x4833, 0xc773, 0x6156, 0xdad9, 0x02a5);
   VLOAD_16(v8, 0xe798, 0x1fe5, 0xca4f, 0xb93c, 0xafe4, 0x5641, 0x4848, 0x82a3,
            0x6065, 0x1385, 0x5a53, 0x3318, 0xd488, 0xb1cf, 0x5142, 0x0277);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmacc.vv v6, v4, v8, v0.t");
-  VSET(16, e32, m2);
-  VCMP_I32(5, v6, 0x1d5e4130, 0x9ee38abf, 0xe2c407c1, 0x4b21e7d0, 0xc157159f,
+  asm volatile("vwmacc.vv v16, v4, v8, v0.t");
+  VSET(16, e32, m4);
+  VCMP_I32(5, v16, 0x1d5e4130, 0x9ee38abf, 0xe2c407c1, 0x4b21e7d0, 0xc157159f,
            0x6de47e04, 0x0c385a3e, 0x31abe8a7, 0x484e89df, 0xb5b61056,
            0x17a7a4cf, 0xab235b74, 0x177e67d2, 0x2b5e7b64, 0x5b48691f,
            0x032f22c3);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0x37abc1433be408eb, 0xb3af312be2d38e09, 0x3a99dc46913b03d2,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0x37abc1433be408eb, 0xb3af312be2d38e09, 0x3a99dc46913b03d2,
            0xb2cca27c11815d4d, 0x456749124aaf479a, 0xc11d5ef0eaa5ee72,
            0x1e6a624541e03978, 0x36ce0e391abb8a91, 0x552a61c1f7116723,
            0x621ae1e17b7074c2, 0x4c3f1888b5df72b9, 0xde3961024df8c2cf,
            0x37cd59f214853904, 0xe76372440eb37d3d, 0x0f0ff8cee2000142,
            0x061e905b827b9818);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   VLOAD_32(v4, 0xb5c0475b, 0xda0c4af7, 0xa939123e, 0xb7261aa3, 0x510b75c1,
            0x7d5e66d9, 0x3b263bb7, 0xc35c07a0, 0x03b0bb28, 0xba423d88,
            0xb4ddeabb, 0x97b1e0ce, 0x01d07d01, 0x16174f78, 0x40c6b24f,
@@ -119,9 +119,9 @@ void TEST_CASE2() {
            0x2a881643, 0x2e1a8f59, 0xfdc331d1, 0xca03d155, 0x0a51ebfe,
            0xcac2c353);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmacc.vv v6, v4, v8, v0.t");
-  VSET(16, e64, m2);
-  VCMP_I64(6, v6, 0x37abc1433be408eb, 0xc2652748b5903b7c, 0x3a99dc46913b03d2,
+  asm volatile("vwmacc.vv v16, v4, v8, v0.t");
+  VSET(16, e64, m4);
+  VCMP_I64(6, v16, 0x37abc1433be408eb, 0xc2652748b5903b7c, 0x3a99dc46913b03d2,
            0xc1e76e2cf6217c56, 0x456749124aaf479a, 0xf0052607e34f7838,
            0x1e6a624541e03978, 0x1b733cf52ef5b831, 0x552a61c1f7116723,
            0x60ee57a5b80c6232, 0x4c3f1888b5df72b9, 0xcb708510404efc6d,
@@ -131,52 +131,52 @@ void TEST_CASE2() {
 }
 
 void TEST_CASE3() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x17db, 0x9069, 0x8e1f, 0x3584, 0xbb3d, 0x39b2, 0x82cf, 0x015b,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0x17db, 0x9069, 0x8e1f, 0x3584, 0xbb3d, 0x39b2, 0x82cf, 0x015b,
            0xd556, 0xd603, 0x85d1, 0x66a6, 0x4e3e, 0xb965, 0xaa7b, 0x9d27);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   int64_t scalar = 5;
   VLOAD_8(v8, 0x50, 0x56, 0x94, 0x1e, 0x09, 0x8f, 0xe1, 0x9e, 0x86, 0x97, 0x71,
           0x5e, 0x55, 0x09, 0xdd, 0x23);
-  asm volatile("vwmacc.vx v6, %[A], v8" ::[A] "r"(scalar));
-  VSET(16, e16, m2);
-  VCMP_I16(7, v6, 0x196b, 0x9217, 0x8c03, 0x361a, 0xbb6a, 0x377d, 0x8234,
+  asm volatile("vwmacc.vx v16, %[A], v8" ::[A] "r"(scalar));
+  VSET(16, e16, m4);
+  VCMP_I16(7, v16, 0x196b, 0x9217, 0x8c03, 0x361a, 0xbb6a, 0x377d, 0x8234,
            0xff71, 0xd2f4, 0xd3f6, 0x8806, 0x687c, 0x4fe7, 0xb992, 0xa9cc,
            0x9dd6);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0xc9b9ade8, 0xfc9c14a8, 0xe1ace4f7, 0x43ea8b48, 0x3ab3025c,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0xc9b9ade8, 0xfc9c14a8, 0xe1ace4f7, 0x43ea8b48, 0x3ab3025c,
            0xe545695b, 0x538304ce, 0xf430c148, 0xd126fac1, 0xbf51d251,
            0x85ebc0a4, 0x2167faaf, 0x0a2e18cc, 0x0ae19395, 0x03cc9899,
            0x05524f83);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   scalar = -5383;
   VLOAD_16(v8, 0x4324, 0xd762, 0xc34b, 0x6f67, 0x5134, 0x4d9d, 0xfa05, 0xacb7,
            0xb7d2, 0xb079, 0x5bb2, 0x7949, 0x51df, 0xbadd, 0xee81, 0x3b49);
-  asm volatile("vwmacc.vx v6, %[A], v8" ::[A] "r"(scalar));
-  VSET(16, e32, m2);
-  VCMP_I32(8, v6, 0xc435e3ec, 0xfff226fa, 0xe6a966ea, 0x3ac40c77, 0x340785f0,
+  asm volatile("vwmacc.vx v16, %[A], v8" ::[A] "r"(scalar));
+  VSET(16, e32, m4);
+  VCMP_I32(8, v16, 0xc435e3ec, 0xfff226fa, 0xe6a966ea, 0x3ac40c77, 0x340785f0,
            0xdee56910, 0x5400c5ab, 0xfb080547, 0xd714ba03, 0xc5da1202,
            0x7e63a4c6, 0x1771acb0, 0x037490b3, 0x108f568a, 0x053c7e12,
            0x0073b384);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0xc3afd90f697a742a, 0x585e39767c2959ab, 0xfd5f5c31e16d95ba,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0xc3afd90f697a742a, 0x585e39767c2959ab, 0xfd5f5c31e16d95ba,
            0x2c39235d58ff74a1, 0x4a793d202092aeac, 0x6d31f07b7bdfb6ea,
            0x902b8e28be41b10d, 0x89114b9383c4b511, 0x1f9a7e912f5a51f0,
            0x5494b9380432890c, 0xfd260f5f1fc1eb45, 0x80381e728c1baa95,
            0xa6be6d48744a823b, 0xd37b8ae766a82bf8, 0x7992c128f1c1f6ab,
            0xbeca06f79871e7e8);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   scalar = 6474219;
   VLOAD_32(v8, 0x56545434, 0x99cd1438, 0xa1d42f8a, 0x3500b207, 0x642cd563,
            0x7405746d, 0xe92c3246, 0xdab496dc, 0xcbe26107, 0x6bb989c7,
            0xc8542e0c, 0x5849a179, 0x04aac7de, 0x7b5ce579, 0x0ce6e7ea,
            0x77402b10);
-  asm volatile("vwmacc.vx v6, %[A], v8" ::[A] "r"(scalar));
-  VSET(16, e64, m2);
-  VCMP_I64(9, v6, 0xc3d1296f1ae893e6, 0x5836c95c6dbae113, 0xfd3b05253b5c9368,
+  asm volatile("vwmacc.vx v16, %[A], v8" ::[A] "r"(scalar));
+  VSET(16, e64, m4);
+  VCMP_I64(9, v16, 0xc3d1296f1ae893e6, 0x5836c95c6dbae113, 0xfd3b05253b5c9368,
            0x2c4d976fb318600e, 0x4a9fe54cf92b4b8d, 0x6d5eb614d7052bf9,
            0x9022bf12bc18cd4f, 0x8902e74ad235ed05, 0x1f86621f3b05e25d,
            0x54be4b3652df41b9, 0xfd1093afbdc79c49, 0x805a304537cce5a8,
@@ -186,55 +186,55 @@ void TEST_CASE3() {
 }
 
 void TEST_CASE4() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x17db, 0x9069, 0x8e1f, 0x3584, 0xbb3d, 0x39b2, 0x82cf, 0x015b,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0x17db, 0x9069, 0x8e1f, 0x3584, 0xbb3d, 0x39b2, 0x82cf, 0x015b,
            0xd556, 0xd603, 0x85d1, 0x66a6, 0x4e3e, 0xb965, 0xaa7b, 0x9d27);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   int64_t scalar = 5;
   VLOAD_8(v8, 0x50, 0x56, 0x94, 0x1e, 0x09, 0x8f, 0xe1, 0x9e, 0x86, 0x97, 0x71,
           0x5e, 0x55, 0x09, 0xdd, 0x23);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmacc.vx v6, %[A], v8, v0.t" ::[A] "r"(scalar));
-  VSET(16, e16, m2);
-  VCMP_I16(10, v6, 0x17db, 0x9217, 0x8e1f, 0x361a, 0xbb3d, 0x377d, 0x82cf,
+  asm volatile("vwmacc.vx v16, %[A], v8, v0.t" ::[A] "r"(scalar));
+  VSET(16, e16, m4);
+  VCMP_I16(10, v16, 0x17db, 0x9217, 0x8e1f, 0x361a, 0xbb3d, 0x377d, 0x82cf,
            0xff71, 0xd556, 0xd3f6, 0x85d1, 0x687c, 0x4e3e, 0xb992, 0xaa7b,
            0x9dd6);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0xc9b9ade8, 0xfc9c14a8, 0xe1ace4f7, 0x43ea8b48, 0x3ab3025c,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0xc9b9ade8, 0xfc9c14a8, 0xe1ace4f7, 0x43ea8b48, 0x3ab3025c,
            0xe545695b, 0x538304ce, 0xf430c148, 0xd126fac1, 0xbf51d251,
            0x85ebc0a4, 0x2167faaf, 0x0a2e18cc, 0x0ae19395, 0x03cc9899,
            0x05524f83);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   scalar = -5383;
   VLOAD_16(v8, 0x4324, 0xd762, 0xc34b, 0x6f67, 0x5134, 0x4d9d, 0xfa05, 0xacb7,
            0xb7d2, 0xb079, 0x5bb2, 0x7949, 0x51df, 0xbadd, 0xee81, 0x3b49);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmacc.vx v6, %[A], v8, v0.t" ::[A] "r"(scalar));
-  VSET(16, e32, m2);
-  VCMP_I32(11, v6, 0xc9b9ade8, 0xfff226fa, 0xe1ace4f7, 0x3ac40c77, 0x3ab3025c,
+  asm volatile("vwmacc.vx v16, %[A], v8, v0.t" ::[A] "r"(scalar));
+  VSET(16, e32, m4);
+  VCMP_I32(11, v16, 0xc9b9ade8, 0xfff226fa, 0xe1ace4f7, 0x3ac40c77, 0x3ab3025c,
            0xdee56910, 0x538304ce, 0xfb080547, 0xd126fac1, 0xc5da1202,
            0x85ebc0a4, 0x1771acb0, 0x0a2e18cc, 0x108f568a, 0x03cc9899,
            0x0073b384);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0xc3afd90f697a742a, 0x585e39767c2959ab, 0xfd5f5c31e16d95ba,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0xc3afd90f697a742a, 0x585e39767c2959ab, 0xfd5f5c31e16d95ba,
            0x2c39235d58ff74a1, 0x4a793d202092aeac, 0x6d31f07b7bdfb6ea,
            0x902b8e28be41b10d, 0x89114b9383c4b511, 0x1f9a7e912f5a51f0,
            0x5494b9380432890c, 0xfd260f5f1fc1eb45, 0x80381e728c1baa95,
            0xa6be6d48744a823b, 0xd37b8ae766a82bf8, 0x7992c128f1c1f6ab,
            0xbeca06f79871e7e8);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   scalar = 6474219;
   VLOAD_32(v8, 0x56545434, 0x99cd1438, 0xa1d42f8a, 0x3500b207, 0x642cd563,
            0x7405746d, 0xe92c3246, 0xdab496dc, 0xcbe26107, 0x6bb989c7,
            0xc8542e0c, 0x5849a179, 0x04aac7de, 0x7b5ce579, 0x0ce6e7ea,
            0x77402b10);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmacc.vx v6, %[A], v8, v0.t" ::[A] "r"(scalar));
-  VSET(16, e64, m2);
-  VCMP_I64(12, v6, 0xc3afd90f697a742a, 0x5836c95c6dbae113, 0xfd5f5c31e16d95ba,
+  asm volatile("vwmacc.vx v16, %[A], v8, v0.t" ::[A] "r"(scalar));
+  VSET(16, e64, m4);
+  VCMP_I64(12, v16, 0xc3afd90f697a742a, 0x5836c95c6dbae113, 0xfd5f5c31e16d95ba,
            0x2c4d976fb318600e, 0x4a793d202092aeac, 0x6d5eb614d7052bf9,
            0x902b8e28be41b10d, 0x8902e74ad235ed05, 0x1f9a7e912f5a51f0,
            0x54be4b3652df41b9, 0xfd260f5f1fc1eb45, 0x805a304537cce5a8,
diff --git a/sw/riscvTests/isa/rv64uv/vwmaccsu.c b/sw/riscvTests/isa/rv64uv/vwmaccsu.c
index d97b76a4..0db0d68d 100644
--- a/sw/riscvTests/isa/rv64uv/vwmaccsu.c
+++ b/sw/riscvTests/isa/rv64uv/vwmaccsu.c
@@ -8,46 +8,46 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x30dc, 0x7235, 0xd5f6, 0xa008, 0x6e79, 0xa159, 0xa05c, 0x5914,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0x30dc, 0x7235, 0xd5f6, 0xa008, 0x6e79, 0xa159, 0xa05c, 0x5914,
            0xd06f, 0x69c5, 0x9475, 0x5625, 0xa5bd, 0x7be7, 0x823c, 0x5fb2);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   VLOAD_8(v4, 0xb6, 0xbb, 0xb6, 0x57, 0xf9, 0x7c, 0xbf, 0x62, 0x1a, 0xeb, 0xa4,
           0x34, 0xde, 0x96, 0x80, 0xe6);
   VLOAD_8(v8, 0x26, 0xea, 0xe8, 0x85, 0x2e, 0xf1, 0x46, 0x8f, 0x68, 0x29, 0xbb,
           0x9b, 0xec, 0x5c, 0x8e, 0x77);
-  asm volatile("vwmaccsu.vv v6, v4, v8");
-  VSET(16, e16, m2);
-  VCMP_I16(1, v6, 0x25e0, 0x3323, 0x92e6, 0xcd3b, 0x6d37, 0x1615, 0x8e96,
+  asm volatile("vwmaccsu.vv v16, v4, v8");
+  VSET(16, e16, m4);
+  VCMP_I16(1, v16, 0x25e0, 0x3323, 0x92e6, 0xcd3b, 0x6d37, 0x1615, 0x8e96,
            0x8fd2, 0xdaff, 0x6668, 0x5141, 0x75a1, 0x8665, 0x55cf, 0x3b3c,
            0x539c);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0xdbc5b23d, 0x86bd7dad, 0xb744b5c2, 0xc32f4a47, 0x237edfc4,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0xdbc5b23d, 0x86bd7dad, 0xb744b5c2, 0xc32f4a47, 0x237edfc4,
            0x5d6e851a, 0xbd3110cd, 0x18c61b57, 0x7ade2943, 0x7e4f5ed6,
            0x90e5ba77, 0xce45b744, 0x82d1976e, 0xa88bb4e1, 0x989fbb9a,
            0xab29da17);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   VLOAD_16(v4, 0x23fb, 0xcee7, 0xa704, 0xc00f, 0xed9f, 0x2cf0, 0x4b53, 0xc0ba,
            0x775b, 0x557c, 0x57b7, 0xbb06, 0xf9ba, 0x178f, 0xec73, 0x8240);
   VLOAD_16(v8, 0xad9d, 0x104d, 0xdc56, 0x96af, 0x8c68, 0x1d25, 0x2d70, 0x467a,
            0xc27c, 0x96e2, 0x1c85, 0xe8b6, 0xf7e0, 0xd069, 0x0bca, 0x4f36);
-  asm volatile("vwmaccsu.vv v6, v4, v8");
-  VSET(16, e32, m2);
-  VCMP_I32(2, v6, 0xf42c622c, 0x839d2928, 0x6aae411a, 0x9d8c5e88, 0x196a5c5c,
+  asm volatile("vwmaccsu.vv v16, v4, v8");
+  VSET(16, e32, m4);
+  VCMP_I32(2, v16, 0xf42c622c, 0x839d2928, 0x6aae411a, 0x9d8c5e88, 0x196a5c5c,
            0x628c33ca, 0xca8f9c1d, 0x075acffb, 0xd58aef57, 0xb0b17e4e,
            0x9aab508a, 0x8f921d88, 0x7cbe902e, 0xbbb98e88, 0x97b93f58,
            0x84411397);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0xf8e162af4fefb46a, 0x8e859cff3b076a9d, 0xa7279ec622e749eb,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0xf8e162af4fefb46a, 0x8e859cff3b076a9d, 0xa7279ec622e749eb,
            0x67bbdace6d6bf1a9, 0xf2090d8d3b00e5b8, 0x9259e92430c5a337,
            0x7cc51e4cc8fd46c6, 0xe5c6946a8e9787fd, 0x0d36e747a75534cc,
            0x9c1a70c0989504f9, 0xa7b0f15e7b51c000, 0x4566f8ffa299d104,
            0xf385b581a4c1c25b, 0xb067f1a7621f9cdd, 0x54ffc96dc442d7b5,
            0x3fc18a6aa65ab8d5);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   VLOAD_32(v4, 0x189138d0, 0xe2f3f48f, 0x58448029, 0x44298d07, 0x6f6b15cf,
            0x13e9cf30, 0x23b6edb8, 0xd532420a, 0xdab302ee, 0xa5e6854e,
            0x538f91b0, 0xc5d4db0e, 0xbc6d31b3, 0x754d418c, 0x96198b07,
@@ -56,9 +56,9 @@ void TEST_CASE1() {
            0x13db3502, 0x64efb3f9, 0x55c57a21, 0x31cd5a79, 0x5c0b4048,
            0x899cfb88, 0xfab9de9d, 0x6fa41232, 0x9462cda3, 0x0f8de6ea,
            0x8064029f);
-  asm volatile("vwmaccsu.vv v6, v4, v8");
-  VSET(16, e64, m2);
-  VCMP_I64(3, v6, 0x00d3fd4343a241fa, 0x7bbc44d6fa22c6ff, 0xe7a7ead9df60a04d,
+  asm volatile("vwmaccsu.vv v16, v4, v8");
+  VSET(16, e64, m4);
+  VCMP_I64(3, v16, 0x00d3fd4343a241fa, 0x7bbc44d6fa22c6ff, 0xe7a7ead9df60a04d,
            0x7ddc4c9a72efd193, 0x2d44ed6d874572c1, 0x93e550a88e8e3197,
            0x8ada040c3cea26be, 0xd76f3f99213ccf47, 0x05f53f01db8f434a,
            0x7bb552f0a51802e9, 0xd49c03ec9aaeb580, 0x0c6e9b2885384c9a,
@@ -68,48 +68,48 @@ void TEST_CASE1() {
 }
 
 void TEST_CASE2() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x30dc, 0x7235, 0xd5f6, 0xa008, 0x6e79, 0xa159, 0xa05c, 0x5914,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0x30dc, 0x7235, 0xd5f6, 0xa008, 0x6e79, 0xa159, 0xa05c, 0x5914,
            0xd06f, 0x69c5, 0x9475, 0x5625, 0xa5bd, 0x7be7, 0x823c, 0x5fb2);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   VLOAD_8(v4, 0xb6, 0xbb, 0xb6, 0x57, 0xf9, 0x7c, 0xbf, 0x62, 0x1a, 0xeb, 0xa4,
           0x34, 0xde, 0x96, 0x80, 0xe6);
   VLOAD_8(v8, 0x26, 0xea, 0xe8, 0x85, 0x2e, 0xf1, 0x46, 0x8f, 0x68, 0x29, 0xbb,
           0x9b, 0xec, 0x5c, 0x8e, 0x77);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccsu.vv v6, v4, v8, v0.t");
-  VSET(16, e16, m2);
-  VCMP_I16(4, v6, 0x30dc, 0x3323, 0xd5f6, 0xcd3b, 0x6e79, 0x1615, 0xa05c,
+  asm volatile("vwmaccsu.vv v16, v4, v8, v0.t");
+  VSET(16, e16, m4);
+  VCMP_I16(4, v16, 0x30dc, 0x3323, 0xd5f6, 0xcd3b, 0x6e79, 0x1615, 0xa05c,
            0x8fd2, 0xd06f, 0x6668, 0x9475, 0x75a1, 0xa5bd, 0x55cf, 0x823c,
            0x539c);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0xdbc5b23d, 0x86bd7dad, 0xb744b5c2, 0xc32f4a47, 0x237edfc4,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0xdbc5b23d, 0x86bd7dad, 0xb744b5c2, 0xc32f4a47, 0x237edfc4,
            0x5d6e851a, 0xbd3110cd, 0x18c61b57, 0x7ade2943, 0x7e4f5ed6,
            0x90e5ba77, 0xce45b744, 0x82d1976e, 0xa88bb4e1, 0x989fbb9a,
            0xab29da17);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   VLOAD_16(v4, 0x23fb, 0xcee7, 0xa704, 0xc00f, 0xed9f, 0x2cf0, 0x4b53, 0xc0ba,
            0x775b, 0x557c, 0x57b7, 0xbb06, 0xf9ba, 0x178f, 0xec73, 0x8240);
   VLOAD_16(v8, 0xad9d, 0x104d, 0xdc56, 0x96af, 0x8c68, 0x1d25, 0x2d70, 0x467a,
            0xc27c, 0x96e2, 0x1c85, 0xe8b6, 0xf7e0, 0xd069, 0x0bca, 0x4f36);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccsu.vv v6, v4, v8, v0.t");
-  VSET(16, e32, m2);
-  VCMP_I32(5, v6, 0xdbc5b23d, 0x839d2928, 0xb744b5c2, 0x9d8c5e88, 0x237edfc4,
+  asm volatile("vwmaccsu.vv v16, v4, v8, v0.t");
+  VSET(16, e32, m4);
+  VCMP_I32(5, v16, 0xdbc5b23d, 0x839d2928, 0xb744b5c2, 0x9d8c5e88, 0x237edfc4,
            0x628c33ca, 0xbd3110cd, 0x075acffb, 0x7ade2943, 0xb0b17e4e,
            0x90e5ba77, 0x8f921d88, 0x82d1976e, 0xbbb98e88, 0x989fbb9a,
            0x84411397);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0xf8e162af4fefb46a, 0x8e859cff3b076a9d, 0xa7279ec622e749eb,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0xf8e162af4fefb46a, 0x8e859cff3b076a9d, 0xa7279ec622e749eb,
            0x67bbdace6d6bf1a9, 0xf2090d8d3b00e5b8, 0x9259e92430c5a337,
            0x7cc51e4cc8fd46c6, 0xe5c6946a8e9787fd, 0x0d36e747a75534cc,
            0x9c1a70c0989504f9, 0xa7b0f15e7b51c000, 0x4566f8ffa299d104,
            0xf385b581a4c1c25b, 0xb067f1a7621f9cdd, 0x54ffc96dc442d7b5,
            0x3fc18a6aa65ab8d5);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   VLOAD_32(v4, 0x189138d0, 0xe2f3f48f, 0x58448029, 0x44298d07, 0x6f6b15cf,
            0x13e9cf30, 0x23b6edb8, 0xd532420a, 0xdab302ee, 0xa5e6854e,
            0x538f91b0, 0xc5d4db0e, 0xbc6d31b3, 0x754d418c, 0x96198b07,
@@ -119,9 +119,9 @@ void TEST_CASE2() {
            0x899cfb88, 0xfab9de9d, 0x6fa41232, 0x9462cda3, 0x0f8de6ea,
            0x8064029f);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccsu.vv v6, v4, v8, v0.t");
-  VSET(16, e64, m2);
-  VCMP_I64(6, v6, 0xf8e162af4fefb46a, 0x7bbc44d6fa22c6ff, 0xa7279ec622e749eb,
+  asm volatile("vwmaccsu.vv v16, v4, v8, v0.t");
+  VSET(16, e64, m4);
+  VCMP_I64(6, v16, 0xf8e162af4fefb46a, 0x7bbc44d6fa22c6ff, 0xa7279ec622e749eb,
            0x7ddc4c9a72efd193, 0xf2090d8d3b00e5b8, 0x93e550a88e8e3197,
            0x7cc51e4cc8fd46c6, 0xd76f3f99213ccf47, 0x0d36e747a75534cc,
            0x7bb552f0a51802e9, 0xa7b0f15e7b51c000, 0x0c6e9b2885384c9a,
@@ -131,52 +131,52 @@ void TEST_CASE2() {
 }
 
 void TEST_CASE3() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0xadd2, 0x2112, 0xbbc6, 0xd113, 0xc6f7, 0xbd07, 0xfd9a, 0x0c0e,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0xadd2, 0x2112, 0xbbc6, 0xd113, 0xc6f7, 0xbd07, 0xfd9a, 0x0c0e,
            0xe110, 0xe81b, 0xb432, 0x5c2c, 0x4da9, 0x8c48, 0x6f94, 0x6250);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   int64_t scalar = 5;
   VLOAD_8(v8, 0xfe, 0xd1, 0xc2, 0x3b, 0x79, 0x2f, 0xf5, 0xe8, 0x7f, 0x4b, 0x64,
           0x57, 0x2b, 0x4f, 0x4e, 0xda);
-  asm volatile("vwmaccsu.vx v6, %[A], v8" ::[A] "r"(scalar));
-  VSET(16, e16, m2);
-  VCMP_I16(7, v6, 0xb2c8, 0x2527, 0xbf90, 0xd23a, 0xc954, 0xbdf2, 0x0263,
+  asm volatile("vwmaccsu.vx v16, %[A], v8" ::[A] "r"(scalar));
+  VSET(16, e16, m4);
+  VCMP_I16(7, v16, 0xb2c8, 0x2527, 0xbf90, 0xd23a, 0xc954, 0xbdf2, 0x0263,
            0x1096, 0xe38b, 0xe992, 0xb626, 0x5ddf, 0x4e80, 0x8dd3, 0x711a,
            0x6692);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0x39d3ea89, 0x451d8e1a, 0x83edb2d7, 0xc1919ab3, 0x243c3d4d,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0x39d3ea89, 0x451d8e1a, 0x83edb2d7, 0xc1919ab3, 0x243c3d4d,
            0xd4745be8, 0x50a58cbe, 0x53b75e9f, 0x2a648b62, 0xd74ce1cf,
            0xa2c6a2e7, 0xc30eadb0, 0x7a908fb9, 0xd4455b56, 0x48109ee2,
            0x2f5b537a);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   scalar = -5383;
   VLOAD_16(v8, 0x29f8, 0x6958, 0x6635, 0x03a0, 0x07bc, 0x4881, 0x7d4e, 0x37e3,
            0x8370, 0x405f, 0x1f0d, 0x1252, 0xacf1, 0x06ee, 0x790d, 0x73af);
-  asm volatile("vwmaccsu.vx v6, %[A], v8" ::[A] "r"(scalar));
-  VSET(16, e32, m2);
-  VCMP_I32(8, v6, 0x36616cc1, 0x3c7674b2, 0x7b888e64, 0xc1456153, 0x23999b29,
+  asm volatile("vwmaccsu.vx v16, %[A], v8" ::[A] "r"(scalar));
+  VSET(16, e32, m4);
+  VCMP_I32(8, v16, 0x36616cc1, 0x3c7674b2, 0x7b888e64, 0xc1456153, 0x23999b29,
            0xce7fcb61, 0x465ab99c, 0x4f20386a, 0x1f98c352, 0xd2035436,
            0xa039b88c, 0xc18d7372, 0x6c5c1022, 0xd3b3a4d4, 0x3e1f3e87,
            0x25daceb1);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0xd860771ff910e8a1, 0xd8de9ddf3be66e90, 0xe55e25348ff4c406,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0xd860771ff910e8a1, 0xd8de9ddf3be66e90, 0xe55e25348ff4c406,
            0x6ee24d9ebeda1c54, 0x78437fc8299017d1, 0x46a2833ed69dec1d,
            0x0331761dcc2485b7, 0x99c00b7ecbecb5bf, 0xd68d230a95510605,
            0x0e82f981980d47c8, 0x7bb0e1dd5f273626, 0x044cc7c24be55121,
            0x341b063e01c35796, 0xb77a96fdf1826215, 0xdcbd3fe115470433,
            0xc2797417b552325b);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   scalar = 6474219;
   VLOAD_32(v8, 0x53046c2d, 0x3b0c65ed, 0x6565f981, 0xaa4c1d70, 0x0a18c71e,
            0xbc91ff46, 0xa52c32d1, 0x73cca3fc, 0xb2a7e5d2, 0x1939af0a,
            0xe4fdb1f5, 0x783f5c5d, 0x3514c875, 0xce346d04, 0x68047428,
            0x72ca548f);
-  asm volatile("vwmaccsu.vx v6, %[A], v8" ::[A] "r"(scalar));
-  VSET(16, e64, m2);
-  VCMP_I64(9, v6, 0xd880804c10498af0, 0xd8f567313109141f, 0xe585463838d91671,
+  asm volatile("vwmaccsu.vx v16, %[A], v8" ::[A] "r"(scalar));
+  VSET(16, e64, m4);
+  VCMP_I64(9, v16, 0xd880804c10498af0, 0xd8f567313109141f, 0xe585463838d91671,
            0x6f2405141ab61224, 0x7847653b1c216e5b, 0x46eb47de4add375f,
            0x03713350939f4492, 0x99ecbb2b8c001a13, 0xd6d2143a6346dfcb,
            0x0e8cb57c0c43cff6, 0x7c093f98e48cef0d, 0x047b2edbc92e1f80,
@@ -186,55 +186,55 @@ void TEST_CASE3() {
 }
 
 void TEST_CASE4() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0xadd2, 0x2112, 0xbbc6, 0xd113, 0xc6f7, 0xbd07, 0xfd9a, 0x0c0e,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0xadd2, 0x2112, 0xbbc6, 0xd113, 0xc6f7, 0xbd07, 0xfd9a, 0x0c0e,
            0xe110, 0xe81b, 0xb432, 0x5c2c, 0x4da9, 0x8c48, 0x6f94, 0x6250);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   int64_t scalar = 5;
   VLOAD_8(v8, 0xfe, 0xd1, 0xc2, 0x3b, 0x79, 0x2f, 0xf5, 0xe8, 0x7f, 0x4b, 0x64,
           0x57, 0x2b, 0x4f, 0x4e, 0xda);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccsu.vx v6, %[A], v8, v0.t" ::[A] "r"(scalar));
-  VSET(16, e16, m2);
-  VCMP_I16(10, v6, 0xadd2, 0x2527, 0xbbc6, 0xd23a, 0xc6f7, 0xbdf2, 0xfd9a,
+  asm volatile("vwmaccsu.vx v16, %[A], v8, v0.t" ::[A] "r"(scalar));
+  VSET(16, e16, m4);
+  VCMP_I16(10, v16, 0xadd2, 0x2527, 0xbbc6, 0xd23a, 0xc6f7, 0xbdf2, 0xfd9a,
            0x1096, 0xe110, 0xe992, 0xb432, 0x5ddf, 0x4da9, 0x8dd3, 0x6f94,
            0x6692);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0x39d3ea89, 0x451d8e1a, 0x83edb2d7, 0xc1919ab3, 0x243c3d4d,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0x39d3ea89, 0x451d8e1a, 0x83edb2d7, 0xc1919ab3, 0x243c3d4d,
            0xd4745be8, 0x50a58cbe, 0x53b75e9f, 0x2a648b62, 0xd74ce1cf,
            0xa2c6a2e7, 0xc30eadb0, 0x7a908fb9, 0xd4455b56, 0x48109ee2,
            0x2f5b537a);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   scalar = -5383;
   VLOAD_16(v8, 0x29f8, 0x6958, 0x6635, 0x03a0, 0x07bc, 0x4881, 0x7d4e, 0x37e3,
            0x8370, 0x405f, 0x1f0d, 0x1252, 0xacf1, 0x06ee, 0x790d, 0x73af);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccsu.vx v6, %[A], v8, v0.t" ::[A] "r"(scalar));
-  VSET(16, e32, m2);
-  VCMP_I32(11, v6, 0x39d3ea89, 0x3c7674b2, 0x83edb2d7, 0xc1456153, 0x243c3d4d,
+  asm volatile("vwmaccsu.vx v16, %[A], v8, v0.t" ::[A] "r"(scalar));
+  VSET(16, e32, m4);
+  VCMP_I32(11, v16, 0x39d3ea89, 0x3c7674b2, 0x83edb2d7, 0xc1456153, 0x243c3d4d,
            0xce7fcb61, 0x50a58cbe, 0x4f20386a, 0x2a648b62, 0xd2035436,
            0xa2c6a2e7, 0xc18d7372, 0x7a908fb9, 0xd3b3a4d4, 0x48109ee2,
            0x25daceb1);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0xd860771ff910e8a1, 0xd8de9ddf3be66e90, 0xe55e25348ff4c406,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0xd860771ff910e8a1, 0xd8de9ddf3be66e90, 0xe55e25348ff4c406,
            0x6ee24d9ebeda1c54, 0x78437fc8299017d1, 0x46a2833ed69dec1d,
            0x0331761dcc2485b7, 0x99c00b7ecbecb5bf, 0xd68d230a95510605,
            0x0e82f981980d47c8, 0x7bb0e1dd5f273626, 0x044cc7c24be55121,
            0x341b063e01c35796, 0xb77a96fdf1826215, 0xdcbd3fe115470433,
            0xc2797417b552325b);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   scalar = 6474219;
   VLOAD_32(v8, 0x53046c2d, 0x3b0c65ed, 0x6565f981, 0xaa4c1d70, 0x0a18c71e,
            0xbc91ff46, 0xa52c32d1, 0x73cca3fc, 0xb2a7e5d2, 0x1939af0a,
            0xe4fdb1f5, 0x783f5c5d, 0x3514c875, 0xce346d04, 0x68047428,
            0x72ca548f);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccsu.vx v6, %[A], v8, v0.t" ::[A] "r"(scalar));
-  VSET(16, e64, m2);
-  VCMP_I64(12, v6, 0xd860771ff910e8a1, 0xd8f567313109141f, 0xe55e25348ff4c406,
+  asm volatile("vwmaccsu.vx v16, %[A], v8, v0.t" ::[A] "r"(scalar));
+  VSET(16, e64, m4);
+  VCMP_I64(12, v16, 0xd860771ff910e8a1, 0xd8f567313109141f, 0xe55e25348ff4c406,
            0x6f2405141ab61224, 0x78437fc8299017d1, 0x46eb47de4add375f,
            0x0331761dcc2485b7, 0x99ecbb2b8c001a13, 0xd68d230a95510605,
            0x0e8cb57c0c43cff6, 0x7bb0e1dd5f273626, 0x047b2edbc92e1f80,
diff --git a/sw/riscvTests/isa/rv64uv/vwmaccu.c b/sw/riscvTests/isa/rv64uv/vwmaccu.c
index 2bba6cae..82be8acb 100644
--- a/sw/riscvTests/isa/rv64uv/vwmaccu.c
+++ b/sw/riscvTests/isa/rv64uv/vwmaccu.c
@@ -8,46 +8,46 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x519d, 0x7122, 0x672c, 0x4d97, 0x436e, 0x3f1f, 0x423d, 0x44e8,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0x519d, 0x7122, 0x672c, 0x4d97, 0x436e, 0x3f1f, 0x423d, 0x44e8,
            0x3d7b, 0x5570, 0x1e90, 0x79f4, 0x456b, 0x0283, 0x02b5, 0x6865);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   VLOAD_8(v4, 0xce, 0x96, 0x33, 0x88, 0xf8, 0x3f, 0x0c, 0xde, 0x1e, 0x9d, 0x5a,
           0x75, 0x73, 0x43, 0xd9, 0x43);
   VLOAD_8(v8, 0x51, 0x88, 0x16, 0xf6, 0x57, 0xab, 0xd8, 0x26, 0x2e, 0x35, 0x94,
           0xd1, 0xf0, 0xb9, 0x09, 0x8a);
-  asm volatile("vwmaccu.vv v6, v4, v8");
-  VSET(16, e16, m2);
-  VCMP_U16(1, v6, 0x92cb, 0xc0d2, 0x6b8e, 0xd047, 0x97b6, 0x6934, 0x4c5d,
+  asm volatile("vwmaccu.vv v16, v4, v8");
+  VSET(16, e16, m4);
+  VCMP_U16(1, v16, 0x92cb, 0xc0d2, 0x6b8e, 0xd047, 0x97b6, 0x6934, 0x4c5d,
            0x65dc, 0x42df, 0x75f1, 0x5298, 0xd979, 0xb13b, 0x32ee, 0x0a56,
            0x8c83);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0x1f50b763, 0x6d1a7f46, 0x17b8b2b5, 0x6b69c966, 0x25d945cb,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0x1f50b763, 0x6d1a7f46, 0x17b8b2b5, 0x6b69c966, 0x25d945cb,
            0x3e6c375b, 0x314db8d3, 0x35ade27d, 0x74fa2d58, 0x735f513d,
            0x3cad4e4d, 0x628eb81a, 0x1c48c2f9, 0x14f08921, 0x77de05bf,
            0x528c354b);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   VLOAD_16(v4, 0x4ed5, 0xcf74, 0x3442, 0x280f, 0x795e, 0x3007, 0xdf3e, 0xb348,
            0x3865, 0xcb59, 0x1291, 0xa04b, 0xc5bd, 0x957f, 0xefe4, 0xe75d);
   VLOAD_16(v8, 0x7d39, 0xddd8, 0x17d7, 0x0574, 0x251a, 0x4ce4, 0x4817, 0x9de1,
            0xd773, 0xdcc8, 0xeb92, 0x8fa8, 0x9382, 0x4369, 0xb1c7, 0x9185);
-  asm volatile("vwmaccu.vv v6, v4, v8");
-  VSET(16, e32, m2);
-  VCMP_U32(2, v6, 0x45e045d0, 0x20e0ad26, 0x1c968423, 0x6c443b32, 0x37702f57,
+  asm volatile("vwmaccu.vv v16, v4, v8");
+  VSET(16, e32, m4);
+  VCMP_U32(2, v16, 0x45e045d0, 0x20e0ad26, 0x1c968423, 0x6c443b32, 0x37702f57,
            0x4cd91197, 0x702b3765, 0xa43e9cc5, 0xa47055b7, 0x22beaac5,
            0x4dc2ffff, 0xbc81ce52, 0x8e38b3f3, 0x3c4e1738, 0x1e7523fb,
            0xd610159c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0x5118504f9237ea08, 0x6b71d4ee88073dde, 0x4420559f61e6927c,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0x5118504f9237ea08, 0x6b71d4ee88073dde, 0x4420559f61e6927c,
            0x24eea54c6530475c, 0x289211cb16ebbbc9, 0x1a0b2b7644ecd474,
            0x159c16af3e71f736, 0x12dda0d2ca288012, 0x790fab107c1346b6,
            0x589cc8132c869645, 0x323623bba87568ce, 0x5ce2e94d5e335c5d,
            0x6e6b3c19c0d78ca0, 0x0502bed40a0600bc, 0x5ff6f4b3610e009c,
            0x40d6eb0605052915);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   VLOAD_32(v4, 0xd1247b78, 0xfd5d326b, 0x7fe40cf5, 0xfd802d90, 0x9ec23b7e,
            0x67219fe8, 0x9dc7f026, 0x257d8b7f, 0x782bc512, 0x42fa808b,
            0x48d3273d, 0x7ca0371d, 0x06409254, 0xb77ce3ba, 0x28aac174,
@@ -56,9 +56,9 @@ void TEST_CASE1() {
            0xeec0354b, 0x8b4595bf, 0x9200fb5c, 0x0d627fcf, 0xdf0a8280,
            0x4b5733be, 0x4f3bd496, 0x10f5d788, 0x3499c99d, 0xdeee29dd,
            0x7e8643a4);
-  asm volatile("vwmaccu.vv v6, v4, v8");
-  VSET(16, e64, m2);
-  VCMP_U64(3, v6, 0xdcfc2b3ca5c34640, 0x52260af0834ff780, 0x5dd0d00a7e576638,
+  asm volatile("vwmaccu.vv v16, v4, v8");
+  VSET(16, e64, m4);
+  VCMP_U64(3, v16, 0xdcfc2b3ca5c34640, 0x52260af0834ff780, 0x5dd0d00a7e576638,
            0x1f3e3a8021c0226c, 0x37a86e0412f255b1, 0x7a39dcd00fe1b56c,
            0x6b728942b1a24190, 0x283f5f30c90c26b6, 0x7f5820d2b91f8e44,
            0x92f7bdf9f97b71c5, 0x47a4ceb4fab8af14, 0x83757ab9b866ab5b,
@@ -68,48 +68,48 @@ void TEST_CASE1() {
 }
 
 void TEST_CASE2() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x519d, 0x7122, 0x672c, 0x4d97, 0x436e, 0x3f1f, 0x423d, 0x44e8,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0x519d, 0x7122, 0x672c, 0x4d97, 0x436e, 0x3f1f, 0x423d, 0x44e8,
            0x3d7b, 0x5570, 0x1e90, 0x79f4, 0x456b, 0x0283, 0x02b5, 0x6865);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   VLOAD_8(v4, 0xce, 0x96, 0x33, 0x88, 0xf8, 0x3f, 0x0c, 0xde, 0x1e, 0x9d, 0x5a,
           0x75, 0x73, 0x43, 0xd9, 0x43);
   VLOAD_8(v8, 0x51, 0x88, 0x16, 0xf6, 0x57, 0xab, 0xd8, 0x26, 0x2e, 0x35, 0x94,
           0xd1, 0xf0, 0xb9, 0x09, 0x8a);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccu.vv v6, v4, v8, v0.t");
-  VSET(16, e16, m2);
-  VCMP_U16(4, v6, 0x519d, 0xc0d2, 0x672c, 0xd047, 0x436e, 0x6934, 0x423d,
+  asm volatile("vwmaccu.vv v16, v4, v8, v0.t");
+  VSET(16, e16, m4);
+  VCMP_U16(4, v16, 0x519d, 0xc0d2, 0x672c, 0xd047, 0x436e, 0x6934, 0x423d,
            0x65dc, 0x3d7b, 0x75f1, 0x1e90, 0xd979, 0x456b, 0x32ee, 0x02b5,
            0x8c83);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0x1f50b763, 0x6d1a7f46, 0x17b8b2b5, 0x6b69c966, 0x25d945cb,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0x1f50b763, 0x6d1a7f46, 0x17b8b2b5, 0x6b69c966, 0x25d945cb,
            0x3e6c375b, 0x314db8d3, 0x35ade27d, 0x74fa2d58, 0x735f513d,
            0x3cad4e4d, 0x628eb81a, 0x1c48c2f9, 0x14f08921, 0x77de05bf,
            0x528c354b);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   VLOAD_16(v4, 0x4ed5, 0xcf74, 0x3442, 0x280f, 0x795e, 0x3007, 0xdf3e, 0xb348,
            0x3865, 0xcb59, 0x1291, 0xa04b, 0xc5bd, 0x957f, 0xefe4, 0xe75d);
   VLOAD_16(v8, 0x7d39, 0xddd8, 0x17d7, 0x0574, 0x251a, 0x4ce4, 0x4817, 0x9de1,
            0xd773, 0xdcc8, 0xeb92, 0x8fa8, 0x9382, 0x4369, 0xb1c7, 0x9185);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccu.vv v6, v4, v8, v0.t");
-  VSET(16, e32, m2);
-  VCMP_U32(5, v6, 0x1f50b763, 0x20e0ad26, 0x17b8b2b5, 0x6c443b32, 0x25d945cb,
+  asm volatile("vwmaccu.vv v16, v4, v8, v0.t");
+  VSET(16, e32, m4);
+  VCMP_U32(5, v16, 0x1f50b763, 0x20e0ad26, 0x17b8b2b5, 0x6c443b32, 0x25d945cb,
            0x4cd91197, 0x314db8d3, 0xa43e9cc5, 0x74fa2d58, 0x22beaac5,
            0x3cad4e4d, 0xbc81ce52, 0x1c48c2f9, 0x3c4e1738, 0x77de05bf,
            0xd610159c);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0x5118504f9237ea08, 0x6b71d4ee88073dde, 0x4420559f61e6927c,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0x5118504f9237ea08, 0x6b71d4ee88073dde, 0x4420559f61e6927c,
            0x24eea54c6530475c, 0x289211cb16ebbbc9, 0x1a0b2b7644ecd474,
            0x159c16af3e71f736, 0x12dda0d2ca288012, 0x790fab107c1346b6,
            0x589cc8132c869645, 0x323623bba87568ce, 0x5ce2e94d5e335c5d,
            0x6e6b3c19c0d78ca0, 0x0502bed40a0600bc, 0x5ff6f4b3610e009c,
            0x40d6eb0605052915);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   VLOAD_32(v4, 0xd1247b78, 0xfd5d326b, 0x7fe40cf5, 0xfd802d90, 0x9ec23b7e,
            0x67219fe8, 0x9dc7f026, 0x257d8b7f, 0x782bc512, 0x42fa808b,
            0x48d3273d, 0x7ca0371d, 0x06409254, 0xb77ce3ba, 0x28aac174,
@@ -119,9 +119,9 @@ void TEST_CASE2() {
            0x4b5733be, 0x4f3bd496, 0x10f5d788, 0x3499c99d, 0xdeee29dd,
            0x7e8643a4);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccu.vv v6, v4, v8, v0.t");
-  VSET(16, e64, m2);
-  VCMP_U64(6, v6, 0x5118504f9237ea08, 0x52260af0834ff780, 0x4420559f61e6927c,
+  asm volatile("vwmaccu.vv v16, v4, v8, v0.t");
+  VSET(16, e64, m4);
+  VCMP_U64(6, v16, 0x5118504f9237ea08, 0x52260af0834ff780, 0x4420559f61e6927c,
            0x1f3e3a8021c0226c, 0x289211cb16ebbbc9, 0x7a39dcd00fe1b56c,
            0x159c16af3e71f736, 0x283f5f30c90c26b6, 0x790fab107c1346b6,
            0x92f7bdf9f97b71c5, 0x323623bba87568ce, 0x83757ab9b866ab5b,
@@ -131,52 +131,52 @@ void TEST_CASE2() {
 }
 
 void TEST_CASE3() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x6f50, 0x0299, 0x3578, 0x0e45, 0x752b, 0x60c7, 0x7d0c, 0x0943,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0x6f50, 0x0299, 0x3578, 0x0e45, 0x752b, 0x60c7, 0x7d0c, 0x0943,
            0x3f2d, 0x47bc, 0x4468, 0x616d, 0x5844, 0x3a7d, 0x32fe, 0x7813);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   uint64_t scalar = 5;
   VLOAD_8(v8, 0x01, 0xd6, 0x1e, 0x57, 0xcc, 0x31, 0x29, 0x06, 0x5a, 0xab, 0x1e,
           0x0a, 0x97, 0x6f, 0xe0, 0xfc);
-  asm volatile("vwmaccu.vx v6, %[A], v8" ::[A] "r"(scalar));
-  VSET(16, e16, m2);
-  VCMP_U16(7, v6, 0x6f55, 0x06c7, 0x360e, 0x0ff8, 0x7927, 0x61bc, 0x7dd9,
+  asm volatile("vwmaccu.vx v16, %[A], v8" ::[A] "r"(scalar));
+  VSET(16, e16, m4);
+  VCMP_U16(7, v16, 0x6f55, 0x06c7, 0x360e, 0x0ff8, 0x7927, 0x61bc, 0x7dd9,
            0x0961, 0x40ef, 0x4b13, 0x44fe, 0x619f, 0x5b37, 0x3ca8, 0x375e,
            0x7cff);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0x681721c9, 0x5c07924a, 0x5147143e, 0x14da5785, 0x30a43e20,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0x681721c9, 0x5c07924a, 0x5147143e, 0x14da5785, 0x30a43e20,
            0x3498177e, 0x551df71d, 0x29656468, 0x12550807, 0x7dc95cbd,
            0x2167ff36, 0x194b0d6c, 0x79119a1d, 0x6d77fab6, 0x3e32c755,
            0x6e479bf4);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   scalar = 5383;
   VLOAD_16(v8, 0x9752, 0x45a4, 0xfde9, 0xa659, 0x957b, 0x1a3f, 0x2212, 0x5d43,
            0xdc08, 0x1fb8, 0x5e15, 0x08da, 0x0468, 0x4458, 0xe1e2, 0x4ef7);
-  asm volatile("vwmaccu.vx v6, %[A], v8" ::[A] "r"(scalar));
-  VSET(16, e32, m2);
-  VCMP_U32(8, v6, 0x7484ff07, 0x61bfedc6, 0x6622229d, 0x228430f4, 0x3ceb6b7d,
+  asm volatile("vwmaccu.vx v16, %[A], v8" ::[A] "r"(scalar));
+  VSET(16, e32, m4);
+  VCMP_U32(8, v16, 0x7484ff07, 0x61bfedc6, 0x6622229d, 0x228430f4, 0x3ceb6b7d,
            0x36bffa37, 0x57ea5f9b, 0x310e703d, 0x2467b43f, 0x806452c5,
            0x29224ac9, 0x1a052d62, 0x796e40f5, 0x7315111e, 0x50c07e83,
            0x74c407b5);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0x27a0a02f7e9757d4, 0x7ff7bb4d394926a0, 0x09d25e3173571efd,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0x27a0a02f7e9757d4, 0x7ff7bb4d394926a0, 0x09d25e3173571efd,
            0x11661c8ece6711ac, 0x1e5ffff32ed851dd, 0x0698334d63d206a9,
            0x79598c88fd85995f, 0x2fa78b4b7d90a222, 0x7d65cbfdfc7f2e1d,
            0x6c0101ef46924df6, 0x59ff3d4e018b50f4, 0x2c8ec8409f219401,
            0x20b183b4bb89c200, 0x28bee831261ca372, 0x5b9d142326bcef0a,
            0x1c2ad051e4e7281e);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   scalar = 6474219;
   VLOAD_32(v8, 0x307dc235, 0x92187481, 0xa69319d1, 0x682b9abe, 0x8bdce4be,
            0x95ec65ce, 0x46915d6f, 0xd59243e6, 0x1d0943e5, 0x3ae27787,
            0x33c32e03, 0x8be66da2, 0x0fc78147, 0x2ce8d421, 0x9c9bc2fb,
            0x10c8c9f7);
-  asm volatile("vwmaccu.vx v6, %[A], v8" ::[A] "r"(scalar));
-  VSET(16, e64, m2);
-  VCMP_U64(9, v6, 0x27b3569317ce3b7b, 0x80301be52297620b, 0x0a12a5e3bda6ead8,
+  asm volatile("vwmaccu.vx v16, %[A], v8" ::[A] "r"(scalar));
+  VSET(16, e64, m4);
+  VCMP_U64(9, v16, 0x27b3569317ce3b7b, 0x80301be52297620b, 0x0a12a5e3bda6ead8,
            0x118e4f69e7a94c16, 0x1e95f8d392f37a47, 0x06d20e0c989e38c3,
            0x7974c7d7abd08544, 0x2ff9f5bd60308c44, 0x7d710070e7f94e54,
            0x6c17bb12e5fd05e3, 0x5a1336d961fce8b5, 0x2cc4c4ceefc069b7,
@@ -186,55 +186,55 @@ void TEST_CASE3() {
 }
 
 void TEST_CASE4() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x6f50, 0x0299, 0x3578, 0x0e45, 0x752b, 0x60c7, 0x7d0c, 0x0943,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0x6f50, 0x0299, 0x3578, 0x0e45, 0x752b, 0x60c7, 0x7d0c, 0x0943,
            0x3f2d, 0x47bc, 0x4468, 0x616d, 0x5844, 0x3a7d, 0x32fe, 0x7813);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   uint64_t scalar = 5;
   VLOAD_8(v8, 0x01, 0xd6, 0x1e, 0x57, 0xcc, 0x31, 0x29, 0x06, 0x5a, 0xab, 0x1e,
           0x0a, 0x97, 0x6f, 0xe0, 0xfc);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccu.vx v6, %[A], v8, v0.t" ::[A] "r"(scalar));
-  VSET(16, e16, m2);
-  VCMP_U16(10, v6, 0x6f50, 0x06c7, 0x3578, 0x0ff8, 0x752b, 0x61bc, 0x7d0c,
+  asm volatile("vwmaccu.vx v16, %[A], v8, v0.t" ::[A] "r"(scalar));
+  VSET(16, e16, m4);
+  VCMP_U16(10, v16, 0x6f50, 0x06c7, 0x3578, 0x0ff8, 0x752b, 0x61bc, 0x7d0c,
            0x0961, 0x3f2d, 0x4b13, 0x4468, 0x619f, 0x5844, 0x3ca8, 0x32fe,
            0x7cff);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0x681721c9, 0x5c07924a, 0x5147143e, 0x14da5785, 0x30a43e20,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0x681721c9, 0x5c07924a, 0x5147143e, 0x14da5785, 0x30a43e20,
            0x3498177e, 0x551df71d, 0x29656468, 0x12550807, 0x7dc95cbd,
            0x2167ff36, 0x194b0d6c, 0x79119a1d, 0x6d77fab6, 0x3e32c755,
            0x6e479bf4);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   scalar = 5383;
   VLOAD_16(v8, 0x9752, 0x45a4, 0xfde9, 0xa659, 0x957b, 0x1a3f, 0x2212, 0x5d43,
            0xdc08, 0x1fb8, 0x5e15, 0x08da, 0x0468, 0x4458, 0xe1e2, 0x4ef7);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccu.vx v6, %[A], v8, v0.t" ::[A] "r"(scalar));
-  VSET(16, e32, m2);
-  VCMP_U32(11, v6, 0x681721c9, 0x61bfedc6, 0x5147143e, 0x228430f4, 0x30a43e20,
+  asm volatile("vwmaccu.vx v16, %[A], v8, v0.t" ::[A] "r"(scalar));
+  VSET(16, e32, m4);
+  VCMP_U32(11, v16, 0x681721c9, 0x61bfedc6, 0x5147143e, 0x228430f4, 0x30a43e20,
            0x36bffa37, 0x551df71d, 0x310e703d, 0x12550807, 0x806452c5,
            0x2167ff36, 0x1a052d62, 0x79119a1d, 0x7315111e, 0x3e32c755,
            0x74c407b5);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0x27a0a02f7e9757d4, 0x7ff7bb4d394926a0, 0x09d25e3173571efd,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0x27a0a02f7e9757d4, 0x7ff7bb4d394926a0, 0x09d25e3173571efd,
            0x11661c8ece6711ac, 0x1e5ffff32ed851dd, 0x0698334d63d206a9,
            0x79598c88fd85995f, 0x2fa78b4b7d90a222, 0x7d65cbfdfc7f2e1d,
            0x6c0101ef46924df6, 0x59ff3d4e018b50f4, 0x2c8ec8409f219401,
            0x20b183b4bb89c200, 0x28bee831261ca372, 0x5b9d142326bcef0a,
            0x1c2ad051e4e7281e);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   scalar = 6474219;
   VLOAD_32(v8, 0x307dc235, 0x92187481, 0xa69319d1, 0x682b9abe, 0x8bdce4be,
            0x95ec65ce, 0x46915d6f, 0xd59243e6, 0x1d0943e5, 0x3ae27787,
            0x33c32e03, 0x8be66da2, 0x0fc78147, 0x2ce8d421, 0x9c9bc2fb,
            0x10c8c9f7);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccu.vx v6, %[A], v8, v0.t" ::[A] "r"(scalar));
-  VSET(16, e64, m2);
-  VCMP_U64(12, v6, 0x27a0a02f7e9757d4, 0x80301be52297620b, 0x09d25e3173571efd,
+  asm volatile("vwmaccu.vx v16, %[A], v8, v0.t" ::[A] "r"(scalar));
+  VSET(16, e64, m4);
+  VCMP_U64(12, v16, 0x27a0a02f7e9757d4, 0x80301be52297620b, 0x09d25e3173571efd,
            0x118e4f69e7a94c16, 0x1e5ffff32ed851dd, 0x06d20e0c989e38c3,
            0x79598c88fd85995f, 0x2ff9f5bd60308c44, 0x7d65cbfdfc7f2e1d,
            0x6c17bb12e5fd05e3, 0x59ff3d4e018b50f4, 0x2cc4c4ceefc069b7,
diff --git a/sw/riscvTests/isa/rv64uv/vwmaccus.c b/sw/riscvTests/isa/rv64uv/vwmaccus.c
index 44953427..3c0ff032 100644
--- a/sw/riscvTests/isa/rv64uv/vwmaccus.c
+++ b/sw/riscvTests/isa/rv64uv/vwmaccus.c
@@ -8,52 +8,52 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x4c8e, 0xd449, 0xe266, 0xb6d1, 0xf28a, 0x1655, 0x3111, 0x4bde,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0x4c8e, 0xd449, 0xe266, 0xb6d1, 0xf28a, 0x1655, 0x3111, 0x4bde,
            0x8787, 0x2ce4, 0x1083, 0xaa0c, 0x9fdf, 0x3e42, 0x98e7, 0xe33b);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   uint64_t scalar = 5;
   VLOAD_8(v8, 0x83, 0xfe, 0xa2, 0xc3, 0xa6, 0x18, 0xd9, 0x4c, 0x6e, 0xeb, 0x43,
           0xb7, 0xec, 0x48, 0xb7, 0xe5);
-  asm volatile("vwmaccus.vx v6, %[A], v8" ::[A] "r"(scalar));
-  VSET(16, e16, m2);
-  VCMP_I16(1, v6, 0x4a1d, 0xd43f, 0xe090, 0xb5a0, 0xf0c8, 0x16cd, 0x304e,
+  asm volatile("vwmaccus.vx v16, %[A], v8" ::[A] "r"(scalar));
+  VSET(16, e16, m4);
+  VCMP_I16(1, v16, 0x4a1d, 0xd43f, 0xe090, 0xb5a0, 0xf0c8, 0x16cd, 0x304e,
            0x4d5a, 0x89ad, 0x2c7b, 0x11d2, 0xa89f, 0x9f7b, 0x3faa, 0x977a,
            0xe2b4);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0xe318cc7a, 0x489815a8, 0x6e6fc053, 0x8d746807, 0xbc3e6244,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0xe318cc7a, 0x489815a8, 0x6e6fc053, 0x8d746807, 0xbc3e6244,
            0xcdfeb4fe, 0x22d24149, 0x26962240, 0x5ef85b7e, 0x2f61a9e8,
            0x373dc202, 0x1567a6b5, 0x763c5239, 0x60dd0502, 0xab178102,
            0x753e0a11);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   scalar = 5383;
   VLOAD_16(v8, 0xce02, 0x6935, 0xc803, 0x75bc, 0x80b7, 0x19d2, 0x3b7c, 0xc269,
            0xb639, 0x66f1, 0x678b, 0xc83e, 0x5a5c, 0x389e, 0x9e46, 0xfae9);
-  asm volatile("vwmaccus.vx v6, %[A], v8" ::[A] "r"(scalar));
-  VSET(16, e32, m2);
-  VCMP_I32(2, v6, 0xdefd9888, 0x513c4f1b, 0x69d67768, 0x97200c2b, 0xb1c9ea45,
+  asm volatile("vwmaccus.vx v16, %[A], v8" ::[A] "r"(scalar));
+  VSET(16, e32, m4);
+  VCMP_I32(2, v16, 0xdefd9888, 0x513c4f1b, 0x69d67768, 0x97200c2b, 0xb1c9ea45,
            0xd01da3bc, 0x27b50dad, 0x2187101f, 0x58e9040d, 0x37d63f7f,
            0x3fbefdcf, 0x10d33667, 0x7da856bd, 0x65838754, 0xa31092ec,
            0x74d30370);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0xb6a5b1c3c6d69abb, 0x3c6a647eb0d79a41, 0xf0c3eb8821045259,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0xb6a5b1c3c6d69abb, 0x3c6a647eb0d79a41, 0xf0c3eb8821045259,
            0x91d74be946352cae, 0x524c6db6c58f9da6, 0x39185a920f7787e8,
            0x4080fbf0fdcc64ec, 0x9ed1fb83f53270fc, 0xff0661a19269f0c0,
            0x47d26c599193fe0b, 0xd8cc0342dc3104ce, 0xc51f802bc93381cd,
            0xe7d6522aa1c51245, 0x6fa0a9d3f57bc667, 0xd140731478a147a8,
            0x5d716379591922f4);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   scalar = 6474219;
   VLOAD_32(v8, 0x09377def, 0x99ee4d30, 0x8b8452d1, 0xc9e17667, 0x2254aa29,
            0xb56ca9f5, 0xa1276371, 0x32ac1413, 0x59ff6af3, 0x6b61bf57,
            0xc0eb37b3, 0x26f06be7, 0x0e9b21b2, 0x22898a93, 0xe3646841,
            0xdd301fdc);
-  asm volatile("vwmaccus.vx v6, %[A], v8" ::[A] "r"(scalar));
-  VSET(16, e64, m2);
-  VCMP_I64(3, v6, 0xb6a940470425dc20, 0x3c430136a5932551, 0xf096f84fcc847134,
+  asm volatile("vwmaccus.vx v16, %[A], v8" ::[A] "r"(scalar));
+  VSET(16, e64, m4);
+  VCMP_I64(3, v16, 0xb6a940470425dc20, 0x3c430136a5932551, 0xf096f84fcc847134,
            0x91c26988f191bc3b, 0x5259ad33e6940249, 0x38fb9358fb72e8cf,
            0x405c6235eb4a66a7, 0x9ee5895b4431c96d, 0xff291c64abdfe8d1,
            0x47fbdc7722d7f1e8, 0xd8b3ab8cf55eb11f, 0xc52e86eb9b0cedda,
@@ -63,55 +63,55 @@ void TEST_CASE1() {
 }
 
 void TEST_CASE2() {
-  VSET(16, e16, m2);
-  VLOAD_16(v6, 0x4c8e, 0xd449, 0xe266, 0xb6d1, 0xf28a, 0x1655, 0x3111, 0x4bde,
+  VSET(16, e16, m4);
+  VLOAD_16(v16, 0x4c8e, 0xd449, 0xe266, 0xb6d1, 0xf28a, 0x1655, 0x3111, 0x4bde,
            0x8787, 0x2ce4, 0x1083, 0xaa0c, 0x9fdf, 0x3e42, 0x98e7, 0xe33b);
-  VSET(16, e8, m2);
+  VSET(16, e8, m4);
   uint64_t scalar = 5;
   VLOAD_8(v8, 0x83, 0xfe, 0xa2, 0xc3, 0xa6, 0x18, 0xd9, 0x4c, 0x6e, 0xeb, 0x43,
           0xb7, 0xec, 0x48, 0xb7, 0xe5);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccus.vx v6, %[A], v8, v0.t" ::[A] "r"(scalar));
-  VSET(16, e16, m2);
-  VCMP_I16(4, v6, 0x4c8e, 0xd43f, 0xe266, 0xb5a0, 0xf28a, 0x16cd, 0x3111,
+  asm volatile("vwmaccus.vx v16, %[A], v8, v0.t" ::[A] "r"(scalar));
+  VSET(16, e16, m4);
+  VCMP_I16(4, v16, 0x4c8e, 0xd43f, 0xe266, 0xb5a0, 0xf28a, 0x16cd, 0x3111,
            0x4d5a, 0x8787, 0x2c7b, 0x1083, 0xa89f, 0x9fdf, 0x3faa, 0x98e7,
            0xe2b4);
 
-  VSET(16, e32, m2);
-  VLOAD_32(v6, 0xe318cc7a, 0x489815a8, 0x6e6fc053, 0x8d746807, 0xbc3e6244,
+  VSET(16, e32, m4);
+  VLOAD_32(v16, 0xe318cc7a, 0x489815a8, 0x6e6fc053, 0x8d746807, 0xbc3e6244,
            0xcdfeb4fe, 0x22d24149, 0x26962240, 0x5ef85b7e, 0x2f61a9e8,
            0x373dc202, 0x1567a6b5, 0x763c5239, 0x60dd0502, 0xab178102,
            0x753e0a11);
-  VSET(16, e16, m2);
+  VSET(16, e16, m4);
   scalar = 5383;
   VLOAD_16(v8, 0xce02, 0x6935, 0xc803, 0x75bc, 0x80b7, 0x19d2, 0x3b7c, 0xc269,
            0xb639, 0x66f1, 0x678b, 0xc83e, 0x5a5c, 0x389e, 0x9e46, 0xfae9);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccus.vx v6, %[A], v8, v0.t" ::[A] "r"(scalar));
-  VSET(16, e32, m2);
-  VCMP_I32(5, v6, 0xe318cc7a, 0x513c4f1b, 0x6e6fc053, 0x97200c2b, 0xbc3e6244,
+  asm volatile("vwmaccus.vx v16, %[A], v8, v0.t" ::[A] "r"(scalar));
+  VSET(16, e32, m4);
+  VCMP_I32(5, v16, 0xe318cc7a, 0x513c4f1b, 0x6e6fc053, 0x97200c2b, 0xbc3e6244,
            0xd01da3bc, 0x22d24149, 0x2187101f, 0x5ef85b7e, 0x37d63f7f,
            0x373dc202, 0x10d33667, 0x763c5239, 0x65838754, 0xab178102,
            0x74d30370);
 
 #if ELEN == 64
-  VSET(16, e64, m2);
-  VLOAD_64(v6, 0xb6a5b1c3c6d69abb, 0x3c6a647eb0d79a41, 0xf0c3eb8821045259,
+  VSET(16, e64, m4);
+  VLOAD_64(v16, 0xb6a5b1c3c6d69abb, 0x3c6a647eb0d79a41, 0xf0c3eb8821045259,
            0x91d74be946352cae, 0x524c6db6c58f9da6, 0x39185a920f7787e8,
            0x4080fbf0fdcc64ec, 0x9ed1fb83f53270fc, 0xff0661a19269f0c0,
            0x47d26c599193fe0b, 0xd8cc0342dc3104ce, 0xc51f802bc93381cd,
            0xe7d6522aa1c51245, 0x6fa0a9d3f57bc667, 0xd140731478a147a8,
            0x5d716379591922f4);
-  VSET(16, e32, m2);
+  VSET(16, e32, m4);
   scalar = 6474219;
   VLOAD_32(v8, 0x09377def, 0x99ee4d30, 0x8b8452d1, 0xc9e17667, 0x2254aa29,
            0xb56ca9f5, 0xa1276371, 0x32ac1413, 0x59ff6af3, 0x6b61bf57,
            0xc0eb37b3, 0x26f06be7, 0x0e9b21b2, 0x22898a93, 0xe3646841,
            0xdd301fdc);
   VLOAD_8(v0, 0xAA, 0xAA);
-  asm volatile("vwmaccus.vx v6, %[A], v8, v0.t" ::[A] "r"(scalar));
-  VSET(16, e64, m2);
-  VCMP_I64(6, v6, 0xb6a5b1c3c6d69abb, 0x3c430136a5932551, 0xf0c3eb8821045259,
+  asm volatile("vwmaccus.vx v16, %[A], v8, v0.t" ::[A] "r"(scalar));
+  VSET(16, e64, m4);
+  VCMP_I64(6, v16, 0xb6a5b1c3c6d69abb, 0x3c430136a5932551, 0xf0c3eb8821045259,
            0x91c26988f191bc3b, 0x524c6db6c58f9da6, 0x38fb9358fb72e8cf,
            0x4080fbf0fdcc64ec, 0x9ee5895b4431c96d, 0xff0661a19269f0c0,
            0x47fbdc7722d7f1e8, 0xd8cc0342dc3104ce, 0xc52e86eb9b0cedda,
diff --git a/sw/riscvTests/isa/rv64uv/vxor.c b/sw/riscvTests/isa/rv64uv/vxor.c
index 82f02dac..6e4bb684 100644
--- a/sw/riscvTests/isa/rv64uv/vxor.c
+++ b/sw/riscvTests/isa/rv64uv/vxor.c
@@ -8,48 +8,48 @@
 #include "vector_macros.h"
 
 void TEST_CASE1() {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
-  VLOAD_8(v6, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03,
+  VLOAD_8(v24, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03,
           0xf0);
-  asm volatile("vxor.vv v2, v4, v6");
-  VCMP_U8(1, v2, 0x0f, 0x02, 0x00, 0x0f, 0x02, 0x00, 0x0f, 0x02, 0x00, 0x0f,
+  asm volatile("vxor.vv v8, v16, v24");
+  VCMP_U8(1, v8, 0x0f, 0x02, 0x00, 0x0f, 0x02, 0x00, 0x0f, 0x02, 0x00, 0x0f,
           0x02, 0x00);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
-  VLOAD_16(v6, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003,
+  VLOAD_16(v24, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003,
            0xf0f0, 0xff00, 0x0003, 0xf0f0);
-  asm volatile("vxor.vv v2, v4, v6");
-  VCMP_U16(2, v2, 0x00ff, 0x0002, 0x0000, 0x00ff, 0x0002, 0x0000, 0x00ff,
+  asm volatile("vxor.vv v8, v16, v24");
+  VCMP_U16(2, v8, 0x00ff, 0x0002, 0x0000, 0x00ff, 0x0002, 0x0000, 0x00ff,
            0x0002, 0x0000, 0x00ff, 0x0002, 0x0000);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
-  VLOAD_32(v6, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000, 0x00000003,
+  VLOAD_32(v24, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000, 0x00000003,
            0xf0f0f0f0, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000,
            0x00000003, 0xf0f0f0f0);
-  asm volatile("vxor.vv v2, v4, v6");
-  VCMP_U32(3, v2, 0x0000ffff, 0x00000002, 0x00000000, 0x0000ffff, 0x00000002,
+  asm volatile("vxor.vv v8, v16, v24");
+  VCMP_U32(3, v8, 0x0000ffff, 0x00000002, 0x00000000, 0x0000ffff, 0x00000002,
            0x00000000, 0x0000ffff, 0x00000002, 0x00000000, 0x0000ffff,
            0x00000002, 0x00000000);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
-  VLOAD_64(v6, 0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
+  VLOAD_64(v24, 0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0);
-  asm volatile("vxor.vv v2, v4, v6");
-  VCMP_U64(4, v2, 0x00000000ffffffff, 0x0000000000000002, 0x0000000000000000,
+  asm volatile("vxor.vv v8, v16, v24");
+  VCMP_U64(4, v8, 0x00000000ffffffff, 0x0000000000000002, 0x0000000000000000,
            0x00000000ffffffff, 0x0000000000000002, 0x0000000000000000,
            0x00000000ffffffff, 0x0000000000000002, 0x0000000000000000,
            0x00000000ffffffff, 0x0000000000000002, 0x0000000000000000);
@@ -57,63 +57,63 @@ void TEST_CASE1() {
 }
 
 void TEST_CASE2() {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
-  VLOAD_8(v6, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03,
+  VLOAD_8(v24, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03, 0xf0, 0xf0, 0x03,
           0xf0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef);
-  asm volatile("vxor.vv v2, v4, v6, v0.t");
-  VCMP_U8(5, v2, 0x0f, 0xef, 0x00, 0x0f, 0xef, 0x00, 0x0f, 0xef, 0x00, 0x0f,
+  asm volatile("vxor.vv v8, v16, v24, v0.t");
+  VCMP_U8(5, v8, 0x0f, 0xef, 0x00, 0x0f, 0xef, 0x00, 0x0f, 0xef, 0x00, 0x0f,
           0xef, 0x00);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
-  VLOAD_16(v6, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003,
+  VLOAD_16(v24, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003, 0xf0f0, 0xff00, 0x0003,
            0xf0f0, 0xff00, 0x0003, 0xf0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vxor.vv v2, v4, v6, v0.t");
-  VCMP_U16(6, v2, 0x00ff, 0xbeef, 0x0000, 0x00ff, 0xbeef, 0x0000, 0x00ff,
+  asm volatile("vxor.vv v8, v16, v24, v0.t");
+  VCMP_U16(6, v8, 0x00ff, 0xbeef, 0x0000, 0x00ff, 0xbeef, 0x0000, 0x00ff,
            0xbeef, 0x0000, 0x00ff, 0xbeef, 0x0000);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
-  VLOAD_32(v6, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000, 0x00000003,
+  VLOAD_32(v24, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000, 0x00000003,
            0xf0f0f0f0, 0xffff0000, 0x00000003, 0xf0f0f0f0, 0xffff0000,
            0x00000003, 0xf0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef);
-  asm volatile("vxor.vv v2, v4, v6, v0.t");
-  VCMP_U32(7, v2, 0x0000ffff, 0xdeadbeef, 0x00000000, 0x0000ffff, 0xdeadbeef,
+  asm volatile("vxor.vv v8, v16, v24, v0.t");
+  VCMP_U32(7, v8, 0x0000ffff, 0xdeadbeef, 0x00000000, 0x0000ffff, 0xdeadbeef,
            0x00000000, 0x0000ffff, 0xdeadbeef, 0x00000000, 0x0000ffff,
            0xdeadbeef, 0x00000000);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
-  VLOAD_64(v6, 0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
+  VLOAD_64(v24, 0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0,
            0xffffffff00000000, 0x0000000000000003, 0xf0f0f0f0f0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef);
-  asm volatile("vxor.vv v2, v4, v6, v0.t");
-  VCMP_U64(8, v2, 0x00000000ffffffff, 0xdeadbeefdeadbeef, 0x0000000000000000,
+  asm volatile("vxor.vv v8, v16, v24, v0.t");
+  VCMP_U64(8, v8, 0x00000000ffffffff, 0xdeadbeefdeadbeef, 0x0000000000000000,
            0x00000000ffffffff, 0xdeadbeefdeadbeef, 0x0000000000000000,
            0x00000000ffffffff, 0xdeadbeefdeadbeef, 0x0000000000000000,
            0x00000000ffffffff, 0xdeadbeefdeadbeef, 0x0000000000000000);
@@ -123,37 +123,37 @@ void TEST_CASE2() {
 void TEST_CASE3() {
   const uint32_t scalar = 0x0ff00ff0;
 
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
-  asm volatile("vxor.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U8(9, v2, 0x0f, 0xf1, 0x00, 0x0f, 0xf1, 0x00, 0x0f, 0xf1, 0x00, 0x0f,
+  asm volatile("vxor.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U8(9, v8, 0x0f, 0xf1, 0x00, 0x0f, 0xf1, 0x00, 0x0f, 0xf1, 0x00, 0x0f,
           0xf1, 0x00);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
-  asm volatile("vxor.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U16(10, v2, 0xf00f, 0x0ff1, 0xff00, 0xf00f, 0x0ff1, 0xff00, 0xf00f,
+  asm volatile("vxor.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U16(10, v8, 0xf00f, 0x0ff1, 0xff00, 0xf00f, 0x0ff1, 0xff00, 0xf00f,
            0x0ff1, 0xff00, 0xf00f, 0x0ff1, 0xff00);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
-  asm volatile("vxor.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U32(11, v2, 0xf00ff00f, 0x0ff00ff1, 0xff00ff00, 0xf00ff00f, 0x0ff00ff1,
+  asm volatile("vxor.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U32(11, v8, 0xf00ff00f, 0x0ff00ff1, 0xff00ff00, 0xf00ff00f, 0x0ff00ff1,
            0xff00ff00, 0xf00ff00f, 0x0ff00ff1, 0xff00ff00, 0xf00ff00f,
            0x0ff00ff1, 0xff00ff00);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
-  asm volatile("vxor.vx v2, v4, %[A]" ::[A] "r"(scalar));
-  VCMP_U64(12, v2, 0xfffffffff00ff00f, 0x000000000ff00ff1, 0xf0f0f0f0ff00ff00,
+  asm volatile("vxor.vx v8, v16, %[A]" ::[A] "r"(scalar));
+  VCMP_U64(12, v8, 0xfffffffff00ff00f, 0x000000000ff00ff1, 0xf0f0f0f0ff00ff00,
            0xfffffffff00ff00f, 0x000000000ff00ff1, 0xf0f0f0f0ff00ff00,
            0xfffffffff00ff00f, 0x000000000ff00ff1, 0xf0f0f0f0ff00ff00,
            0xfffffffff00ff00f, 0x000000000ff00ff1, 0xf0f0f0f0ff00ff00);
@@ -163,52 +163,52 @@ void TEST_CASE3() {
 void TEST_CASE4() {
   const uint32_t scalar = 0x0ff00ff0;
 
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef);
-  asm volatile("vxor.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U8(13, v2, 0x0f, 0xef, 0x00, 0x0f, 0xef, 0x00, 0x0f, 0xef, 0x00, 0x0f,
+  asm volatile("vxor.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U8(13, v8, 0x0f, 0xef, 0x00, 0x0f, 0xef, 0x00, 0x0f, 0xef, 0x00, 0x0f,
           0xef, 0x00);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vxor.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U16(14, v2, 0xf00f, 0xbeef, 0xff00, 0xf00f, 0xbeef, 0xff00, 0xf00f,
+  asm volatile("vxor.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U16(14, v8, 0xf00f, 0xbeef, 0xff00, 0xf00f, 0xbeef, 0xff00, 0xf00f,
            0xbeef, 0xff00, 0xf00f, 0xbeef, 0xff00);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef);
-  asm volatile("vxor.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U32(15, v2, 0xf00ff00f, 0xdeadbeef, 0xff00ff00, 0xf00ff00f, 0xdeadbeef,
+  asm volatile("vxor.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U32(15, v8, 0xf00ff00f, 0xdeadbeef, 0xff00ff00, 0xf00ff00f, 0xdeadbeef,
            0xff00ff00, 0xf00ff00f, 0xdeadbeef, 0xff00ff00, 0xf00ff00f,
            0xdeadbeef, 0xff00ff00);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef);
-  asm volatile("vxor.vx v2, v4, %[A], v0.t" ::[A] "r"(scalar));
-  VCMP_U64(16, v2, 0xfffffffff00ff00f, 0xdeadbeefdeadbeef, 0xf0f0f0f0ff00ff00,
+  asm volatile("vxor.vx v8, v16, %[A], v0.t" ::[A] "r"(scalar));
+  VCMP_U64(16, v8, 0xfffffffff00ff00f, 0xdeadbeefdeadbeef, 0xf0f0f0f0ff00ff00,
            0xfffffffff00ff00f, 0xdeadbeefdeadbeef, 0xf0f0f0f0ff00ff00,
            0xfffffffff00ff00f, 0xdeadbeefdeadbeef, 0xf0f0f0f0ff00ff00,
            0xfffffffff00ff00f, 0xdeadbeefdeadbeef, 0xf0f0f0f0ff00ff00);
@@ -216,37 +216,37 @@ void TEST_CASE4() {
 }
 
 void TEST_CASE5() {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
-  asm volatile("vxor.vi v2, v4, 15");
-  VCMP_U8(17, v2, 0xf0, 0x0e, 0xff, 0xf0, 0x0e, 0xff, 0xf0, 0x0e, 0xff, 0xf0,
+  asm volatile("vxor.vi v8, v16, 15");
+  VCMP_U8(17, v8, 0xf0, 0x0e, 0xff, 0xf0, 0x0e, 0xff, 0xf0, 0x0e, 0xff, 0xf0,
           0x0e, 0xff);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
-  asm volatile("vxor.vi v2, v4, 15");
-  VCMP_U16(18, v2, 0xfff0, 0x000e, 0xf0ff, 0xfff0, 0x000e, 0xf0ff, 0xfff0,
+  asm volatile("vxor.vi v8, v16, 15");
+  VCMP_U16(18, v8, 0xfff0, 0x000e, 0xf0ff, 0xfff0, 0x000e, 0xf0ff, 0xfff0,
            0x000e, 0xf0ff, 0xfff0, 0x000e, 0xf0ff);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
-  asm volatile("vxor.vi v2, v4, 15");
-  VCMP_U32(19, v2, 0xfffffff0, 0x0000000e, 0xf0f0f0ff, 0xfffffff0, 0x0000000e,
+  asm volatile("vxor.vi v8, v16, 15");
+  VCMP_U32(19, v8, 0xfffffff0, 0x0000000e, 0xf0f0f0ff, 0xfffffff0, 0x0000000e,
            0xf0f0f0ff, 0xfffffff0, 0x0000000e, 0xf0f0f0ff, 0xfffffff0,
            0x0000000e, 0xf0f0f0ff);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
-  asm volatile("vxor.vi v2, v4, 15");
-  VCMP_U64(20, v2, 0xfffffffffffffff0, 0x000000000000000e, 0xf0f0f0f0f0f0f0ff,
+  asm volatile("vxor.vi v8, v16, 15");
+  VCMP_U64(20, v8, 0xfffffffffffffff0, 0x000000000000000e, 0xf0f0f0f0f0f0f0ff,
            0xfffffffffffffff0, 0x000000000000000e, 0xf0f0f0f0f0f0f0ff,
            0xfffffffffffffff0, 0x000000000000000e, 0xf0f0f0f0f0f0f0ff,
            0xfffffffffffffff0, 0x000000000000000e, 0xf0f0f0f0f0f0f0ff);
@@ -254,52 +254,52 @@ void TEST_CASE5() {
 }
 
 void TEST_CASE6() {
-  VSET(12, e8, m2);
-  VLOAD_8(v4, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
+  VSET(12, e8, m8);
+  VLOAD_8(v16, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01, 0xf0, 0xff, 0x01,
           0xf0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_8(v2, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
+  VLOAD_8(v8, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
           0xef);
-  asm volatile("vxor.vi v2, v4, 15, v0.t");
-  VCMP_U8(21, v2, 0xf0, 0xef, 0xff, 0xf0, 0xef, 0xff, 0xf0, 0xef, 0xff, 0xf0,
+  asm volatile("vxor.vi v8, v16, 15, v0.t");
+  VCMP_U8(21, v8, 0xf0, 0xef, 0xff, 0xf0, 0xef, 0xff, 0xf0, 0xef, 0xff, 0xf0,
           0xef, 0xff);
 
-  VSET(12, e16, m2);
-  VLOAD_16(v4, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
+  VSET(12, e16, m8);
+  VLOAD_16(v16, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001, 0xf0f0, 0xffff, 0x0001,
            0xf0f0, 0xffff, 0x0001, 0xf0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_16(v2, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
+  VLOAD_16(v8, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef, 0xbeef,
            0xbeef, 0xbeef, 0xbeef, 0xbeef);
-  asm volatile("vxor.vi v2, v4, 15, v0.t");
-  VCMP_U16(22, v2, 0xfff0, 0xbeef, 0xf0ff, 0xfff0, 0xbeef, 0xf0ff, 0xfff0,
+  asm volatile("vxor.vi v8, v16, 15, v0.t");
+  VCMP_U16(22, v8, 0xfff0, 0xbeef, 0xf0ff, 0xfff0, 0xbeef, 0xf0ff, 0xfff0,
            0xbeef, 0xf0ff, 0xfff0, 0xbeef, 0xf0ff);
 
-  VSET(12, e32, m2);
-  VLOAD_32(v4, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
+  VSET(12, e32, m8);
+  VLOAD_32(v16, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff, 0x00000001,
            0xf0f0f0f0, 0xffffffff, 0x00000001, 0xf0f0f0f0, 0xffffffff,
            0x00000001, 0xf0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_32(v2, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
+  VLOAD_32(v8, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef,
            0xdeadbeef, 0xdeadbeef);
-  asm volatile("vxor.vi v2, v4, 15, v0.t");
-  VCMP_U32(23, v2, 0xfffffff0, 0xdeadbeef, 0xf0f0f0ff, 0xfffffff0, 0xdeadbeef,
+  asm volatile("vxor.vi v8, v16, 15, v0.t");
+  VCMP_U32(23, v8, 0xfffffff0, 0xdeadbeef, 0xf0f0f0ff, 0xfffffff0, 0xdeadbeef,
            0xf0f0f0ff, 0xfffffff0, 0xdeadbeef, 0xf0f0f0ff, 0xfffffff0,
            0xdeadbeef, 0xf0f0f0ff);
 
 #if ELEN == 64
-  VSET(12, e64, m2);
-  VLOAD_64(v4, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
+  VSET(12, e64, m8);
+  VLOAD_64(v16, 0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0,
            0xffffffffffffffff, 0x0000000000000001, 0xf0f0f0f0f0f0f0f0);
   VLOAD_8(v0, 0x6D, 0x0B);
-  VLOAD_64(v2, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
+  VLOAD_64(v8, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef,
            0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef, 0xdeadbeefdeadbeef);
-  asm volatile("vxor.vi v2, v4, 15, v0.t");
-  VCMP_U64(40, v2, 0xfffffffffffffff0, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0ff,
+  asm volatile("vxor.vi v8, v16, 15, v0.t");
+  VCMP_U64(40, v8, 0xfffffffffffffff0, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0ff,
            0xfffffffffffffff0, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0ff,
            0xfffffffffffffff0, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0ff,
            0xfffffffffffffff0, 0xdeadbeefdeadbeef, 0xf0f0f0f0f0f0f0ff);