diff --git a/sim/kelvin.bin_fmt b/sim/kelvin.bin_fmt
index b68959b..71b48d3 100644
--- a/sim/kelvin.bin_fmt
+++ b/sim/kelvin.bin_fmt
@@ -1199,6 +1199,18 @@
   vmadd_w_vx_m   : KelvinV2ArgsType : func2 == 0b01'0101, sz == 0b10, m == 0b01, func1 == 0b011, form == 0b10;
 
   //vslidevn
+  vsliden_b_1_vv      : KelvinV2ArgsType : func2 == 0b00'0000, sz == 0b00, m == 0b00, func1 == 0b110, form == 0b00;
+  vsliden_b_2_vv      : KelvinV2ArgsType : func2 == 0b00'0001, sz == 0b00, m == 0b00, func1 == 0b110, form == 0b00;
+  vsliden_b_3_vv      : KelvinV2ArgsType : func2 == 0b00'0010, sz == 0b00, m == 0b00, func1 == 0b110, form == 0b00;
+  vsliden_b_4_vv      : KelvinV2ArgsType : func2 == 0b00'0011, sz == 0b00, m == 0b00, func1 == 0b110, form == 0b00;
+  vsliden_h_1_vv      : KelvinV2ArgsType : func2 == 0b00'0000, sz == 0b01, m == 0b00, func1 == 0b110, form == 0b00;
+  vsliden_h_2_vv      : KelvinV2ArgsType : func2 == 0b00'0001, sz == 0b01, m == 0b00, func1 == 0b110, form == 0b00;
+  vsliden_h_3_vv      : KelvinV2ArgsType : func2 == 0b00'0010, sz == 0b01, m == 0b00, func1 == 0b110, form == 0b00;
+  vsliden_h_4_vv      : KelvinV2ArgsType : func2 == 0b00'0011, sz == 0b01, m == 0b00, func1 == 0b110, form == 0b00;
+  vsliden_w_1_vv      : KelvinV2ArgsType : func2 == 0b00'0000, sz == 0b10, m == 0b00, func1 == 0b110, form == 0b00;
+  vsliden_w_2_vv      : KelvinV2ArgsType : func2 == 0b00'0001, sz == 0b10, m == 0b00, func1 == 0b110, form == 0b00;
+  vsliden_w_3_vv      : KelvinV2ArgsType : func2 == 0b00'0010, sz == 0b10, m == 0b00, func1 == 0b110, form == 0b00;
+  vsliden_w_4_vv      : KelvinV2ArgsType : func2 == 0b00'0011, sz == 0b10, m == 0b00, func1 == 0b110, form == 0b00;
   vslidevn_b_1_vv_m   : KelvinV2ArgsType : func2 == 0b00'0000, sz == 0b00, m == 0b01, func1 == 0b110, form == 0b00;
   vslidevn_b_2_vv_m   : KelvinV2ArgsType : func2 == 0b00'0001, sz == 0b00, m == 0b01, func1 == 0b110, form == 0b00;
   vslidevn_b_3_vv_m   : KelvinV2ArgsType : func2 == 0b00'0010, sz == 0b00, m == 0b01, func1 == 0b110, form == 0b00;
@@ -1227,6 +1239,18 @@
   vslidehn_w_4_vv_m   : KelvinV2ArgsType : func2 == 0b00'0111, sz == 0b10, m == 0b01, func1 == 0b110, form == 0b00;
 
   //vslidevp
