diff --git a/src/hotspot/share/opto/superword.cpp b/src/hotspot/share/opto/superword.cpp
index 47735f6bbba..a042f66b348 100644
--- a/src/hotspot/share/opto/superword.cpp
+++ b/src/hotspot/share/opto/superword.cpp
@@ -2286,27 +2286,44 @@ bool SuperWord::is_vector_use(Node* use, int u_idx) const {
   Node* def = use->in(u_idx);
   Node_List* d_pk = get_pack(def);
   if (d_pk == nullptr) {
-    Node* n = u_pk->at(0)->in(u_idx);
-    if (n == iv()) {
-      // check for index population
-      BasicType bt = velt_basic_type(use);
-      if (!VectorNode::is_populate_index_supported(bt)) return false;
-      for (uint i = 1; i < u_pk->size(); i++) {
-        // We can create a vector filled with iv indices if all other nodes
-        // in use pack have inputs of iv plus node index.
-        Node* use_in = u_pk->at(i)->in(u_idx);
-        if (!use_in->is_Add() || use_in->in(1) != n) return false;
-        const TypeInt* offset_t = use_in->in(2)->bottom_type()->is_int();
-        if (offset_t == nullptr || !offset_t->is_con() ||
-            offset_t->get_con() != (jint) i) return false;
-      }
-    } else {
-      // check for scalar promotion
-      for (uint i = 1; i < u_pk->size(); i++) {
-        if (u_pk->at(i)->in(u_idx) != n) return false;
+    // We did not find an input pack.
+    // Let's see if it is a special case, otherwise we cannot vectorize.
+    if (is_vector_use_of_scalar_promotion(u_pk, u_idx)) { return true; }
+    if (is_vector_use_of_populate_index(u_pk, u_idx)) { return true; }
+
+#ifndef PRODUCT
+    if (is_trace_superword_rejections()) {
+      tty->print_cr("\nThe following pack does not have a matching input vector for in(%d):", u_idx);
+      u_pk->dump();
+      tty->print_cr("\nHere are the nodes for in(%d):", u_idx);
+      for (uint i = 0; i < u_pk->size(); i++) {
+        tty->print("    %d: ", i);
+        u_pk->at(i)->in(u_idx)->dump();
       }
     }
-    return true;
+#endif
+    return false;
+    //Node* n = u_pk->at(0)->in(u_idx);
+    //if (n == iv()) {
+    //  // check for index population
+    //  BasicType bt = velt_basic_type(use);
+    //  if (!VectorNode::is_populate_index_supported(bt)) return false;
+    //  for (uint i = 1; i < u_pk->size(); i++) {
+    //    // We can create a vector filled with iv indices if all other nodes
+    //    // in use pack have inputs of iv plus node index.
+    //    Node* use_in = u_pk->at(i)->in(u_idx);
+    //    if (!use_in->is_Add() || use_in->in(1) != n) return false;
+    //    const TypeInt* offset_t = use_in->in(2)->bottom_type()->is_int();
+    //    if (offset_t == nullptr || !offset_t->is_con() ||
+    //        offset_t->get_con() != (jint) i) return false;
+    //  }
+    //} else {
+    //  // check for scalar promotion
+    //  for (uint i = 1; i < u_pk->size(); i++) {
+    //    if (u_pk->at(i)->in(u_idx) != n) return false;
+    //  }
+    //}
+    //return true;
   }
 
   if (!is_velt_basic_type_compatible_use_def(use, def)) {
@@ -2320,6 +2337,54 @@ bool SuperWord::is_vector_use(Node* use, int u_idx) const {
   return _packset.pack_input_at_index_or_null(u_pk, u_idx) != nullptr;
 }
 
+// Replicate pattern: all elements have the same input node.
+bool SuperWord::is_vector_use_of_scalar_promotion(Node_List* use_pack, int u_idx) const {
+  Node* unique_input = use_pack->at(0)->in(u_idx);
+  for (uint i = 1; i < use_pack->size(); i++) {
+    if (use_pack->at(i)->in(u_idx) != unique_input) { return false; }
+  }
+  return true;
+}
+
+// TODO: desc
+bool SuperWord::is_vector_use_of_populate_index(Node_List* use_pack, int u_idx) const {
+  BasicType bt = velt_basic_type(use_pack->at(0)->in(u_idx));
+  if (!VectorNode::is_populate_index_supported(bt)) return false;
+
+  for (uint i = 0; i < use_pack->size(); i++) {
+    const IVPlusCon iv_plus_con = is_iv_plus_con(use_pack->at(i)->in(u_idx));
+    iv_plus_con.print();
+    if (!iv_plus_con.is_valid() || iv_plus_con.con() != (jint)i) {
+      return false;
+    }
+  }
+  return true;
+}
+
+SuperWord::IVPlusCon SuperWord::is_iv_plus_con(Node* n) const {
+  tty->print("lookin at: "); n->dump();
+  if (n->Opcode() == Op_ConvI2L) {
+    n = n->in(1);
+  }
+  if (n == iv()) {
+    return IVPlusCon::make_iv();
+  }
+  if (n->is_Add()) {
+    Node* in1 = n->in(1);
+    Node* in2 = n->in(2);
+    if (in1->Opcode() == Op_ConvI2L) {
+      in1 = in1->in(1);
+    }
+    if (in1 == iv() && in2->is_Con()) {
+      // TODO: check if long fits in int?
+      tty->print("  con? "); in2->dump();
+      jlong con = (in2->Opcode() == Op_ConI) ? in2->get_int() : in2->get_long();
+      return IVPlusCon::make_iv_plus_con(con);
+    }
+  }
+  return IVPlusCon::make_invalid();
+}
+
 // MulAddS2I takes 4 shorts and produces an int. We can reinterpret
 // the 4 shorts as two ints: a = (a0, a1) and b = (b0, b1).
 //
diff --git a/src/hotspot/share/opto/superword.hpp b/src/hotspot/share/opto/superword.hpp
index 57a403b4498..2c0d932126f 100644
--- a/src/hotspot/share/opto/superword.hpp
+++ b/src/hotspot/share/opto/superword.hpp
@@ -652,6 +652,34 @@ class SuperWord : public ResourceObj {
 
   // Is use->in(u_idx) a vector use?
   bool is_vector_use(Node* use, int u_idx) const;
+  bool is_vector_use_of_scalar_promotion(Node_List* use_pack, int u_idx) const;
+  bool is_vector_use_of_populate_index(Node_List* use_pack, int u_idx) const;
+
+  class IVPlusCon : public StackObj {
+  private:
+    const bool _valid;
+    const jlong _con;
+
+    IVPlusCon(bool valid, jlong con) : _valid(valid), _con(con) {}
+
+  public:
+    static IVPlusCon make_invalid() { return IVPlusCon(false, 0); }
+    static IVPlusCon make_iv() { return IVPlusCon(true, 0); }
+    static IVPlusCon make_iv_plus_con(jlong con) { return IVPlusCon(true, con); }
+
+    bool is_valid() const { return _valid; }
+    jlong con() const { return _con; }
+
+    void print() const {
+      if (!_valid) {
+        tty->print_cr("IVPlusCon: invalid");
+      } else {
+        tty->print_cr("IVPlusCon: iv + con(%d)", (jint)_con);
+      }
+    }
+  };
+
+  IVPlusCon is_iv_plus_con(Node* n) const;
 
   bool is_velt_basic_type_compatible_use_def(Node* use, Node* def) const;
 
diff --git a/test/micro/org/openjdk/bench/vm/compiler/VectorReduction2.java b/test/micro/org/openjdk/bench/vm/compiler/VectorReduction2.java
index ec614cb324b..d724f7424ca 100644
--- a/test/micro/org/openjdk/bench/vm/compiler/VectorReduction2.java
+++ b/test/micro/org/openjdk/bench/vm/compiler/VectorReduction2.java
@@ -33,7 +33,8 @@
 @State(Scope.Thread)
 @Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
 @Measurement(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
-public abstract class VectorReduction2 {
+@Fork(value = 1)
+public class VectorReduction2 {
     @Param({"2048"})
     public int SIZE;
 
@@ -134,644 +135,644 @@ public void init() {
     //     - min:     acc = min(acc, val)
     //     - max:     acc = max(acc, val)
 
-    // ---------byte***Simple ------------------------------------------------------------
-    @Benchmark
-    public void byteAndSimple(Blackhole bh) {
-        byte acc = (byte)0xFF; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = in1B[i];
-            acc &= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteOrSimple(Blackhole bh) {
-        byte acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = in1B[i];
-            acc |= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteXorSimple(Blackhole bh) {
-        byte acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = in1B[i];
-            acc ^= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteAddSimple(Blackhole bh) {
-        byte acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = in1B[i];
-            acc += val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteMulSimple(Blackhole bh) {
-        byte acc = 1; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = in1B[i];
-            acc *= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteMinSimple(Blackhole bh) {
-        byte acc = Byte.MAX_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = in1B[i];
-            acc = (byte)Math.min(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteMaxSimple(Blackhole bh) {
-        byte acc = Byte.MIN_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = in1B[i];
-            acc = (byte)Math.max(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    // ---------byte***DotProduct ------------------------------------------------------------
-    @Benchmark
-    public void byteAndDotProduct(Blackhole bh) {
-        byte acc = (byte)0xFF; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)(in1B[i] * in2B[i]);
-            acc &= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteOrDotProduct(Blackhole bh) {
-        byte acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)(in1B[i] * in2B[i]);
-            acc |= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteXorDotProduct(Blackhole bh) {
-        byte acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)(in1B[i] * in2B[i]);
-            acc ^= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteAddDotProduct(Blackhole bh) {
-        byte acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)(in1B[i] * in2B[i]);
-            acc += val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteMulDotProduct(Blackhole bh) {
-        byte acc = 1; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)(in1B[i] * in2B[i]);
-            acc *= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteMinDotProduct(Blackhole bh) {
-        byte acc = Byte.MAX_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)(in1B[i] * in2B[i]);
-            acc = (byte)Math.min(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteMaxDotProduct(Blackhole bh) {
-        byte acc = Byte.MIN_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)(in1B[i] * in2B[i]);
-            acc = (byte)Math.max(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    // ---------byte***Big ------------------------------------------------------------
-    @Benchmark
-    public void byteAndBig(Blackhole bh) {
-        byte acc = (byte)0xFF; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
-            acc &= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteOrBig(Blackhole bh) {
-        byte acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
-            acc |= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteXorBig(Blackhole bh) {
-        byte acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
-            acc ^= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteAddBig(Blackhole bh) {
-        byte acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
-            acc += val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteMulBig(Blackhole bh) {
-        byte acc = 1; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
-            acc *= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteMinBig(Blackhole bh) {
-        byte acc = Byte.MAX_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
-            acc = (byte)Math.min(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void byteMaxBig(Blackhole bh) {
-        byte acc = Byte.MIN_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
-            acc = (byte)Math.max(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    // ---------char***Simple ------------------------------------------------------------
-    @Benchmark
-    public void charAndSimple(Blackhole bh) {
-        char acc = (char)0xFFFF; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = in1C[i];
-            acc &= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charOrSimple(Blackhole bh) {
-        char acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = in1C[i];
-            acc |= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charXorSimple(Blackhole bh) {
-        char acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = in1C[i];
-            acc ^= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charAddSimple(Blackhole bh) {
-        char acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = in1C[i];
-            acc += val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charMulSimple(Blackhole bh) {
-        char acc = 1; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = in1C[i];
-            acc *= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charMinSimple(Blackhole bh) {
-        char acc = Character.MAX_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = in1C[i];
-            acc = (char)Math.min(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charMaxSimple(Blackhole bh) {
-        char acc = Character.MIN_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = in1C[i];
-            acc = (char)Math.max(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    // ---------char***DotProduct ------------------------------------------------------------
-    @Benchmark
-    public void charAndDotProduct(Blackhole bh) {
-        char acc = (char)0xFFFF; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)(in1C[i] * in2C[i]);
-            acc &= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charOrDotProduct(Blackhole bh) {
-        char acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)(in1C[i] * in2C[i]);
-            acc |= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charXorDotProduct(Blackhole bh) {
-        char acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)(in1C[i] * in2C[i]);
-            acc ^= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charAddDotProduct(Blackhole bh) {
-        char acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)(in1C[i] * in2C[i]);
-            acc += val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charMulDotProduct(Blackhole bh) {
-        char acc = 1; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)(in1C[i] * in2C[i]);
-            acc *= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charMinDotProduct(Blackhole bh) {
-        char acc = Character.MAX_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)(in1C[i] * in2C[i]);
-            acc = (char)Math.min(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charMaxDotProduct(Blackhole bh) {
-        char acc = Character.MIN_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)(in1C[i] * in2C[i]);
-            acc = (char)Math.max(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    // ---------char***Big ------------------------------------------------------------
-    @Benchmark
-    public void charAndBig(Blackhole bh) {
-        char acc = (char)0xFFFF; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
-            acc &= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charOrBig(Blackhole bh) {
-        char acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
-            acc |= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charXorBig(Blackhole bh) {
-        char acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
-            acc ^= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charAddBig(Blackhole bh) {
-        char acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
-            acc += val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charMulBig(Blackhole bh) {
-        char acc = 1; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
-            acc *= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charMinBig(Blackhole bh) {
-        char acc = Character.MAX_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
-            acc = (char)Math.min(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void charMaxBig(Blackhole bh) {
-        char acc = Character.MIN_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
-            acc = (char)Math.max(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    // ---------short***Simple ------------------------------------------------------------
-    @Benchmark
-    public void shortAndSimple(Blackhole bh) {
-        short acc = (short)0xFFFF; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = in1S[i];
-            acc &= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortOrSimple(Blackhole bh) {
-        short acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = in1S[i];
-            acc |= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortXorSimple(Blackhole bh) {
-        short acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = in1S[i];
-            acc ^= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortAddSimple(Blackhole bh) {
-        short acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = in1S[i];
-            acc += val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortMulSimple(Blackhole bh) {
-        short acc = 1; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = in1S[i];
-            acc *= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortMinSimple(Blackhole bh) {
-        short acc = Short.MAX_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = in1S[i];
-            acc = (short)Math.min(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortMaxSimple(Blackhole bh) {
-        short acc = Short.MIN_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = in1S[i];
-            acc = (short)Math.max(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    // ---------short***DotProduct ------------------------------------------------------------
-    @Benchmark
-    public void shortAndDotProduct(Blackhole bh) {
-        short acc = (short)0xFFFF; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)(in1S[i] * in2S[i]);
-            acc &= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortOrDotProduct(Blackhole bh) {
-        short acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)(in1S[i] * in2S[i]);
-            acc |= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortXorDotProduct(Blackhole bh) {
-        short acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)(in1S[i] * in2S[i]);
-            acc ^= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortAddDotProduct(Blackhole bh) {
-        short acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)(in1S[i] * in2S[i]);
-            acc += val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortMulDotProduct(Blackhole bh) {
-        short acc = 1; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)(in1S[i] * in2S[i]);
-            acc *= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortMinDotProduct(Blackhole bh) {
-        short acc = Short.MAX_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)(in1S[i] * in2S[i]);
-            acc = (short)Math.min(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortMaxDotProduct(Blackhole bh) {
-        short acc = Short.MIN_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)(in1S[i] * in2S[i]);
-            acc = (short)Math.max(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    // ---------short***Big ------------------------------------------------------------
-    @Benchmark
-    public void shortAndBig(Blackhole bh) {
-        short acc = (short)0xFFFF; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
-            acc &= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortOrBig(Blackhole bh) {
-        short acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
-            acc |= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortXorBig(Blackhole bh) {
-        short acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
-            acc ^= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortAddBig(Blackhole bh) {
-        short acc = 0; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
-            acc += val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortMulBig(Blackhole bh) {
-        short acc = 1; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
-            acc *= val;
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortMinBig(Blackhole bh) {
-        short acc = Short.MAX_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
-            acc = (short)Math.min(acc, val);
-        }
-        bh.consume(acc);
-    }
-
-    @Benchmark
-    public void shortMaxBig(Blackhole bh) {
-        short acc = Short.MIN_VALUE; // neutral element
-        for (int i = 0; i < SIZE; i++) {
-            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
-            acc = (short)Math.max(acc, val);
-        }
-        bh.consume(acc);
-    }
+// x //    // ---------byte***Simple ------------------------------------------------------------
+// x //    @Benchmark
+// x //    public void byteAndSimple(Blackhole bh) {
+// x //        byte acc = (byte)0xFF; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = in1B[i];
+// x //            acc &= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteOrSimple(Blackhole bh) {
+// x //        byte acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = in1B[i];
+// x //            acc |= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteXorSimple(Blackhole bh) {
+// x //        byte acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = in1B[i];
+// x //            acc ^= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteAddSimple(Blackhole bh) {
+// x //        byte acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = in1B[i];
+// x //            acc += val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteMulSimple(Blackhole bh) {
+// x //        byte acc = 1; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = in1B[i];
+// x //            acc *= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteMinSimple(Blackhole bh) {
+// x //        byte acc = Byte.MAX_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = in1B[i];
+// x //            acc = (byte)Math.min(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteMaxSimple(Blackhole bh) {
+// x //        byte acc = Byte.MIN_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = in1B[i];
+// x //            acc = (byte)Math.max(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    // ---------byte***DotProduct ------------------------------------------------------------
+// x //    @Benchmark
+// x //    public void byteAndDotProduct(Blackhole bh) {
+// x //        byte acc = (byte)0xFF; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)(in1B[i] * in2B[i]);
+// x //            acc &= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteOrDotProduct(Blackhole bh) {
+// x //        byte acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)(in1B[i] * in2B[i]);
+// x //            acc |= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteXorDotProduct(Blackhole bh) {
+// x //        byte acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)(in1B[i] * in2B[i]);
+// x //            acc ^= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteAddDotProduct(Blackhole bh) {
+// x //        byte acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)(in1B[i] * in2B[i]);
+// x //            acc += val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteMulDotProduct(Blackhole bh) {
+// x //        byte acc = 1; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)(in1B[i] * in2B[i]);
+// x //            acc *= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteMinDotProduct(Blackhole bh) {
+// x //        byte acc = Byte.MAX_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)(in1B[i] * in2B[i]);
+// x //            acc = (byte)Math.min(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteMaxDotProduct(Blackhole bh) {
+// x //        byte acc = Byte.MIN_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)(in1B[i] * in2B[i]);
+// x //            acc = (byte)Math.max(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    // ---------byte***Big ------------------------------------------------------------
+// x //    @Benchmark
+// x //    public void byteAndBig(Blackhole bh) {
+// x //        byte acc = (byte)0xFF; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
+// x //            acc &= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteOrBig(Blackhole bh) {
+// x //        byte acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
+// x //            acc |= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteXorBig(Blackhole bh) {
+// x //        byte acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
+// x //            acc ^= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteAddBig(Blackhole bh) {
+// x //        byte acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
+// x //            acc += val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteMulBig(Blackhole bh) {
+// x //        byte acc = 1; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
+// x //            acc *= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteMinBig(Blackhole bh) {
+// x //        byte acc = Byte.MAX_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
+// x //            acc = (byte)Math.min(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void byteMaxBig(Blackhole bh) {
+// x //        byte acc = Byte.MIN_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            byte val = (byte)((in1B[i] * in2B[i]) + (in1B[i] * in3B[i]) + (in2B[i] * in3B[i]));
+// x //            acc = (byte)Math.max(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    // ---------char***Simple ------------------------------------------------------------
+// x //    @Benchmark
+// x //    public void charAndSimple(Blackhole bh) {
+// x //        char acc = (char)0xFFFF; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = in1C[i];
+// x //            acc &= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charOrSimple(Blackhole bh) {
+// x //        char acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = in1C[i];
+// x //            acc |= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charXorSimple(Blackhole bh) {
+// x //        char acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = in1C[i];
+// x //            acc ^= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charAddSimple(Blackhole bh) {
+// x //        char acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = in1C[i];
+// x //            acc += val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charMulSimple(Blackhole bh) {
+// x //        char acc = 1; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = in1C[i];
+// x //            acc *= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charMinSimple(Blackhole bh) {
+// x //        char acc = Character.MAX_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = in1C[i];
+// x //            acc = (char)Math.min(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charMaxSimple(Blackhole bh) {
+// x //        char acc = Character.MIN_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = in1C[i];
+// x //            acc = (char)Math.max(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    // ---------char***DotProduct ------------------------------------------------------------
+// x //    @Benchmark
+// x //    public void charAndDotProduct(Blackhole bh) {
+// x //        char acc = (char)0xFFFF; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)(in1C[i] * in2C[i]);
+// x //            acc &= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charOrDotProduct(Blackhole bh) {
+// x //        char acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)(in1C[i] * in2C[i]);
+// x //            acc |= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charXorDotProduct(Blackhole bh) {
+// x //        char acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)(in1C[i] * in2C[i]);
+// x //            acc ^= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charAddDotProduct(Blackhole bh) {
+// x //        char acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)(in1C[i] * in2C[i]);
+// x //            acc += val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charMulDotProduct(Blackhole bh) {
+// x //        char acc = 1; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)(in1C[i] * in2C[i]);
+// x //            acc *= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charMinDotProduct(Blackhole bh) {
+// x //        char acc = Character.MAX_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)(in1C[i] * in2C[i]);
+// x //            acc = (char)Math.min(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charMaxDotProduct(Blackhole bh) {
+// x //        char acc = Character.MIN_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)(in1C[i] * in2C[i]);
+// x //            acc = (char)Math.max(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    // ---------char***Big ------------------------------------------------------------
+// x //    @Benchmark
+// x //    public void charAndBig(Blackhole bh) {
+// x //        char acc = (char)0xFFFF; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
+// x //            acc &= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charOrBig(Blackhole bh) {
+// x //        char acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
+// x //            acc |= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charXorBig(Blackhole bh) {
+// x //        char acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
+// x //            acc ^= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charAddBig(Blackhole bh) {
+// x //        char acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
+// x //            acc += val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charMulBig(Blackhole bh) {
+// x //        char acc = 1; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
+// x //            acc *= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charMinBig(Blackhole bh) {
+// x //        char acc = Character.MAX_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
+// x //            acc = (char)Math.min(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void charMaxBig(Blackhole bh) {
+// x //        char acc = Character.MIN_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            char val = (char)((in1C[i] * in2C[i]) + (in1C[i] * in3C[i]) + (in2C[i] * in3C[i]));
+// x //            acc = (char)Math.max(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    // ---------short***Simple ------------------------------------------------------------
+// x //    @Benchmark
+// x //    public void shortAndSimple(Blackhole bh) {
+// x //        short acc = (short)0xFFFF; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = in1S[i];
+// x //            acc &= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortOrSimple(Blackhole bh) {
+// x //        short acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = in1S[i];
+// x //            acc |= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortXorSimple(Blackhole bh) {
+// x //        short acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = in1S[i];
+// x //            acc ^= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortAddSimple(Blackhole bh) {
+// x //        short acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = in1S[i];
+// x //            acc += val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortMulSimple(Blackhole bh) {
+// x //        short acc = 1; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = in1S[i];
+// x //            acc *= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortMinSimple(Blackhole bh) {
+// x //        short acc = Short.MAX_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = in1S[i];
+// x //            acc = (short)Math.min(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortMaxSimple(Blackhole bh) {
+// x //        short acc = Short.MIN_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = in1S[i];
+// x //            acc = (short)Math.max(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    // ---------short***DotProduct ------------------------------------------------------------
+// x //    @Benchmark
+// x //    public void shortAndDotProduct(Blackhole bh) {
+// x //        short acc = (short)0xFFFF; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)(in1S[i] * in2S[i]);
+// x //            acc &= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortOrDotProduct(Blackhole bh) {
+// x //        short acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)(in1S[i] * in2S[i]);
+// x //            acc |= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortXorDotProduct(Blackhole bh) {
+// x //        short acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)(in1S[i] * in2S[i]);
+// x //            acc ^= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortAddDotProduct(Blackhole bh) {
+// x //        short acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)(in1S[i] * in2S[i]);
+// x //            acc += val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortMulDotProduct(Blackhole bh) {
+// x //        short acc = 1; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)(in1S[i] * in2S[i]);
+// x //            acc *= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortMinDotProduct(Blackhole bh) {
+// x //        short acc = Short.MAX_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)(in1S[i] * in2S[i]);
+// x //            acc = (short)Math.min(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortMaxDotProduct(Blackhole bh) {
+// x //        short acc = Short.MIN_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)(in1S[i] * in2S[i]);
+// x //            acc = (short)Math.max(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    // ---------short***Big ------------------------------------------------------------
+// x //    @Benchmark
+// x //    public void shortAndBig(Blackhole bh) {
+// x //        short acc = (short)0xFFFF; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
+// x //            acc &= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortOrBig(Blackhole bh) {
+// x //        short acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
+// x //            acc |= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortXorBig(Blackhole bh) {
+// x //        short acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
+// x //            acc ^= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortAddBig(Blackhole bh) {
+// x //        short acc = 0; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
+// x //            acc += val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortMulBig(Blackhole bh) {
+// x //        short acc = 1; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
+// x //            acc *= val;
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortMinBig(Blackhole bh) {
+// x //        short acc = Short.MAX_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
+// x //            acc = (short)Math.min(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
+// x //
+// x //    @Benchmark
+// x //    public void shortMaxBig(Blackhole bh) {
+// x //        short acc = Short.MIN_VALUE; // neutral element
+// x //        for (int i = 0; i < SIZE; i++) {
+// x //            short val = (short)((in1S[i] * in2S[i]) + (in1S[i] * in3S[i]) + (in2S[i] * in3S[i]));
+// x //            acc = (short)Math.max(acc, val);
+// x //        }
+// x //        bh.consume(acc);
+// x //    }
 
     // ---------int***Simple ------------------------------------------------------------
     @Benchmark
@@ -1445,10 +1446,10 @@ public void doubleMaxBig(Blackhole bh) {
         bh.consume(acc);
     }
 
-    @Fork(value = 1, jvmArgs = {"-XX:+UseSuperWord"})
-    public static class WithSuperword extends VectorReduction2 {}
+    //@Fork(value = 1, jvmArgs = {"-XX:+UseSuperWord"})
+    //public static class WithSuperword extends VectorReduction2 {}
 
-    @Fork(value = 1, jvmArgs = {"-XX:-UseSuperWord"})
-    public static class NoSuperword extends VectorReduction2 {}
+    //@Fork(value = 1, jvmArgs = {"-XX:-UseSuperWord"})
+    //public static class NoSuperword extends VectorReduction2 {}
 }
 