+  vslidep_b_1_vv      : KelvinV2ArgsType : func2 == 0b00'1000, sz == 0b00, m == 0b00, func1 == 0b110, form == 0b00;
+  vslidep_b_2_vv      : KelvinV2ArgsType : func2 == 0b00'1001, sz == 0b00, m == 0b00, func1 == 0b110, form == 0b00;
+  vslidep_b_3_vv      : KelvinV2ArgsType : func2 == 0b00'1010, sz == 0b00, m == 0b00, func1 == 0b110, form == 0b00;
+  vslidep_b_4_vv      : KelvinV2ArgsType : func2 == 0b00'1011, sz == 0b00, m == 0b00, func1 == 0b110, form == 0b00;
+  vslidep_h_1_vv      : KelvinV2ArgsType : func2 == 0b00'1000, sz == 0b01, m == 0b00, func1 == 0b110, form == 0b00;
+  vslidep_h_2_vv      : KelvinV2ArgsType : func2 == 0b00'1001, sz == 0b01, m == 0b00, func1 == 0b110, form == 0b00;
+  vslidep_h_3_vv      : KelvinV2ArgsType : func2 == 0b00'1010, sz == 0b01, m == 0b00, func1 == 0b110, form == 0b00;
+  vslidep_h_4_vv      : KelvinV2ArgsType : func2 == 0b00'1011, sz == 0b01, m == 0b00, func1 == 0b110, form == 0b00;
+  vslidep_w_1_vv      : KelvinV2ArgsType : func2 == 0b00'1000, sz == 0b10, m == 0b00, func1 == 0b110, form == 0b00;
+  vslidep_w_2_vv      : KelvinV2ArgsType : func2 == 0b00'1001, sz == 0b10, m == 0b00, func1 == 0b110, form == 0b00;
+  vslidep_w_3_vv      : KelvinV2ArgsType : func2 == 0b00'1010, sz == 0b10, m == 0b00, func1 == 0b110, form == 0b00;
+  vslidep_w_4_vv      : KelvinV2ArgsType : func2 == 0b00'1011, sz == 0b10, m == 0b00, func1 == 0b110, form == 0b00;
   vslidevp_b_1_vv_m   : KelvinV2ArgsType : func2 == 0b00'1000, sz == 0b00, m == 0b01, func1 == 0b110, form == 0b00;
   vslidevp_b_2_vv_m   : KelvinV2ArgsType : func2 == 0b00'1001, sz == 0b00, m == 0b01, func1 == 0b110, form == 0b00;
   vslidevp_b_3_vv_m   : KelvinV2ArgsType : func2 == 0b00'1010, sz == 0b00, m == 0b01, func1 == 0b110, form == 0b00;
diff --git a/sim/kelvin.isa b/sim/kelvin.isa
index 764d413..6cf7aaa 100644
--- a/sim/kelvin.isa
+++ b/sim/kelvin.isa
@@ -375,7 +375,7 @@
 }
 
 // Kelvin simd instructions:
-// https://spacebeaker.googlesource.com/shodan/experimental-kelvin/+/refs/heads/master/docs/arch/isa.md
+// https://spacebeaker.googlesource.com/shodan/sw/kelvin/+/refs/heads/master/docs/kelvin_isa.md
 slot kelvin_arith {
   includes {
     #include "sim/kelvin_instructions.h"
@@ -2866,42 +2866,78 @@
       semfunc: "absl::bind_front(&KelvinVMadd<int32_t>, /*scalar*/ true, /*strip_mine*/ true)";
 
     //vslidevn
+    vsliden_b_1_vv{: vs1, vs2 : vd},
+      disasm: "vsliden.b.1.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int8_t>, 1 /* index */, false /* strip_mine */)";
+    vsliden_b_2_vv{: vs1, vs2 : vd},
+      disasm: "vsliden.b.2.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int8_t>, 2 /* index */, false /* strip_mine */)";
+    vsliden_b_3_vv{: vs1, vs2 : vd},
+      disasm: "vsliden.b.3.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int8_t>, 3 /* index */, false /* strip_mine */)";
+    vsliden_b_4_vv{: vs1, vs2 : vd},
+      disasm: "vsliden.b.4.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int8_t>, 4 /* index */, false /* strip_mine */)";
+    vsliden_h_1_vv{: vs1, vs2 : vd},
+      disasm: "vsliden.h.1.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int16_t>, 1 /* index */, false /* strip_mine */)";
+    vsliden_h_2_vv{: vs1, vs2 : vd},
+      disasm: "vsliden.h.2.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int16_t>, 2 /* index */, false /* strip_mine */)";
+    vsliden_h_3_vv{: vs1, vs2 : vd},
+      disasm: "vsliden.h.3.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int16_t>, 3 /* index */, false /* strip_mine */)";
+    vsliden_h_4_vv{: vs1, vs2 : vd},
+      disasm: "vsliden.h.4.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int16_t>, 4 /* index */, false /* strip_mine */)";
+    vsliden_w_1_vv{: vs1, vs2 : vd},
+      disasm: "vsliden.w.1.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int32_t>, 1 /* index */, false /* strip_mine */)";
+    vsliden_w_2_vv{: vs1, vs2 : vd},
+      disasm: "vsliden.w.2.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int32_t>, 2 /* index */, false /* strip_mine */)";
+    vsliden_w_3_vv{: vs1, vs2 : vd},
+      disasm: "vsliden.w.3.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int32_t>, 3 /* index */, false /* strip_mine */)";
+    vsliden_w_4_vv{: vs1, vs2 : vd},
+      disasm: "vsliden.w.4.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int32_t>, 4 /* index */, false /* strip_mine */)";
     vslidevn_b_1_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevn.b.1.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevn<int8_t>, 1 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int8_t>, 1 /* index */, true /* strip_mine */)";
     vslidevn_b_2_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevn.b.2.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevn<int8_t>, 2 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int8_t>, 2 /* index */, true /* strip_mine */)";
     vslidevn_b_3_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevn.b.3.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevn<int8_t>, 3 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int8_t>, 3 /* index */, true /* strip_mine */)";
     vslidevn_b_4_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevn.b.4.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevn<int8_t>, 4 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int8_t>, 4 /* index */, true /* strip_mine */)";
     vslidevn_h_1_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevn.h.1.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevn<int16_t>, 1 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int16_t>, 1 /* index */, true /* strip_mine */)";
     vslidevn_h_2_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevn.h.2.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevn<int16_t>, 2 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int16_t>, 2 /* index */, true /* strip_mine */)";
     vslidevn_h_3_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevn.h.3.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevn<int16_t>, 3 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int16_t>, 3 /* index */, true /* strip_mine */)";
     vslidevn_h_4_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevn.h.4.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevn<int16_t>, 4 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int16_t>, 4 /* index */, true /* strip_mine */)";
     vslidevn_w_1_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevn.w.1.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevn<int32_t>, 1 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int32_t>, 1 /* index */, true /* strip_mine */)";
     vslidevn_w_2_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevn.w.2.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevn<int32_t>, 2 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int32_t>, 2 /* index */, true /* strip_mine */)";
     vslidevn_w_3_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevn.w.3.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevn<int32_t>, 3 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int32_t>, 3 /* index */, true /* strip_mine */)";
     vslidevn_w_4_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevn.w.4.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevn<int32_t>, 4 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevn<int32_t>, 4 /* index */, true /* strip_mine */)";
 
     //vslidehn
     vslidehn_b_1_vv_m{: vs1, vs2 : vd},
@@ -2942,42 +2978,78 @@
       semfunc: "absl::bind_front(&KelvinVSlidehn<int32_t>, 4 /* index */)";
 
     //vslidevp
+    vslidep_b_1_vv{: vs1, vs2 : vd},
+      disasm: "vslidep.b.1.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int8_t>, 1 /* index */, false /* strip_mine */)";
+    vslidep_b_2_vv{: vs1, vs2 : vd},
+      disasm: "vslidep.b.2.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int8_t>, 2 /* index */, false /* strip_mine */)";
+    vslidep_b_3_vv{: vs1, vs2 : vd},
+      disasm: "vslidep.b.3.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int8_t>, 3 /* index */, false /* strip_mine */)";
+    vslidep_b_4_vv{: vs1, vs2 : vd},
+      disasm: "vslidep.b.4.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int8_t>, 4 /* index */, false /* strip_mine */)";
+    vslidep_h_1_vv{: vs1, vs2 : vd},
+      disasm: "vslidep.h.1.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int16_t>, 1 /* index */, false /* strip_mine */)";
+    vslidep_h_2_vv{: vs1, vs2 : vd},
+      disasm: "vslidep.h.2.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int16_t>, 2 /* index */, false /* strip_mine */)";
+    vslidep_h_3_vv{: vs1, vs2 : vd},
+      disasm: "vslidep.h.3.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int16_t>, 3 /* index */, false /* strip_mine */)";
+    vslidep_h_4_vv{: vs1, vs2 : vd},
+      disasm: "vslidep.h.4.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int16_t>, 4 /* index */, false /* strip_mine */)";
+    vslidep_w_1_vv{: vs1, vs2 : vd},
+      disasm: "vslidep.w.1.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int32_t>, 1 /* index */, false /* strip_mine */)";
+    vslidep_w_2_vv{: vs1, vs2 : vd},
+      disasm: "vslidep.w.2.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int32_t>, 2 /* index */, false /* strip_mine */)";
+    vslidep_w_3_vv{: vs1, vs2 : vd},
+      disasm: "vslidep.w.3.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int32_t>, 3 /* index */, false /* strip_mine */)";
+    vslidep_w_4_vv{: vs1, vs2 : vd},
+      disasm: "vslidep.w.4.vv", "%vd, %vs1, %vs2",
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int32_t>, 4 /* index */, false /* strip_mine */)";
     vslidevp_b_1_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevp.b.1.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevp<int8_t>, 1 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int8_t>, 1 /* index */, true /* strip_mine */)";
     vslidevp_b_2_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevp.b.2.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevp<int8_t>, 2 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int8_t>, 2 /* index */, true /* strip_mine */)";
     vslidevp_b_3_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevp.b.3.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevp<int8_t>, 3 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int8_t>, 3 /* index */, true /* strip_mine */)";
     vslidevp_b_4_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevp.b.4.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevp<int8_t>, 4 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int8_t>, 4 /* index */, true /* strip_mine */)";
     vslidevp_h_1_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevp.h.1.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevp<int16_t>, 1 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int16_t>, 1 /* index */, true /* strip_mine */)";
     vslidevp_h_2_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevp.h.2.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevp<int16_t>, 2 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int16_t>, 2 /* index */, true /* strip_mine */)";
     vslidevp_h_3_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevp.h.3.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevp<int16_t>, 3 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int16_t>, 3 /* index */, true /* strip_mine */)";
     vslidevp_h_4_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevp.h.4.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevp<int16_t>, 4 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int16_t>, 4 /* index */, true /* strip_mine */)";
     vslidevp_w_1_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevp.w.1.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevp<int32_t>, 1 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int32_t>, 1 /* index */, true /* strip_mine */)";
     vslidevp_w_2_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevp.w.2.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevp<int32_t>, 2 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int32_t>, 2 /* index */, true /* strip_mine */)";
     vslidevp_w_3_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevp.w.3.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevp<int32_t>, 3 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int32_t>, 3 /* index */, true /* strip_mine */)";
     vslidevp_w_4_vv_m{: vs1, vs2 : vd},
       disasm: "vslidevp.w.4.vv.m", "%vd, %vs1, %vs2",
-      semfunc: "absl::bind_front(&KelvinVSlidevp<int32_t>, 4 /* index */)";
+      semfunc: "absl::bind_front(&KelvinVSlidevp<int32_t>, 4 /* index */, true /* strip_mine */)";
 
     //vslidehp
     vslidehp_b_1_vv_m{: vs1, vs2 : vd},
diff --git a/sim/kelvin_vector_instructions.cc b/sim/kelvin_vector_instructions.cc
index 33e6401..94c9724 100644
--- a/sim/kelvin_vector_instructions.cc
+++ b/sim/kelvin_vector_instructions.cc
@@ -19,7 +19,6 @@
 
 using mpact::sim::generic::DataBuffer;
 using mpact::sim::generic::GetInstructionSource;
-using mpact::sim::generic::Instruction;
 using mpact::sim::riscv::RV32VectorDestinationOperand;
 
 template <typename Vd, typename Vs1, typename Vs2>
@@ -1018,11 +1017,23 @@
     int register_num;
     int source_arg;
   };
-  const Interleave interleave_start[2][4] = {{{3, 0}, {2, 0}, {1, 0}, {0, 0}},
-                                             {{3, 0}, {2, 0}, {1, 0}, {0, 0}}};
-  const Interleave interleave_end[2][4] = {{{3, 1}, {2, 1}, {1, 1}, {0, 1}},
-                                           {{0, 1}, {3, 0}, {2, 0}, {1, 0}}};
-
+  const Interleave interleave_start[2][4] = {{{0, 0}, {1, 0}, {2, 0}, {3, 0}},
+                                             {{0, 0}, {1, 0}, {2, 0}, {3, 0}}};
+  const Interleave interleave_end[2][4] = {{{0, 1}, {1, 1}, {2, 1}, {3, 1}},
+                                           {{1, 0}, {2, 0}, {3, 0}, {0, 1}}};
+  // Get the elements from the right up to `index`.
+  // For the horizontal mode, it treats the stripmine `vm` register based on
+  // `vs1` as a contiguous block, and only the first `index` elements from `vs2`
+  // will be used.
+  //
+  // For the vertical mode, each stripmine vector register `op_index` is mapped
+  // separatedly. it mimics the imaging tiling process shift of
+  //   |--------|--------|
+  //   | 4xVLEN | 4xVLEN |
+  //   |  (vs1) |  (vs2) |
+  //   |--------|--------|
+  // The vertical mode can also support the non-stripmine version to handle
+  // the last columns of the image.
   if (dst_element_index + index < elts_per_register) {
     auto src_element_index =
         interleave_start[horizontal][op_index].register_num *
@@ -1042,16 +1053,16 @@
 
 // Slide next register vertically by index.
 template <typename T>
-void KelvinVSlidevn(int index, Instruction *inst) {
+void KelvinVSlidevn(int index, bool strip_mine, Instruction *inst) {
   KelvinBinaryVectorOp(
-      inst, false /* scalar */, true /* strip_mine */,
+      inst, false /* scalar */, strip_mine,
       std::function<T(T, T)>([](T vs1, T vs2) -> T { return vs1; }),
       SourceArgGetter<T, T, T, T>(absl::bind_front(
           VSlidenOpGetArg1<T>, false /* horizontal */, index)));
 }
-template void KelvinVSlidevn<int8_t>(int, Instruction *);
-template void KelvinVSlidevn<int16_t>(int, Instruction *);
-template void KelvinVSlidevn<int32_t>(int, Instruction *);
+template void KelvinVSlidevn<int8_t>(int, bool, Instruction *);
+template void KelvinVSlidevn<int16_t>(int, bool, Instruction *);
+template void KelvinVSlidevn<int32_t>(int, bool, Instruction *);
 
 // Slide next register horizontally by index.
 template <typename T>
@@ -1080,16 +1091,28 @@
     int register_num;
     int source_arg;
   };
-  const Interleave interleave_start[2][4] = {{{3, 0}, {2, 0}, {1, 0}, {0, 0}},
-                                             {{3, 0}, {2, 0}, {1, 0}, {0, 0}}};
-  const Interleave interleave_end[2][4] = {{{2, 0}, {1, 0}, {0, 0}, {3, 1}},
-                                           {{0, 1}, {3, 0}, {2, 0}, {1, 0}}};
-
-  if (dst_element_index >= index) {
+  const Interleave interleave_start[2][4] = {{{0, 0}, {1, 0}, {2, 0}, {3, 0}},
+                                             {{3, 0}, {0, 1}, {1, 1}, {2, 1}}};
+  const Interleave interleave_end[2][4] = {{{0, 1}, {1, 1}, {2, 1}, {3, 1}},
+                                           {{0, 1}, {1, 1}, {2, 1}, {3, 1}}};
+  // Get the elements from the left up to `index`.
+  // For the horizontal mode, it treats the stripmine `vm` register based on
+  // `vs2` as a contiguous block, and only the LAST `index` elements from
+  // stripmine vm register based on `vs1` will be used AT THE BEGINNING.
+  //
+  // For the vertical mode, each stripmine vector register `op_index` is mapped
+  // separatedly. it mimics the imaging tiling process shift of
+  //   |--------|--------|
+  //   | 4xVLEN | 4xVLEN |
+  //   |  (vs1) |  (vs2) |
+  //   |--------|--------|
+  // The vertical mode can also support the non-stripmine version to handle
+  // the last columns of the image.
+  if (dst_element_index < index) {
     auto src_element_index =
         interleave_start[horizontal][op_index].register_num *
             elts_per_register +
-        dst_element_index - index;
+        dst_element_index - index + elts_per_register;
     return GetInstructionSource<T>(
         inst, interleave_start[horizontal][op_index].source_arg,
         src_element_index);
@@ -1097,23 +1120,23 @@
 
   auto src_element_index =
       interleave_end[horizontal][op_index].register_num * elts_per_register +
-      elts_per_register + dst_element_index - index;
+      dst_element_index - index;
   return GetInstructionSource<T>(
       inst, interleave_end[horizontal][op_index].source_arg, src_element_index);
 }
 
 // Slide previous register vertically by index.
 template <typename T>
-void KelvinVSlidevp(int index, Instruction *inst) {
+void KelvinVSlidevp(int index, bool strip_mine, Instruction *inst) {
   KelvinBinaryVectorOp(
-      inst, false /* scalar */, true /* strip_mine */,
+      inst, false /* scalar */, strip_mine,
       std::function<T(T, T)>([](T vs1, T vs2) -> T { return vs1; }),
       SourceArgGetter<T, T, T, T>(absl::bind_front(
           VSlidepOpGetArg1<T>, false /* horizontal */, index)));
 }
-template void KelvinVSlidevp<int8_t>(int, Instruction *);
-template void KelvinVSlidevp<int16_t>(int, Instruction *);
-template void KelvinVSlidevp<int32_t>(int, Instruction *);
+template void KelvinVSlidevp<int8_t>(int, bool, Instruction *);
+template void KelvinVSlidevp<int16_t>(int, bool, Instruction *);
+template void KelvinVSlidevp<int32_t>(int, bool, Instruction *);
 
 // Slide previous register horizontally by index.
 template <typename T>
diff --git a/sim/kelvin_vector_instructions.h b/sim/kelvin_vector_instructions.h
index 447dcc4..64a31c1 100644
--- a/sim/kelvin_vector_instructions.h
+++ b/sim/kelvin_vector_instructions.h
@@ -151,13 +151,13 @@
 void KelvinVMadd(bool scalar, bool strip_mine, Instruction *inst);
 
 template <typename T>
-void KelvinVSlidevn(int index, Instruction *inst);
+void KelvinVSlidevn(int index, bool strip_mine, Instruction *inst);
 
 template <typename T>
 void KelvinVSlidehn(int index, Instruction *inst);
 
 template <typename T>
-void KelvinVSlidevp(int index, Instruction *inst);
+void KelvinVSlidevp(int index, bool strip_mine, Instruction *inst);
 
 template <typename T>
 void KelvinVSlidehp(int index, Instruction *inst);
diff --git a/sim/test/kelvin_vector_instructions_test.cc b/sim/test/kelvin_vector_instructions_test.cc
index f4c4c0b..ee6ccfb 100644
--- a/sim/test/kelvin_vector_instructions_test.cc
+++ b/sim/test/kelvin_vector_instructions_test.cc
@@ -259,23 +259,26 @@
   }
 
   template <template <typename> class F, typename T>
-  void KelvinSlideOpHelper(absl::string_view name, bool horizontal) {
+  void KelvinSlideOpHelper(absl::string_view name, bool horizontal,
+                           bool strip_mine) {
     const auto name_with_type = absl::StrCat(name, KelvinTestTypeSuffix<T>());
 
     for (int i = 1; i < 5; ++i) {
       BinaryOpTestHelper<T, T, T>(
-          absl::bind_front(F<T>::KelvinOp, i),
-          absl::StrCat(name_with_type, i, "VM"), kNonScalar, kIsStripmine,
-          F<T>::Op, absl::bind_front(F<T>::kArgsGetter, horizontal, i),
-          kNonHalftypeOp, kNonVmvpOp, kNonWidenDst);
+          absl::bind_front(F<T>::KelvinOp, i, strip_mine),
+          absl::StrCat(name_with_type, i, "V", strip_mine ? "M" : ""),
+          kNonScalar, strip_mine, F<T>::Op,
+          absl::bind_front(F<T>::kArgsGetter, horizontal, i), kNonHalftypeOp,
+          kNonVmvpOp, kNonWidenDst);
     }
   }
 
   template <template <typename> class F, typename T, typename TNext1,
             typename... TNext>
-  void KelvinSlideOpHelper(absl::string_view name, bool horizontal) {
-    KelvinSlideOpHelper<F, T>(name, horizontal);
-    KelvinSlideOpHelper<F, TNext1, TNext...>(name, horizontal);
+  void KelvinSlideOpHelper(absl::string_view name, bool horizontal,
+                           bool strip_mine) {
+    KelvinSlideOpHelper<F, T>(name, horizontal, strip_mine);
+    KelvinSlideOpHelper<F, TNext1, TNext...>(name, horizontal, strip_mine);
   }
 
   template <template <typename> class F, typename T>
@@ -1429,10 +1432,10 @@
     int register_num;
     int source_arg;
   };
-  const Interleave interleave_start[2][4] = {{{3, 0}, {2, 0}, {1, 0}, {0, 0}},
-                                             {{3, 0}, {2, 0}, {1, 0}, {0, 0}}};
-  const Interleave interleave_end[2][4] = {{{3, 1}, {2, 1}, {1, 1}, {0, 1}},
-                                           {{0, 1}, {3, 0}, {2, 0}, {1, 0}}};
+  const Interleave interleave_start[2][4] = {{{0, 0}, {1, 0}, {2, 0}, {3, 0}},
+                                             {{0, 0}, {1, 0}, {2, 0}, {3, 0}}};
+  const Interleave interleave_end[2][4] = {{{0, 1}, {1, 1}, {2, 1}, {3, 1}},
+                                           {{1, 0}, {2, 0}, {3, 0}, {0, 1}}};
 
   T arg1;
   if (element_index + index < vd_size) {
@@ -1460,29 +1463,33 @@
 struct VSlidehnOp {
   static constexpr auto kArgsGetter = SlidenArgsGetter<T>;
   static T Op(T vs1, T vs2) { return vs1; }
-  static void KelvinOp(int index, Instruction *inst) {
+  static void KelvinOp(int index, bool strip_mine, Instruction *inst) {
     KelvinVSlidehn<T>(index, inst);
   }
 };
 
-TEST_F(KelvinVectorInstructionsTest, VSlidehnOp) {
-  KelvinSlideOpHelper<VSlidehnOp, int8_t, int16_t, int32_t>("VSlidehnOp",
-                                                            kHorizontal);
+TEST_F(KelvinVectorInstructionsTest, VSlidehn) {
+  KelvinSlideOpHelper<VSlidehnOp, int8_t, int16_t, int32_t>(
+      "VSlidehnOp", kHorizontal, true /* strip_mine */);
 }
 
-// Slide next register vertically by index.
 template <typename T>
 struct VSlidevnOp {
   static constexpr auto kArgsGetter = SlidenArgsGetter<T>;
   static T Op(T vs1, T vs2) { return vs1; }
-  static void KelvinOp(int index, Instruction *inst) {
-    KelvinVSlidevn<T>(index, inst);
+  static void KelvinOp(int index, bool strip_mine, Instruction *inst) {
+    KelvinVSlidevn<T>(index, strip_mine, inst);
   }
 };
 
-TEST_F(KelvinVectorInstructionsTest, VSlidevnOp) {
-  KelvinSlideOpHelper<VSlidevnOp, int8_t, int16_t, int32_t>("VSlidevnOp",
-                                                            kVertical);
+TEST_F(KelvinVectorInstructionsTest, VSliden) {
+  KelvinSlideOpHelper<VSlidevnOp, int8_t, int16_t, int32_t>(
+      "VSlidenOp", kVertical, false /* strip_mine */);
+}
+
+TEST_F(KelvinVectorInstructionsTest, VSlidevn) {
+  KelvinSlideOpHelper<VSlidevnOp, int8_t, int16_t, int32_t>(
+      "VSlidevnOp", kVertical, true /* strip_mine */);
 }
 
 // Slide previous register by index.
@@ -1499,23 +1506,23 @@
     int register_num;
     int source_arg;
   };
-  const Interleave interleave_start[2][4] = {{{3, 0}, {2, 0}, {1, 0}, {0, 0}},
-                                             {{3, 0}, {2, 0}, {1, 0}, {0, 0}}};
-  const Interleave interleave_end[2][4] = {{{2, 0}, {1, 0}, {0, 0}, {3, 1}},
-                                           {{0, 1}, {3, 0}, {2, 0}, {1, 0}}};
+  const Interleave interleave_start[2][4] = {{{0, 0}, {1, 0}, {2, 0}, {3, 0}},
+                                             {{3, 0}, {0, 1}, {1, 1}, {2, 1}}};
+  const Interleave interleave_end[2][4] = {{{0, 1}, {1, 1}, {2, 1}, {3, 1}},
+                                           {{0, 1}, {1, 1}, {2, 1}, {3, 1}}};
 
   T arg1;
-  if (element_index >= index) {
+  if (element_index < index) {
     auto src_element_index =
         interleave_start[horizontal][op_num].register_num * vd_size +
-        element_index - index;
+        element_index - index + vd_size;
     arg1 = interleave_start[horizontal][op_num].source_arg
                ? vs2_value[src_element_index]
                : vs1_value[src_element_index];
   } else {
     auto src_element_index =
         interleave_end[horizontal][op_num].register_num * vd_size +
-        element_index - index + vd_size;
+        element_index - index;
 
     arg1 = interleave_end[horizontal][op_num].source_arg
                ? vs2_value[src_element_index]
@@ -1530,29 +1537,33 @@
 struct VSlidehpOp {
   static constexpr auto kArgsGetter = SlidepArgsGetter<T>;
   static T Op(T vs1, T vs2) { return vs1; }
-  static void KelvinOp(int index, Instruction *inst) {
+  static void KelvinOp(int index, bool strip_mine, Instruction *inst) {
     KelvinVSlidehp<T>(index, inst);
   }
 };
 
-TEST_F(KelvinVectorInstructionsTest, VSlidehpOp) {
-  KelvinSlideOpHelper<VSlidehpOp, int8_t, int16_t, int32_t>("VSlidehpOp",
-                                                            kHorizontal);
+TEST_F(KelvinVectorInstructionsTest, VSlidehp) {
+  KelvinSlideOpHelper<VSlidehpOp, int8_t, int16_t, int32_t>(
+      "VSlidehpOp", kHorizontal, true /* strip_mine */);
 }
 
-// Slide previous register vertically by index.
 template <typename T>
 struct VSlidevpOp {
   static constexpr auto kArgsGetter = SlidepArgsGetter<T>;
   static T Op(T vs1, T vs2) { return vs1; }
-  static void KelvinOp(int index, Instruction *inst) {
-    KelvinVSlidevp<T>(index, inst);
+  static void KelvinOp(int index, bool strip_mine, Instruction *inst) {
+    KelvinVSlidevp<T>(index, strip_mine, inst);
   }
 };
 
-TEST_F(KelvinVectorInstructionsTest, VSlidevpOp) {
-  KelvinSlideOpHelper<VSlidevpOp, int8_t, int16_t, int32_t>("VSlidevpOp",
-                                                            kVertical);
+TEST_F(KelvinVectorInstructionsTest, VSlidep) {
+  KelvinSlideOpHelper<VSlidevpOp, int8_t, int16_t, int32_t>(
+      "VSlidepOp", kVertical, false /* strip_mine */);
+}
+
+TEST_F(KelvinVectorInstructionsTest, VSlidevp) {
+  KelvinSlideOpHelper<VSlidevpOp, int8_t, int16_t, int32_t>(
+      "VSlidevpOp", kVertical, true /* strip_mine */);
 }
 
 // Select lanes from two operands with vector selection boolean.