1 /*
   2  * Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * @test
  26  * @key randomness
  27  *
  28  * @library /test/lib
  29  * @modules jdk.incubator.vector
  30  * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Int64VectorTests
  31  */
  32 
  33 // -- This file was mechanically generated: Do not edit! -- //
  34 
  35 import jdk.incubator.vector.VectorShape;
  36 import jdk.incubator.vector.VectorSpecies;
  37 import jdk.incubator.vector.VectorShuffle;
  38 import jdk.incubator.vector.VectorMask;
  39 import jdk.incubator.vector.VectorOperators;
  40 import jdk.incubator.vector.Vector;
  41 import jdk.incubator.vector.VectorMath;
  42 
  43 import jdk.incubator.vector.IntVector;
  44 
  45 import org.testng.Assert;
  46 import org.testng.annotations.DataProvider;
  47 import org.testng.annotations.Test;
  48 
  49 import java.lang.Integer;
  50 import java.util.List;
  51 import java.util.Arrays;
  52 import java.util.function.BiFunction;
  53 import java.util.function.IntFunction;
  54 import java.util.Objects;
  55 import java.util.stream.Collectors;
  56 import java.util.stream.Stream;
  57 
  58 @Test
  59 public class Int64VectorTests extends AbstractVectorTest {
  60 
  61     static final VectorSpecies<Integer> SPECIES =
  62                 IntVector.SPECIES_64;
  63 
  64     static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
  65 


  66 
  67     private static final int CONST_SHIFT = Integer.SIZE / 2;
  68 
  69     static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 64);
  70 
  71     static void assertArraysStrictlyEquals(int[] r, int[] a) {
  72         for (int i = 0; i < a.length; i++) {
  73             if (r[i] != a[i]) {
  74                 Assert.fail("at index #" + i + ", expected = " + a[i] + ", actual = " + r[i]);
  75             }
  76         }
  77     }
  78 
  79     interface FUnOp {
  80         int apply(int a);
  81     }
  82 
  83     static void assertArraysEquals(int[] r, int[] a, FUnOp f) {
  84         int i = 0;
  85         try {
  86             for (; i < a.length; i++) {
  87                 Assert.assertEquals(r[i], f.apply(a[i]));
  88             }
  89         } catch (AssertionError e) {
  90             Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
  91         }
  92     }
  93 
  94     interface FUnArrayOp {
  95         int[] apply(int a);
  96     }
  97 
  98     static void assertArraysEquals(int[] r, int[] a, FUnArrayOp f) {
  99         int i = 0;
 100         try {
 101             for (; i < a.length; i += SPECIES.length()) {
 102                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 103                   f.apply(a[i]));
 104             }
 105         } catch (AssertionError e) {
 106             int[] ref = f.apply(a[i]);
 107             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 108             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 109               + ", res: " + Arrays.toString(res)
 110               + "), at index #" + i);
 111         }
 112     }
 113 
 114     static void assertArraysEquals(int[] r, int[] a, boolean[] mask, FUnOp f) {
 115         int i = 0;
 116         try {
 117             for (; i < a.length; i++) {
 118                 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
 119             }
 120         } catch (AssertionError e) {
 121             Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i], "at index #" + i + ", input = " + a[i] + ", mask = " + mask[i % SPECIES.length()]);
 122         }
 123     }
 124 
 125     interface FReductionOp {
 126         int apply(int[] a, int idx);
 127     }
 128 
 129     interface FReductionAllOp {
 130         int apply(int[] a);
 131     }
 132 
 133     static void assertReductionArraysEquals(int[] r, int rc, int[] a,
 134                                             FReductionOp f, FReductionAllOp fa) {
 135         int i = 0;
 136         try {
 137             Assert.assertEquals(rc, fa.apply(a));
 138             for (; i < a.length; i += SPECIES.length()) {
 139                 Assert.assertEquals(r[i], f.apply(a, i));
 140             }
 141         } catch (AssertionError e) {
 142             Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
 143             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 144         }
 145     }
 146 
 147     interface FReductionMaskedOp {
 148         int apply(int[] a, int idx, boolean[] mask);
 149     }
 150 
 151     interface FReductionAllMaskedOp {
 152         int apply(int[] a, boolean[] mask);
 153     }
 154 
 155     static void assertReductionArraysEqualsMasked(int[] r, int rc, int[] a, boolean[] mask,
 156                                             FReductionMaskedOp f, FReductionAllMaskedOp fa) {
 157         int i = 0;
 158         try {
 159             Assert.assertEquals(rc, fa.apply(a, mask));
 160             for (; i < a.length; i += SPECIES.length()) {
 161                 Assert.assertEquals(r[i], f.apply(a, i, mask));
 162             }
 163         } catch (AssertionError e) {
 164             Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
 165             Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
 166         }
 167     }
 168 
 169     interface FReductionOpLong {
 170         long apply(int[] a, int idx);
 171     }
 172 
 173     interface FReductionAllOpLong {
 174         long apply(int[] a);
 175     }
 176 
 177     static void assertReductionLongArraysEquals(long[] r, long rc, int[] a,
 178                                             FReductionOpLong f, FReductionAllOpLong fa) {
 179         int i = 0;
 180         try {
 181             Assert.assertEquals(rc, fa.apply(a));
 182             for (; i < a.length; i += SPECIES.length()) {
 183                 Assert.assertEquals(r[i], f.apply(a, i));
 184             }
 185         } catch (AssertionError e) {
 186             Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
 187             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 188         }
 189     }
 190 
 191     interface FReductionMaskedOpLong {
 192         long apply(int[] a, int idx, boolean[] mask);
 193     }
 194 
 195     interface FReductionAllMaskedOpLong {
 196         long apply(int[] a, boolean[] mask);
 197     }
 198 
 199     static void assertReductionLongArraysEqualsMasked(long[] r, long rc, int[] a, boolean[] mask,
 200                                             FReductionMaskedOpLong f, FReductionAllMaskedOpLong fa) {
 201         int i = 0;
 202         try {
 203             Assert.assertEquals(rc, fa.apply(a, mask));
 204             for (; i < a.length; i += SPECIES.length()) {
 205                 Assert.assertEquals(r[i], f.apply(a, i, mask));
 206             }
 207         } catch (AssertionError e) {
 208             Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
 209             Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
 210         }
 211     }
 212 
 213     interface FBoolReductionOp {
 214         boolean apply(boolean[] a, int idx);
 215     }
 216 
 217     static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) {
 218         int i = 0;
 219         try {
 220             for (; i < a.length; i += SPECIES.length()) {
 221                 Assert.assertEquals(r[i], f.apply(a, i));
 222             }
 223         } catch (AssertionError e) {
 224             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 225         }
 226     }
 227 
 228     interface FMaskReductionOp {
 229         int apply(boolean[] a, int idx);
 230     }
 231 
 232     static void assertMaskReductionArraysEquals(int[] r, boolean[] a, FMaskReductionOp f) {
 233         int i = 0;
 234         try {
 235             for (; i < a.length; i += SPECIES.length()) {
 236                 Assert.assertEquals(r[i], f.apply(a, i));
 237             }
 238         } catch (AssertionError e) {
 239             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 240         }
 241     }
 242 
 243     static void assertRearrangeArraysEquals(int[] r, int[] a, int[] order, int vector_len) {
 244         int i = 0, j = 0;
 245         try {
 246             for (; i < a.length; i += vector_len) {
 247                 for (j = 0; j < vector_len; j++) {
 248                     Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 249                 }
 250             }
 251         } catch (AssertionError e) {
 252             int idx = i + j;
 253             Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
 254         }
 255     }
 256 
 257     static void assertcompressArraysEquals(int[] r, int[] a, boolean[] m, int vector_len) {
 258         int i = 0, j = 0, k = 0;
 259         try {
 260             for (; i < a.length; i += vector_len) {
 261                 k = 0;
 262                 for (j = 0; j < vector_len; j++) {
 263                     if (m[(i + j) % SPECIES.length()]) {
 264                         Assert.assertEquals(r[i + k], a[i + j]);
 265                         k++;
 266                     }
 267                 }
 268                 for (; k < vector_len; k++) {
 269                     Assert.assertEquals(r[i + k], (int)0);
 270                 }
 271             }
 272         } catch (AssertionError e) {
 273             int idx = i + k;
 274             if (m[(i + j) % SPECIES.length()]) {
 275                 Assert.assertEquals(r[idx], a[i + j], "at index #" + idx);
 276             } else {
 277                 Assert.assertEquals(r[idx], (int)0, "at index #" + idx);
 278             }
 279         }
 280     }
 281 
 282     static void assertexpandArraysEquals(int[] r, int[] a, boolean[] m, int vector_len) {
 283         int i = 0, j = 0, k = 0;
 284         try {
 285             for (; i < a.length; i += vector_len) {
 286                 k = 0;
 287                 for (j = 0; j < vector_len; j++) {
 288                     if (m[(i + j) % SPECIES.length()]) {
 289                         Assert.assertEquals(r[i + j], a[i + k]);
 290                         k++;
 291                     } else {
 292                         Assert.assertEquals(r[i + j], (int)0);
 293                     }
 294                 }
 295             }
 296         } catch (AssertionError e) {
 297             int idx = i + j;
 298             if (m[idx % SPECIES.length()]) {
 299                 Assert.assertEquals(r[idx], a[i + k], "at index #" + idx);
 300             } else {
 301                 Assert.assertEquals(r[idx], (int)0, "at index #" + idx);
 302             }
 303         }
 304     }
 305 
 306     static void assertSelectFromTwoVectorEquals(int[] r, int[] order, int[] a, int[] b, int vector_len) {
 307         int i = 0, j = 0;
 308         boolean is_exceptional_idx = false;
 309         int idx = 0, wrapped_index = 0, oidx = 0;
 310         try {
 311             for (; i < a.length; i += vector_len) {
 312                 for (j = 0; j < vector_len; j++) {
 313                     idx = i + j;
 314                     wrapped_index = Math.floorMod((int)order[idx], 2 * vector_len);
 315                     is_exceptional_idx = wrapped_index >= vector_len;
 316                     oidx = is_exceptional_idx ? (wrapped_index - vector_len) : wrapped_index;
 317                     Assert.assertEquals(r[idx], (is_exceptional_idx ? b[i + oidx] : a[i + oidx]));
 318                 }
 319             }
 320         } catch (AssertionError e) {
 321             Assert.assertEquals(r[idx], (is_exceptional_idx ? b[i + oidx] : a[i + oidx]), "at index #" + idx + ", order = " + order[idx] + ", a = " + a[i + oidx] + ", b = " + b[i + oidx]);
 322         }
 323     }
 324 
 325     static void assertSelectFromArraysEquals(int[] r, int[] a, int[] order, int vector_len) {
 326         int i = 0, j = 0;
 327         try {
 328             for (; i < a.length; i += vector_len) {
 329                 for (j = 0; j < vector_len; j++) {
 330                     Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 331                 }
 332             }
 333         } catch (AssertionError e) {
 334             int idx = i + j;
 335             Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
 336         }
 337     }
 338 
 339     static void assertRearrangeArraysEquals(int[] r, int[] a, int[] order, boolean[] mask, int vector_len) {
 340         int i = 0, j = 0;
 341         try {
 342             for (; i < a.length; i += vector_len) {
 343                 for (j = 0; j < vector_len; j++) {
 344                     if (mask[j % SPECIES.length()])
 345                          Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 346                     else
 347                          Assert.assertEquals(r[i+j], (int)0);
 348                 }
 349             }
 350         } catch (AssertionError e) {
 351             int idx = i + j;
 352             if (mask[j % SPECIES.length()])
 353                 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 354             else
 355                 Assert.assertEquals(r[i+j], (int)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 356         }
 357     }
 358 
 359     static void assertSelectFromArraysEquals(int[] r, int[] a, int[] order, boolean[] mask, int vector_len) {
 360         int i = 0, j = 0;
 361         try {
 362             for (; i < a.length; i += vector_len) {
 363                 for (j = 0; j < vector_len; j++) {
 364                     if (mask[j % SPECIES.length()])
 365                          Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 366                     else
 367                          Assert.assertEquals(r[i+j], (int)0);
 368                 }
 369             }
 370         } catch (AssertionError e) {
 371             int idx = i + j;
 372             if (mask[j % SPECIES.length()])
 373                 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 374             else
 375                 Assert.assertEquals(r[i+j], (int)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 376         }
 377     }
 378 
 379     static void assertBroadcastArraysEquals(int[] r, int[] a) {
 380         int i = 0;
 381         for (; i < a.length; i += SPECIES.length()) {
 382             int idx = i;
 383             for (int j = idx; j < (idx + SPECIES.length()); j++)
 384                 a[j]=a[idx];
 385         }
 386 
 387         try {
 388             for (i = 0; i < a.length; i++) {
 389                 Assert.assertEquals(r[i], a[i]);
 390             }
 391         } catch (AssertionError e) {
 392             Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
 393         }
 394     }
 395 
 396     interface FBinOp {
 397         int apply(int a, int b);
 398     }
 399 
 400     interface FBinMaskOp {
 401         int apply(int a, int b, boolean m);
 402 
 403         static FBinMaskOp lift(FBinOp f) {
 404             return (a, b, m) -> m ? f.apply(a, b) : a;
 405         }
 406     }
 407 
 408     static void assertArraysEqualsAssociative(int[] rl, int[] rr, int[] a, int[] b, int[] c, FBinOp f) {
 409         int i = 0;
 410         try {
 411             for (; i < a.length; i++) {
 412                 //Left associative
 413                 Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i]), c[i]));
 414 
 415                 //Right associative
 416                 Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i])));
 417 
 418                 //Results equal sanity check
 419                 Assert.assertEquals(rl[i], rr[i]);
 420             }
 421         } catch (AssertionError e) {
 422             Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i]), c[i]), "left associative test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 423             Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i])), "right associative test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 424             Assert.assertEquals(rl[i], rr[i], "Result checks not equal at index #" + i + "leftRes = " + rl[i] + ", rightRes = " + rr[i]);
 425         }
 426     }
 427 
 428    static void assertArraysEqualsAssociative(int[] rl, int[] rr, int[] a, int[] b, int[] c, boolean[] mask, FBinOp f) {
 429        assertArraysEqualsAssociative(rl, rr, a, b, c, mask, FBinMaskOp.lift(f));
 430    }
 431 
 432     static void assertArraysEqualsAssociative(int[] rl, int[] rr, int[] a, int[] b, int[] c, boolean[] mask, FBinMaskOp f) {
 433         int i = 0;
 434         boolean mask_bit = false;
 435         try {
 436             for (; i < a.length; i++) {
 437                 mask_bit = mask[i % SPECIES.length()];
 438                 //Left associative
 439                 Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i], mask_bit), c[i], mask_bit));
 440 
 441                 //Right associative
 442                 Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i], mask_bit), mask_bit));
 443 
 444                 //Results equal sanity check
 445                 Assert.assertEquals(rl[i], rr[i]);
 446             }
 447         } catch (AssertionError e) {
 448             Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i], mask_bit), c[i], mask_bit), "left associative masked test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i] + ", mask = " + mask_bit);
 449             Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i], mask_bit), mask_bit), "right associative masked test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i] + ", mask = " + mask_bit);
 450             Assert.assertEquals(rl[i], rr[i], "Result checks not equal at index #" + i + "leftRes = " + rl[i] + ", rightRes = " + rr[i]);
 451         }
 452     }
 453 
 454     static void assertArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
 455         int i = 0;
 456         try {
 457             for (; i < a.length; i++) {
 458                 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
 459             }
 460         } catch (AssertionError e) {
 461             Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
 462         }
 463     }
 464 
 465     static void assertArraysEquals(int[] r, int[] a, int b, FBinOp f) {
 466         int i = 0;
 467         try {
 468             for (; i < a.length; i++) {
 469                 Assert.assertEquals(r[i], f.apply(a[i], b));
 470             }
 471         } catch (AssertionError e) {
 472             Assert.assertEquals(r[i], f.apply(a[i], b), "(" + a[i] + ", " + b + ") at index #" + i);
 473         }
 474     }
 475 
 476     static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
 477         int i = 0;
 478         try {
 479             for (; i < a.length; i++) {
 480                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
 481             }
 482         } catch (AssertionError e) {
 483             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
 484                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 485         }
 486     }
 487 
 488     static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
 489         int i = 0;
 490         try {
 491             for (; i < a.length; i++) {
 492                 Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
 493             }
 494         } catch (AssertionError e) {
 495             Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
 496                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 497         }
 498     }
 499 
 500     static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
 501         assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 502     }
 503 
 504     static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
 505         int i = 0;
 506         try {
 507             for (; i < a.length; i++) {
 508                 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
 509             }
 510         } catch (AssertionError err) {
 511             Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", mask = " + mask[i % SPECIES.length()]);
 512         }
 513     }
 514 
 515     static void assertArraysEquals(int[] r, int[] a, int b, boolean[] mask, FBinOp f) {
 516         assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 517     }
 518 
 519     static void assertArraysEquals(int[] r, int[] a, int b, boolean[] mask, FBinMaskOp f) {
 520         int i = 0;
 521         try {
 522             for (; i < a.length; i++) {
 523                 Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]));
 524             }
 525         } catch (AssertionError err) {
 526             Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b + ", mask = " + mask[i % SPECIES.length()]);
 527         }
 528     }
 529 
 530     static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
 531         assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 532     }
 533 
 534     static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
 535         int i = 0;
 536         try {
 537             for (; i < a.length; i++) {
 538                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 539             }
 540         } catch (AssertionError err) {
 541             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 542                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 543                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 544                                 mask[i % SPECIES.length()]);
 545         }
 546     }
 547 
 548     static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
 549         assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 550     }
 551 
 552     static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
 553         int i = 0;
 554         try {
 555             for (; i < a.length; i++) {
 556                 Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
 557             }
 558         } catch (AssertionError err) {
 559             Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
 560                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 561                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 562                                 mask[i % SPECIES.length()]);
 563         }
 564     }
 565 
 566     static void assertShiftArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
 567         int i = 0;
 568         int j = 0;
 569         try {
 570             for (; j < a.length; j += SPECIES.length()) {
 571                 for (i = 0; i < SPECIES.length(); i++) {
 572                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
 573                 }
 574             }
 575         } catch (AssertionError e) {
 576             Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
 577         }
 578     }
 579 
 580     static void assertShiftArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
 581         assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 582     }
 583 
 584     static void assertShiftArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
 585         int i = 0;
 586         int j = 0;
 587         try {
 588             for (; j < a.length; j += SPECIES.length()) {
 589                 for (i = 0; i < SPECIES.length(); i++) {
 590                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
 591                 }
 592             }
 593         } catch (AssertionError err) {
 594             Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", input2 = " + b[j] + ", mask = " + mask[i]);
 595         }
 596     }
 597 
 598     interface FBinConstOp {
 599         int apply(int a);
 600     }
 601 
 602     interface FBinConstMaskOp {
 603         int apply(int a, boolean m);
 604 
 605         static FBinConstMaskOp lift(FBinConstOp f) {
 606             return (a, m) -> m ? f.apply(a) : a;
 607         }
 608     }
 609 
 610     static void assertShiftConstEquals(int[] r, int[] a, FBinConstOp f) {
 611         int i = 0;
 612         int j = 0;
 613         try {
 614             for (; j < a.length; j += SPECIES.length()) {
 615                 for (i = 0; i < SPECIES.length(); i++) {
 616                     Assert.assertEquals(r[i+j], f.apply(a[i+j]));
 617                 }
 618             }
 619         } catch (AssertionError e) {
 620             Assert.assertEquals(r[i+j], f.apply(a[i+j]), "at index #" + i + ", " + j);
 621         }
 622     }
 623 
 624     static void assertShiftConstEquals(int[] r, int[] a, boolean[] mask, FBinConstOp f) {
 625         assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f));
 626     }
 627 
 628     static void assertShiftConstEquals(int[] r, int[] a, boolean[] mask, FBinConstMaskOp f) {
 629         int i = 0;
 630         int j = 0;
 631         try {
 632             for (; j < a.length; j += SPECIES.length()) {
 633                 for (i = 0; i < SPECIES.length(); i++) {
 634                     Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]));
 635                 }
 636             }
 637         } catch (AssertionError err) {
 638             Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", mask = " + mask[i]);
 639         }
 640     }
 641 
 642     interface FTernOp {
 643         int apply(int a, int b, int c);
 644     }
 645 
 646     interface FTernMaskOp {
 647         int apply(int a, int b, int c, boolean m);
 648 
 649         static FTernMaskOp lift(FTernOp f) {
 650             return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
 651         }
 652     }
 653 
 654     static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
 655         int i = 0;
 656         try {
 657             for (; i < a.length; i++) {
 658                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
 659             }
 660         } catch (AssertionError e) {
 661             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 662         }
 663     }
 664 
 665     static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, FTernOp f) {
 666         assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 667     }
 668 
 669     static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, FTernMaskOp f) {
 670         int i = 0;
 671         try {
 672             for (; i < a.length; i++) {
 673                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
 674             }
 675         } catch (AssertionError err) {
 676             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
 677               + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 678         }
 679     }
 680 
 681     static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
 682         int i = 0;
 683         try {
 684             for (; i < a.length; i++) {
 685                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
 686             }
 687         } catch (AssertionError e) {
 688             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
 689                                 i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
 690                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 691         }
 692     }
 693 
 694     static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
 695         int i = 0;
 696         try {
 697             for (; i < a.length; i++) {
 698                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
 699             }
 700         } catch (AssertionError e) {
 701             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
 702                                 i + ", input1 = " + a[i] + ", input2 = " +
 703                                 b[(i / SPECIES.length()) * SPECIES.length()] + ",  input3 = " + c[i]);
 704         }
 705     }
 706 
 707     static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
 708                                             FTernOp f) {
 709         assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 710     }
 711 
 712     static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
 713                                             FTernMaskOp f) {
 714         int i = 0;
 715         try {
 716             for (; i < a.length; i++) {
 717                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 718                                     mask[i % SPECIES.length()]));
 719             }
 720         } catch (AssertionError err) {
 721             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 722                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
 723                                 b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 724                                 mask[i % SPECIES.length()]);
 725         }
 726     }
 727 
 728     static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
 729                                             FTernOp f) {
 730         assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 731     }
 732 
 733     static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
 734                                             FTernMaskOp f) {
 735         int i = 0;
 736         try {
 737             for (; i < a.length; i++) {
 738                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 739                                     mask[i % SPECIES.length()]));
 740             }
 741         } catch (AssertionError err) {
 742             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 743                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 744                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 745                                 ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 746         }
 747     }
 748 
 749     static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
 750         int i = 0;
 751         try {
 752             for (; i < a.length; i++) {
 753                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 754                                     c[(i / SPECIES.length()) * SPECIES.length()]));
 755             }
 756         } catch (AssertionError e) {
 757             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 758                                 c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
 759                                 + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
 760                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 761         }
 762     }
 763 
 764     static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
 765                                                   FTernOp f) {
 766         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 767     }
 768 
 769     static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
 770                                                   FTernMaskOp f) {
 771         int i = 0;
 772         try {
 773             for (; i < a.length; i++) {
 774                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 775                                     c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 776             }
 777         } catch (AssertionError err) {
 778             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 779                                 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
 780                                 + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 781                                 ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 782                                 mask[i % SPECIES.length()]);
 783         }
 784     }
 785 
 786 
 787 
 788     interface FGatherScatterOp {
 789         int[] apply(int[] a, int ix, int[] b, int iy);
 790     }
 791 
 792     static void assertArraysEquals(int[] r, int[] a, int[] b, FGatherScatterOp f) {
 793         int i = 0;
 794         try {
 795             for (; i < a.length; i += SPECIES.length()) {
 796                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 797                   f.apply(a, i, b, i));
 798             }
 799         } catch (AssertionError e) {
 800             int[] ref = f.apply(a, i, b, i);
 801             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 802             Assert.assertEquals(res, ref,
 803               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 804               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 805               + ", b: "
 806               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 807               + " at index #" + i);
 808         }
 809     }
 810 
 811     interface FGatherMaskedOp {
 812         int[] apply(int[] a, int ix, boolean[] mask, int[] b, int iy);
 813     }
 814 
 815     interface FScatterMaskedOp {
 816         int[] apply(int[] r, int[] a, int ix, boolean[] mask, int[] b, int iy);
 817     }
 818 
 819     static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
 820         int i = 0;
 821         try {
 822             for (; i < a.length; i += SPECIES.length()) {
 823                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 824                   f.apply(a, i, mask, b, i));
 825             }
 826         } catch (AssertionError e) {
 827             int[] ref = f.apply(a, i, mask, b, i);
 828             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 829             Assert.assertEquals(res, ref,
 830               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 831               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 832               + ", b: "
 833               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 834               + ", mask: "
 835               + Arrays.toString(mask)
 836               + " at index #" + i);
 837         }
 838     }
 839 
 840     static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
 841         int i = 0;
 842         try {
 843             for (; i < a.length; i += SPECIES.length()) {
 844                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 845                   f.apply(r, a, i, mask, b, i));
 846             }
 847         } catch (AssertionError e) {
 848             int[] ref = f.apply(r, a, i, mask, b, i);
 849             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 850             Assert.assertEquals(res, ref,
 851               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 852               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 853               + ", b: "
 854               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 855               + ", r: "
 856               + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
 857               + ", mask: "
 858               + Arrays.toString(mask)
 859               + " at index #" + i);
 860         }
 861     }
 862 
 863     interface FLaneOp {
 864         int[] apply(int[] a, int origin, int idx);
 865     }
 866 
 867     static void assertArraysEquals(int[] r, int[] a, int origin, FLaneOp f) {
 868         int i = 0;
 869         try {
 870             for (; i < a.length; i += SPECIES.length()) {
 871                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 872                   f.apply(a, origin, i));
 873             }
 874         } catch (AssertionError e) {
 875             int[] ref = f.apply(a, origin, i);
 876             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 877             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 878               + ", res: " + Arrays.toString(res)
 879               + "), at index #" + i);
 880         }
 881     }
 882 
 883     interface FLaneBop {
 884         int[] apply(int[] a, int[] b, int origin, int idx);
 885     }
 886 
 887     static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, FLaneBop f) {
 888         int i = 0;
 889         try {
 890             for (; i < a.length; i += SPECIES.length()) {
 891                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 892                   f.apply(a, b, origin, i));
 893             }
 894         } catch (AssertionError e) {
 895             int[] ref = f.apply(a, b, origin, i);
 896             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 897             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 898               + ", res: " + Arrays.toString(res)
 899               + "), at index #" + i
 900               + ", at origin #" + origin);
 901         }
 902     }
 903 
 904     interface FLaneMaskedBop {
 905         int[] apply(int[] a, int[] b, int origin, boolean[] mask, int idx);
 906     }
 907 
 908     static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
 909         int i = 0;
 910         try {
 911             for (; i < a.length; i += SPECIES.length()) {
 912                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 913                   f.apply(a, b, origin, mask, i));
 914             }
 915         } catch (AssertionError e) {
 916             int[] ref = f.apply(a, b, origin, mask, i);
 917             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 918             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 919               + ", res: " + Arrays.toString(res)
 920               + "), at index #" + i
 921               + ", at origin #" + origin);
 922         }
 923     }
 924 
 925     interface FLanePartBop {
 926         int[] apply(int[] a, int[] b, int origin, int part, int idx);
 927     }
 928 
 929     static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, int part, FLanePartBop f) {
 930         int i = 0;
 931         try {
 932             for (; i < a.length; i += SPECIES.length()) {
 933                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 934                   f.apply(a, b, origin, part, i));
 935             }
 936         } catch (AssertionError e) {
 937             int[] ref = f.apply(a, b, origin, part, i);
 938             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 939             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 940               + ", res: " + Arrays.toString(res)
 941               + "), at index #" + i
 942               + ", at origin #" + origin
 943               + ", with part #" + part);
 944         }
 945     }
 946 
 947     interface FLanePartMaskedBop {
 948         int[] apply(int[] a, int[] b, int origin, int part, boolean[] mask, int idx);
 949     }
 950 
 951     static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
 952         int i = 0;
 953         try {
 954             for (; i < a.length; i += SPECIES.length()) {
 955                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 956                   f.apply(a, b, origin, part, mask, i));
 957             }
 958         } catch (AssertionError e) {
 959             int[] ref = f.apply(a, b, origin, part, mask, i);
 960             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 961             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 962               + ", res: " + Arrays.toString(res)
 963               + "), at index #" + i
 964               + ", at origin #" + origin
 965               + ", with part #" + part);
 966         }
 967     }
 968 
 969 
 970     static void assertArraysEquals(int[] r, int[] a, int offs) {
 971         int i = 0;
 972         try {
 973             for (; i < r.length; i++) {
 974                 Assert.assertEquals(r[i], (int)(a[i+offs]));
 975             }
 976         } catch (AssertionError e) {
 977             Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 978         }
 979     }
 980 
 981 
 982 
 983     static void assertArraysEquals(long[] r, int[] a, int offs) {
 984         int i = 0;
 985         try {
 986             for (; i < r.length; i++) {
 987                 Assert.assertEquals(r[i], (long)(a[i+offs]));
 988             }
 989         } catch (AssertionError e) {
 990             Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 991         }
 992     }
 993 
 994     static void assertArraysEquals(double[] r, int[] a, int offs) {
 995         int i = 0;
 996         try {
 997             for (; i < r.length; i++) {
 998                 Assert.assertEquals(r[i], (double)(a[i+offs]));
 999             }
1000         } catch (AssertionError e) {
1001             Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
1002         }
1003     }
1004 
1005     static int bits(int e) {
1006         return  e;
1007     }
1008 
1009     static final List<IntFunction<int[]>> INT_GENERATORS = List.of(
1010             withToString("int[-i * 5]", (int s) -> {
1011                 return fill(s * BUFFER_REPS,
1012                             i -> (int)(-i * 5));
1013             }),
1014             withToString("int[i * 5]", (int s) -> {
1015                 return fill(s * BUFFER_REPS,
1016                             i -> (int)(i * 5));
1017             }),
1018             withToString("int[i + 1]", (int s) -> {
1019                 return fill(s * BUFFER_REPS,
1020                             i -> (((int)(i + 1) == 0) ? 1 : (int)(i + 1)));
1021             }),
1022             withToString("int[cornerCaseValue(i)]", (int s) -> {
1023                 return fill(s * BUFFER_REPS,
1024                             i -> cornerCaseValue(i));
1025             })
1026     );
1027 
1028     static final List<IntFunction<int[]>> INT_SATURATING_GENERATORS = List.of(
1029             withToString("int[Integer.MIN_VALUE]", (int s) -> {
1030                 return fill(s * BUFFER_REPS,
1031                             i -> (int)(Integer.MIN_VALUE));
1032             }),
1033             withToString("int[Integer.MAX_VALUE]", (int s) -> {
1034                 return fill(s * BUFFER_REPS,
1035                             i -> (int)(Integer.MAX_VALUE));
1036             }),
1037             withToString("int[Integer.MAX_VALUE - 100]", (int s) -> {
1038                 return fill(s * BUFFER_REPS,
1039                             i -> (int)(Integer.MAX_VALUE - 100));
1040             }),
1041             withToString("int[Integer.MIN_VALUE + 100]", (int s) -> {
1042                 return fill(s * BUFFER_REPS,
1043                             i -> (int)(Integer.MIN_VALUE + 100));
1044             }),
1045             withToString("int[-i * 5]", (int s) -> {
1046                 return fill(s * BUFFER_REPS,
1047                             i -> (int)(-i * 5));
1048             }),
1049             withToString("int[i * 5]", (int s) -> {
1050                 return fill(s * BUFFER_REPS,
1051                             i -> (int)(i * 5));
1052             })
1053     );
1054 
1055     static final List<IntFunction<int[]>> INT_SATURATING_GENERATORS_ASSOC = List.of(
1056             withToString("int[Integer.MAX_VALUE]", (int s) -> {
1057                 return fill(s * BUFFER_REPS,
1058                             i -> (int)(Integer.MAX_VALUE));
1059             }),
1060             withToString("int[Integer.MAX_VALUE - 100]", (int s) -> {
1061                 return fill(s * BUFFER_REPS,
1062                             i -> (int)(Integer.MAX_VALUE - 100));
1063             }),
1064             withToString("int[-1]", (int s) -> {
1065                 return fill(s * BUFFER_REPS,
1066                             i -> (int)(-1));
1067             })
1068     );
1069 
1070     // Create combinations of pairs
1071     // @@@ Might be sensitive to order e.g. div by 0
1072     static final List<List<IntFunction<int[]>>> INT_GENERATOR_PAIRS =
1073         Stream.of(INT_GENERATORS.get(0)).
1074                 flatMap(fa -> INT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
1075                 collect(Collectors.toList());
1076 
1077     static final List<List<IntFunction<int[]>>> INT_SATURATING_GENERATOR_PAIRS =
1078         Stream.of(INT_GENERATORS.get(0)).
1079                 flatMap(fa -> INT_SATURATING_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
1080                 collect(Collectors.toList());
1081 
1082     static final List<List<IntFunction<int[]>>> INT_SATURATING_GENERATOR_TRIPLETS =
1083             Stream.of(INT_GENERATORS.get(1))
1084                     .flatMap(fa -> INT_SATURATING_GENERATORS_ASSOC.stream().map(fb -> List.of(fa, fb)))
1085                     .flatMap(pair -> INT_SATURATING_GENERATORS_ASSOC.stream().map(f -> List.of(pair.get(0), pair.get(1), f)))
1086                     .collect(Collectors.toList());
1087 
1088     @DataProvider
1089     public Object[][] boolUnaryOpProvider() {
1090         return BOOL_ARRAY_GENERATORS.stream().
1091                 map(f -> new Object[]{f}).
1092                 toArray(Object[][]::new);
1093     }
1094 
1095     static final List<List<IntFunction<int[]>>> INT_GENERATOR_TRIPLES =
1096         INT_GENERATOR_PAIRS.stream().
1097                 flatMap(pair -> INT_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
1098                 collect(Collectors.toList());
1099 
1100     static final List<IntFunction<int[]>> SELECT_FROM_INDEX_GENERATORS = List.of(
1101             withToString("int[0..VECLEN*2)", (int s) -> {
1102                 return fill(s * BUFFER_REPS,
1103                             i -> (int)(RAND.nextInt()));
1104             })
1105     );
1106 
1107     static final List<List<IntFunction<int[]>>> INT_GENERATOR_SELECT_FROM_TRIPLES =
1108         INT_GENERATOR_PAIRS.stream().
1109                 flatMap(pair -> SELECT_FROM_INDEX_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
1110                 collect(Collectors.toList());
1111 
1112     @DataProvider
1113     public Object[][] intBinaryOpProvider() {
1114         return INT_GENERATOR_PAIRS.stream().map(List::toArray).
1115                 toArray(Object[][]::new);
1116     }
1117 
1118     @DataProvider
1119     public Object[][] intSaturatingBinaryOpProvider() {
1120         return INT_SATURATING_GENERATOR_PAIRS.stream().map(List::toArray).
1121                 toArray(Object[][]::new);
1122     }
1123 
1124     @DataProvider
1125     public Object[][] intSaturatingBinaryOpAssocProvider() {
1126         return INT_SATURATING_GENERATOR_TRIPLETS.stream().map(List::toArray).
1127                 toArray(Object[][]::new);
1128     }
1129 
1130     @DataProvider
1131     public Object[][] intSaturatingBinaryOpAssocMaskProvider() {
1132         return BOOLEAN_MASK_GENERATORS.stream().
1133                 flatMap(fm -> INT_SATURATING_GENERATOR_TRIPLETS.stream().map(lfa -> {
1134                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1135                 })).
1136                 toArray(Object[][]::new);
1137     }
1138 
1139 
1140     @DataProvider
1141     public Object[][] intIndexedOpProvider() {
1142         return INT_GENERATOR_PAIRS.stream().map(List::toArray).
1143                 toArray(Object[][]::new);
1144     }
1145 
1146     @DataProvider
1147     public Object[][] intSaturatingBinaryOpMaskProvider() {
1148         return BOOLEAN_MASK_GENERATORS.stream().
1149                 flatMap(fm -> INT_SATURATING_GENERATOR_PAIRS.stream().map(lfa -> {
1150                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1151                 })).
1152                 toArray(Object[][]::new);
1153     }
1154 
1155    @DataProvider
1156    public Object[][] intSaturatingUnaryOpProvider() {
1157        return INT_SATURATING_GENERATORS.stream().
1158                     map(f -> new Object[]{f}).
1159                     toArray(Object[][]::new);
1160    }
1161 
1162    @DataProvider
1163    public Object[][] intSaturatingUnaryOpMaskProvider() {
1164         return BOOLEAN_MASK_GENERATORS.stream().
1165                 flatMap(fm -> INT_SATURATING_GENERATORS.stream().map(fa -> {
1166                     return new Object[] {fa, fm};
1167                 })).
1168                 toArray(Object[][]::new);
1169    }
1170 
1171     @DataProvider
1172     public Object[][] intBinaryOpMaskProvider() {
1173         return BOOLEAN_MASK_GENERATORS.stream().
1174                 flatMap(fm -> INT_GENERATOR_PAIRS.stream().map(lfa -> {
1175                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1176                 })).
1177                 toArray(Object[][]::new);
1178     }
1179 
1180     @DataProvider
1181     public Object[][] intTernaryOpProvider() {
1182         return INT_GENERATOR_TRIPLES.stream().map(List::toArray).
1183                 toArray(Object[][]::new);
1184     }
1185 
1186     @DataProvider
1187     public Object[][] intSelectFromTwoVectorOpProvider() {
1188         return INT_GENERATOR_SELECT_FROM_TRIPLES.stream().map(List::toArray).
1189                 toArray(Object[][]::new);
1190     }
1191 
1192     @DataProvider
1193     public Object[][] intTernaryOpMaskProvider() {
1194         return BOOLEAN_MASK_GENERATORS.stream().
1195                 flatMap(fm -> INT_GENERATOR_TRIPLES.stream().map(lfa -> {
1196                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1197                 })).
1198                 toArray(Object[][]::new);
1199     }
1200 
1201     @DataProvider
1202     public Object[][] intUnaryOpProvider() {
1203         return INT_GENERATORS.stream().
1204                 map(f -> new Object[]{f}).
1205                 toArray(Object[][]::new);
1206     }
1207 
1208     @DataProvider
1209     public Object[][] intUnaryOpMaskProvider() {
1210         return BOOLEAN_MASK_GENERATORS.stream().
1211                 flatMap(fm -> INT_GENERATORS.stream().map(fa -> {
1212                     return new Object[] {fa, fm};
1213                 })).
1214                 toArray(Object[][]::new);
1215     }
1216 
1217     @DataProvider
1218     public Object[][] maskProvider() {
1219         return BOOLEAN_MASK_GENERATORS.stream().
1220                 map(f -> new Object[]{f}).
1221                 toArray(Object[][]::new);
1222     }
1223 
1224     @DataProvider
1225     public Object[][] maskCompareOpProvider() {
1226         return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1227                 toArray(Object[][]::new);
1228     }
1229 
1230     @DataProvider
1231     public Object[][] shuffleProvider() {
1232         return INT_SHUFFLE_GENERATORS.stream().
1233                 map(f -> new Object[]{f}).
1234                 toArray(Object[][]::new);
1235     }
1236 
1237     @DataProvider
1238     public Object[][] shuffleCompareOpProvider() {
1239         return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1240                 toArray(Object[][]::new);
1241     }
1242 
1243     @DataProvider
1244     public Object[][] intUnaryOpShuffleProvider() {
1245         return INT_SHUFFLE_GENERATORS.stream().
1246                 flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
1247                     return new Object[] {fa, fs};
1248                 })).
1249                 toArray(Object[][]::new);
1250     }
1251 
1252     @DataProvider
1253     public Object[][] intUnaryOpShuffleMaskProvider() {
1254         return BOOLEAN_MASK_GENERATORS.stream().
1255                 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
1256                     flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
1257                         return new Object[] {fa, fs, fm};
1258                 }))).
1259                 toArray(Object[][]::new);
1260     }
1261 
1262     static final List<IntFunction<int[]>> INT_COMPARE_GENERATORS = List.of(
1263             withToString("int[i]", (int s) -> {
1264                 return fill(s * BUFFER_REPS,
1265                             i -> (int)i);
1266             }),
1267             withToString("int[i - length / 2]", (int s) -> {
1268                 return fill(s * BUFFER_REPS,
1269                             i -> (int)(i - (s * BUFFER_REPS / 2)));
1270             }),
1271             withToString("int[i + 1]", (int s) -> {
1272                 return fill(s * BUFFER_REPS,
1273                             i -> (int)(i + 1));
1274             }),
1275             withToString("int[i - 2]", (int s) -> {
1276                 return fill(s * BUFFER_REPS,
1277                             i -> (int)(i - 2));
1278             }),
1279             withToString("int[zigZag(i)]", (int s) -> {
1280                 return fill(s * BUFFER_REPS,
1281                             i -> i%3 == 0 ? (int)i : (i%3 == 1 ? (int)(i + 1) : (int)(i - 2)));
1282             }),
1283             withToString("int[cornerCaseValue(i)]", (int s) -> {
1284                 return fill(s * BUFFER_REPS,
1285                             i -> cornerCaseValue(i));
1286             })
1287     );
1288 
1289     static final List<List<IntFunction<int[]>>> INT_TEST_GENERATOR_ARGS =
1290         INT_COMPARE_GENERATORS.stream().
1291                 map(fa -> List.of(fa)).
1292                 collect(Collectors.toList());
1293 
1294     @DataProvider
1295     public Object[][] intTestOpProvider() {
1296         return INT_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1297                 toArray(Object[][]::new);
1298     }
1299 
1300     @DataProvider
1301     public Object[][] intTestOpMaskProvider() {
1302         return BOOLEAN_MASK_GENERATORS.stream().
1303                 flatMap(fm -> INT_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1304                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1305                 })).
1306                 toArray(Object[][]::new);
1307     }
1308 
1309     static final List<List<IntFunction<int[]>>> INT_COMPARE_GENERATOR_PAIRS =
1310         INT_COMPARE_GENERATORS.stream().
1311                 flatMap(fa -> INT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1312                 collect(Collectors.toList());
1313 
1314     @DataProvider
1315     public Object[][] intCompareOpProvider() {
1316         return INT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1317                 toArray(Object[][]::new);
1318     }
1319 
1320     @DataProvider
1321     public Object[][] intCompareOpMaskProvider() {
1322         return BOOLEAN_MASK_GENERATORS.stream().
1323                 flatMap(fm -> INT_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1324                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1325                 })).
1326                 toArray(Object[][]::new);
1327     }
1328 
1329     interface ToIntF {
1330         int apply(int i);
1331     }
1332 
1333     static int[] fill(int s , ToIntF f) {
1334         return fill(new int[s], f);
1335     }
1336 
1337     static int[] fill(int[] a, ToIntF f) {
1338         for (int i = 0; i < a.length; i++) {
1339             a[i] = f.apply(i);
1340         }
1341         return a;
1342     }
1343 
1344     static int cornerCaseValue(int i) {
1345         switch(i % 5) {
1346             case 0:
1347                 return Integer.MAX_VALUE;
1348             case 1:
1349                 return Integer.MIN_VALUE;
1350             case 2:
1351                 return Integer.MIN_VALUE;
1352             case 3:
1353                 return Integer.MAX_VALUE;
1354             default:
1355                 return (int)0;
1356         }
1357     }
1358 
1359     static final IntFunction<int[]> fr = (vl) -> {
1360         int length = BUFFER_REPS * vl;
1361         return new int[length];
1362     };
1363 
1364     static final IntFunction<boolean[]> fmr = (vl) -> {
1365         int length = BUFFER_REPS * vl;
1366         return new boolean[length];
1367     };
1368 
1369     static final IntFunction<long[]> lfr = (vl) -> {
1370         int length = BUFFER_REPS * vl;
1371         return new long[length];
1372     };
1373 
1374     static void replaceZero(int[] a, int v) {
1375         for (int i = 0; i < a.length; i++) {
1376             if (a[i] == 0) {
1377                 a[i] = v;
1378             }
1379         }
1380     }
1381 
1382     static void replaceZero(int[] a, boolean[] mask, int v) {
1383         for (int i = 0; i < a.length; i++) {
1384             if (mask[i % mask.length] && a[i] == 0) {
1385                 a[i] = v;
1386             }
1387         }
1388     }
1389 
1390     static int ROL_scalar(int a, int b) {
1391         return Integer.rotateLeft(a, ((int)b));
1392     }
1393 
1394     static int ROR_scalar(int a, int b) {
1395         return Integer.rotateRight(a, ((int)b));
1396     }
1397 
1398     static int TRAILING_ZEROS_COUNT_scalar(int a) {
1399         return Integer.numberOfTrailingZeros(a);
1400     }
1401 
1402     static int LEADING_ZEROS_COUNT_scalar(int a) {
1403         return Integer.numberOfLeadingZeros(a);
1404     }
1405 
1406     static int REVERSE_scalar(int a) {
1407         return Integer.reverse(a);
1408     }
1409 
1410     static boolean eq(int a, int b) {
1411         return a == b;
1412     }
1413 
1414     static boolean neq(int a, int b) {
1415         return a != b;
1416     }
1417 
1418     static boolean lt(int a, int b) {
1419         return a < b;
1420     }
1421 
1422     static boolean le(int a, int b) {
1423         return a <= b;
1424     }
1425 
1426     static boolean gt(int a, int b) {
1427         return a > b;
1428     }
1429 
1430     static boolean ge(int a, int b) {
1431         return a >= b;
1432     }
1433 
1434     static boolean ult(int a, int b) {
1435         return Integer.compareUnsigned(a, b) < 0;
1436     }
1437 
1438     static boolean ule(int a, int b) {
1439         return Integer.compareUnsigned(a, b) <= 0;
1440     }
1441 
1442     static boolean ugt(int a, int b) {
1443         return Integer.compareUnsigned(a, b) > 0;
1444     }
1445 
1446     static boolean uge(int a, int b) {
1447         return Integer.compareUnsigned(a, b) >= 0;
1448     }
1449 
1450     static int firstNonZero(int a, int b) {
1451         return Integer.compare(a, (int) 0) != 0 ? a : b;
1452     }
1453 
1454     @Test
1455     static void smokeTest1() {
1456         IntVector three = IntVector.broadcast(SPECIES, (byte)-3);
1457         IntVector three2 = (IntVector) SPECIES.broadcast(-3);
1458         assert(three.eq(three2).allTrue());
1459         IntVector three3 = three2.broadcast(1).broadcast(-3);
1460         assert(three.eq(three3).allTrue());
1461         int scale = 2;
1462         Class<?> ETYPE = int.class;
1463         if (ETYPE == double.class || ETYPE == long.class)
1464             scale = 1000000;
1465         else if (ETYPE == byte.class && SPECIES.length() >= 64)
1466             scale = 1;
1467         IntVector higher = three.addIndex(scale);
1468         VectorMask<Integer> m = three.compare(VectorOperators.LE, higher);
1469         assert(m.allTrue());
1470         m = higher.min((int)-1).test(VectorOperators.IS_NEGATIVE);
1471         assert(m.allTrue());
1472         int max = higher.reduceLanes(VectorOperators.MAX);
1473         assert(max == -3 + scale * (SPECIES.length()-1));
1474     }
1475 
1476     private static int[]
1477     bothToArray(IntVector a, IntVector b) {
1478         int[] r = new int[a.length() + b.length()];
1479         a.intoArray(r, 0);
1480         b.intoArray(r, a.length());
1481         return r;
1482     }
1483 
1484     @Test
1485     static void smokeTest2() {
1486         // Do some zipping and shuffling.
1487         IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
1488         IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1489         Assert.assertEquals(io, io2);
1490         IntVector a = io.add((int)1); //[1,2]
1491         IntVector b = a.neg();  //[-1,-2]
1492         int[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1493         VectorShuffle<Integer> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1494         VectorShuffle<Integer> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1495         IntVector zab0 = a.rearrange(zip0,b); //[1,-1]
1496         IntVector zab1 = a.rearrange(zip1,b); //[2,-2]
1497         int[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1498         // manually zip
1499         int[] manual = new int[zabValues.length];
1500         for (int i = 0; i < manual.length; i += 2) {
1501             manual[i+0] = abValues[i/2];
1502             manual[i+1] = abValues[a.length() + i/2];
1503         }
1504         Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1505         VectorShuffle<Integer> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1506         VectorShuffle<Integer> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1507         IntVector uab0 = zab0.rearrange(unz0,zab1);
1508         IntVector uab1 = zab0.rearrange(unz1,zab1);
1509         int[] abValues1 = bothToArray(uab0, uab1);
1510         Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1511     }
1512 
1513     static void iotaShuffle() {
1514         IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
1515         IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1516         Assert.assertEquals(io, io2);
1517     }
1518 
1519     @Test
1520     // Test all shuffle related operations.
1521     static void shuffleTest() {
1522         // To test backend instructions, make sure that C2 is used.
1523         for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1524             iotaShuffle();
1525         }
1526     }
1527 
1528     @Test
1529     void viewAsIntegeralLanesTest() {
1530         Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1531         Assert.assertEquals(asIntegral.species(), SPECIES);
1532     }
1533 
1534     @Test
1535     void viewAsFloatingLanesTest() {
1536         Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
1537         VectorSpecies<?> asFloatingSpecies = asFloating.species();
1538         Assert.assertNotEquals(asFloatingSpecies.elementType(), SPECIES.elementType());
1539         Assert.assertEquals(asFloatingSpecies.vectorShape(), SPECIES.vectorShape());
1540         Assert.assertEquals(asFloatingSpecies.length(), SPECIES.length());
1541         Assert.assertEquals(asFloating.viewAsIntegralLanes().species(), SPECIES);
1542     }
1543 
1544     @Test
1545     // Test div by 0.
1546     static void bitwiseDivByZeroSmokeTest() {
1547         try {
1548             IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
1549             IntVector b = (IntVector) SPECIES.broadcast(0);
1550             a.div(b);
1551             Assert.fail();
1552         } catch (ArithmeticException e) {
1553         }
1554 
1555         try {
1556             IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
1557             IntVector b = (IntVector) SPECIES.broadcast(0);
1558             VectorMask<Integer> m = a.lt((int) 1);
1559             a.div(b, m);
1560             Assert.fail();
1561         } catch (ArithmeticException e) {
1562         }
1563     }
1564 
1565     static int ADD(int a, int b) {
1566         return (int)(a + b);
1567     }
1568 
1569     @Test(dataProvider = "intBinaryOpProvider")
1570     static void ADDInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1571         int[] a = fa.apply(SPECIES.length());
1572         int[] b = fb.apply(SPECIES.length());
1573         int[] r = fr.apply(SPECIES.length());
1574 
1575         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1576             for (int i = 0; i < a.length; i += SPECIES.length()) {
1577                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1578                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1579                 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
1580             }
1581         }
1582 
1583         assertArraysEquals(r, a, b, Int64VectorTests::ADD);
1584     }
1585 
1586     static int add(int a, int b) {
1587         return (int)(a + b);
1588     }
1589 
1590     @Test(dataProvider = "intBinaryOpProvider")
1591     static void addInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1592         int[] a = fa.apply(SPECIES.length());
1593         int[] b = fb.apply(SPECIES.length());
1594         int[] r = fr.apply(SPECIES.length());
1595 
1596         for (int i = 0; i < a.length; i += SPECIES.length()) {
1597             IntVector av = IntVector.fromArray(SPECIES, a, i);
1598             IntVector bv = IntVector.fromArray(SPECIES, b, i);
1599             av.add(bv).intoArray(r, i);
1600         }
1601 
1602         assertArraysEquals(r, a, b, Int64VectorTests::add);
1603     }
1604 
1605     @Test(dataProvider = "intBinaryOpMaskProvider")
1606     static void ADDInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1607                                           IntFunction<boolean[]> fm) {
1608         int[] a = fa.apply(SPECIES.length());
1609         int[] b = fb.apply(SPECIES.length());
1610         int[] r = fr.apply(SPECIES.length());
1611         boolean[] mask = fm.apply(SPECIES.length());
1612         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1613 
1614         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1615             for (int i = 0; i < a.length; i += SPECIES.length()) {
1616                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1617                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1618                 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
1619             }
1620         }
1621 
1622         assertArraysEquals(r, a, b, mask, Int64VectorTests::ADD);
1623     }
1624 
1625     @Test(dataProvider = "intBinaryOpMaskProvider")
1626     static void addInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1627                                           IntFunction<boolean[]> fm) {
1628         int[] a = fa.apply(SPECIES.length());
1629         int[] b = fb.apply(SPECIES.length());
1630         int[] r = fr.apply(SPECIES.length());
1631         boolean[] mask = fm.apply(SPECIES.length());
1632         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1633 
1634         for (int i = 0; i < a.length; i += SPECIES.length()) {
1635             IntVector av = IntVector.fromArray(SPECIES, a, i);
1636             IntVector bv = IntVector.fromArray(SPECIES, b, i);
1637             av.add(bv, vmask).intoArray(r, i);
1638         }
1639 
1640         assertArraysEquals(r, a, b, mask, Int64VectorTests::add);
1641     }
1642 
1643     static int SUB(int a, int b) {
1644         return (int)(a - b);
1645     }
1646 
1647     @Test(dataProvider = "intBinaryOpProvider")
1648     static void SUBInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1649         int[] a = fa.apply(SPECIES.length());
1650         int[] b = fb.apply(SPECIES.length());
1651         int[] r = fr.apply(SPECIES.length());
1652 
1653         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1654             for (int i = 0; i < a.length; i += SPECIES.length()) {
1655                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1656                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1657                 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1658             }
1659         }
1660 
1661         assertArraysEquals(r, a, b, Int64VectorTests::SUB);
1662     }
1663 
1664     static int sub(int a, int b) {
1665         return (int)(a - b);
1666     }
1667 
1668     @Test(dataProvider = "intBinaryOpProvider")
1669     static void subInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1670         int[] a = fa.apply(SPECIES.length());
1671         int[] b = fb.apply(SPECIES.length());
1672         int[] r = fr.apply(SPECIES.length());
1673 
1674         for (int i = 0; i < a.length; i += SPECIES.length()) {
1675             IntVector av = IntVector.fromArray(SPECIES, a, i);
1676             IntVector bv = IntVector.fromArray(SPECIES, b, i);
1677             av.sub(bv).intoArray(r, i);
1678         }
1679 
1680         assertArraysEquals(r, a, b, Int64VectorTests::sub);
1681     }
1682 
1683     @Test(dataProvider = "intBinaryOpMaskProvider")
1684     static void SUBInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1685                                           IntFunction<boolean[]> fm) {
1686         int[] a = fa.apply(SPECIES.length());
1687         int[] b = fb.apply(SPECIES.length());
1688         int[] r = fr.apply(SPECIES.length());
1689         boolean[] mask = fm.apply(SPECIES.length());
1690         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1691 
1692         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1693             for (int i = 0; i < a.length; i += SPECIES.length()) {
1694                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1695                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1696                 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1697             }
1698         }
1699 
1700         assertArraysEquals(r, a, b, mask, Int64VectorTests::SUB);
1701     }
1702 
1703     @Test(dataProvider = "intBinaryOpMaskProvider")
1704     static void subInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1705                                           IntFunction<boolean[]> fm) {
1706         int[] a = fa.apply(SPECIES.length());
1707         int[] b = fb.apply(SPECIES.length());
1708         int[] r = fr.apply(SPECIES.length());
1709         boolean[] mask = fm.apply(SPECIES.length());
1710         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1711 
1712         for (int i = 0; i < a.length; i += SPECIES.length()) {
1713             IntVector av = IntVector.fromArray(SPECIES, a, i);
1714             IntVector bv = IntVector.fromArray(SPECIES, b, i);
1715             av.sub(bv, vmask).intoArray(r, i);
1716         }
1717 
1718         assertArraysEquals(r, a, b, mask, Int64VectorTests::sub);
1719     }
1720 
1721     static int MUL(int a, int b) {
1722         return (int)(a * b);
1723     }
1724 
1725     @Test(dataProvider = "intBinaryOpProvider")
1726     static void MULInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1727         int[] a = fa.apply(SPECIES.length());
1728         int[] b = fb.apply(SPECIES.length());
1729         int[] r = fr.apply(SPECIES.length());
1730 
1731         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1732             for (int i = 0; i < a.length; i += SPECIES.length()) {
1733                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1734                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1735                 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1736             }
1737         }
1738 
1739         assertArraysEquals(r, a, b, Int64VectorTests::MUL);
1740     }
1741 
1742     static int mul(int a, int b) {
1743         return (int)(a * b);
1744     }
1745 
1746     @Test(dataProvider = "intBinaryOpProvider")
1747     static void mulInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1748         int[] a = fa.apply(SPECIES.length());
1749         int[] b = fb.apply(SPECIES.length());
1750         int[] r = fr.apply(SPECIES.length());
1751 
1752         for (int i = 0; i < a.length; i += SPECIES.length()) {
1753             IntVector av = IntVector.fromArray(SPECIES, a, i);
1754             IntVector bv = IntVector.fromArray(SPECIES, b, i);
1755             av.mul(bv).intoArray(r, i);
1756         }
1757 
1758         assertArraysEquals(r, a, b, Int64VectorTests::mul);
1759     }
1760 
1761     @Test(dataProvider = "intBinaryOpMaskProvider")
1762     static void MULInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1763                                           IntFunction<boolean[]> fm) {
1764         int[] a = fa.apply(SPECIES.length());
1765         int[] b = fb.apply(SPECIES.length());
1766         int[] r = fr.apply(SPECIES.length());
1767         boolean[] mask = fm.apply(SPECIES.length());
1768         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1769 
1770         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1771             for (int i = 0; i < a.length; i += SPECIES.length()) {
1772                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1773                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1774                 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1775             }
1776         }
1777 
1778         assertArraysEquals(r, a, b, mask, Int64VectorTests::MUL);
1779     }
1780 
1781     @Test(dataProvider = "intBinaryOpMaskProvider")
1782     static void mulInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1783                                           IntFunction<boolean[]> fm) {
1784         int[] a = fa.apply(SPECIES.length());
1785         int[] b = fb.apply(SPECIES.length());
1786         int[] r = fr.apply(SPECIES.length());
1787         boolean[] mask = fm.apply(SPECIES.length());
1788         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1789 
1790         for (int i = 0; i < a.length; i += SPECIES.length()) {
1791             IntVector av = IntVector.fromArray(SPECIES, a, i);
1792             IntVector bv = IntVector.fromArray(SPECIES, b, i);
1793             av.mul(bv, vmask).intoArray(r, i);
1794         }
1795 
1796         assertArraysEquals(r, a, b, mask, Int64VectorTests::mul);
1797     }
1798 
1799     static int DIV(int a, int b) {
1800         return (int)(a / b);
1801     }
1802 
1803     @Test(dataProvider = "intBinaryOpProvider")
1804     static void DIVInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1805         int[] a = fa.apply(SPECIES.length());
1806         int[] b = fb.apply(SPECIES.length());
1807         int[] r = fr.apply(SPECIES.length());
1808 
1809         replaceZero(b, (int) 1);
1810 
1811         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1812             for (int i = 0; i < a.length; i += SPECIES.length()) {
1813                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1814                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1815                 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1816             }
1817         }
1818 
1819         assertArraysEquals(r, a, b, Int64VectorTests::DIV);
1820     }
1821 
1822     static int div(int a, int b) {
1823         return (int)(a / b);
1824     }
1825 
1826     @Test(dataProvider = "intBinaryOpProvider")
1827     static void divInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1828         int[] a = fa.apply(SPECIES.length());
1829         int[] b = fb.apply(SPECIES.length());
1830         int[] r = fr.apply(SPECIES.length());
1831 
1832         replaceZero(b, (int) 1);
1833 
1834         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1835             for (int i = 0; i < a.length; i += SPECIES.length()) {
1836                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1837                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1838                 av.div(bv).intoArray(r, i);
1839             }
1840         }
1841 
1842         assertArraysEquals(r, a, b, Int64VectorTests::div);
1843     }
1844 
1845     @Test(dataProvider = "intBinaryOpMaskProvider")
1846     static void DIVInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1847                                           IntFunction<boolean[]> fm) {
1848         int[] a = fa.apply(SPECIES.length());
1849         int[] b = fb.apply(SPECIES.length());
1850         int[] r = fr.apply(SPECIES.length());
1851         boolean[] mask = fm.apply(SPECIES.length());
1852         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1853 
1854         replaceZero(b, mask, (int) 1);
1855 
1856         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1857             for (int i = 0; i < a.length; i += SPECIES.length()) {
1858                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1859                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1860                 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1861             }
1862         }
1863 
1864         assertArraysEquals(r, a, b, mask, Int64VectorTests::DIV);
1865     }
1866 
1867     @Test(dataProvider = "intBinaryOpMaskProvider")
1868     static void divInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1869                                           IntFunction<boolean[]> fm) {
1870         int[] a = fa.apply(SPECIES.length());
1871         int[] b = fb.apply(SPECIES.length());
1872         int[] r = fr.apply(SPECIES.length());
1873         boolean[] mask = fm.apply(SPECIES.length());
1874         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1875 
1876         replaceZero(b, mask, (int) 1);
1877 
1878         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1879             for (int i = 0; i < a.length; i += SPECIES.length()) {
1880                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1881                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1882                 av.div(bv, vmask).intoArray(r, i);
1883             }
1884         }
1885 
1886         assertArraysEquals(r, a, b, mask, Int64VectorTests::div);
1887     }
1888 
1889     static int FIRST_NONZERO(int a, int b) {
1890         return (int)((a)!=0?a:b);
1891     }
1892 
1893     @Test(dataProvider = "intBinaryOpProvider")
1894     static void FIRST_NONZEROInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1895         int[] a = fa.apply(SPECIES.length());
1896         int[] b = fb.apply(SPECIES.length());
1897         int[] r = fr.apply(SPECIES.length());
1898 
1899         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1900             for (int i = 0; i < a.length; i += SPECIES.length()) {
1901                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1902                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1903                 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1904             }
1905         }
1906 
1907         assertArraysEquals(r, a, b, Int64VectorTests::FIRST_NONZERO);
1908     }
1909 
1910     @Test(dataProvider = "intBinaryOpMaskProvider")
1911     static void FIRST_NONZEROInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1912                                           IntFunction<boolean[]> fm) {
1913         int[] a = fa.apply(SPECIES.length());
1914         int[] b = fb.apply(SPECIES.length());
1915         int[] r = fr.apply(SPECIES.length());
1916         boolean[] mask = fm.apply(SPECIES.length());
1917         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1918 
1919         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1920             for (int i = 0; i < a.length; i += SPECIES.length()) {
1921                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1922                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1923                 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1924             }
1925         }
1926 
1927         assertArraysEquals(r, a, b, mask, Int64VectorTests::FIRST_NONZERO);
1928     }
1929 
1930     static int AND(int a, int b) {
1931         return (int)(a & b);
1932     }
1933 
1934     @Test(dataProvider = "intBinaryOpProvider")
1935     static void ANDInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1936         int[] a = fa.apply(SPECIES.length());
1937         int[] b = fb.apply(SPECIES.length());
1938         int[] r = fr.apply(SPECIES.length());
1939 
1940         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1941             for (int i = 0; i < a.length; i += SPECIES.length()) {
1942                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1943                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1944                 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1945             }
1946         }
1947 
1948         assertArraysEquals(r, a, b, Int64VectorTests::AND);
1949     }
1950 
1951     static int and(int a, int b) {
1952         return (int)(a & b);
1953     }
1954 
1955     @Test(dataProvider = "intBinaryOpProvider")
1956     static void andInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1957         int[] a = fa.apply(SPECIES.length());
1958         int[] b = fb.apply(SPECIES.length());
1959         int[] r = fr.apply(SPECIES.length());
1960 
1961         for (int i = 0; i < a.length; i += SPECIES.length()) {
1962             IntVector av = IntVector.fromArray(SPECIES, a, i);
1963             IntVector bv = IntVector.fromArray(SPECIES, b, i);
1964             av.and(bv).intoArray(r, i);
1965         }
1966 
1967         assertArraysEquals(r, a, b, Int64VectorTests::and);
1968     }
1969 
1970     @Test(dataProvider = "intBinaryOpMaskProvider")
1971     static void ANDInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1972                                           IntFunction<boolean[]> fm) {
1973         int[] a = fa.apply(SPECIES.length());
1974         int[] b = fb.apply(SPECIES.length());
1975         int[] r = fr.apply(SPECIES.length());
1976         boolean[] mask = fm.apply(SPECIES.length());
1977         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1978 
1979         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1980             for (int i = 0; i < a.length; i += SPECIES.length()) {
1981                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1982                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1983                 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
1984             }
1985         }
1986 
1987         assertArraysEquals(r, a, b, mask, Int64VectorTests::AND);
1988     }
1989 
1990     static int AND_NOT(int a, int b) {
1991         return (int)(a & ~b);
1992     }
1993 
1994     @Test(dataProvider = "intBinaryOpProvider")
1995     static void AND_NOTInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1996         int[] a = fa.apply(SPECIES.length());
1997         int[] b = fb.apply(SPECIES.length());
1998         int[] r = fr.apply(SPECIES.length());
1999 
2000         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2001             for (int i = 0; i < a.length; i += SPECIES.length()) {
2002                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2003                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2004                 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
2005             }
2006         }
2007 
2008         assertArraysEquals(r, a, b, Int64VectorTests::AND_NOT);
2009     }
2010 
2011     @Test(dataProvider = "intBinaryOpMaskProvider")
2012     static void AND_NOTInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2013                                           IntFunction<boolean[]> fm) {
2014         int[] a = fa.apply(SPECIES.length());
2015         int[] b = fb.apply(SPECIES.length());
2016         int[] r = fr.apply(SPECIES.length());
2017         boolean[] mask = fm.apply(SPECIES.length());
2018         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2019 
2020         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2021             for (int i = 0; i < a.length; i += SPECIES.length()) {
2022                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2023                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2024                 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
2025             }
2026         }
2027 
2028         assertArraysEquals(r, a, b, mask, Int64VectorTests::AND_NOT);
2029     }
2030 
2031     static int OR(int a, int b) {
2032         return (int)(a | b);
2033     }
2034 
2035     @Test(dataProvider = "intBinaryOpProvider")
2036     static void ORInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2037         int[] a = fa.apply(SPECIES.length());
2038         int[] b = fb.apply(SPECIES.length());
2039         int[] r = fr.apply(SPECIES.length());
2040 
2041         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2042             for (int i = 0; i < a.length; i += SPECIES.length()) {
2043                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2044                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2045                 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
2046             }
2047         }
2048 
2049         assertArraysEquals(r, a, b, Int64VectorTests::OR);
2050     }
2051 
2052     static int or(int a, int b) {
2053         return (int)(a | b);
2054     }
2055 
2056     @Test(dataProvider = "intBinaryOpProvider")
2057     static void orInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2058         int[] a = fa.apply(SPECIES.length());
2059         int[] b = fb.apply(SPECIES.length());
2060         int[] r = fr.apply(SPECIES.length());
2061 
2062         for (int i = 0; i < a.length; i += SPECIES.length()) {
2063             IntVector av = IntVector.fromArray(SPECIES, a, i);
2064             IntVector bv = IntVector.fromArray(SPECIES, b, i);
2065             av.or(bv).intoArray(r, i);
2066         }
2067 
2068         assertArraysEquals(r, a, b, Int64VectorTests::or);
2069     }
2070 
2071     @Test(dataProvider = "intBinaryOpMaskProvider")
2072     static void ORInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2073                                           IntFunction<boolean[]> fm) {
2074         int[] a = fa.apply(SPECIES.length());
2075         int[] b = fb.apply(SPECIES.length());
2076         int[] r = fr.apply(SPECIES.length());
2077         boolean[] mask = fm.apply(SPECIES.length());
2078         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2079 
2080         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2081             for (int i = 0; i < a.length; i += SPECIES.length()) {
2082                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2083                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2084                 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
2085             }
2086         }
2087 
2088         assertArraysEquals(r, a, b, mask, Int64VectorTests::OR);
2089     }
2090 
2091     static int XOR(int a, int b) {
2092         return (int)(a ^ b);
2093     }
2094 
2095     @Test(dataProvider = "intBinaryOpProvider")
2096     static void XORInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2097         int[] a = fa.apply(SPECIES.length());
2098         int[] b = fb.apply(SPECIES.length());
2099         int[] r = fr.apply(SPECIES.length());
2100 
2101         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2102             for (int i = 0; i < a.length; i += SPECIES.length()) {
2103                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2104                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2105                 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
2106             }
2107         }
2108 
2109         assertArraysEquals(r, a, b, Int64VectorTests::XOR);
2110     }
2111 
2112     @Test(dataProvider = "intBinaryOpMaskProvider")
2113     static void XORInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2114                                           IntFunction<boolean[]> fm) {
2115         int[] a = fa.apply(SPECIES.length());
2116         int[] b = fb.apply(SPECIES.length());
2117         int[] r = fr.apply(SPECIES.length());
2118         boolean[] mask = fm.apply(SPECIES.length());
2119         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2120 
2121         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2122             for (int i = 0; i < a.length; i += SPECIES.length()) {
2123                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2124                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2125                 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
2126             }
2127         }
2128 
2129         assertArraysEquals(r, a, b, mask, Int64VectorTests::XOR);
2130     }
2131 
2132     static int COMPRESS_BITS(int a, int b) {
2133         return (int)(Integer.compress(a, b));
2134     }
2135 
2136     @Test(dataProvider = "intBinaryOpProvider")
2137     static void COMPRESS_BITSInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2138         int[] a = fa.apply(SPECIES.length());
2139         int[] b = fb.apply(SPECIES.length());
2140         int[] r = fr.apply(SPECIES.length());
2141 
2142         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2143             for (int i = 0; i < a.length; i += SPECIES.length()) {
2144                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2145                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2146                 av.lanewise(VectorOperators.COMPRESS_BITS, bv).intoArray(r, i);
2147             }
2148         }
2149 
2150         assertArraysEquals(r, a, b, Int64VectorTests::COMPRESS_BITS);
2151     }
2152 
2153     @Test(dataProvider = "intBinaryOpMaskProvider")
2154     static void COMPRESS_BITSInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2155                                           IntFunction<boolean[]> fm) {
2156         int[] a = fa.apply(SPECIES.length());
2157         int[] b = fb.apply(SPECIES.length());
2158         int[] r = fr.apply(SPECIES.length());
2159         boolean[] mask = fm.apply(SPECIES.length());
2160         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2161 
2162         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2163             for (int i = 0; i < a.length; i += SPECIES.length()) {
2164                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2165                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2166                 av.lanewise(VectorOperators.COMPRESS_BITS, bv, vmask).intoArray(r, i);
2167             }
2168         }
2169 
2170         assertArraysEquals(r, a, b, mask, Int64VectorTests::COMPRESS_BITS);
2171     }
2172 
2173     static int EXPAND_BITS(int a, int b) {
2174         return (int)(Integer.expand(a, b));
2175     }
2176 
2177     @Test(dataProvider = "intBinaryOpProvider")
2178     static void EXPAND_BITSInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2179         int[] a = fa.apply(SPECIES.length());
2180         int[] b = fb.apply(SPECIES.length());
2181         int[] r = fr.apply(SPECIES.length());
2182 
2183         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2184             for (int i = 0; i < a.length; i += SPECIES.length()) {
2185                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2186                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2187                 av.lanewise(VectorOperators.EXPAND_BITS, bv).intoArray(r, i);
2188             }
2189         }
2190 
2191         assertArraysEquals(r, a, b, Int64VectorTests::EXPAND_BITS);
2192     }
2193 
2194     @Test(dataProvider = "intBinaryOpMaskProvider")
2195     static void EXPAND_BITSInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2196                                           IntFunction<boolean[]> fm) {
2197         int[] a = fa.apply(SPECIES.length());
2198         int[] b = fb.apply(SPECIES.length());
2199         int[] r = fr.apply(SPECIES.length());
2200         boolean[] mask = fm.apply(SPECIES.length());
2201         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2202 
2203         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2204             for (int i = 0; i < a.length; i += SPECIES.length()) {
2205                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2206                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2207                 av.lanewise(VectorOperators.EXPAND_BITS, bv, vmask).intoArray(r, i);
2208             }
2209         }
2210 
2211         assertArraysEquals(r, a, b, mask, Int64VectorTests::EXPAND_BITS);
2212     }
2213 
2214     @Test(dataProvider = "intBinaryOpProvider")
2215     static void addInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2216         int[] a = fa.apply(SPECIES.length());
2217         int[] b = fb.apply(SPECIES.length());
2218         int[] r = fr.apply(SPECIES.length());
2219 
2220         for (int i = 0; i < a.length; i += SPECIES.length()) {
2221             IntVector av = IntVector.fromArray(SPECIES, a, i);
2222             av.add(b[i]).intoArray(r, i);
2223         }
2224 
2225         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::add);
2226     }
2227 
2228     @Test(dataProvider = "intBinaryOpMaskProvider")
2229     static void addInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2230                                           IntFunction<boolean[]> fm) {
2231         int[] a = fa.apply(SPECIES.length());
2232         int[] b = fb.apply(SPECIES.length());
2233         int[] r = fr.apply(SPECIES.length());
2234         boolean[] mask = fm.apply(SPECIES.length());
2235         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2236 
2237         for (int i = 0; i < a.length; i += SPECIES.length()) {
2238             IntVector av = IntVector.fromArray(SPECIES, a, i);
2239             av.add(b[i], vmask).intoArray(r, i);
2240         }
2241 
2242         assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::add);
2243     }
2244 
2245     @Test(dataProvider = "intBinaryOpProvider")
2246     static void subInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2247         int[] a = fa.apply(SPECIES.length());
2248         int[] b = fb.apply(SPECIES.length());
2249         int[] r = fr.apply(SPECIES.length());
2250 
2251         for (int i = 0; i < a.length; i += SPECIES.length()) {
2252             IntVector av = IntVector.fromArray(SPECIES, a, i);
2253             av.sub(b[i]).intoArray(r, i);
2254         }
2255 
2256         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::sub);
2257     }
2258 
2259     @Test(dataProvider = "intBinaryOpMaskProvider")
2260     static void subInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2261                                           IntFunction<boolean[]> fm) {
2262         int[] a = fa.apply(SPECIES.length());
2263         int[] b = fb.apply(SPECIES.length());
2264         int[] r = fr.apply(SPECIES.length());
2265         boolean[] mask = fm.apply(SPECIES.length());
2266         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2267 
2268         for (int i = 0; i < a.length; i += SPECIES.length()) {
2269             IntVector av = IntVector.fromArray(SPECIES, a, i);
2270             av.sub(b[i], vmask).intoArray(r, i);
2271         }
2272 
2273         assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::sub);
2274     }
2275 
2276     @Test(dataProvider = "intBinaryOpProvider")
2277     static void mulInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2278         int[] a = fa.apply(SPECIES.length());
2279         int[] b = fb.apply(SPECIES.length());
2280         int[] r = fr.apply(SPECIES.length());
2281 
2282         for (int i = 0; i < a.length; i += SPECIES.length()) {
2283             IntVector av = IntVector.fromArray(SPECIES, a, i);
2284             av.mul(b[i]).intoArray(r, i);
2285         }
2286 
2287         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::mul);
2288     }
2289 
2290     @Test(dataProvider = "intBinaryOpMaskProvider")
2291     static void mulInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2292                                           IntFunction<boolean[]> fm) {
2293         int[] a = fa.apply(SPECIES.length());
2294         int[] b = fb.apply(SPECIES.length());
2295         int[] r = fr.apply(SPECIES.length());
2296         boolean[] mask = fm.apply(SPECIES.length());
2297         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2298 
2299         for (int i = 0; i < a.length; i += SPECIES.length()) {
2300             IntVector av = IntVector.fromArray(SPECIES, a, i);
2301             av.mul(b[i], vmask).intoArray(r, i);
2302         }
2303 
2304         assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::mul);
2305     }
2306 
2307     @Test(dataProvider = "intBinaryOpProvider")
2308     static void divInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2309         int[] a = fa.apply(SPECIES.length());
2310         int[] b = fb.apply(SPECIES.length());
2311         int[] r = fr.apply(SPECIES.length());
2312 
2313         replaceZero(b, (int) 1);
2314 
2315         for (int i = 0; i < a.length; i += SPECIES.length()) {
2316             IntVector av = IntVector.fromArray(SPECIES, a, i);
2317             av.div(b[i]).intoArray(r, i);
2318         }
2319 
2320         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::div);
2321     }
2322 
2323     @Test(dataProvider = "intBinaryOpMaskProvider")
2324     static void divInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2325                                           IntFunction<boolean[]> fm) {
2326         int[] a = fa.apply(SPECIES.length());
2327         int[] b = fb.apply(SPECIES.length());
2328         int[] r = fr.apply(SPECIES.length());
2329         boolean[] mask = fm.apply(SPECIES.length());
2330         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2331 
2332         replaceZero(b, (int) 1);
2333 
2334         for (int i = 0; i < a.length; i += SPECIES.length()) {
2335             IntVector av = IntVector.fromArray(SPECIES, a, i);
2336             av.div(b[i], vmask).intoArray(r, i);
2337         }
2338 
2339         assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::div);
2340     }
2341 
2342     @Test(dataProvider = "intBinaryOpProvider")
2343     static void ORInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2344         int[] a = fa.apply(SPECIES.length());
2345         int[] b = fb.apply(SPECIES.length());
2346         int[] r = fr.apply(SPECIES.length());
2347 
2348         for (int i = 0; i < a.length; i += SPECIES.length()) {
2349             IntVector av = IntVector.fromArray(SPECIES, a, i);
2350             av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
2351         }
2352 
2353         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::OR);
2354     }
2355 
2356     @Test(dataProvider = "intBinaryOpProvider")
2357     static void orInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2358         int[] a = fa.apply(SPECIES.length());
2359         int[] b = fb.apply(SPECIES.length());
2360         int[] r = fr.apply(SPECIES.length());
2361 
2362         for (int i = 0; i < a.length; i += SPECIES.length()) {
2363             IntVector av = IntVector.fromArray(SPECIES, a, i);
2364             av.or(b[i]).intoArray(r, i);
2365         }
2366 
2367         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::or);
2368     }
2369 
2370     @Test(dataProvider = "intBinaryOpMaskProvider")
2371     static void ORInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2372                                           IntFunction<boolean[]> fm) {
2373         int[] a = fa.apply(SPECIES.length());
2374         int[] b = fb.apply(SPECIES.length());
2375         int[] r = fr.apply(SPECIES.length());
2376         boolean[] mask = fm.apply(SPECIES.length());
2377         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2378 
2379         for (int i = 0; i < a.length; i += SPECIES.length()) {
2380             IntVector av = IntVector.fromArray(SPECIES, a, i);
2381             av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
2382         }
2383 
2384         assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::OR);
2385     }
2386 
2387     @Test(dataProvider = "intBinaryOpProvider")
2388     static void ANDInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2389         int[] a = fa.apply(SPECIES.length());
2390         int[] b = fb.apply(SPECIES.length());
2391         int[] r = fr.apply(SPECIES.length());
2392 
2393         for (int i = 0; i < a.length; i += SPECIES.length()) {
2394             IntVector av = IntVector.fromArray(SPECIES, a, i);
2395             av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i);
2396         }
2397 
2398         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::AND);
2399     }
2400 
2401     @Test(dataProvider = "intBinaryOpProvider")
2402     static void andInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2403         int[] a = fa.apply(SPECIES.length());
2404         int[] b = fb.apply(SPECIES.length());
2405         int[] r = fr.apply(SPECIES.length());
2406 
2407         for (int i = 0; i < a.length; i += SPECIES.length()) {
2408             IntVector av = IntVector.fromArray(SPECIES, a, i);
2409             av.and(b[i]).intoArray(r, i);
2410         }
2411 
2412         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::and);
2413     }
2414 
2415     @Test(dataProvider = "intBinaryOpMaskProvider")
2416     static void ANDInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2417                                           IntFunction<boolean[]> fm) {
2418         int[] a = fa.apply(SPECIES.length());
2419         int[] b = fb.apply(SPECIES.length());
2420         int[] r = fr.apply(SPECIES.length());
2421         boolean[] mask = fm.apply(SPECIES.length());
2422         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2423 
2424         for (int i = 0; i < a.length; i += SPECIES.length()) {
2425             IntVector av = IntVector.fromArray(SPECIES, a, i);
2426             av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i);
2427         }
2428 
2429         assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::AND);
2430     }
2431 
2432     @Test(dataProvider = "intBinaryOpProvider")
2433     static void ORInt64VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2434         int[] a = fa.apply(SPECIES.length());
2435         int[] b = fb.apply(SPECIES.length());
2436         int[] r = fr.apply(SPECIES.length());
2437 
2438         for (int i = 0; i < a.length; i += SPECIES.length()) {
2439             IntVector av = IntVector.fromArray(SPECIES, a, i);
2440             av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i);
2441         }
2442 
2443         assertBroadcastLongArraysEquals(r, a, b, Int64VectorTests::OR);
2444     }
2445 
2446     @Test(dataProvider = "intBinaryOpMaskProvider")
2447     static void ORInt64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2448                                           IntFunction<boolean[]> fm) {
2449         int[] a = fa.apply(SPECIES.length());
2450         int[] b = fb.apply(SPECIES.length());
2451         int[] r = fr.apply(SPECIES.length());
2452         boolean[] mask = fm.apply(SPECIES.length());
2453         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2454 
2455         for (int i = 0; i < a.length; i += SPECIES.length()) {
2456             IntVector av = IntVector.fromArray(SPECIES, a, i);
2457             av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i);
2458         }
2459 
2460         assertBroadcastLongArraysEquals(r, a, b, mask, Int64VectorTests::OR);
2461     }
2462 
2463     @Test(dataProvider = "intBinaryOpProvider")
2464     static void ADDInt64VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2465         int[] a = fa.apply(SPECIES.length());
2466         int[] b = fb.apply(SPECIES.length());
2467         int[] r = fr.apply(SPECIES.length());
2468 
2469         for (int i = 0; i < a.length; i += SPECIES.length()) {
2470             IntVector av = IntVector.fromArray(SPECIES, a, i);
2471             av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
2472         }
2473 
2474         assertBroadcastLongArraysEquals(r, a, b, Int64VectorTests::ADD);
2475     }
2476 
2477     @Test(dataProvider = "intBinaryOpMaskProvider")
2478     static void ADDInt64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2479                                           IntFunction<boolean[]> fm) {
2480         int[] a = fa.apply(SPECIES.length());
2481         int[] b = fb.apply(SPECIES.length());
2482         int[] r = fr.apply(SPECIES.length());
2483         boolean[] mask = fm.apply(SPECIES.length());
2484         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2485 
2486         for (int i = 0; i < a.length; i += SPECIES.length()) {
2487             IntVector av = IntVector.fromArray(SPECIES, a, i);
2488             av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
2489         }
2490 
2491         assertBroadcastLongArraysEquals(r, a, b, mask, Int64VectorTests::ADD);
2492     }
2493 
2494     static int LSHL(int a, int b) {
2495         return (int)((a << b));
2496     }
2497 
2498     @Test(dataProvider = "intBinaryOpProvider")
2499     static void LSHLInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2500         int[] a = fa.apply(SPECIES.length());
2501         int[] b = fb.apply(SPECIES.length());
2502         int[] r = fr.apply(SPECIES.length());
2503 
2504         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2505             for (int i = 0; i < a.length; i += SPECIES.length()) {
2506                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2507                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2508                 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
2509             }
2510         }
2511 
2512         assertArraysEquals(r, a, b, Int64VectorTests::LSHL);
2513     }
2514 
2515     @Test(dataProvider = "intBinaryOpMaskProvider")
2516     static void LSHLInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2517                                           IntFunction<boolean[]> fm) {
2518         int[] a = fa.apply(SPECIES.length());
2519         int[] b = fb.apply(SPECIES.length());
2520         int[] r = fr.apply(SPECIES.length());
2521         boolean[] mask = fm.apply(SPECIES.length());
2522         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2523 
2524         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2525             for (int i = 0; i < a.length; i += SPECIES.length()) {
2526                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2527                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2528                 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
2529             }
2530         }
2531 
2532         assertArraysEquals(r, a, b, mask, Int64VectorTests::LSHL);
2533     }
2534 
2535     static int ASHR(int a, int b) {
2536         return (int)((a >> b));
2537     }
2538 
2539     @Test(dataProvider = "intBinaryOpProvider")
2540     static void ASHRInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2541         int[] a = fa.apply(SPECIES.length());
2542         int[] b = fb.apply(SPECIES.length());
2543         int[] r = fr.apply(SPECIES.length());
2544 
2545         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2546             for (int i = 0; i < a.length; i += SPECIES.length()) {
2547                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2548                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2549                 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
2550             }
2551         }
2552 
2553         assertArraysEquals(r, a, b, Int64VectorTests::ASHR);
2554     }
2555 
2556     @Test(dataProvider = "intBinaryOpMaskProvider")
2557     static void ASHRInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2558                                           IntFunction<boolean[]> fm) {
2559         int[] a = fa.apply(SPECIES.length());
2560         int[] b = fb.apply(SPECIES.length());
2561         int[] r = fr.apply(SPECIES.length());
2562         boolean[] mask = fm.apply(SPECIES.length());
2563         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2564 
2565         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2566             for (int i = 0; i < a.length; i += SPECIES.length()) {
2567                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2568                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2569                 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
2570             }
2571         }
2572 
2573         assertArraysEquals(r, a, b, mask, Int64VectorTests::ASHR);
2574     }
2575 
2576     static int LSHR(int a, int b) {
2577         return (int)((a >>> b));
2578     }
2579 
2580     @Test(dataProvider = "intBinaryOpProvider")
2581     static void LSHRInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2582         int[] a = fa.apply(SPECIES.length());
2583         int[] b = fb.apply(SPECIES.length());
2584         int[] r = fr.apply(SPECIES.length());
2585 
2586         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2587             for (int i = 0; i < a.length; i += SPECIES.length()) {
2588                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2589                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2590                 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
2591             }
2592         }
2593 
2594         assertArraysEquals(r, a, b, Int64VectorTests::LSHR);
2595     }
2596 
2597     @Test(dataProvider = "intBinaryOpMaskProvider")
2598     static void LSHRInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2599                                           IntFunction<boolean[]> fm) {
2600         int[] a = fa.apply(SPECIES.length());
2601         int[] b = fb.apply(SPECIES.length());
2602         int[] r = fr.apply(SPECIES.length());
2603         boolean[] mask = fm.apply(SPECIES.length());
2604         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2605 
2606         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2607             for (int i = 0; i < a.length; i += SPECIES.length()) {
2608                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2609                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2610                 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
2611             }
2612         }
2613 
2614         assertArraysEquals(r, a, b, mask, Int64VectorTests::LSHR);
2615     }
2616 
2617     static int LSHL_unary(int a, int b) {
2618         return (int)((a << b));
2619     }
2620 
2621     @Test(dataProvider = "intBinaryOpProvider")
2622     static void LSHLInt64VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2623         int[] a = fa.apply(SPECIES.length());
2624         int[] b = fb.apply(SPECIES.length());
2625         int[] r = fr.apply(SPECIES.length());
2626 
2627         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2628             for (int i = 0; i < a.length; i += SPECIES.length()) {
2629                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2630                 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
2631             }
2632         }
2633 
2634         assertShiftArraysEquals(r, a, b, Int64VectorTests::LSHL_unary);
2635     }
2636 
2637     @Test(dataProvider = "intBinaryOpMaskProvider")
2638     static void LSHLInt64VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2639                                           IntFunction<boolean[]> fm) {
2640         int[] a = fa.apply(SPECIES.length());
2641         int[] b = fb.apply(SPECIES.length());
2642         int[] r = fr.apply(SPECIES.length());
2643         boolean[] mask = fm.apply(SPECIES.length());
2644         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2645 
2646         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2647             for (int i = 0; i < a.length; i += SPECIES.length()) {
2648                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2649                 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
2650             }
2651         }
2652 
2653         assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::LSHL_unary);
2654     }
2655 
2656     static int LSHR_unary(int a, int b) {
2657         return (int)((a >>> b));
2658     }
2659 
2660     @Test(dataProvider = "intBinaryOpProvider")
2661     static void LSHRInt64VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2662         int[] a = fa.apply(SPECIES.length());
2663         int[] b = fb.apply(SPECIES.length());
2664         int[] r = fr.apply(SPECIES.length());
2665 
2666         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2667             for (int i = 0; i < a.length; i += SPECIES.length()) {
2668                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2669                 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
2670             }
2671         }
2672 
2673         assertShiftArraysEquals(r, a, b, Int64VectorTests::LSHR_unary);
2674     }
2675 
2676     @Test(dataProvider = "intBinaryOpMaskProvider")
2677     static void LSHRInt64VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2678                                           IntFunction<boolean[]> fm) {
2679         int[] a = fa.apply(SPECIES.length());
2680         int[] b = fb.apply(SPECIES.length());
2681         int[] r = fr.apply(SPECIES.length());
2682         boolean[] mask = fm.apply(SPECIES.length());
2683         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2684 
2685         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2686             for (int i = 0; i < a.length; i += SPECIES.length()) {
2687                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2688                 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
2689             }
2690         }
2691 
2692         assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::LSHR_unary);
2693     }
2694 
2695     static int ASHR_unary(int a, int b) {
2696         return (int)((a >> b));
2697     }
2698 
2699     @Test(dataProvider = "intBinaryOpProvider")
2700     static void ASHRInt64VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2701         int[] a = fa.apply(SPECIES.length());
2702         int[] b = fb.apply(SPECIES.length());
2703         int[] r = fr.apply(SPECIES.length());
2704 
2705         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2706             for (int i = 0; i < a.length; i += SPECIES.length()) {
2707                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2708                 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
2709             }
2710         }
2711 
2712         assertShiftArraysEquals(r, a, b, Int64VectorTests::ASHR_unary);
2713     }
2714 
2715     @Test(dataProvider = "intBinaryOpMaskProvider")
2716     static void ASHRInt64VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2717                                           IntFunction<boolean[]> fm) {
2718         int[] a = fa.apply(SPECIES.length());
2719         int[] b = fb.apply(SPECIES.length());
2720         int[] r = fr.apply(SPECIES.length());
2721         boolean[] mask = fm.apply(SPECIES.length());
2722         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2723 
2724         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2725             for (int i = 0; i < a.length; i += SPECIES.length()) {
2726                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2727                 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
2728             }
2729         }
2730 
2731         assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::ASHR_unary);
2732     }
2733 
2734     static int ROR(int a, int b) {
2735         return (int)(ROR_scalar(a,b));
2736     }
2737 
2738     @Test(dataProvider = "intBinaryOpProvider")
2739     static void RORInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2740         int[] a = fa.apply(SPECIES.length());
2741         int[] b = fb.apply(SPECIES.length());
2742         int[] r = fr.apply(SPECIES.length());
2743 
2744         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2745             for (int i = 0; i < a.length; i += SPECIES.length()) {
2746                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2747                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2748                 av.lanewise(VectorOperators.ROR, bv).intoArray(r, i);
2749             }
2750         }
2751 
2752         assertArraysEquals(r, a, b, Int64VectorTests::ROR);
2753     }
2754 
2755     @Test(dataProvider = "intBinaryOpMaskProvider")
2756     static void RORInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2757                                           IntFunction<boolean[]> fm) {
2758         int[] a = fa.apply(SPECIES.length());
2759         int[] b = fb.apply(SPECIES.length());
2760         int[] r = fr.apply(SPECIES.length());
2761         boolean[] mask = fm.apply(SPECIES.length());
2762         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2763 
2764         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2765             for (int i = 0; i < a.length; i += SPECIES.length()) {
2766                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2767                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2768                 av.lanewise(VectorOperators.ROR, bv, vmask).intoArray(r, i);
2769             }
2770         }
2771 
2772         assertArraysEquals(r, a, b, mask, Int64VectorTests::ROR);
2773     }
2774 
2775     static int ROL(int a, int b) {
2776         return (int)(ROL_scalar(a,b));
2777     }
2778 
2779     @Test(dataProvider = "intBinaryOpProvider")
2780     static void ROLInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2781         int[] a = fa.apply(SPECIES.length());
2782         int[] b = fb.apply(SPECIES.length());
2783         int[] r = fr.apply(SPECIES.length());
2784 
2785         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2786             for (int i = 0; i < a.length; i += SPECIES.length()) {
2787                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2788                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2789                 av.lanewise(VectorOperators.ROL, bv).intoArray(r, i);
2790             }
2791         }
2792 
2793         assertArraysEquals(r, a, b, Int64VectorTests::ROL);
2794     }
2795 
2796     @Test(dataProvider = "intBinaryOpMaskProvider")
2797     static void ROLInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2798                                           IntFunction<boolean[]> fm) {
2799         int[] a = fa.apply(SPECIES.length());
2800         int[] b = fb.apply(SPECIES.length());
2801         int[] r = fr.apply(SPECIES.length());
2802         boolean[] mask = fm.apply(SPECIES.length());
2803         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2804 
2805         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2806             for (int i = 0; i < a.length; i += SPECIES.length()) {
2807                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2808                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2809                 av.lanewise(VectorOperators.ROL, bv, vmask).intoArray(r, i);
2810             }
2811         }
2812 
2813         assertArraysEquals(r, a, b, mask, Int64VectorTests::ROL);
2814     }
2815 
2816     static int ROR_unary(int a, int b) {
2817         return (int)(ROR_scalar(a, b));
2818     }
2819 
2820     @Test(dataProvider = "intBinaryOpProvider")
2821     static void RORInt64VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2822         int[] a = fa.apply(SPECIES.length());
2823         int[] b = fb.apply(SPECIES.length());
2824         int[] r = fr.apply(SPECIES.length());
2825 
2826         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2827             for (int i = 0; i < a.length; i += SPECIES.length()) {
2828                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2829                 av.lanewise(VectorOperators.ROR, (int)b[i]).intoArray(r, i);
2830             }
2831         }
2832 
2833         assertShiftArraysEquals(r, a, b, Int64VectorTests::ROR_unary);
2834     }
2835 
2836     @Test(dataProvider = "intBinaryOpMaskProvider")
2837     static void RORInt64VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2838                                           IntFunction<boolean[]> fm) {
2839         int[] a = fa.apply(SPECIES.length());
2840         int[] b = fb.apply(SPECIES.length());
2841         int[] r = fr.apply(SPECIES.length());
2842         boolean[] mask = fm.apply(SPECIES.length());
2843         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2844 
2845         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2846             for (int i = 0; i < a.length; i += SPECIES.length()) {
2847                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2848                 av.lanewise(VectorOperators.ROR, (int)b[i], vmask).intoArray(r, i);
2849             }
2850         }
2851 
2852         assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::ROR_unary);
2853     }
2854 
2855     static int ROL_unary(int a, int b) {
2856         return (int)(ROL_scalar(a, b));
2857     }
2858 
2859     @Test(dataProvider = "intBinaryOpProvider")
2860     static void ROLInt64VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2861         int[] a = fa.apply(SPECIES.length());
2862         int[] b = fb.apply(SPECIES.length());
2863         int[] r = fr.apply(SPECIES.length());
2864 
2865         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2866             for (int i = 0; i < a.length; i += SPECIES.length()) {
2867                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2868                 av.lanewise(VectorOperators.ROL, (int)b[i]).intoArray(r, i);
2869             }
2870         }
2871 
2872         assertShiftArraysEquals(r, a, b, Int64VectorTests::ROL_unary);
2873     }
2874 
2875     @Test(dataProvider = "intBinaryOpMaskProvider")
2876     static void ROLInt64VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2877                                           IntFunction<boolean[]> fm) {
2878         int[] a = fa.apply(SPECIES.length());
2879         int[] b = fb.apply(SPECIES.length());
2880         int[] r = fr.apply(SPECIES.length());
2881         boolean[] mask = fm.apply(SPECIES.length());
2882         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2883 
2884         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2885             for (int i = 0; i < a.length; i += SPECIES.length()) {
2886                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2887                 av.lanewise(VectorOperators.ROL, (int)b[i], vmask).intoArray(r, i);
2888             }
2889         }
2890 
2891         assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::ROL_unary);
2892     }
2893     static int LSHR_binary_const(int a) {
2894         return (int)((a >>> CONST_SHIFT));
2895     }
2896 
2897     @Test(dataProvider = "intUnaryOpProvider")
2898     static void LSHRInt64VectorTestsScalarShiftConst(IntFunction<int[]> fa) {
2899         int[] a = fa.apply(SPECIES.length());
2900         int[] r = fr.apply(SPECIES.length());
2901 
2902         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2903             for (int i = 0; i < a.length; i += SPECIES.length()) {
2904                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2905                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT).intoArray(r, i);
2906             }
2907         }
2908 
2909         assertShiftConstEquals(r, a, Int64VectorTests::LSHR_binary_const);
2910     }
2911 
2912     @Test(dataProvider = "intUnaryOpMaskProvider")
2913     static void LSHRInt64VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
2914                                           IntFunction<boolean[]> fm) {
2915         int[] a = fa.apply(SPECIES.length());
2916         int[] r = fr.apply(SPECIES.length());
2917         boolean[] mask = fm.apply(SPECIES.length());
2918         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2919 
2920         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2921             for (int i = 0; i < a.length; i += SPECIES.length()) {
2922                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2923                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT, vmask).intoArray(r, i);
2924             }
2925         }
2926 
2927         assertShiftConstEquals(r, a, mask, Int64VectorTests::LSHR_binary_const);
2928     }
2929 
2930     static int LSHL_binary_const(int a) {
2931         return (int)((a << CONST_SHIFT));
2932     }
2933 
2934     @Test(dataProvider = "intUnaryOpProvider")
2935     static void LSHLInt64VectorTestsScalarShiftConst(IntFunction<int[]> fa) {
2936         int[] a = fa.apply(SPECIES.length());
2937         int[] r = fr.apply(SPECIES.length());
2938 
2939         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2940             for (int i = 0; i < a.length; i += SPECIES.length()) {
2941                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2942                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT).intoArray(r, i);
2943             }
2944         }
2945 
2946         assertShiftConstEquals(r, a, Int64VectorTests::LSHL_binary_const);
2947     }
2948 
2949     @Test(dataProvider = "intUnaryOpMaskProvider")
2950     static void LSHLInt64VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
2951                                           IntFunction<boolean[]> fm) {
2952         int[] a = fa.apply(SPECIES.length());
2953         int[] r = fr.apply(SPECIES.length());
2954         boolean[] mask = fm.apply(SPECIES.length());
2955         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2956 
2957         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2958             for (int i = 0; i < a.length; i += SPECIES.length()) {
2959                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2960                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT, vmask).intoArray(r, i);
2961             }
2962         }
2963 
2964         assertShiftConstEquals(r, a, mask, Int64VectorTests::LSHL_binary_const);
2965     }
2966 
2967     static int ASHR_binary_const(int a) {
2968         return (int)((a >> CONST_SHIFT));
2969     }
2970 
2971     @Test(dataProvider = "intUnaryOpProvider")
2972     static void ASHRInt64VectorTestsScalarShiftConst(IntFunction<int[]> fa) {
2973         int[] a = fa.apply(SPECIES.length());
2974         int[] r = fr.apply(SPECIES.length());
2975 
2976         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2977             for (int i = 0; i < a.length; i += SPECIES.length()) {
2978                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2979                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT).intoArray(r, i);
2980             }
2981         }
2982 
2983         assertShiftConstEquals(r, a, Int64VectorTests::ASHR_binary_const);
2984     }
2985 
2986     @Test(dataProvider = "intUnaryOpMaskProvider")
2987     static void ASHRInt64VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
2988                                           IntFunction<boolean[]> fm) {
2989         int[] a = fa.apply(SPECIES.length());
2990         int[] r = fr.apply(SPECIES.length());
2991         boolean[] mask = fm.apply(SPECIES.length());
2992         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2993 
2994         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2995             for (int i = 0; i < a.length; i += SPECIES.length()) {
2996                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2997                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT, vmask).intoArray(r, i);
2998             }
2999         }
3000 
3001         assertShiftConstEquals(r, a, mask, Int64VectorTests::ASHR_binary_const);
3002     }
3003 
3004     static int ROR_binary_const(int a) {
3005         return (int)(ROR_scalar(a, CONST_SHIFT));
3006     }
3007 
3008     @Test(dataProvider = "intUnaryOpProvider")
3009     static void RORInt64VectorTestsScalarShiftConst(IntFunction<int[]> fa) {
3010         int[] a = fa.apply(SPECIES.length());
3011         int[] r = fr.apply(SPECIES.length());
3012 
3013         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3014             for (int i = 0; i < a.length; i += SPECIES.length()) {
3015                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3016                 av.lanewise(VectorOperators.ROR, CONST_SHIFT).intoArray(r, i);
3017             }
3018         }
3019 
3020         assertShiftConstEquals(r, a, Int64VectorTests::ROR_binary_const);
3021     }
3022 
3023     @Test(dataProvider = "intUnaryOpMaskProvider")
3024     static void RORInt64VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
3025                                           IntFunction<boolean[]> fm) {
3026         int[] a = fa.apply(SPECIES.length());
3027         int[] r = fr.apply(SPECIES.length());
3028         boolean[] mask = fm.apply(SPECIES.length());
3029         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3030 
3031         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3032             for (int i = 0; i < a.length; i += SPECIES.length()) {
3033                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3034                 av.lanewise(VectorOperators.ROR, CONST_SHIFT, vmask).intoArray(r, i);
3035             }
3036         }
3037 
3038         assertShiftConstEquals(r, a, mask, Int64VectorTests::ROR_binary_const);
3039     }
3040 
3041     static int ROL_binary_const(int a) {
3042         return (int)(ROL_scalar(a, CONST_SHIFT));
3043     }
3044 
3045     @Test(dataProvider = "intUnaryOpProvider")
3046     static void ROLInt64VectorTestsScalarShiftConst(IntFunction<int[]> fa) {
3047         int[] a = fa.apply(SPECIES.length());
3048         int[] r = fr.apply(SPECIES.length());
3049 
3050         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3051             for (int i = 0; i < a.length; i += SPECIES.length()) {
3052                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3053                 av.lanewise(VectorOperators.ROL, CONST_SHIFT).intoArray(r, i);
3054             }
3055         }
3056 
3057         assertShiftConstEquals(r, a, Int64VectorTests::ROL_binary_const);
3058     }
3059 
3060     @Test(dataProvider = "intUnaryOpMaskProvider")
3061     static void ROLInt64VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
3062                                           IntFunction<boolean[]> fm) {
3063         int[] a = fa.apply(SPECIES.length());
3064         int[] r = fr.apply(SPECIES.length());
3065         boolean[] mask = fm.apply(SPECIES.length());
3066         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3067 
3068         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3069             for (int i = 0; i < a.length; i += SPECIES.length()) {
3070                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3071                 av.lanewise(VectorOperators.ROL, CONST_SHIFT, vmask).intoArray(r, i);
3072             }
3073         }
3074 
3075         assertShiftConstEquals(r, a, mask, Int64VectorTests::ROL_binary_const);
3076     }
3077 
3078 
3079     static IntVector bv_MIN = IntVector.broadcast(SPECIES, (int)10);
3080 
3081     @Test(dataProvider = "intUnaryOpProvider")
3082     static void MINInt64VectorTestsWithMemOp(IntFunction<int[]> fa) {
3083         int[] a = fa.apply(SPECIES.length());
3084         int[] r = fr.apply(SPECIES.length());
3085 
3086         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3087             for (int i = 0; i < a.length; i += SPECIES.length()) {
3088                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3089                 av.lanewise(VectorOperators.MIN, bv_MIN).intoArray(r, i);
3090             }
3091         }
3092 
3093         assertArraysEquals(r, a, (int)10, Int64VectorTests::MIN);
3094     }
3095 
3096     static IntVector bv_min = IntVector.broadcast(SPECIES, (int)10);
3097 
3098     @Test(dataProvider = "intUnaryOpProvider")
3099     static void minInt64VectorTestsWithMemOp(IntFunction<int[]> fa) {
3100         int[] a = fa.apply(SPECIES.length());
3101         int[] r = fr.apply(SPECIES.length());
3102 
3103         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3104             for (int i = 0; i < a.length; i += SPECIES.length()) {
3105                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3106                 av.min(bv_min).intoArray(r, i);
3107             }
3108         }
3109 
3110         assertArraysEquals(r, a, (int)10, Int64VectorTests::min);
3111     }
3112 
3113     static IntVector bv_MIN_M = IntVector.broadcast(SPECIES, (int)10);
3114 
3115     @Test(dataProvider = "intUnaryOpMaskProvider")
3116     static void MINInt64VectorTestsMaskedWithMemOp(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3117         int[] a = fa.apply(SPECIES.length());
3118         int[] r = fr.apply(SPECIES.length());
3119         boolean[] mask = fm.apply(SPECIES.length());
3120         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3121 
3122         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3123             for (int i = 0; i < a.length; i += SPECIES.length()) {
3124                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3125                 av.lanewise(VectorOperators.MIN, bv_MIN_M, vmask).intoArray(r, i);
3126             }
3127         }
3128 
3129         assertArraysEquals(r, a, (int)10, mask, Int64VectorTests::MIN);
3130     }
3131 
3132     static IntVector bv_MAX = IntVector.broadcast(SPECIES, (int)10);
3133 
3134     @Test(dataProvider = "intUnaryOpProvider")
3135     static void MAXInt64VectorTestsWithMemOp(IntFunction<int[]> fa) {
3136         int[] a = fa.apply(SPECIES.length());
3137         int[] r = fr.apply(SPECIES.length());
3138 
3139         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3140             for (int i = 0; i < a.length; i += SPECIES.length()) {
3141                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3142                 av.lanewise(VectorOperators.MAX, bv_MAX).intoArray(r, i);
3143             }
3144         }
3145 
3146         assertArraysEquals(r, a, (int)10, Int64VectorTests::MAX);
3147     }
3148 
3149     static IntVector bv_max = IntVector.broadcast(SPECIES, (int)10);
3150 
3151     @Test(dataProvider = "intUnaryOpProvider")
3152     static void maxInt64VectorTestsWithMemOp(IntFunction<int[]> fa) {
3153         int[] a = fa.apply(SPECIES.length());
3154         int[] r = fr.apply(SPECIES.length());
3155 
3156         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3157             for (int i = 0; i < a.length; i += SPECIES.length()) {
3158                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3159                 av.max(bv_max).intoArray(r, i);
3160             }
3161         }
3162 
3163         assertArraysEquals(r, a, (int)10, Int64VectorTests::max);
3164     }
3165 
3166     static IntVector bv_MAX_M = IntVector.broadcast(SPECIES, (int)10);
3167 
3168     @Test(dataProvider = "intUnaryOpMaskProvider")
3169     static void MAXInt64VectorTestsMaskedWithMemOp(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3170         int[] a = fa.apply(SPECIES.length());
3171         int[] r = fr.apply(SPECIES.length());
3172         boolean[] mask = fm.apply(SPECIES.length());
3173         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3174 
3175         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3176             for (int i = 0; i < a.length; i += SPECIES.length()) {
3177                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3178                 av.lanewise(VectorOperators.MAX, bv_MAX_M, vmask).intoArray(r, i);
3179             }
3180         }
3181 
3182         assertArraysEquals(r, a, (int)10, mask, Int64VectorTests::MAX);
3183     }
3184 
3185     static int MIN(int a, int b) {
3186         return (int)(Math.min(a, b));
3187     }
3188 
3189     @Test(dataProvider = "intBinaryOpProvider")
3190     static void MINInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3191         int[] a = fa.apply(SPECIES.length());
3192         int[] b = fb.apply(SPECIES.length());
3193         int[] r = fr.apply(SPECIES.length());
3194 
3195         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3196             for (int i = 0; i < a.length; i += SPECIES.length()) {
3197                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3198                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3199                 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
3200             }
3201         }
3202 
3203         assertArraysEquals(r, a, b, Int64VectorTests::MIN);
3204     }
3205 
3206     static int min(int a, int b) {
3207         return (int)(Math.min(a, b));
3208     }
3209 
3210     @Test(dataProvider = "intBinaryOpProvider")
3211     static void minInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3212         int[] a = fa.apply(SPECIES.length());
3213         int[] b = fb.apply(SPECIES.length());
3214         int[] r = fr.apply(SPECIES.length());
3215 
3216         for (int i = 0; i < a.length; i += SPECIES.length()) {
3217             IntVector av = IntVector.fromArray(SPECIES, a, i);
3218             IntVector bv = IntVector.fromArray(SPECIES, b, i);
3219             av.min(bv).intoArray(r, i);
3220         }
3221 
3222         assertArraysEquals(r, a, b, Int64VectorTests::min);
3223     }
3224 
3225     static int MAX(int a, int b) {
3226         return (int)(Math.max(a, b));
3227     }
3228 
3229     @Test(dataProvider = "intBinaryOpProvider")
3230     static void MAXInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3231         int[] a = fa.apply(SPECIES.length());
3232         int[] b = fb.apply(SPECIES.length());
3233         int[] r = fr.apply(SPECIES.length());
3234 
3235         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3236             for (int i = 0; i < a.length; i += SPECIES.length()) {
3237                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3238                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3239                 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
3240             }
3241         }
3242 
3243         assertArraysEquals(r, a, b, Int64VectorTests::MAX);
3244     }
3245 
3246     static int max(int a, int b) {
3247         return (int)(Math.max(a, b));
3248     }
3249 
3250     @Test(dataProvider = "intBinaryOpProvider")
3251     static void maxInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3252         int[] a = fa.apply(SPECIES.length());
3253         int[] b = fb.apply(SPECIES.length());
3254         int[] r = fr.apply(SPECIES.length());
3255 
3256         for (int i = 0; i < a.length; i += SPECIES.length()) {
3257             IntVector av = IntVector.fromArray(SPECIES, a, i);
3258             IntVector bv = IntVector.fromArray(SPECIES, b, i);
3259             av.max(bv).intoArray(r, i);
3260         }
3261 
3262         assertArraysEquals(r, a, b, Int64VectorTests::max);
3263     }
3264 
3265     static int UMIN(int a, int b) {
3266         return (int)(VectorMath.minUnsigned(a, b));
3267     }
3268 
3269     @Test(dataProvider = "intBinaryOpProvider")
3270     static void UMINInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3271         int[] a = fa.apply(SPECIES.length());
3272         int[] b = fb.apply(SPECIES.length());
3273         int[] r = fr.apply(SPECIES.length());
3274 
3275         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3276             for (int i = 0; i < a.length; i += SPECIES.length()) {
3277                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3278                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3279                 av.lanewise(VectorOperators.UMIN, bv).intoArray(r, i);
3280             }
3281         }
3282 
3283         assertArraysEquals(r, a, b, Int64VectorTests::UMIN);
3284     }
3285 
3286     @Test(dataProvider = "intBinaryOpMaskProvider")
3287     static void UMINInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3288                                           IntFunction<boolean[]> fm) {
3289         int[] a = fa.apply(SPECIES.length());
3290         int[] b = fb.apply(SPECIES.length());
3291         int[] r = fr.apply(SPECIES.length());
3292         boolean[] mask = fm.apply(SPECIES.length());
3293         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3294 
3295         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3296             for (int i = 0; i < a.length; i += SPECIES.length()) {
3297                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3298                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3299                 av.lanewise(VectorOperators.UMIN, bv, vmask).intoArray(r, i);
3300             }
3301         }
3302 
3303         assertArraysEquals(r, a, b, mask, Int64VectorTests::UMIN);
3304     }
3305 
3306     static int UMAX(int a, int b) {
3307         return (int)(VectorMath.maxUnsigned(a, b));
3308     }
3309 
3310     @Test(dataProvider = "intBinaryOpProvider")
3311     static void UMAXInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3312         int[] a = fa.apply(SPECIES.length());
3313         int[] b = fb.apply(SPECIES.length());
3314         int[] r = fr.apply(SPECIES.length());
3315 
3316         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3317             for (int i = 0; i < a.length; i += SPECIES.length()) {
3318                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3319                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3320                 av.lanewise(VectorOperators.UMAX, bv).intoArray(r, i);
3321             }
3322         }
3323 
3324         assertArraysEquals(r, a, b, Int64VectorTests::UMAX);
3325     }
3326 
3327     @Test(dataProvider = "intBinaryOpMaskProvider")
3328     static void UMAXInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3329                                           IntFunction<boolean[]> fm) {
3330         int[] a = fa.apply(SPECIES.length());
3331         int[] b = fb.apply(SPECIES.length());
3332         int[] r = fr.apply(SPECIES.length());
3333         boolean[] mask = fm.apply(SPECIES.length());
3334         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3335 
3336         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3337             for (int i = 0; i < a.length; i += SPECIES.length()) {
3338                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3339                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3340                 av.lanewise(VectorOperators.UMAX, bv, vmask).intoArray(r, i);
3341             }
3342         }
3343 
3344         assertArraysEquals(r, a, b, mask, Int64VectorTests::UMAX);
3345     }
3346 
3347     static int SADD(int a, int b) {
3348         return (int)(VectorMath.addSaturating(a, b));
3349     }
3350 
3351     @Test(dataProvider = "intSaturatingBinaryOpProvider")
3352     static void SADDInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3353         int[] a = fa.apply(SPECIES.length());
3354         int[] b = fb.apply(SPECIES.length());
3355         int[] r = fr.apply(SPECIES.length());
3356 
3357         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3358             for (int i = 0; i < a.length; i += SPECIES.length()) {
3359                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3360                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3361                 av.lanewise(VectorOperators.SADD, bv).intoArray(r, i);
3362             }
3363         }
3364 
3365         assertArraysEquals(r, a, b, Int64VectorTests::SADD);
3366     }
3367 
3368     @Test(dataProvider = "intSaturatingBinaryOpMaskProvider")
3369     static void SADDInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3370                                           IntFunction<boolean[]> fm) {
3371         int[] a = fa.apply(SPECIES.length());
3372         int[] b = fb.apply(SPECIES.length());
3373         int[] r = fr.apply(SPECIES.length());
3374         boolean[] mask = fm.apply(SPECIES.length());
3375         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3376 
3377         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3378             for (int i = 0; i < a.length; i += SPECIES.length()) {
3379                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3380                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3381                 av.lanewise(VectorOperators.SADD, bv, vmask).intoArray(r, i);
3382             }
3383         }
3384 
3385         assertArraysEquals(r, a, b, mask, Int64VectorTests::SADD);
3386     }
3387 
3388     static int SSUB(int a, int b) {
3389         return (int)(VectorMath.subSaturating(a, b));
3390     }
3391 
3392     @Test(dataProvider = "intSaturatingBinaryOpProvider")
3393     static void SSUBInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3394         int[] a = fa.apply(SPECIES.length());
3395         int[] b = fb.apply(SPECIES.length());
3396         int[] r = fr.apply(SPECIES.length());
3397 
3398         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3399             for (int i = 0; i < a.length; i += SPECIES.length()) {
3400                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3401                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3402                 av.lanewise(VectorOperators.SSUB, bv).intoArray(r, i);
3403             }
3404         }
3405 
3406         assertArraysEquals(r, a, b, Int64VectorTests::SSUB);
3407     }
3408 
3409     @Test(dataProvider = "intSaturatingBinaryOpMaskProvider")
3410     static void SSUBInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3411                                           IntFunction<boolean[]> fm) {
3412         int[] a = fa.apply(SPECIES.length());
3413         int[] b = fb.apply(SPECIES.length());
3414         int[] r = fr.apply(SPECIES.length());
3415         boolean[] mask = fm.apply(SPECIES.length());
3416         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3417 
3418         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3419             for (int i = 0; i < a.length; i += SPECIES.length()) {
3420                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3421                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3422                 av.lanewise(VectorOperators.SSUB, bv, vmask).intoArray(r, i);
3423             }
3424         }
3425 
3426         assertArraysEquals(r, a, b, mask, Int64VectorTests::SSUB);
3427     }
3428 
3429     static int SUADD(int a, int b) {
3430         return (int)(VectorMath.addSaturatingUnsigned(a, b));
3431     }
3432 
3433     @Test(dataProvider = "intSaturatingBinaryOpProvider")
3434     static void SUADDInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3435         int[] a = fa.apply(SPECIES.length());
3436         int[] b = fb.apply(SPECIES.length());
3437         int[] r = fr.apply(SPECIES.length());
3438 
3439         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3440             for (int i = 0; i < a.length; i += SPECIES.length()) {
3441                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3442                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3443                 av.lanewise(VectorOperators.SUADD, bv).intoArray(r, i);
3444             }
3445         }
3446 
3447         assertArraysEquals(r, a, b, Int64VectorTests::SUADD);
3448     }
3449 
3450     @Test(dataProvider = "intSaturatingBinaryOpMaskProvider")
3451     static void SUADDInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3452                                           IntFunction<boolean[]> fm) {
3453         int[] a = fa.apply(SPECIES.length());
3454         int[] b = fb.apply(SPECIES.length());
3455         int[] r = fr.apply(SPECIES.length());
3456         boolean[] mask = fm.apply(SPECIES.length());
3457         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3458 
3459         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3460             for (int i = 0; i < a.length; i += SPECIES.length()) {
3461                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3462                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3463                 av.lanewise(VectorOperators.SUADD, bv, vmask).intoArray(r, i);
3464             }
3465         }
3466 
3467         assertArraysEquals(r, a, b, mask, Int64VectorTests::SUADD);
3468     }
3469 
3470     static int SUSUB(int a, int b) {
3471         return (int)(VectorMath.subSaturatingUnsigned(a, b));
3472     }
3473 
3474     @Test(dataProvider = "intSaturatingBinaryOpProvider")
3475     static void SUSUBInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3476         int[] a = fa.apply(SPECIES.length());
3477         int[] b = fb.apply(SPECIES.length());
3478         int[] r = fr.apply(SPECIES.length());
3479 
3480         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3481             for (int i = 0; i < a.length; i += SPECIES.length()) {
3482                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3483                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3484                 av.lanewise(VectorOperators.SUSUB, bv).intoArray(r, i);
3485             }
3486         }
3487 
3488         assertArraysEquals(r, a, b, Int64VectorTests::SUSUB);
3489     }
3490 
3491     @Test(dataProvider = "intSaturatingBinaryOpMaskProvider")
3492     static void SUSUBInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3493                                           IntFunction<boolean[]> fm) {
3494         int[] a = fa.apply(SPECIES.length());
3495         int[] b = fb.apply(SPECIES.length());
3496         int[] r = fr.apply(SPECIES.length());
3497         boolean[] mask = fm.apply(SPECIES.length());
3498         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3499 
3500         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3501             for (int i = 0; i < a.length; i += SPECIES.length()) {
3502                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3503                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3504                 av.lanewise(VectorOperators.SUSUB, bv, vmask).intoArray(r, i);
3505             }
3506         }
3507 
3508         assertArraysEquals(r, a, b, mask, Int64VectorTests::SUSUB);
3509     }
3510 
3511     @Test(dataProvider = "intBinaryOpProvider")
3512     static void MINInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3513         int[] a = fa.apply(SPECIES.length());
3514         int[] b = fb.apply(SPECIES.length());
3515         int[] r = fr.apply(SPECIES.length());
3516 
3517         for (int i = 0; i < a.length; i += SPECIES.length()) {
3518             IntVector av = IntVector.fromArray(SPECIES, a, i);
3519             av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
3520         }
3521 
3522         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::MIN);
3523     }
3524 
3525     @Test(dataProvider = "intBinaryOpProvider")
3526     static void minInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3527         int[] a = fa.apply(SPECIES.length());
3528         int[] b = fb.apply(SPECIES.length());
3529         int[] r = fr.apply(SPECIES.length());
3530 
3531         for (int i = 0; i < a.length; i += SPECIES.length()) {
3532             IntVector av = IntVector.fromArray(SPECIES, a, i);
3533             av.min(b[i]).intoArray(r, i);
3534         }
3535 
3536         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::min);
3537     }
3538 
3539     @Test(dataProvider = "intBinaryOpProvider")
3540     static void MAXInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3541         int[] a = fa.apply(SPECIES.length());
3542         int[] b = fb.apply(SPECIES.length());
3543         int[] r = fr.apply(SPECIES.length());
3544 
3545         for (int i = 0; i < a.length; i += SPECIES.length()) {
3546             IntVector av = IntVector.fromArray(SPECIES, a, i);
3547             av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
3548         }
3549 
3550         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::MAX);
3551     }
3552 
3553     @Test(dataProvider = "intBinaryOpProvider")
3554     static void maxInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3555         int[] a = fa.apply(SPECIES.length());
3556         int[] b = fb.apply(SPECIES.length());
3557         int[] r = fr.apply(SPECIES.length());
3558 
3559         for (int i = 0; i < a.length; i += SPECIES.length()) {
3560             IntVector av = IntVector.fromArray(SPECIES, a, i);
3561             av.max(b[i]).intoArray(r, i);
3562         }
3563 
3564         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::max);
3565     }
3566     @Test(dataProvider = "intSaturatingBinaryOpAssocProvider")
3567     static void SUADDAssocInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
3568         int[] a = fa.apply(SPECIES.length());
3569         int[] b = fb.apply(SPECIES.length());
3570         int[] c = fc.apply(SPECIES.length());
3571         int[] rl = fr.apply(SPECIES.length());
3572         int[] rr = fr.apply(SPECIES.length());
3573 
3574         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3575             for (int i = 0; i < a.length; i += SPECIES.length()) {
3576                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3577                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3578                 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3579                 av.lanewise(VectorOperators.SUADD, bv).lanewise(VectorOperators.SUADD, cv).intoArray(rl, i);
3580                 av.lanewise(VectorOperators.SUADD, bv.lanewise(VectorOperators.SUADD, cv)).intoArray(rr, i);
3581             }
3582         }
3583 
3584         assertArraysEqualsAssociative(rl, rr, a, b, c, Int64VectorTests::SUADD);
3585     }
3586 
3587     @Test(dataProvider = "intSaturatingBinaryOpAssocMaskProvider")
3588     static void SUADDAssocInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3589                                                      IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
3590         int[] a = fa.apply(SPECIES.length());
3591         int[] b = fb.apply(SPECIES.length());
3592         int[] c = fc.apply(SPECIES.length());
3593         boolean[] mask = fm.apply(SPECIES.length());
3594         int[] rl = fr.apply(SPECIES.length());
3595         int[] rr = fr.apply(SPECIES.length());
3596 
3597         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3598 
3599         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3600             for (int i = 0; i < a.length; i += SPECIES.length()) {
3601                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3602                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3603                 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3604                 av.lanewise(VectorOperators.SUADD, bv, vmask).lanewise(VectorOperators.SUADD, cv, vmask).intoArray(rl, i);
3605                 av.lanewise(VectorOperators.SUADD, bv.lanewise(VectorOperators.SUADD, cv, vmask), vmask).intoArray(rr, i);
3606             }
3607         }
3608 
3609         assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Int64VectorTests::SUADD);
3610     }
3611 
3612     static int ANDReduce(int[] a, int idx) {
3613         int res = -1;
3614         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3615             res &= a[i];
3616         }
3617 
3618         return res;
3619     }
3620 
3621     static int ANDReduceAll(int[] a) {
3622         int res = -1;
3623         for (int i = 0; i < a.length; i += SPECIES.length()) {
3624             res &= ANDReduce(a, i);
3625         }
3626 
3627         return res;
3628     }
3629 
3630     @Test(dataProvider = "intUnaryOpProvider")
3631     static void ANDReduceInt64VectorTests(IntFunction<int[]> fa) {
3632         int[] a = fa.apply(SPECIES.length());
3633         int[] r = fr.apply(SPECIES.length());
3634         int ra = -1;
3635 
3636         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3637             for (int i = 0; i < a.length; i += SPECIES.length()) {
3638                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3639                 r[i] = av.reduceLanes(VectorOperators.AND);
3640             }
3641         }
3642 
3643         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3644             ra = -1;
3645             for (int i = 0; i < a.length; i += SPECIES.length()) {
3646                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3647                 ra &= av.reduceLanes(VectorOperators.AND);
3648             }
3649         }
3650 
3651         assertReductionArraysEquals(r, ra, a,
3652                 Int64VectorTests::ANDReduce, Int64VectorTests::ANDReduceAll);
3653     }
3654 
3655     static int ANDReduceMasked(int[] a, int idx, boolean[] mask) {
3656         int res = -1;
3657         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3658             if (mask[i % SPECIES.length()])
3659                 res &= a[i];
3660         }
3661 
3662         return res;
3663     }
3664 
3665     static int ANDReduceAllMasked(int[] a, boolean[] mask) {
3666         int res = -1;
3667         for (int i = 0; i < a.length; i += SPECIES.length()) {
3668             res &= ANDReduceMasked(a, i, mask);
3669         }
3670 
3671         return res;
3672     }
3673 
3674     @Test(dataProvider = "intUnaryOpMaskProvider")
3675     static void ANDReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3676         int[] a = fa.apply(SPECIES.length());
3677         int[] r = fr.apply(SPECIES.length());
3678         boolean[] mask = fm.apply(SPECIES.length());
3679         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3680         int ra = -1;
3681 
3682         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3683             for (int i = 0; i < a.length; i += SPECIES.length()) {
3684                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3685                 r[i] = av.reduceLanes(VectorOperators.AND, vmask);
3686             }
3687         }
3688 
3689         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3690             ra = -1;
3691             for (int i = 0; i < a.length; i += SPECIES.length()) {
3692                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3693                 ra &= av.reduceLanes(VectorOperators.AND, vmask);
3694             }
3695         }
3696 
3697         assertReductionArraysEqualsMasked(r, ra, a, mask,
3698                 Int64VectorTests::ANDReduceMasked, Int64VectorTests::ANDReduceAllMasked);
3699     }
3700 
3701     static int ORReduce(int[] a, int idx) {
3702         int res = 0;
3703         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3704             res |= a[i];
3705         }
3706 
3707         return res;
3708     }
3709 
3710     static int ORReduceAll(int[] a) {
3711         int res = 0;
3712         for (int i = 0; i < a.length; i += SPECIES.length()) {
3713             res |= ORReduce(a, i);
3714         }
3715 
3716         return res;
3717     }
3718 
3719     @Test(dataProvider = "intUnaryOpProvider")
3720     static void ORReduceInt64VectorTests(IntFunction<int[]> fa) {
3721         int[] a = fa.apply(SPECIES.length());
3722         int[] r = fr.apply(SPECIES.length());
3723         int ra = 0;
3724 
3725         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3726             for (int i = 0; i < a.length; i += SPECIES.length()) {
3727                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3728                 r[i] = av.reduceLanes(VectorOperators.OR);
3729             }
3730         }
3731 
3732         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3733             ra = 0;
3734             for (int i = 0; i < a.length; i += SPECIES.length()) {
3735                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3736                 ra |= av.reduceLanes(VectorOperators.OR);
3737             }
3738         }
3739 
3740         assertReductionArraysEquals(r, ra, a,
3741                 Int64VectorTests::ORReduce, Int64VectorTests::ORReduceAll);
3742     }
3743 
3744     static int ORReduceMasked(int[] a, int idx, boolean[] mask) {
3745         int res = 0;
3746         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3747             if (mask[i % SPECIES.length()])
3748                 res |= a[i];
3749         }
3750 
3751         return res;
3752     }
3753 
3754     static int ORReduceAllMasked(int[] a, boolean[] mask) {
3755         int res = 0;
3756         for (int i = 0; i < a.length; i += SPECIES.length()) {
3757             res |= ORReduceMasked(a, i, mask);
3758         }
3759 
3760         return res;
3761     }
3762 
3763     @Test(dataProvider = "intUnaryOpMaskProvider")
3764     static void ORReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3765         int[] a = fa.apply(SPECIES.length());
3766         int[] r = fr.apply(SPECIES.length());
3767         boolean[] mask = fm.apply(SPECIES.length());
3768         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3769         int ra = 0;
3770 
3771         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3772             for (int i = 0; i < a.length; i += SPECIES.length()) {
3773                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3774                 r[i] = av.reduceLanes(VectorOperators.OR, vmask);
3775             }
3776         }
3777 
3778         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3779             ra = 0;
3780             for (int i = 0; i < a.length; i += SPECIES.length()) {
3781                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3782                 ra |= av.reduceLanes(VectorOperators.OR, vmask);
3783             }
3784         }
3785 
3786         assertReductionArraysEqualsMasked(r, ra, a, mask,
3787                 Int64VectorTests::ORReduceMasked, Int64VectorTests::ORReduceAllMasked);
3788     }
3789 
3790     static int XORReduce(int[] a, int idx) {
3791         int res = 0;
3792         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3793             res ^= a[i];
3794         }
3795 
3796         return res;
3797     }
3798 
3799     static int XORReduceAll(int[] a) {
3800         int res = 0;
3801         for (int i = 0; i < a.length; i += SPECIES.length()) {
3802             res ^= XORReduce(a, i);
3803         }
3804 
3805         return res;
3806     }
3807 
3808     @Test(dataProvider = "intUnaryOpProvider")
3809     static void XORReduceInt64VectorTests(IntFunction<int[]> fa) {
3810         int[] a = fa.apply(SPECIES.length());
3811         int[] r = fr.apply(SPECIES.length());
3812         int ra = 0;
3813 
3814         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3815             for (int i = 0; i < a.length; i += SPECIES.length()) {
3816                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3817                 r[i] = av.reduceLanes(VectorOperators.XOR);
3818             }
3819         }
3820 
3821         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3822             ra = 0;
3823             for (int i = 0; i < a.length; i += SPECIES.length()) {
3824                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3825                 ra ^= av.reduceLanes(VectorOperators.XOR);
3826             }
3827         }
3828 
3829         assertReductionArraysEquals(r, ra, a,
3830                 Int64VectorTests::XORReduce, Int64VectorTests::XORReduceAll);
3831     }
3832 
3833     static int XORReduceMasked(int[] a, int idx, boolean[] mask) {
3834         int res = 0;
3835         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3836             if (mask[i % SPECIES.length()])
3837                 res ^= a[i];
3838         }
3839 
3840         return res;
3841     }
3842 
3843     static int XORReduceAllMasked(int[] a, boolean[] mask) {
3844         int res = 0;
3845         for (int i = 0; i < a.length; i += SPECIES.length()) {
3846             res ^= XORReduceMasked(a, i, mask);
3847         }
3848 
3849         return res;
3850     }
3851 
3852     @Test(dataProvider = "intUnaryOpMaskProvider")
3853     static void XORReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3854         int[] a = fa.apply(SPECIES.length());
3855         int[] r = fr.apply(SPECIES.length());
3856         boolean[] mask = fm.apply(SPECIES.length());
3857         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3858         int ra = 0;
3859 
3860         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3861             for (int i = 0; i < a.length; i += SPECIES.length()) {
3862                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3863                 r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
3864             }
3865         }
3866 
3867         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3868             ra = 0;
3869             for (int i = 0; i < a.length; i += SPECIES.length()) {
3870                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3871                 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
3872             }
3873         }
3874 
3875         assertReductionArraysEqualsMasked(r, ra, a, mask,
3876                 Int64VectorTests::XORReduceMasked, Int64VectorTests::XORReduceAllMasked);
3877     }
3878 
3879     static int ADDReduce(int[] a, int idx) {
3880         int res = 0;
3881         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3882             res += a[i];
3883         }
3884 
3885         return res;
3886     }
3887 
3888     static int ADDReduceAll(int[] a) {
3889         int res = 0;
3890         for (int i = 0; i < a.length; i += SPECIES.length()) {
3891             res += ADDReduce(a, i);
3892         }
3893 
3894         return res;
3895     }
3896 
3897     @Test(dataProvider = "intUnaryOpProvider")
3898     static void ADDReduceInt64VectorTests(IntFunction<int[]> fa) {
3899         int[] a = fa.apply(SPECIES.length());
3900         int[] r = fr.apply(SPECIES.length());
3901         int ra = 0;
3902 
3903         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3904             for (int i = 0; i < a.length; i += SPECIES.length()) {
3905                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3906                 r[i] = av.reduceLanes(VectorOperators.ADD);
3907             }
3908         }
3909 
3910         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3911             ra = 0;
3912             for (int i = 0; i < a.length; i += SPECIES.length()) {
3913                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3914                 ra += av.reduceLanes(VectorOperators.ADD);
3915             }
3916         }
3917 
3918         assertReductionArraysEquals(r, ra, a,
3919                 Int64VectorTests::ADDReduce, Int64VectorTests::ADDReduceAll);
3920     }
3921 
3922     static int ADDReduceMasked(int[] a, int idx, boolean[] mask) {
3923         int res = 0;
3924         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3925             if (mask[i % SPECIES.length()])
3926                 res += a[i];
3927         }
3928 
3929         return res;
3930     }
3931 
3932     static int ADDReduceAllMasked(int[] a, boolean[] mask) {
3933         int res = 0;
3934         for (int i = 0; i < a.length; i += SPECIES.length()) {
3935             res += ADDReduceMasked(a, i, mask);
3936         }
3937 
3938         return res;
3939     }
3940 
3941     @Test(dataProvider = "intUnaryOpMaskProvider")
3942     static void ADDReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3943         int[] a = fa.apply(SPECIES.length());
3944         int[] r = fr.apply(SPECIES.length());
3945         boolean[] mask = fm.apply(SPECIES.length());
3946         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3947         int ra = 0;
3948 
3949         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3950             for (int i = 0; i < a.length; i += SPECIES.length()) {
3951                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3952                 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
3953             }
3954         }
3955 
3956         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3957             ra = 0;
3958             for (int i = 0; i < a.length; i += SPECIES.length()) {
3959                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3960                 ra += av.reduceLanes(VectorOperators.ADD, vmask);
3961             }
3962         }
3963 
3964         assertReductionArraysEqualsMasked(r, ra, a, mask,
3965                 Int64VectorTests::ADDReduceMasked, Int64VectorTests::ADDReduceAllMasked);
3966     }
3967 
3968     static int MULReduce(int[] a, int idx) {
3969         int res = 1;
3970         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3971             res *= a[i];
3972         }
3973 
3974         return res;
3975     }
3976 
3977     static int MULReduceAll(int[] a) {
3978         int res = 1;
3979         for (int i = 0; i < a.length; i += SPECIES.length()) {
3980             res *= MULReduce(a, i);
3981         }
3982 
3983         return res;
3984     }
3985 
3986     @Test(dataProvider = "intUnaryOpProvider")
3987     static void MULReduceInt64VectorTests(IntFunction<int[]> fa) {
3988         int[] a = fa.apply(SPECIES.length());
3989         int[] r = fr.apply(SPECIES.length());
3990         int ra = 1;
3991 
3992         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3993             for (int i = 0; i < a.length; i += SPECIES.length()) {
3994                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3995                 r[i] = av.reduceLanes(VectorOperators.MUL);
3996             }
3997         }
3998 
3999         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4000             ra = 1;
4001             for (int i = 0; i < a.length; i += SPECIES.length()) {
4002                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4003                 ra *= av.reduceLanes(VectorOperators.MUL);
4004             }
4005         }
4006 
4007         assertReductionArraysEquals(r, ra, a,
4008                 Int64VectorTests::MULReduce, Int64VectorTests::MULReduceAll);
4009     }
4010 
4011     static int MULReduceMasked(int[] a, int idx, boolean[] mask) {
4012         int res = 1;
4013         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4014             if (mask[i % SPECIES.length()])
4015                 res *= a[i];
4016         }
4017 
4018         return res;
4019     }
4020 
4021     static int MULReduceAllMasked(int[] a, boolean[] mask) {
4022         int res = 1;
4023         for (int i = 0; i < a.length; i += SPECIES.length()) {
4024             res *= MULReduceMasked(a, i, mask);
4025         }
4026 
4027         return res;
4028     }
4029 
4030     @Test(dataProvider = "intUnaryOpMaskProvider")
4031     static void MULReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4032         int[] a = fa.apply(SPECIES.length());
4033         int[] r = fr.apply(SPECIES.length());
4034         boolean[] mask = fm.apply(SPECIES.length());
4035         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4036         int ra = 1;
4037 
4038         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4039             for (int i = 0; i < a.length; i += SPECIES.length()) {
4040                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4041                 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
4042             }
4043         }
4044 
4045         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4046             ra = 1;
4047             for (int i = 0; i < a.length; i += SPECIES.length()) {
4048                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4049                 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
4050             }
4051         }
4052 
4053         assertReductionArraysEqualsMasked(r, ra, a, mask,
4054                 Int64VectorTests::MULReduceMasked, Int64VectorTests::MULReduceAllMasked);
4055     }
4056 
4057     static int MINReduce(int[] a, int idx) {
4058         int res = Integer.MAX_VALUE;
4059         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4060             res = (int) Math.min(res, a[i]);
4061         }
4062 
4063         return res;
4064     }
4065 
4066     static int MINReduceAll(int[] a) {
4067         int res = Integer.MAX_VALUE;
4068         for (int i = 0; i < a.length; i += SPECIES.length()) {
4069             res = (int) Math.min(res, MINReduce(a, i));
4070         }
4071 
4072         return res;
4073     }
4074 
4075     @Test(dataProvider = "intUnaryOpProvider")
4076     static void MINReduceInt64VectorTests(IntFunction<int[]> fa) {
4077         int[] a = fa.apply(SPECIES.length());
4078         int[] r = fr.apply(SPECIES.length());
4079         int ra = Integer.MAX_VALUE;
4080 
4081         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4082             for (int i = 0; i < a.length; i += SPECIES.length()) {
4083                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4084                 r[i] = av.reduceLanes(VectorOperators.MIN);
4085             }
4086         }
4087 
4088         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4089             ra = Integer.MAX_VALUE;
4090             for (int i = 0; i < a.length; i += SPECIES.length()) {
4091                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4092                 ra = (int) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
4093             }
4094         }
4095 
4096         assertReductionArraysEquals(r, ra, a,
4097                 Int64VectorTests::MINReduce, Int64VectorTests::MINReduceAll);
4098     }
4099 
4100     static int MINReduceMasked(int[] a, int idx, boolean[] mask) {
4101         int res = Integer.MAX_VALUE;
4102         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4103             if (mask[i % SPECIES.length()])
4104                 res = (int) Math.min(res, a[i]);
4105         }
4106 
4107         return res;
4108     }
4109 
4110     static int MINReduceAllMasked(int[] a, boolean[] mask) {
4111         int res = Integer.MAX_VALUE;
4112         for (int i = 0; i < a.length; i += SPECIES.length()) {
4113             res = (int) Math.min(res, MINReduceMasked(a, i, mask));
4114         }
4115 
4116         return res;
4117     }
4118 
4119     @Test(dataProvider = "intUnaryOpMaskProvider")
4120     static void MINReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4121         int[] a = fa.apply(SPECIES.length());
4122         int[] r = fr.apply(SPECIES.length());
4123         boolean[] mask = fm.apply(SPECIES.length());
4124         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4125         int ra = Integer.MAX_VALUE;
4126 
4127         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4128             for (int i = 0; i < a.length; i += SPECIES.length()) {
4129                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4130                 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
4131             }
4132         }
4133 
4134         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4135             ra = Integer.MAX_VALUE;
4136             for (int i = 0; i < a.length; i += SPECIES.length()) {
4137                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4138                 ra = (int) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
4139             }
4140         }
4141 
4142         assertReductionArraysEqualsMasked(r, ra, a, mask,
4143                 Int64VectorTests::MINReduceMasked, Int64VectorTests::MINReduceAllMasked);
4144     }
4145 
4146     static int MAXReduce(int[] a, int idx) {
4147         int res = Integer.MIN_VALUE;
4148         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4149             res = (int) Math.max(res, a[i]);
4150         }
4151 
4152         return res;
4153     }
4154 
4155     static int MAXReduceAll(int[] a) {
4156         int res = Integer.MIN_VALUE;
4157         for (int i = 0; i < a.length; i += SPECIES.length()) {
4158             res = (int) Math.max(res, MAXReduce(a, i));
4159         }
4160 
4161         return res;
4162     }
4163 
4164     @Test(dataProvider = "intUnaryOpProvider")
4165     static void MAXReduceInt64VectorTests(IntFunction<int[]> fa) {
4166         int[] a = fa.apply(SPECIES.length());
4167         int[] r = fr.apply(SPECIES.length());
4168         int ra = Integer.MIN_VALUE;
4169 
4170         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4171             for (int i = 0; i < a.length; i += SPECIES.length()) {
4172                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4173                 r[i] = av.reduceLanes(VectorOperators.MAX);
4174             }
4175         }
4176 
4177         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4178             ra = Integer.MIN_VALUE;
4179             for (int i = 0; i < a.length; i += SPECIES.length()) {
4180                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4181                 ra = (int) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
4182             }
4183         }
4184 
4185         assertReductionArraysEquals(r, ra, a,
4186                 Int64VectorTests::MAXReduce, Int64VectorTests::MAXReduceAll);
4187     }
4188 
4189     static int MAXReduceMasked(int[] a, int idx, boolean[] mask) {
4190         int res = Integer.MIN_VALUE;
4191         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4192             if (mask[i % SPECIES.length()])
4193                 res = (int) Math.max(res, a[i]);
4194         }
4195 
4196         return res;
4197     }
4198 
4199     static int MAXReduceAllMasked(int[] a, boolean[] mask) {
4200         int res = Integer.MIN_VALUE;
4201         for (int i = 0; i < a.length; i += SPECIES.length()) {
4202             res = (int) Math.max(res, MAXReduceMasked(a, i, mask));
4203         }
4204 
4205         return res;
4206     }
4207 
4208     @Test(dataProvider = "intUnaryOpMaskProvider")
4209     static void MAXReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4210         int[] a = fa.apply(SPECIES.length());
4211         int[] r = fr.apply(SPECIES.length());
4212         boolean[] mask = fm.apply(SPECIES.length());
4213         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4214         int ra = Integer.MIN_VALUE;
4215 
4216         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4217             for (int i = 0; i < a.length; i += SPECIES.length()) {
4218                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4219                 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
4220             }
4221         }
4222 
4223         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4224             ra = Integer.MIN_VALUE;
4225             for (int i = 0; i < a.length; i += SPECIES.length()) {
4226                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4227                 ra = (int) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
4228             }
4229         }
4230 
4231         assertReductionArraysEqualsMasked(r, ra, a, mask,
4232                 Int64VectorTests::MAXReduceMasked, Int64VectorTests::MAXReduceAllMasked);
4233     }
4234 
4235     static int UMINReduce(int[] a, int idx) {
4236         int res = Integer.MAX_VALUE;
4237         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4238             res = (int) VectorMath.minUnsigned(res, a[i]);
4239         }
4240 
4241         return res;
4242     }
4243 
4244     static int UMINReduceAll(int[] a) {
4245         int res = Integer.MAX_VALUE;
4246         for (int i = 0; i < a.length; i += SPECIES.length()) {
4247             res = (int) VectorMath.minUnsigned(res, UMINReduce(a, i));
4248         }
4249 
4250         return res;
4251     }
4252 
4253     @Test(dataProvider = "intUnaryOpProvider")
4254     static void UMINReduceInt64VectorTests(IntFunction<int[]> fa) {
4255         int[] a = fa.apply(SPECIES.length());
4256         int[] r = fr.apply(SPECIES.length());
4257         int ra = Integer.MAX_VALUE;
4258 
4259         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4260             for (int i = 0; i < a.length; i += SPECIES.length()) {
4261                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4262                 r[i] = av.reduceLanes(VectorOperators.UMIN);
4263             }
4264         }
4265 
4266         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4267             ra = Integer.MAX_VALUE;
4268             for (int i = 0; i < a.length; i += SPECIES.length()) {
4269                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4270                 ra = (int) VectorMath.minUnsigned(ra, av.reduceLanes(VectorOperators.UMIN));
4271             }
4272         }
4273 
4274         assertReductionArraysEquals(r, ra, a,
4275                 Int64VectorTests::UMINReduce, Int64VectorTests::UMINReduceAll);
4276     }
4277 
4278     static int UMINReduceMasked(int[] a, int idx, boolean[] mask) {
4279         int res = Integer.MAX_VALUE;
4280         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4281             if (mask[i % SPECIES.length()])
4282                 res = (int) VectorMath.minUnsigned(res, a[i]);
4283         }
4284 
4285         return res;
4286     }
4287 
4288     static int UMINReduceAllMasked(int[] a, boolean[] mask) {
4289         int res = Integer.MAX_VALUE;
4290         for (int i = 0; i < a.length; i += SPECIES.length()) {
4291             res = (int) VectorMath.minUnsigned(res, UMINReduceMasked(a, i, mask));
4292         }
4293 
4294         return res;
4295     }
4296 
4297     @Test(dataProvider = "intUnaryOpMaskProvider")
4298     static void UMINReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4299         int[] a = fa.apply(SPECIES.length());
4300         int[] r = fr.apply(SPECIES.length());
4301         boolean[] mask = fm.apply(SPECIES.length());
4302         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4303         int ra = Integer.MAX_VALUE;
4304 
4305         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4306             for (int i = 0; i < a.length; i += SPECIES.length()) {
4307                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4308                 r[i] = av.reduceLanes(VectorOperators.UMIN, vmask);
4309             }
4310         }
4311 
4312         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4313             ra = Integer.MAX_VALUE;
4314             for (int i = 0; i < a.length; i += SPECIES.length()) {
4315                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4316                 ra = (int) VectorMath.minUnsigned(ra, av.reduceLanes(VectorOperators.UMIN, vmask));
4317             }
4318         }
4319 
4320         assertReductionArraysEqualsMasked(r, ra, a, mask,
4321                 Int64VectorTests::UMINReduceMasked, Int64VectorTests::UMINReduceAllMasked);
4322     }
4323 
4324     static int UMAXReduce(int[] a, int idx) {
4325         int res = Integer.MIN_VALUE;
4326         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4327             res = (int) VectorMath.maxUnsigned(res, a[i]);
4328         }
4329 
4330         return res;
4331     }
4332 
4333     static int UMAXReduceAll(int[] a) {
4334         int res = Integer.MIN_VALUE;
4335         for (int i = 0; i < a.length; i += SPECIES.length()) {
4336             res = (int) VectorMath.maxUnsigned(res, UMAXReduce(a, i));
4337         }
4338 
4339         return res;
4340     }
4341 
4342     @Test(dataProvider = "intUnaryOpProvider")
4343     static void UMAXReduceInt64VectorTests(IntFunction<int[]> fa) {
4344         int[] a = fa.apply(SPECIES.length());
4345         int[] r = fr.apply(SPECIES.length());
4346         int ra = Integer.MIN_VALUE;
4347 
4348         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4349             for (int i = 0; i < a.length; i += SPECIES.length()) {
4350                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4351                 r[i] = av.reduceLanes(VectorOperators.UMAX);
4352             }
4353         }
4354 
4355         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4356             ra = Integer.MIN_VALUE;
4357             for (int i = 0; i < a.length; i += SPECIES.length()) {
4358                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4359                 ra = (int) VectorMath.maxUnsigned(ra, av.reduceLanes(VectorOperators.UMAX));
4360             }
4361         }
4362 
4363         assertReductionArraysEquals(r, ra, a,
4364                 Int64VectorTests::UMAXReduce, Int64VectorTests::UMAXReduceAll);
4365     }
4366 
4367     static int UMAXReduceMasked(int[] a, int idx, boolean[] mask) {
4368         int res = Integer.MIN_VALUE;
4369         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4370             if (mask[i % SPECIES.length()])
4371                 res = (int) VectorMath.maxUnsigned(res, a[i]);
4372         }
4373 
4374         return res;
4375     }
4376 
4377     static int UMAXReduceAllMasked(int[] a, boolean[] mask) {
4378         int res = Integer.MIN_VALUE;
4379         for (int i = 0; i < a.length; i += SPECIES.length()) {
4380             res = (int) VectorMath.maxUnsigned(res, UMAXReduceMasked(a, i, mask));
4381         }
4382 
4383         return res;
4384     }
4385 
4386     @Test(dataProvider = "intUnaryOpMaskProvider")
4387     static void UMAXReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4388         int[] a = fa.apply(SPECIES.length());
4389         int[] r = fr.apply(SPECIES.length());
4390         boolean[] mask = fm.apply(SPECIES.length());
4391         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4392         int ra = Integer.MIN_VALUE;
4393 
4394         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4395             for (int i = 0; i < a.length; i += SPECIES.length()) {
4396                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4397                 r[i] = av.reduceLanes(VectorOperators.UMAX, vmask);
4398             }
4399         }
4400 
4401         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4402             ra = Integer.MIN_VALUE;
4403             for (int i = 0; i < a.length; i += SPECIES.length()) {
4404                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4405                 ra = (int) VectorMath.maxUnsigned(ra, av.reduceLanes(VectorOperators.UMAX, vmask));
4406             }
4407         }
4408 
4409         assertReductionArraysEqualsMasked(r, ra, a, mask,
4410                 Int64VectorTests::UMAXReduceMasked, Int64VectorTests::UMAXReduceAllMasked);
4411     }
4412 
4413     static int FIRST_NONZEROReduce(int[] a, int idx) {
4414         int res = (int) 0;
4415         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4416             res = firstNonZero(res, a[i]);
4417         }
4418 
4419         return res;
4420     }
4421 
4422     static int FIRST_NONZEROReduceAll(int[] a) {
4423         int res = (int) 0;
4424         for (int i = 0; i < a.length; i += SPECIES.length()) {
4425             res = firstNonZero(res, FIRST_NONZEROReduce(a, i));
4426         }
4427 
4428         return res;
4429     }
4430 
4431     @Test(dataProvider = "intUnaryOpProvider")
4432     static void FIRST_NONZEROReduceInt64VectorTests(IntFunction<int[]> fa) {
4433         int[] a = fa.apply(SPECIES.length());
4434         int[] r = fr.apply(SPECIES.length());
4435         int ra = (int) 0;
4436 
4437         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4438             for (int i = 0; i < a.length; i += SPECIES.length()) {
4439                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4440                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO);
4441             }
4442         }
4443 
4444         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4445             ra = (int) 0;
4446             for (int i = 0; i < a.length; i += SPECIES.length()) {
4447                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4448                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
4449             }
4450         }
4451 
4452         assertReductionArraysEquals(r, ra, a,
4453                 Int64VectorTests::FIRST_NONZEROReduce, Int64VectorTests::FIRST_NONZEROReduceAll);
4454     }
4455 
4456     static int FIRST_NONZEROReduceMasked(int[] a, int idx, boolean[] mask) {
4457         int res = (int) 0;
4458         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4459             if (mask[i % SPECIES.length()])
4460                 res = firstNonZero(res, a[i]);
4461         }
4462 
4463         return res;
4464     }
4465 
4466     static int FIRST_NONZEROReduceAllMasked(int[] a, boolean[] mask) {
4467         int res = (int) 0;
4468         for (int i = 0; i < a.length; i += SPECIES.length()) {
4469             res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask));
4470         }
4471 
4472         return res;
4473     }
4474 
4475     @Test(dataProvider = "intUnaryOpMaskProvider")
4476     static void FIRST_NONZEROReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4477         int[] a = fa.apply(SPECIES.length());
4478         int[] r = fr.apply(SPECIES.length());
4479         boolean[] mask = fm.apply(SPECIES.length());
4480         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4481         int ra = (int) 0;
4482 
4483         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4484             for (int i = 0; i < a.length; i += SPECIES.length()) {
4485                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4486                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask);
4487             }
4488         }
4489 
4490         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4491             ra = (int) 0;
4492             for (int i = 0; i < a.length; i += SPECIES.length()) {
4493                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4494                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
4495             }
4496         }
4497 
4498         assertReductionArraysEqualsMasked(r, ra, a, mask,
4499                 Int64VectorTests::FIRST_NONZEROReduceMasked, Int64VectorTests::FIRST_NONZEROReduceAllMasked);
4500     }
4501 
4502     static boolean anyTrue(boolean[] a, int idx) {
4503         boolean res = false;
4504         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4505             res |= a[i];
4506         }
4507 
4508         return res;
4509     }
4510 
4511     @Test(dataProvider = "boolUnaryOpProvider")
4512     static void anyTrueInt64VectorTests(IntFunction<boolean[]> fm) {
4513         boolean[] mask = fm.apply(SPECIES.length());
4514         boolean[] r = fmr.apply(SPECIES.length());
4515 
4516         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4517             for (int i = 0; i < mask.length; i += SPECIES.length()) {
4518                 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
4519                 r[i] = vmask.anyTrue();
4520             }
4521         }
4522 
4523         assertReductionBoolArraysEquals(r, mask, Int64VectorTests::anyTrue);
4524     }
4525 
4526     static boolean allTrue(boolean[] a, int idx) {
4527         boolean res = true;
4528         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4529             res &= a[i];
4530         }
4531 
4532         return res;
4533     }
4534 
4535     @Test(dataProvider = "boolUnaryOpProvider")
4536     static void allTrueInt64VectorTests(IntFunction<boolean[]> fm) {
4537         boolean[] mask = fm.apply(SPECIES.length());
4538         boolean[] r = fmr.apply(SPECIES.length());
4539 
4540         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4541             for (int i = 0; i < mask.length; i += SPECIES.length()) {
4542                 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
4543                 r[i] = vmask.allTrue();
4544             }
4545         }
4546 
4547         assertReductionBoolArraysEquals(r, mask, Int64VectorTests::allTrue);
4548     }
4549 
4550     static int SUADDReduce(int[] a, int idx) {
4551         int res = 0;
4552         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4553             res = (int) VectorMath.addSaturatingUnsigned(res, a[i]);
4554         }
4555 
4556         return res;
4557     }
4558 
4559     static int SUADDReduceAll(int[] a) {
4560         int res = 0;
4561         for (int i = 0; i < a.length; i += SPECIES.length()) {
4562             res = (int) VectorMath.addSaturatingUnsigned(res, SUADDReduce(a, i));
4563         }
4564 
4565         return res;
4566     }
4567 
4568     @Test(dataProvider = "intSaturatingUnaryOpProvider")
4569     static void SUADDReduceInt64VectorTests(IntFunction<int[]> fa) {
4570         int[] a = fa.apply(SPECIES.length());
4571         int[] r = fr.apply(SPECIES.length());
4572         int ra = 0;
4573 
4574         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4575             for (int i = 0; i < a.length; i += SPECIES.length()) {
4576                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4577                 r[i] = av.reduceLanes(VectorOperators.SUADD);
4578             }
4579         }
4580 
4581         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4582             ra = 0;
4583             for (int i = 0; i < a.length; i += SPECIES.length()) {
4584                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4585                 ra = (int) VectorMath.addSaturatingUnsigned(ra, av.reduceLanes(VectorOperators.SUADD));
4586             }
4587         }
4588 
4589         assertReductionArraysEquals(r, ra, a,
4590                 Int64VectorTests::SUADDReduce, Int64VectorTests::SUADDReduceAll);
4591     }
4592 
4593     static int SUADDReduceMasked(int[] a, int idx, boolean[] mask) {
4594         int res = 0;
4595         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4596             if (mask[i % SPECIES.length()])
4597                 res = (int) VectorMath.addSaturatingUnsigned(res, a[i]);
4598         }
4599 
4600         return res;
4601     }
4602 
4603     static int SUADDReduceAllMasked(int[] a, boolean[] mask) {
4604         int res = 0;
4605         for (int i = 0; i < a.length; i += SPECIES.length()) {
4606             res = (int) VectorMath.addSaturatingUnsigned(res, SUADDReduceMasked(a, i, mask));
4607         }
4608 
4609         return res;
4610     }
4611     @Test(dataProvider = "intSaturatingUnaryOpMaskProvider")
4612     static void SUADDReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4613         int[] a = fa.apply(SPECIES.length());
4614         int[] r = fr.apply(SPECIES.length());
4615         boolean[] mask = fm.apply(SPECIES.length());
4616         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4617         int ra = 0;
4618 
4619         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4620             for (int i = 0; i < a.length; i += SPECIES.length()) {
4621                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4622                 r[i] = av.reduceLanes(VectorOperators.SUADD, vmask);
4623             }
4624         }
4625 
4626         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4627             ra = 0;
4628             for (int i = 0; i < a.length; i += SPECIES.length()) {
4629                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4630                 ra = (int) VectorMath.addSaturatingUnsigned(ra, av.reduceLanes(VectorOperators.SUADD, vmask));
4631             }
4632         }
4633 
4634         assertReductionArraysEqualsMasked(r, ra, a, mask,
4635                 Int64VectorTests::SUADDReduceMasked, Int64VectorTests::SUADDReduceAllMasked);
4636     }
4637 
4638     @Test(dataProvider = "intBinaryOpProvider")
4639     static void withInt64VectorTests(IntFunction<int []> fa, IntFunction<int []> fb) {
4640         int[] a = fa.apply(SPECIES.length());
4641         int[] b = fb.apply(SPECIES.length());
4642         int[] r = fr.apply(SPECIES.length());
4643 
4644         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4645             for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
4646                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4647                 av.withLane(j, b[i + j]).intoArray(r, i);
4648                 a[i + j] = b[i + j];
4649                 j = (j + 1) & (SPECIES.length() - 1);
4650             }
4651         }
4652 
4653 
4654         assertArraysStrictlyEquals(r, a);
4655     }
4656 
4657     static boolean testIS_DEFAULT(int a) {
4658         return bits(a)==0;
4659     }
4660 
4661     @Test(dataProvider = "intTestOpProvider")
4662     static void IS_DEFAULTInt64VectorTests(IntFunction<int[]> fa) {
4663         int[] a = fa.apply(SPECIES.length());
4664 
4665         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4666             for (int i = 0; i < a.length; i += SPECIES.length()) {
4667                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4668                 VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT);
4669 
4670                 // Check results as part of computation.
4671                 for (int j = 0; j < SPECIES.length(); j++) {
4672                     Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
4673                 }
4674             }
4675         }
4676     }
4677 
4678     @Test(dataProvider = "intTestOpMaskProvider")
4679     static void IS_DEFAULTMaskedInt64VectorTests(IntFunction<int[]> fa,
4680                                           IntFunction<boolean[]> fm) {
4681         int[] a = fa.apply(SPECIES.length());
4682         boolean[] mask = fm.apply(SPECIES.length());
4683         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4684 
4685         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4686             for (int i = 0; i < a.length; i += SPECIES.length()) {
4687                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4688                 VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
4689 
4690                 // Check results as part of computation.
4691                 for (int j = 0; j < SPECIES.length(); j++) {
4692                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
4693                 }
4694             }
4695         }
4696     }
4697 
4698     static boolean testIS_NEGATIVE(int a) {
4699         return bits(a)<0;
4700     }
4701 
4702     @Test(dataProvider = "intTestOpProvider")
4703     static void IS_NEGATIVEInt64VectorTests(IntFunction<int[]> fa) {
4704         int[] a = fa.apply(SPECIES.length());
4705 
4706         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4707             for (int i = 0; i < a.length; i += SPECIES.length()) {
4708                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4709                 VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE);
4710 
4711                 // Check results as part of computation.
4712                 for (int j = 0; j < SPECIES.length(); j++) {
4713                     Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
4714                 }
4715             }
4716         }
4717     }
4718 
4719     @Test(dataProvider = "intTestOpMaskProvider")
4720     static void IS_NEGATIVEMaskedInt64VectorTests(IntFunction<int[]> fa,
4721                                           IntFunction<boolean[]> fm) {
4722         int[] a = fa.apply(SPECIES.length());
4723         boolean[] mask = fm.apply(SPECIES.length());
4724         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4725 
4726         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4727             for (int i = 0; i < a.length; i += SPECIES.length()) {
4728                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4729                 VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
4730 
4731                 // Check results as part of computation.
4732                 for (int j = 0; j < SPECIES.length(); j++) {
4733                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
4734                 }
4735             }
4736         }
4737     }
4738 
4739     @Test(dataProvider = "intCompareOpProvider")
4740     static void LTInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4741         int[] a = fa.apply(SPECIES.length());
4742         int[] b = fb.apply(SPECIES.length());
4743 
4744         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4745             for (int i = 0; i < a.length; i += SPECIES.length()) {
4746                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4747                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4748                 VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv);
4749 
4750                 // Check results as part of computation.
4751                 for (int j = 0; j < SPECIES.length(); j++) {
4752                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
4753                 }
4754             }
4755         }
4756     }
4757 
4758     @Test(dataProvider = "intCompareOpProvider")
4759     static void ltInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4760         int[] a = fa.apply(SPECIES.length());
4761         int[] b = fb.apply(SPECIES.length());
4762 
4763         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4764             for (int i = 0; i < a.length; i += SPECIES.length()) {
4765                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4766                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4767                 VectorMask<Integer> mv = av.lt(bv);
4768 
4769                 // Check results as part of computation.
4770                 for (int j = 0; j < SPECIES.length(); j++) {
4771                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
4772                 }
4773             }
4774         }
4775     }
4776 
4777     @Test(dataProvider = "intCompareOpMaskProvider")
4778     static void LTInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4779                                                 IntFunction<boolean[]> fm) {
4780         int[] a = fa.apply(SPECIES.length());
4781         int[] b = fb.apply(SPECIES.length());
4782         boolean[] mask = fm.apply(SPECIES.length());
4783 
4784         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4785 
4786         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4787             for (int i = 0; i < a.length; i += SPECIES.length()) {
4788                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4789                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4790                 VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv, vmask);
4791 
4792                 // Check results as part of computation.
4793                 for (int j = 0; j < SPECIES.length(); j++) {
4794                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
4795                 }
4796             }
4797         }
4798     }
4799 
4800     @Test(dataProvider = "intCompareOpProvider")
4801     static void GTInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4802         int[] a = fa.apply(SPECIES.length());
4803         int[] b = fb.apply(SPECIES.length());
4804 
4805         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4806             for (int i = 0; i < a.length; i += SPECIES.length()) {
4807                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4808                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4809                 VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv);
4810 
4811                 // Check results as part of computation.
4812                 for (int j = 0; j < SPECIES.length(); j++) {
4813                     Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
4814                 }
4815             }
4816         }
4817     }
4818 
4819     @Test(dataProvider = "intCompareOpMaskProvider")
4820     static void GTInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4821                                                 IntFunction<boolean[]> fm) {
4822         int[] a = fa.apply(SPECIES.length());
4823         int[] b = fb.apply(SPECIES.length());
4824         boolean[] mask = fm.apply(SPECIES.length());
4825 
4826         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4827 
4828         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4829             for (int i = 0; i < a.length; i += SPECIES.length()) {
4830                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4831                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4832                 VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv, vmask);
4833 
4834                 // Check results as part of computation.
4835                 for (int j = 0; j < SPECIES.length(); j++) {
4836                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
4837                 }
4838             }
4839         }
4840     }
4841 
4842     @Test(dataProvider = "intCompareOpProvider")
4843     static void EQInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4844         int[] a = fa.apply(SPECIES.length());
4845         int[] b = fb.apply(SPECIES.length());
4846 
4847         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4848             for (int i = 0; i < a.length; i += SPECIES.length()) {
4849                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4850                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4851                 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv);
4852 
4853                 // Check results as part of computation.
4854                 for (int j = 0; j < SPECIES.length(); j++) {
4855                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
4856                 }
4857             }
4858         }
4859     }
4860 
4861     @Test(dataProvider = "intCompareOpProvider")
4862     static void eqInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4863         int[] a = fa.apply(SPECIES.length());
4864         int[] b = fb.apply(SPECIES.length());
4865 
4866         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4867             for (int i = 0; i < a.length; i += SPECIES.length()) {
4868                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4869                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4870                 VectorMask<Integer> mv = av.eq(bv);
4871 
4872                 // Check results as part of computation.
4873                 for (int j = 0; j < SPECIES.length(); j++) {
4874                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
4875                 }
4876             }
4877         }
4878     }
4879 
4880     @Test(dataProvider = "intCompareOpMaskProvider")
4881     static void EQInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4882                                                 IntFunction<boolean[]> fm) {
4883         int[] a = fa.apply(SPECIES.length());
4884         int[] b = fb.apply(SPECIES.length());
4885         boolean[] mask = fm.apply(SPECIES.length());
4886 
4887         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4888 
4889         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4890             for (int i = 0; i < a.length; i += SPECIES.length()) {
4891                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4892                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4893                 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv, vmask);
4894 
4895                 // Check results as part of computation.
4896                 for (int j = 0; j < SPECIES.length(); j++) {
4897                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
4898                 }
4899             }
4900         }
4901     }
4902 
4903     @Test(dataProvider = "intCompareOpProvider")
4904     static void NEInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4905         int[] a = fa.apply(SPECIES.length());
4906         int[] b = fb.apply(SPECIES.length());
4907 
4908         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4909             for (int i = 0; i < a.length; i += SPECIES.length()) {
4910                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4911                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4912                 VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv);
4913 
4914                 // Check results as part of computation.
4915                 for (int j = 0; j < SPECIES.length(); j++) {
4916                     Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
4917                 }
4918             }
4919         }
4920     }
4921 
4922     @Test(dataProvider = "intCompareOpMaskProvider")
4923     static void NEInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4924                                                 IntFunction<boolean[]> fm) {
4925         int[] a = fa.apply(SPECIES.length());
4926         int[] b = fb.apply(SPECIES.length());
4927         boolean[] mask = fm.apply(SPECIES.length());
4928 
4929         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4930 
4931         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4932             for (int i = 0; i < a.length; i += SPECIES.length()) {
4933                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4934                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4935                 VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv, vmask);
4936 
4937                 // Check results as part of computation.
4938                 for (int j = 0; j < SPECIES.length(); j++) {
4939                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
4940                 }
4941             }
4942         }
4943     }
4944 
4945     @Test(dataProvider = "intCompareOpProvider")
4946     static void LEInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4947         int[] a = fa.apply(SPECIES.length());
4948         int[] b = fb.apply(SPECIES.length());
4949 
4950         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4951             for (int i = 0; i < a.length; i += SPECIES.length()) {
4952                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4953                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4954                 VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv);
4955 
4956                 // Check results as part of computation.
4957                 for (int j = 0; j < SPECIES.length(); j++) {
4958                     Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
4959                 }
4960             }
4961         }
4962     }
4963 
4964     @Test(dataProvider = "intCompareOpMaskProvider")
4965     static void LEInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4966                                                 IntFunction<boolean[]> fm) {
4967         int[] a = fa.apply(SPECIES.length());
4968         int[] b = fb.apply(SPECIES.length());
4969         boolean[] mask = fm.apply(SPECIES.length());
4970 
4971         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4972 
4973         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4974             for (int i = 0; i < a.length; i += SPECIES.length()) {
4975                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4976                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4977                 VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv, vmask);
4978 
4979                 // Check results as part of computation.
4980                 for (int j = 0; j < SPECIES.length(); j++) {
4981                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
4982                 }
4983             }
4984         }
4985     }
4986 
4987     @Test(dataProvider = "intCompareOpProvider")
4988     static void GEInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4989         int[] a = fa.apply(SPECIES.length());
4990         int[] b = fb.apply(SPECIES.length());
4991 
4992         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4993             for (int i = 0; i < a.length; i += SPECIES.length()) {
4994                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4995                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4996                 VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv);
4997 
4998                 // Check results as part of computation.
4999                 for (int j = 0; j < SPECIES.length(); j++) {
5000                     Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
5001                 }
5002             }
5003         }
5004     }
5005 
5006     @Test(dataProvider = "intCompareOpMaskProvider")
5007     static void GEInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5008                                                 IntFunction<boolean[]> fm) {
5009         int[] a = fa.apply(SPECIES.length());
5010         int[] b = fb.apply(SPECIES.length());
5011         boolean[] mask = fm.apply(SPECIES.length());
5012 
5013         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5014 
5015         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5016             for (int i = 0; i < a.length; i += SPECIES.length()) {
5017                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5018                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5019                 VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv, vmask);
5020 
5021                 // Check results as part of computation.
5022                 for (int j = 0; j < SPECIES.length(); j++) {
5023                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
5024                 }
5025             }
5026         }
5027     }
5028 
5029     @Test(dataProvider = "intCompareOpProvider")
5030     static void ULTInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5031         int[] a = fa.apply(SPECIES.length());
5032         int[] b = fb.apply(SPECIES.length());
5033 
5034         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5035             for (int i = 0; i < a.length; i += SPECIES.length()) {
5036                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5037                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5038                 VectorMask<Integer> mv = av.compare(VectorOperators.ULT, bv);
5039 
5040                 // Check results as part of computation.
5041                 for (int j = 0; j < SPECIES.length(); j++) {
5042                     Assert.assertEquals(mv.laneIsSet(j), ult(a[i + j], b[i + j]));
5043                 }
5044             }
5045         }
5046     }
5047 
5048     @Test(dataProvider = "intCompareOpMaskProvider")
5049     static void ULTInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5050                                                 IntFunction<boolean[]> fm) {
5051         int[] a = fa.apply(SPECIES.length());
5052         int[] b = fb.apply(SPECIES.length());
5053         boolean[] mask = fm.apply(SPECIES.length());
5054 
5055         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5056 
5057         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5058             for (int i = 0; i < a.length; i += SPECIES.length()) {
5059                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5060                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5061                 VectorMask<Integer> mv = av.compare(VectorOperators.ULT, bv, vmask);
5062 
5063                 // Check results as part of computation.
5064                 for (int j = 0; j < SPECIES.length(); j++) {
5065                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ult(a[i + j], b[i + j]));
5066                 }
5067             }
5068         }
5069     }
5070 
5071     @Test(dataProvider = "intCompareOpProvider")
5072     static void UGTInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5073         int[] a = fa.apply(SPECIES.length());
5074         int[] b = fb.apply(SPECIES.length());
5075 
5076         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5077             for (int i = 0; i < a.length; i += SPECIES.length()) {
5078                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5079                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5080                 VectorMask<Integer> mv = av.compare(VectorOperators.UGT, bv);
5081 
5082                 // Check results as part of computation.
5083                 for (int j = 0; j < SPECIES.length(); j++) {
5084                     Assert.assertEquals(mv.laneIsSet(j), ugt(a[i + j], b[i + j]));
5085                 }
5086             }
5087         }
5088     }
5089 
5090     @Test(dataProvider = "intCompareOpMaskProvider")
5091     static void UGTInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5092                                                 IntFunction<boolean[]> fm) {
5093         int[] a = fa.apply(SPECIES.length());
5094         int[] b = fb.apply(SPECIES.length());
5095         boolean[] mask = fm.apply(SPECIES.length());
5096 
5097         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5098 
5099         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5100             for (int i = 0; i < a.length; i += SPECIES.length()) {
5101                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5102                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5103                 VectorMask<Integer> mv = av.compare(VectorOperators.UGT, bv, vmask);
5104 
5105                 // Check results as part of computation.
5106                 for (int j = 0; j < SPECIES.length(); j++) {
5107                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ugt(a[i + j], b[i + j]));
5108                 }
5109             }
5110         }
5111     }
5112 
5113     @Test(dataProvider = "intCompareOpProvider")
5114     static void ULEInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5115         int[] a = fa.apply(SPECIES.length());
5116         int[] b = fb.apply(SPECIES.length());
5117 
5118         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5119             for (int i = 0; i < a.length; i += SPECIES.length()) {
5120                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5121                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5122                 VectorMask<Integer> mv = av.compare(VectorOperators.ULE, bv);
5123 
5124                 // Check results as part of computation.
5125                 for (int j = 0; j < SPECIES.length(); j++) {
5126                     Assert.assertEquals(mv.laneIsSet(j), ule(a[i + j], b[i + j]));
5127                 }
5128             }
5129         }
5130     }
5131 
5132     @Test(dataProvider = "intCompareOpMaskProvider")
5133     static void ULEInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5134                                                 IntFunction<boolean[]> fm) {
5135         int[] a = fa.apply(SPECIES.length());
5136         int[] b = fb.apply(SPECIES.length());
5137         boolean[] mask = fm.apply(SPECIES.length());
5138 
5139         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5140 
5141         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5142             for (int i = 0; i < a.length; i += SPECIES.length()) {
5143                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5144                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5145                 VectorMask<Integer> mv = av.compare(VectorOperators.ULE, bv, vmask);
5146 
5147                 // Check results as part of computation.
5148                 for (int j = 0; j < SPECIES.length(); j++) {
5149                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ule(a[i + j], b[i + j]));
5150                 }
5151             }
5152         }
5153     }
5154 
5155     @Test(dataProvider = "intCompareOpProvider")
5156     static void UGEInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5157         int[] a = fa.apply(SPECIES.length());
5158         int[] b = fb.apply(SPECIES.length());
5159 
5160         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5161             for (int i = 0; i < a.length; i += SPECIES.length()) {
5162                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5163                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5164                 VectorMask<Integer> mv = av.compare(VectorOperators.UGE, bv);
5165 
5166                 // Check results as part of computation.
5167                 for (int j = 0; j < SPECIES.length(); j++) {
5168                     Assert.assertEquals(mv.laneIsSet(j), uge(a[i + j], b[i + j]));
5169                 }
5170             }
5171         }
5172     }
5173 
5174     @Test(dataProvider = "intCompareOpMaskProvider")
5175     static void UGEInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5176                                                 IntFunction<boolean[]> fm) {
5177         int[] a = fa.apply(SPECIES.length());
5178         int[] b = fb.apply(SPECIES.length());
5179         boolean[] mask = fm.apply(SPECIES.length());
5180 
5181         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5182 
5183         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5184             for (int i = 0; i < a.length; i += SPECIES.length()) {
5185                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5186                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5187                 VectorMask<Integer> mv = av.compare(VectorOperators.UGE, bv, vmask);
5188 
5189                 // Check results as part of computation.
5190                 for (int j = 0; j < SPECIES.length(); j++) {
5191                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && uge(a[i + j], b[i + j]));
5192                 }
5193             }
5194         }
5195     }
5196 
5197     @Test(dataProvider = "intCompareOpProvider")
5198     static void LTInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5199         int[] a = fa.apply(SPECIES.length());
5200         int[] b = fb.apply(SPECIES.length());
5201 
5202         for (int i = 0; i < a.length; i += SPECIES.length()) {
5203             IntVector av = IntVector.fromArray(SPECIES, a, i);
5204             VectorMask<Integer> mv = av.compare(VectorOperators.LT, b[i]);
5205 
5206             // Check results as part of computation.
5207             for (int j = 0; j < SPECIES.length(); j++) {
5208                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
5209             }
5210         }
5211     }
5212 
5213     @Test(dataProvider = "intCompareOpMaskProvider")
5214     static void LTInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa,
5215                                 IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
5216         int[] a = fa.apply(SPECIES.length());
5217         int[] b = fb.apply(SPECIES.length());
5218         boolean[] mask = fm.apply(SPECIES.length());
5219 
5220         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5221 
5222         for (int i = 0; i < a.length; i += SPECIES.length()) {
5223             IntVector av = IntVector.fromArray(SPECIES, a, i);
5224             VectorMask<Integer> mv = av.compare(VectorOperators.LT, b[i], vmask);
5225 
5226             // Check results as part of computation.
5227             for (int j = 0; j < SPECIES.length(); j++) {
5228                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
5229             }
5230         }
5231     }
5232 
5233     @Test(dataProvider = "intCompareOpProvider")
5234     static void LTInt64VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5235         int[] a = fa.apply(SPECIES.length());
5236         int[] b = fb.apply(SPECIES.length());
5237 
5238         for (int i = 0; i < a.length; i += SPECIES.length()) {
5239             IntVector av = IntVector.fromArray(SPECIES, a, i);
5240             VectorMask<Integer> mv = av.compare(VectorOperators.LT, (long)b[i]);
5241 
5242             // Check results as part of computation.
5243             for (int j = 0; j < SPECIES.length(); j++) {
5244                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (int)((long)b[i]));
5245             }
5246         }
5247     }
5248 
5249     @Test(dataProvider = "intCompareOpMaskProvider")
5250     static void LTInt64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<int[]> fa,
5251                                 IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
5252         int[] a = fa.apply(SPECIES.length());
5253         int[] b = fb.apply(SPECIES.length());
5254         boolean[] mask = fm.apply(SPECIES.length());
5255 
5256         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5257 
5258         for (int i = 0; i < a.length; i += SPECIES.length()) {
5259             IntVector av = IntVector.fromArray(SPECIES, a, i);
5260             VectorMask<Integer> mv = av.compare(VectorOperators.LT, (long)b[i], vmask);
5261 
5262             // Check results as part of computation.
5263             for (int j = 0; j < SPECIES.length(); j++) {
5264                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (int)((long)b[i])));
5265             }
5266         }
5267     }
5268 
5269     @Test(dataProvider = "intCompareOpProvider")
5270     static void EQInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5271         int[] a = fa.apply(SPECIES.length());
5272         int[] b = fb.apply(SPECIES.length());
5273 
5274         for (int i = 0; i < a.length; i += SPECIES.length()) {
5275             IntVector av = IntVector.fromArray(SPECIES, a, i);
5276             VectorMask<Integer> mv = av.compare(VectorOperators.EQ, b[i]);
5277 
5278             // Check results as part of computation.
5279             for (int j = 0; j < SPECIES.length(); j++) {
5280                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
5281             }
5282         }
5283     }
5284 
5285     @Test(dataProvider = "intCompareOpMaskProvider")
5286     static void EQInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa,
5287                                 IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
5288         int[] a = fa.apply(SPECIES.length());
5289         int[] b = fb.apply(SPECIES.length());
5290         boolean[] mask = fm.apply(SPECIES.length());
5291 
5292         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5293 
5294         for (int i = 0; i < a.length; i += SPECIES.length()) {
5295             IntVector av = IntVector.fromArray(SPECIES, a, i);
5296             VectorMask<Integer> mv = av.compare(VectorOperators.EQ, b[i], vmask);
5297 
5298             // Check results as part of computation.
5299             for (int j = 0; j < SPECIES.length(); j++) {
5300                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
5301             }
5302         }
5303     }
5304 
5305     @Test(dataProvider = "intCompareOpProvider")
5306     static void EQInt64VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5307         int[] a = fa.apply(SPECIES.length());
5308         int[] b = fb.apply(SPECIES.length());
5309 
5310         for (int i = 0; i < a.length; i += SPECIES.length()) {
5311             IntVector av = IntVector.fromArray(SPECIES, a, i);
5312             VectorMask<Integer> mv = av.compare(VectorOperators.EQ, (long)b[i]);
5313 
5314             // Check results as part of computation.
5315             for (int j = 0; j < SPECIES.length(); j++) {
5316                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (int)((long)b[i]));
5317             }
5318         }
5319     }
5320 
5321     @Test(dataProvider = "intCompareOpMaskProvider")
5322     static void EQInt64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<int[]> fa,
5323                                 IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
5324         int[] a = fa.apply(SPECIES.length());
5325         int[] b = fb.apply(SPECIES.length());
5326         boolean[] mask = fm.apply(SPECIES.length());
5327 
5328         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5329 
5330         for (int i = 0; i < a.length; i += SPECIES.length()) {
5331             IntVector av = IntVector.fromArray(SPECIES, a, i);
5332             VectorMask<Integer> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask);
5333 
5334             // Check results as part of computation.
5335             for (int j = 0; j < SPECIES.length(); j++) {
5336                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (int)((long)b[i])));
5337             }
5338         }
5339     }
5340 
5341     static int blend(int a, int b, boolean mask) {
5342         return mask ? b : a;
5343     }
5344 
5345     @Test(dataProvider = "intBinaryOpMaskProvider")
5346     static void blendInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
5347                                           IntFunction<boolean[]> fm) {
5348         int[] a = fa.apply(SPECIES.length());
5349         int[] b = fb.apply(SPECIES.length());
5350         int[] r = fr.apply(SPECIES.length());
5351         boolean[] mask = fm.apply(SPECIES.length());
5352         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5353 
5354         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5355             for (int i = 0; i < a.length; i += SPECIES.length()) {
5356                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5357                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5358                 av.blend(bv, vmask).intoArray(r, i);
5359             }
5360         }
5361 
5362         assertArraysEquals(r, a, b, mask, Int64VectorTests::blend);
5363     }
5364 
5365     @Test(dataProvider = "intUnaryOpShuffleProvider")
5366     static void RearrangeInt64VectorTests(IntFunction<int[]> fa,
5367                                            BiFunction<Integer,Integer,int[]> fs) {
5368         int[] a = fa.apply(SPECIES.length());
5369         int[] order = fs.apply(a.length, SPECIES.length());
5370         int[] r = fr.apply(SPECIES.length());
5371 
5372         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5373             for (int i = 0; i < a.length; i += SPECIES.length()) {
5374                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5375                 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
5376             }
5377         }
5378 
5379         assertRearrangeArraysEquals(r, a, order, SPECIES.length());
5380     }
5381 
5382     @Test(dataProvider = "intUnaryOpShuffleMaskProvider")
5383     static void RearrangeInt64VectorTestsMaskedSmokeTest(IntFunction<int[]> fa,
5384                                                           BiFunction<Integer,Integer,int[]> fs,
5385                                                           IntFunction<boolean[]> fm) {
5386         int[] a = fa.apply(SPECIES.length());
5387         int[] order = fs.apply(a.length, SPECIES.length());
5388         int[] r = fr.apply(SPECIES.length());
5389         boolean[] mask = fm.apply(SPECIES.length());
5390         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5391 
5392         for (int i = 0; i < a.length; i += SPECIES.length()) {
5393             IntVector av = IntVector.fromArray(SPECIES, a, i);
5394             av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
5395         }
5396 
5397         assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
5398     }
5399 
5400     @Test(dataProvider = "intUnaryOpMaskProvider")
5401     static void compressInt64VectorTests(IntFunction<int[]> fa,
5402                                                 IntFunction<boolean[]> fm) {
5403         int[] a = fa.apply(SPECIES.length());
5404         int[] r = fr.apply(SPECIES.length());
5405         boolean[] mask = fm.apply(SPECIES.length());
5406         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5407 
5408         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5409             for (int i = 0; i < a.length; i += SPECIES.length()) {
5410                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5411                 av.compress(vmask).intoArray(r, i);
5412             }
5413         }
5414 
5415         assertcompressArraysEquals(r, a, mask, SPECIES.length());
5416     }
5417 
5418     @Test(dataProvider = "intUnaryOpMaskProvider")
5419     static void expandInt64VectorTests(IntFunction<int[]> fa,
5420                                                 IntFunction<boolean[]> fm) {
5421         int[] a = fa.apply(SPECIES.length());
5422         int[] r = fr.apply(SPECIES.length());
5423         boolean[] mask = fm.apply(SPECIES.length());
5424         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5425 
5426         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5427             for (int i = 0; i < a.length; i += SPECIES.length()) {
5428                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5429                 av.expand(vmask).intoArray(r, i);
5430             }
5431         }
5432 
5433         assertexpandArraysEquals(r, a, mask, SPECIES.length());
5434     }
5435 
5436     @Test(dataProvider = "intUnaryOpProvider")
5437     static void getInt64VectorTests(IntFunction<int[]> fa) {
5438         int[] a = fa.apply(SPECIES.length());
5439         int[] r = fr.apply(SPECIES.length());
5440 
5441         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5442             for (int i = 0; i < a.length; i += SPECIES.length()) {
5443                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5444                 int num_lanes = SPECIES.length();
5445                 // Manually unroll because full unroll happens after intrinsification.
5446                 // Unroll is needed because get intrinsic requires for index to be a known constant.
5447                 if (num_lanes == 1) {
5448                     r[i]=av.lane(0);
5449                 } else if (num_lanes == 2) {
5450                     r[i]=av.lane(0);
5451                     r[i+1]=av.lane(1);
5452                 } else if (num_lanes == 4) {
5453                     r[i]=av.lane(0);
5454                     r[i+1]=av.lane(1);
5455                     r[i+2]=av.lane(2);
5456                     r[i+3]=av.lane(3);
5457                 } else if (num_lanes == 8) {
5458                     r[i]=av.lane(0);
5459                     r[i+1]=av.lane(1);
5460                     r[i+2]=av.lane(2);
5461                     r[i+3]=av.lane(3);
5462                     r[i+4]=av.lane(4);
5463                     r[i+5]=av.lane(5);
5464                     r[i+6]=av.lane(6);
5465                     r[i+7]=av.lane(7);
5466                 } else if (num_lanes == 16) {
5467                     r[i]=av.lane(0);
5468                     r[i+1]=av.lane(1);
5469                     r[i+2]=av.lane(2);
5470                     r[i+3]=av.lane(3);
5471                     r[i+4]=av.lane(4);
5472                     r[i+5]=av.lane(5);
5473                     r[i+6]=av.lane(6);
5474                     r[i+7]=av.lane(7);
5475                     r[i+8]=av.lane(8);
5476                     r[i+9]=av.lane(9);
5477                     r[i+10]=av.lane(10);
5478                     r[i+11]=av.lane(11);
5479                     r[i+12]=av.lane(12);
5480                     r[i+13]=av.lane(13);
5481                     r[i+14]=av.lane(14);
5482                     r[i+15]=av.lane(15);
5483                 } else if (num_lanes == 32) {
5484                     r[i]=av.lane(0);
5485                     r[i+1]=av.lane(1);
5486                     r[i+2]=av.lane(2);
5487                     r[i+3]=av.lane(3);
5488                     r[i+4]=av.lane(4);
5489                     r[i+5]=av.lane(5);
5490                     r[i+6]=av.lane(6);
5491                     r[i+7]=av.lane(7);
5492                     r[i+8]=av.lane(8);
5493                     r[i+9]=av.lane(9);
5494                     r[i+10]=av.lane(10);
5495                     r[i+11]=av.lane(11);
5496                     r[i+12]=av.lane(12);
5497                     r[i+13]=av.lane(13);
5498                     r[i+14]=av.lane(14);
5499                     r[i+15]=av.lane(15);
5500                     r[i+16]=av.lane(16);
5501                     r[i+17]=av.lane(17);
5502                     r[i+18]=av.lane(18);
5503                     r[i+19]=av.lane(19);
5504                     r[i+20]=av.lane(20);
5505                     r[i+21]=av.lane(21);
5506                     r[i+22]=av.lane(22);
5507                     r[i+23]=av.lane(23);
5508                     r[i+24]=av.lane(24);
5509                     r[i+25]=av.lane(25);
5510                     r[i+26]=av.lane(26);
5511                     r[i+27]=av.lane(27);
5512                     r[i+28]=av.lane(28);
5513                     r[i+29]=av.lane(29);
5514                     r[i+30]=av.lane(30);
5515                     r[i+31]=av.lane(31);
5516                 } else if (num_lanes == 64) {
5517                     r[i]=av.lane(0);
5518                     r[i+1]=av.lane(1);
5519                     r[i+2]=av.lane(2);
5520                     r[i+3]=av.lane(3);
5521                     r[i+4]=av.lane(4);
5522                     r[i+5]=av.lane(5);
5523                     r[i+6]=av.lane(6);
5524                     r[i+7]=av.lane(7);
5525                     r[i+8]=av.lane(8);
5526                     r[i+9]=av.lane(9);
5527                     r[i+10]=av.lane(10);
5528                     r[i+11]=av.lane(11);
5529                     r[i+12]=av.lane(12);
5530                     r[i+13]=av.lane(13);
5531                     r[i+14]=av.lane(14);
5532                     r[i+15]=av.lane(15);
5533                     r[i+16]=av.lane(16);
5534                     r[i+17]=av.lane(17);
5535                     r[i+18]=av.lane(18);
5536                     r[i+19]=av.lane(19);
5537                     r[i+20]=av.lane(20);
5538                     r[i+21]=av.lane(21);
5539                     r[i+22]=av.lane(22);
5540                     r[i+23]=av.lane(23);
5541                     r[i+24]=av.lane(24);
5542                     r[i+25]=av.lane(25);
5543                     r[i+26]=av.lane(26);
5544                     r[i+27]=av.lane(27);
5545                     r[i+28]=av.lane(28);
5546                     r[i+29]=av.lane(29);
5547                     r[i+30]=av.lane(30);
5548                     r[i+31]=av.lane(31);
5549                     r[i+32]=av.lane(32);
5550                     r[i+33]=av.lane(33);
5551                     r[i+34]=av.lane(34);
5552                     r[i+35]=av.lane(35);
5553                     r[i+36]=av.lane(36);
5554                     r[i+37]=av.lane(37);
5555                     r[i+38]=av.lane(38);
5556                     r[i+39]=av.lane(39);
5557                     r[i+40]=av.lane(40);
5558                     r[i+41]=av.lane(41);
5559                     r[i+42]=av.lane(42);
5560                     r[i+43]=av.lane(43);
5561                     r[i+44]=av.lane(44);
5562                     r[i+45]=av.lane(45);
5563                     r[i+46]=av.lane(46);
5564                     r[i+47]=av.lane(47);
5565                     r[i+48]=av.lane(48);
5566                     r[i+49]=av.lane(49);
5567                     r[i+50]=av.lane(50);
5568                     r[i+51]=av.lane(51);
5569                     r[i+52]=av.lane(52);
5570                     r[i+53]=av.lane(53);
5571                     r[i+54]=av.lane(54);
5572                     r[i+55]=av.lane(55);
5573                     r[i+56]=av.lane(56);
5574                     r[i+57]=av.lane(57);
5575                     r[i+58]=av.lane(58);
5576                     r[i+59]=av.lane(59);
5577                     r[i+60]=av.lane(60);
5578                     r[i+61]=av.lane(61);
5579                     r[i+62]=av.lane(62);
5580                     r[i+63]=av.lane(63);
5581                 } else {
5582                     for (int j = 0; j < SPECIES.length(); j++) {
5583                         r[i+j]=av.lane(j);
5584                     }
5585                 }
5586             }
5587         }
5588 
5589         assertArraysStrictlyEquals(r, a);
5590     }
5591 
5592     @Test(dataProvider = "intUnaryOpProvider")
5593     static void BroadcastInt64VectorTests(IntFunction<int[]> fa) {
5594         int[] a = fa.apply(SPECIES.length());
5595         int[] r = new int[a.length];
5596 
5597         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5598             for (int i = 0; i < a.length; i += SPECIES.length()) {
5599                 IntVector.broadcast(SPECIES, a[i]).intoArray(r, i);
5600             }
5601         }
5602 
5603         assertBroadcastArraysEquals(r, a);
5604     }
5605 
5606     @Test(dataProvider = "intUnaryOpProvider")
5607     static void ZeroInt64VectorTests(IntFunction<int[]> fa) {
5608         int[] a = fa.apply(SPECIES.length());
5609         int[] r = new int[a.length];
5610 
5611         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5612             for (int i = 0; i < a.length; i += SPECIES.length()) {
5613                 IntVector.zero(SPECIES).intoArray(a, i);
5614             }
5615         }
5616 
5617         Assert.assertEquals(a, r);
5618     }
5619 
5620     static int[] sliceUnary(int[] a, int origin, int idx) {
5621         int[] res = new int[SPECIES.length()];
5622         for (int i = 0; i < SPECIES.length(); i++){
5623             if(i+origin < SPECIES.length())
5624                 res[i] = a[idx+i+origin];
5625             else
5626                 res[i] = (int)0;
5627         }
5628         return res;
5629     }
5630 
5631     @Test(dataProvider = "intUnaryOpProvider")
5632     static void sliceUnaryInt64VectorTests(IntFunction<int[]> fa) {
5633         int[] a = fa.apply(SPECIES.length());
5634         int[] r = new int[a.length];
5635         int origin = RAND.nextInt(SPECIES.length());
5636         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5637             for (int i = 0; i < a.length; i += SPECIES.length()) {
5638                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5639                 av.slice(origin).intoArray(r, i);
5640             }
5641         }
5642 
5643         assertArraysEquals(r, a, origin, Int64VectorTests::sliceUnary);
5644     }
5645 
5646     static int[] sliceBinary(int[] a, int[] b, int origin, int idx) {
5647         int[] res = new int[SPECIES.length()];
5648         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5649             if(i+origin < SPECIES.length())
5650                 res[i] = a[idx+i+origin];
5651             else {
5652                 res[i] = b[idx+j];
5653                 j++;
5654             }
5655         }
5656         return res;
5657     }
5658 
5659     @Test(dataProvider = "intBinaryOpProvider")
5660     static void sliceBinaryInt64VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5661         int[] a = fa.apply(SPECIES.length());
5662         int[] b = fb.apply(SPECIES.length());
5663         int[] r = new int[a.length];
5664         int origin = RAND.nextInt(SPECIES.length());
5665         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5666             for (int i = 0; i < a.length; i += SPECIES.length()) {
5667                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5668                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5669                 av.slice(origin, bv).intoArray(r, i);
5670             }
5671         }
5672 
5673         assertArraysEquals(r, a, b, origin, Int64VectorTests::sliceBinary);
5674     }
5675 
5676     static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) {
5677         int[] res = new int[SPECIES.length()];
5678         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5679             if(i+origin < SPECIES.length())
5680                 res[i] = mask[i] ? a[idx+i+origin] : (int)0;
5681             else {
5682                 res[i] = mask[i] ? b[idx+j] : (int)0;
5683                 j++;
5684             }
5685         }
5686         return res;
5687     }
5688 
5689     @Test(dataProvider = "intBinaryOpMaskProvider")
5690     static void sliceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5691     IntFunction<boolean[]> fm) {
5692         int[] a = fa.apply(SPECIES.length());
5693         int[] b = fb.apply(SPECIES.length());
5694         boolean[] mask = fm.apply(SPECIES.length());
5695         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5696 
5697         int[] r = new int[a.length];
5698         int origin = RAND.nextInt(SPECIES.length());
5699         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5700             for (int i = 0; i < a.length; i += SPECIES.length()) {
5701                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5702                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5703                 av.slice(origin, bv, vmask).intoArray(r, i);
5704             }
5705         }
5706 
5707         assertArraysEquals(r, a, b, origin, mask, Int64VectorTests::slice);
5708     }
5709 
5710     static int[] unsliceUnary(int[] a, int origin, int idx) {
5711         int[] res = new int[SPECIES.length()];
5712         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5713             if(i < origin)
5714                 res[i] = (int)0;
5715             else {
5716                 res[i] = a[idx+j];
5717                 j++;
5718             }
5719         }
5720         return res;
5721     }
5722 
5723     @Test(dataProvider = "intUnaryOpProvider")
5724     static void unsliceUnaryInt64VectorTests(IntFunction<int[]> fa) {
5725         int[] a = fa.apply(SPECIES.length());
5726         int[] r = new int[a.length];
5727         int origin = RAND.nextInt(SPECIES.length());
5728         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5729             for (int i = 0; i < a.length; i += SPECIES.length()) {
5730                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5731                 av.unslice(origin).intoArray(r, i);
5732             }
5733         }
5734 
5735         assertArraysEquals(r, a, origin, Int64VectorTests::unsliceUnary);
5736     }
5737 
5738     static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) {
5739         int[] res = new int[SPECIES.length()];
5740         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5741             if (part == 0) {
5742                 if (i < origin)
5743                     res[i] = b[idx+i];
5744                 else {
5745                     res[i] = a[idx+j];
5746                     j++;
5747                 }
5748             } else if (part == 1) {
5749                 if (i < origin)
5750                     res[i] = a[idx+SPECIES.length()-origin+i];
5751                 else {
5752                     res[i] = b[idx+origin+j];
5753                     j++;
5754                 }
5755             }
5756         }
5757         return res;
5758     }
5759 
5760     @Test(dataProvider = "intBinaryOpProvider")
5761     static void unsliceBinaryInt64VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5762         int[] a = fa.apply(SPECIES.length());
5763         int[] b = fb.apply(SPECIES.length());
5764         int[] r = new int[a.length];
5765         int origin = RAND.nextInt(SPECIES.length());
5766         int part = RAND.nextInt(2);
5767         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5768             for (int i = 0; i < a.length; i += SPECIES.length()) {
5769                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5770                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5771                 av.unslice(origin, bv, part).intoArray(r, i);
5772             }
5773         }
5774 
5775         assertArraysEquals(r, a, b, origin, part, Int64VectorTests::unsliceBinary);
5776     }
5777 
5778     static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) {
5779         int[] res = new int[SPECIES.length()];
5780         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5781             if(i+origin < SPECIES.length())
5782                 res[i] = b[idx+i+origin];
5783             else {
5784                 res[i] = b[idx+j];
5785                 j++;
5786             }
5787         }
5788         for (int i = 0; i < SPECIES.length(); i++){
5789             res[i] = mask[i] ? a[idx+i] : res[i];
5790         }
5791         int[] res1 = new int[SPECIES.length()];
5792         if (part == 0) {
5793             for (int i = 0, j = 0; i < SPECIES.length(); i++){
5794                 if (i < origin)
5795                     res1[i] = b[idx+i];
5796                 else {
5797                    res1[i] = res[j];
5798                    j++;
5799                 }
5800             }
5801         } else if (part == 1) {
5802             for (int i = 0, j = 0; i < SPECIES.length(); i++){
5803                 if (i < origin)
5804                     res1[i] = res[SPECIES.length()-origin+i];
5805                 else {
5806                     res1[i] = b[idx+origin+j];
5807                     j++;
5808                 }
5809             }
5810         }
5811         return res1;
5812     }
5813 
5814     @Test(dataProvider = "intBinaryOpMaskProvider")
5815     static void unsliceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5816     IntFunction<boolean[]> fm) {
5817         int[] a = fa.apply(SPECIES.length());
5818         int[] b = fb.apply(SPECIES.length());
5819         boolean[] mask = fm.apply(SPECIES.length());
5820         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5821         int[] r = new int[a.length];
5822         int origin = RAND.nextInt(SPECIES.length());
5823         int part = RAND.nextInt(2);
5824         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5825             for (int i = 0; i < a.length; i += SPECIES.length()) {
5826                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5827                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5828                 av.unslice(origin, bv, part, vmask).intoArray(r, i);
5829             }
5830         }
5831 
5832         assertArraysEquals(r, a, b, origin, part, mask, Int64VectorTests::unslice);
5833     }
5834 
5835     static int BITWISE_BLEND(int a, int b, int c) {
5836         return (int)((a&~(c))|(b&c));
5837     }
5838 
5839     static int bitwiseBlend(int a, int b, int c) {
5840         return (int)((a&~(c))|(b&c));
5841     }
5842 
5843     @Test(dataProvider = "intTernaryOpProvider")
5844     static void BITWISE_BLENDInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5845         int[] a = fa.apply(SPECIES.length());
5846         int[] b = fb.apply(SPECIES.length());
5847         int[] c = fc.apply(SPECIES.length());
5848         int[] r = fr.apply(SPECIES.length());
5849 
5850         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5851             for (int i = 0; i < a.length; i += SPECIES.length()) {
5852                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5853                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5854                 IntVector cv = IntVector.fromArray(SPECIES, c, i);
5855                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
5856             }
5857         }
5858 
5859         assertArraysEquals(r, a, b, c, Int64VectorTests::BITWISE_BLEND);
5860     }
5861 
5862     @Test(dataProvider = "intTernaryOpProvider")
5863     static void bitwiseBlendInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5864         int[] a = fa.apply(SPECIES.length());
5865         int[] b = fb.apply(SPECIES.length());
5866         int[] c = fc.apply(SPECIES.length());
5867         int[] r = fr.apply(SPECIES.length());
5868 
5869         for (int i = 0; i < a.length; i += SPECIES.length()) {
5870             IntVector av = IntVector.fromArray(SPECIES, a, i);
5871             IntVector bv = IntVector.fromArray(SPECIES, b, i);
5872             IntVector cv = IntVector.fromArray(SPECIES, c, i);
5873             av.bitwiseBlend(bv, cv).intoArray(r, i);
5874         }
5875 
5876         assertArraysEquals(r, a, b, c, Int64VectorTests::bitwiseBlend);
5877     }
5878 
5879     @Test(dataProvider = "intTernaryOpMaskProvider")
5880     static void BITWISE_BLENDInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5881                                           IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
5882         int[] a = fa.apply(SPECIES.length());
5883         int[] b = fb.apply(SPECIES.length());
5884         int[] c = fc.apply(SPECIES.length());
5885         int[] r = fr.apply(SPECIES.length());
5886         boolean[] mask = fm.apply(SPECIES.length());
5887         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5888 
5889         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5890             for (int i = 0; i < a.length; i += SPECIES.length()) {
5891                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5892                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5893                 IntVector cv = IntVector.fromArray(SPECIES, c, i);
5894                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
5895             }
5896         }
5897 
5898         assertArraysEquals(r, a, b, c, mask, Int64VectorTests::BITWISE_BLEND);
5899     }
5900 
5901     @Test(dataProvider = "intTernaryOpProvider")
5902     static void BITWISE_BLENDInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5903         int[] a = fa.apply(SPECIES.length());
5904         int[] b = fb.apply(SPECIES.length());
5905         int[] c = fc.apply(SPECIES.length());
5906         int[] r = fr.apply(SPECIES.length());
5907 
5908         for (int i = 0; i < a.length; i += SPECIES.length()) {
5909             IntVector av = IntVector.fromArray(SPECIES, a, i);
5910             IntVector bv = IntVector.fromArray(SPECIES, b, i);
5911             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i);
5912         }
5913         assertBroadcastArraysEquals(r, a, b, c, Int64VectorTests::BITWISE_BLEND);
5914     }
5915 
5916     @Test(dataProvider = "intTernaryOpProvider")
5917     static void BITWISE_BLENDInt64VectorTestsAltBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5918         int[] a = fa.apply(SPECIES.length());
5919         int[] b = fb.apply(SPECIES.length());
5920         int[] c = fc.apply(SPECIES.length());
5921         int[] r = fr.apply(SPECIES.length());
5922 
5923         for (int i = 0; i < a.length; i += SPECIES.length()) {
5924             IntVector av = IntVector.fromArray(SPECIES, a, i);
5925             IntVector cv = IntVector.fromArray(SPECIES, c, i);
5926             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i);
5927         }
5928         assertAltBroadcastArraysEquals(r, a, b, c, Int64VectorTests::BITWISE_BLEND);
5929     }
5930 
5931     @Test(dataProvider = "intTernaryOpProvider")
5932     static void bitwiseBlendInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5933         int[] a = fa.apply(SPECIES.length());
5934         int[] b = fb.apply(SPECIES.length());
5935         int[] c = fc.apply(SPECIES.length());
5936         int[] r = fr.apply(SPECIES.length());
5937 
5938         for (int i = 0; i < a.length; i += SPECIES.length()) {
5939             IntVector av = IntVector.fromArray(SPECIES, a, i);
5940             IntVector bv = IntVector.fromArray(SPECIES, b, i);
5941             av.bitwiseBlend(bv, c[i]).intoArray(r, i);
5942         }
5943         assertBroadcastArraysEquals(r, a, b, c, Int64VectorTests::bitwiseBlend);
5944     }
5945 
5946     @Test(dataProvider = "intTernaryOpProvider")
5947     static void bitwiseBlendInt64VectorTestsAltBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5948         int[] a = fa.apply(SPECIES.length());
5949         int[] b = fb.apply(SPECIES.length());
5950         int[] c = fc.apply(SPECIES.length());
5951         int[] r = fr.apply(SPECIES.length());
5952 
5953         for (int i = 0; i < a.length; i += SPECIES.length()) {
5954             IntVector av = IntVector.fromArray(SPECIES, a, i);
5955             IntVector cv = IntVector.fromArray(SPECIES, c, i);
5956             av.bitwiseBlend(b[i], cv).intoArray(r, i);
5957         }
5958         assertAltBroadcastArraysEquals(r, a, b, c, Int64VectorTests::bitwiseBlend);
5959     }
5960 
5961     @Test(dataProvider = "intTernaryOpMaskProvider")
5962     static void BITWISE_BLENDInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
5963                                           IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
5964         int[] a = fa.apply(SPECIES.length());
5965         int[] b = fb.apply(SPECIES.length());
5966         int[] c = fc.apply(SPECIES.length());
5967         int[] r = fr.apply(SPECIES.length());
5968         boolean[] mask = fm.apply(SPECIES.length());
5969         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5970 
5971         for (int i = 0; i < a.length; i += SPECIES.length()) {
5972             IntVector av = IntVector.fromArray(SPECIES, a, i);
5973             IntVector bv = IntVector.fromArray(SPECIES, b, i);
5974             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i);
5975         }
5976 
5977         assertBroadcastArraysEquals(r, a, b, c, mask, Int64VectorTests::BITWISE_BLEND);
5978     }
5979 
5980     @Test(dataProvider = "intTernaryOpMaskProvider")
5981     static void BITWISE_BLENDInt64VectorTestsAltBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
5982                                           IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
5983         int[] a = fa.apply(SPECIES.length());
5984         int[] b = fb.apply(SPECIES.length());
5985         int[] c = fc.apply(SPECIES.length());
5986         int[] r = fr.apply(SPECIES.length());
5987         boolean[] mask = fm.apply(SPECIES.length());
5988         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5989 
5990         for (int i = 0; i < a.length; i += SPECIES.length()) {
5991             IntVector av = IntVector.fromArray(SPECIES, a, i);
5992             IntVector cv = IntVector.fromArray(SPECIES, c, i);
5993             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i);
5994         }
5995 
5996         assertAltBroadcastArraysEquals(r, a, b, c, mask, Int64VectorTests::BITWISE_BLEND);
5997     }
5998 
5999     @Test(dataProvider = "intTernaryOpProvider")
6000     static void BITWISE_BLENDInt64VectorTestsDoubleBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
6001         int[] a = fa.apply(SPECIES.length());
6002         int[] b = fb.apply(SPECIES.length());
6003         int[] c = fc.apply(SPECIES.length());
6004         int[] r = fr.apply(SPECIES.length());
6005 
6006         for (int i = 0; i < a.length; i += SPECIES.length()) {
6007             IntVector av = IntVector.fromArray(SPECIES, a, i);
6008             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i);
6009         }
6010 
6011         assertDoubleBroadcastArraysEquals(r, a, b, c, Int64VectorTests::BITWISE_BLEND);
6012     }
6013 
6014     @Test(dataProvider = "intTernaryOpProvider")
6015     static void bitwiseBlendInt64VectorTestsDoubleBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
6016         int[] a = fa.apply(SPECIES.length());
6017         int[] b = fb.apply(SPECIES.length());
6018         int[] c = fc.apply(SPECIES.length());
6019         int[] r = fr.apply(SPECIES.length());
6020 
6021         for (int i = 0; i < a.length; i += SPECIES.length()) {
6022             IntVector av = IntVector.fromArray(SPECIES, a, i);
6023             av.bitwiseBlend(b[i], c[i]).intoArray(r, i);
6024         }
6025 
6026         assertDoubleBroadcastArraysEquals(r, a, b, c, Int64VectorTests::bitwiseBlend);
6027     }
6028 
6029     @Test(dataProvider = "intTernaryOpMaskProvider")
6030     static void BITWISE_BLENDInt64VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
6031                                           IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
6032         int[] a = fa.apply(SPECIES.length());
6033         int[] b = fb.apply(SPECIES.length());
6034         int[] c = fc.apply(SPECIES.length());
6035         int[] r = fr.apply(SPECIES.length());
6036         boolean[] mask = fm.apply(SPECIES.length());
6037         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6038 
6039         for (int i = 0; i < a.length; i += SPECIES.length()) {
6040             IntVector av = IntVector.fromArray(SPECIES, a, i);
6041             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i);
6042         }
6043 
6044         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Int64VectorTests::BITWISE_BLEND);
6045     }
6046 
6047     static int NEG(int a) {
6048         return (int)(-((int)a));
6049     }
6050 
6051     static int neg(int a) {
6052         return (int)(-((int)a));
6053     }
6054 
6055     @Test(dataProvider = "intUnaryOpProvider")
6056     static void NEGInt64VectorTests(IntFunction<int[]> fa) {
6057         int[] a = fa.apply(SPECIES.length());
6058         int[] r = fr.apply(SPECIES.length());
6059 
6060         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6061             for (int i = 0; i < a.length; i += SPECIES.length()) {
6062                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6063                 av.lanewise(VectorOperators.NEG).intoArray(r, i);
6064             }
6065         }
6066 
6067         assertArraysEquals(r, a, Int64VectorTests::NEG);
6068     }
6069 
6070     @Test(dataProvider = "intUnaryOpProvider")
6071     static void negInt64VectorTests(IntFunction<int[]> fa) {
6072         int[] a = fa.apply(SPECIES.length());
6073         int[] r = fr.apply(SPECIES.length());
6074 
6075         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6076             for (int i = 0; i < a.length; i += SPECIES.length()) {
6077                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6078                 av.neg().intoArray(r, i);
6079             }
6080         }
6081 
6082         assertArraysEquals(r, a, Int64VectorTests::neg);
6083     }
6084 
6085     @Test(dataProvider = "intUnaryOpMaskProvider")
6086     static void NEGMaskedInt64VectorTests(IntFunction<int[]> fa,
6087                                                 IntFunction<boolean[]> fm) {
6088         int[] a = fa.apply(SPECIES.length());
6089         int[] r = fr.apply(SPECIES.length());
6090         boolean[] mask = fm.apply(SPECIES.length());
6091         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6092 
6093         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6094             for (int i = 0; i < a.length; i += SPECIES.length()) {
6095                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6096                 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
6097             }
6098         }
6099 
6100         assertArraysEquals(r, a, mask, Int64VectorTests::NEG);
6101     }
6102 
6103     static int ABS(int a) {
6104         return (int)(Math.abs((int)a));
6105     }
6106 
6107     static int abs(int a) {
6108         return (int)(Math.abs((int)a));
6109     }
6110 
6111     @Test(dataProvider = "intUnaryOpProvider")
6112     static void ABSInt64VectorTests(IntFunction<int[]> fa) {
6113         int[] a = fa.apply(SPECIES.length());
6114         int[] r = fr.apply(SPECIES.length());
6115 
6116         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6117             for (int i = 0; i < a.length; i += SPECIES.length()) {
6118                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6119                 av.lanewise(VectorOperators.ABS).intoArray(r, i);
6120             }
6121         }
6122 
6123         assertArraysEquals(r, a, Int64VectorTests::ABS);
6124     }
6125 
6126     @Test(dataProvider = "intUnaryOpProvider")
6127     static void absInt64VectorTests(IntFunction<int[]> fa) {
6128         int[] a = fa.apply(SPECIES.length());
6129         int[] r = fr.apply(SPECIES.length());
6130 
6131         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6132             for (int i = 0; i < a.length; i += SPECIES.length()) {
6133                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6134                 av.abs().intoArray(r, i);
6135             }
6136         }
6137 
6138         assertArraysEquals(r, a, Int64VectorTests::abs);
6139     }
6140 
6141     @Test(dataProvider = "intUnaryOpMaskProvider")
6142     static void ABSMaskedInt64VectorTests(IntFunction<int[]> fa,
6143                                                 IntFunction<boolean[]> fm) {
6144         int[] a = fa.apply(SPECIES.length());
6145         int[] r = fr.apply(SPECIES.length());
6146         boolean[] mask = fm.apply(SPECIES.length());
6147         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6148 
6149         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6150             for (int i = 0; i < a.length; i += SPECIES.length()) {
6151                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6152                 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
6153             }
6154         }
6155 
6156         assertArraysEquals(r, a, mask, Int64VectorTests::ABS);
6157     }
6158 
6159     static int NOT(int a) {
6160         return (int)(~((int)a));
6161     }
6162 
6163     static int not(int a) {
6164         return (int)(~((int)a));
6165     }
6166 
6167     @Test(dataProvider = "intUnaryOpProvider")
6168     static void NOTInt64VectorTests(IntFunction<int[]> fa) {
6169         int[] a = fa.apply(SPECIES.length());
6170         int[] r = fr.apply(SPECIES.length());
6171 
6172         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6173             for (int i = 0; i < a.length; i += SPECIES.length()) {
6174                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6175                 av.lanewise(VectorOperators.NOT).intoArray(r, i);
6176             }
6177         }
6178 
6179         assertArraysEquals(r, a, Int64VectorTests::NOT);
6180     }
6181 
6182     @Test(dataProvider = "intUnaryOpProvider")
6183     static void notInt64VectorTests(IntFunction<int[]> fa) {
6184         int[] a = fa.apply(SPECIES.length());
6185         int[] r = fr.apply(SPECIES.length());
6186 
6187         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6188             for (int i = 0; i < a.length; i += SPECIES.length()) {
6189                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6190                 av.not().intoArray(r, i);
6191             }
6192         }
6193 
6194         assertArraysEquals(r, a, Int64VectorTests::not);
6195     }
6196 
6197     @Test(dataProvider = "intUnaryOpMaskProvider")
6198     static void NOTMaskedInt64VectorTests(IntFunction<int[]> fa,
6199                                                 IntFunction<boolean[]> fm) {
6200         int[] a = fa.apply(SPECIES.length());
6201         int[] r = fr.apply(SPECIES.length());
6202         boolean[] mask = fm.apply(SPECIES.length());
6203         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6204 
6205         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6206             for (int i = 0; i < a.length; i += SPECIES.length()) {
6207                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6208                 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
6209             }
6210         }
6211 
6212         assertArraysEquals(r, a, mask, Int64VectorTests::NOT);
6213     }
6214 
6215     static int ZOMO(int a) {
6216         return (int)((a==0?0:-1));
6217     }
6218 
6219     @Test(dataProvider = "intUnaryOpProvider")
6220     static void ZOMOInt64VectorTests(IntFunction<int[]> fa) {
6221         int[] a = fa.apply(SPECIES.length());
6222         int[] r = fr.apply(SPECIES.length());
6223 
6224         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6225             for (int i = 0; i < a.length; i += SPECIES.length()) {
6226                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6227                 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
6228             }
6229         }
6230 
6231         assertArraysEquals(r, a, Int64VectorTests::ZOMO);
6232     }
6233 
6234     @Test(dataProvider = "intUnaryOpMaskProvider")
6235     static void ZOMOMaskedInt64VectorTests(IntFunction<int[]> fa,
6236                                                 IntFunction<boolean[]> fm) {
6237         int[] a = fa.apply(SPECIES.length());
6238         int[] r = fr.apply(SPECIES.length());
6239         boolean[] mask = fm.apply(SPECIES.length());
6240         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6241 
6242         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6243             for (int i = 0; i < a.length; i += SPECIES.length()) {
6244                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6245                 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
6246             }
6247         }
6248 
6249         assertArraysEquals(r, a, mask, Int64VectorTests::ZOMO);
6250     }
6251 
6252     static int BIT_COUNT(int a) {
6253         return (int)(Integer.bitCount(a));
6254     }
6255 
6256     @Test(dataProvider = "intUnaryOpProvider")
6257     static void BIT_COUNTInt64VectorTests(IntFunction<int[]> fa) {
6258         int[] a = fa.apply(SPECIES.length());
6259         int[] r = fr.apply(SPECIES.length());
6260 
6261         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6262             for (int i = 0; i < a.length; i += SPECIES.length()) {
6263                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6264                 av.lanewise(VectorOperators.BIT_COUNT).intoArray(r, i);
6265             }
6266         }
6267 
6268         assertArraysEquals(r, a, Int64VectorTests::BIT_COUNT);
6269     }
6270 
6271     @Test(dataProvider = "intUnaryOpMaskProvider")
6272     static void BIT_COUNTMaskedInt64VectorTests(IntFunction<int[]> fa,
6273                                                 IntFunction<boolean[]> fm) {
6274         int[] a = fa.apply(SPECIES.length());
6275         int[] r = fr.apply(SPECIES.length());
6276         boolean[] mask = fm.apply(SPECIES.length());
6277         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6278 
6279         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6280             for (int i = 0; i < a.length; i += SPECIES.length()) {
6281                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6282                 av.lanewise(VectorOperators.BIT_COUNT, vmask).intoArray(r, i);
6283             }
6284         }
6285 
6286         assertArraysEquals(r, a, mask, Int64VectorTests::BIT_COUNT);
6287     }
6288 
6289     static int TRAILING_ZEROS_COUNT(int a) {
6290         return (int)(TRAILING_ZEROS_COUNT_scalar(a));
6291     }
6292 
6293     @Test(dataProvider = "intUnaryOpProvider")
6294     static void TRAILING_ZEROS_COUNTInt64VectorTests(IntFunction<int[]> fa) {
6295         int[] a = fa.apply(SPECIES.length());
6296         int[] r = fr.apply(SPECIES.length());
6297 
6298         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6299             for (int i = 0; i < a.length; i += SPECIES.length()) {
6300                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6301                 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT).intoArray(r, i);
6302             }
6303         }
6304 
6305         assertArraysEquals(r, a, Int64VectorTests::TRAILING_ZEROS_COUNT);
6306     }
6307 
6308     @Test(dataProvider = "intUnaryOpMaskProvider")
6309     static void TRAILING_ZEROS_COUNTMaskedInt64VectorTests(IntFunction<int[]> fa,
6310                                                 IntFunction<boolean[]> fm) {
6311         int[] a = fa.apply(SPECIES.length());
6312         int[] r = fr.apply(SPECIES.length());
6313         boolean[] mask = fm.apply(SPECIES.length());
6314         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6315 
6316         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6317             for (int i = 0; i < a.length; i += SPECIES.length()) {
6318                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6319                 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT, vmask).intoArray(r, i);
6320             }
6321         }
6322 
6323         assertArraysEquals(r, a, mask, Int64VectorTests::TRAILING_ZEROS_COUNT);
6324     }
6325 
6326     static int LEADING_ZEROS_COUNT(int a) {
6327         return (int)(LEADING_ZEROS_COUNT_scalar(a));
6328     }
6329 
6330     @Test(dataProvider = "intUnaryOpProvider")
6331     static void LEADING_ZEROS_COUNTInt64VectorTests(IntFunction<int[]> fa) {
6332         int[] a = fa.apply(SPECIES.length());
6333         int[] r = fr.apply(SPECIES.length());
6334 
6335         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6336             for (int i = 0; i < a.length; i += SPECIES.length()) {
6337                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6338                 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT).intoArray(r, i);
6339             }
6340         }
6341 
6342         assertArraysEquals(r, a, Int64VectorTests::LEADING_ZEROS_COUNT);
6343     }
6344 
6345     @Test(dataProvider = "intUnaryOpMaskProvider")
6346     static void LEADING_ZEROS_COUNTMaskedInt64VectorTests(IntFunction<int[]> fa,
6347                                                 IntFunction<boolean[]> fm) {
6348         int[] a = fa.apply(SPECIES.length());
6349         int[] r = fr.apply(SPECIES.length());
6350         boolean[] mask = fm.apply(SPECIES.length());
6351         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6352 
6353         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6354             for (int i = 0; i < a.length; i += SPECIES.length()) {
6355                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6356                 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT, vmask).intoArray(r, i);
6357             }
6358         }
6359 
6360         assertArraysEquals(r, a, mask, Int64VectorTests::LEADING_ZEROS_COUNT);
6361     }
6362 
6363     static int REVERSE(int a) {
6364         return (int)(REVERSE_scalar(a));
6365     }
6366 
6367     @Test(dataProvider = "intUnaryOpProvider")
6368     static void REVERSEInt64VectorTests(IntFunction<int[]> fa) {
6369         int[] a = fa.apply(SPECIES.length());
6370         int[] r = fr.apply(SPECIES.length());
6371 
6372         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6373             for (int i = 0; i < a.length; i += SPECIES.length()) {
6374                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6375                 av.lanewise(VectorOperators.REVERSE).intoArray(r, i);
6376             }
6377         }
6378 
6379         assertArraysEquals(r, a, Int64VectorTests::REVERSE);
6380     }
6381 
6382     @Test(dataProvider = "intUnaryOpMaskProvider")
6383     static void REVERSEMaskedInt64VectorTests(IntFunction<int[]> fa,
6384                                                 IntFunction<boolean[]> fm) {
6385         int[] a = fa.apply(SPECIES.length());
6386         int[] r = fr.apply(SPECIES.length());
6387         boolean[] mask = fm.apply(SPECIES.length());
6388         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6389 
6390         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6391             for (int i = 0; i < a.length; i += SPECIES.length()) {
6392                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6393                 av.lanewise(VectorOperators.REVERSE, vmask).intoArray(r, i);
6394             }
6395         }
6396 
6397         assertArraysEquals(r, a, mask, Int64VectorTests::REVERSE);
6398     }
6399 
6400     static int REVERSE_BYTES(int a) {
6401         return (int)(Integer.reverseBytes(a));
6402     }
6403 
6404     @Test(dataProvider = "intUnaryOpProvider")
6405     static void REVERSE_BYTESInt64VectorTests(IntFunction<int[]> fa) {
6406         int[] a = fa.apply(SPECIES.length());
6407         int[] r = fr.apply(SPECIES.length());
6408 
6409         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6410             for (int i = 0; i < a.length; i += SPECIES.length()) {
6411                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6412                 av.lanewise(VectorOperators.REVERSE_BYTES).intoArray(r, i);
6413             }
6414         }
6415 
6416         assertArraysEquals(r, a, Int64VectorTests::REVERSE_BYTES);
6417     }
6418 
6419     @Test(dataProvider = "intUnaryOpMaskProvider")
6420     static void REVERSE_BYTESMaskedInt64VectorTests(IntFunction<int[]> fa,
6421                                                 IntFunction<boolean[]> fm) {
6422         int[] a = fa.apply(SPECIES.length());
6423         int[] r = fr.apply(SPECIES.length());
6424         boolean[] mask = fm.apply(SPECIES.length());
6425         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6426 
6427         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6428             for (int i = 0; i < a.length; i += SPECIES.length()) {
6429                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6430                 av.lanewise(VectorOperators.REVERSE_BYTES, vmask).intoArray(r, i);
6431             }
6432         }
6433 
6434         assertArraysEquals(r, a, mask, Int64VectorTests::REVERSE_BYTES);
6435     }
6436 
6437     @Test(dataProvider = "intCompareOpProvider")
6438     static void ltInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
6439         int[] a = fa.apply(SPECIES.length());
6440         int[] b = fb.apply(SPECIES.length());
6441 
6442         for (int i = 0; i < a.length; i += SPECIES.length()) {
6443             IntVector av = IntVector.fromArray(SPECIES, a, i);
6444             VectorMask<Integer> mv = av.lt(b[i]);
6445 
6446             // Check results as part of computation.
6447             for (int j = 0; j < SPECIES.length(); j++) {
6448                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
6449             }
6450         }
6451     }
6452 
6453     @Test(dataProvider = "intCompareOpProvider")
6454     static void eqInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
6455         int[] a = fa.apply(SPECIES.length());
6456         int[] b = fb.apply(SPECIES.length());
6457 
6458         for (int i = 0; i < a.length; i += SPECIES.length()) {
6459             IntVector av = IntVector.fromArray(SPECIES, a, i);
6460             VectorMask<Integer> mv = av.eq(b[i]);
6461 
6462             // Check results as part of computation.
6463             for (int j = 0; j < SPECIES.length(); j++) {
6464                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
6465             }
6466         }
6467     }
6468 
6469     @Test(dataProvider = "intUnaryOpProvider")
6470     static void toIntArrayInt64VectorTestsSmokeTest(IntFunction<int[]> fa) {
6471         int[] a = fa.apply(SPECIES.length());
6472 
6473         for (int i = 0; i < a.length; i += SPECIES.length()) {
6474             IntVector av = IntVector.fromArray(SPECIES, a, i);
6475             int[] r = av.toIntArray();
6476             assertArraysEquals(r, a, i);
6477         }
6478     }
6479 
6480     @Test(dataProvider = "intUnaryOpProvider")
6481     static void toLongArrayInt64VectorTestsSmokeTest(IntFunction<int[]> fa) {
6482         int[] a = fa.apply(SPECIES.length());
6483 
6484         for (int i = 0; i < a.length; i += SPECIES.length()) {
6485             IntVector av = IntVector.fromArray(SPECIES, a, i);
6486             long[] r = av.toLongArray();
6487             assertArraysEquals(r, a, i);
6488         }
6489     }
6490 
6491     @Test(dataProvider = "intUnaryOpProvider")
6492     static void toDoubleArrayInt64VectorTestsSmokeTest(IntFunction<int[]> fa) {
6493         int[] a = fa.apply(SPECIES.length());
6494 
6495         for (int i = 0; i < a.length; i += SPECIES.length()) {
6496             IntVector av = IntVector.fromArray(SPECIES, a, i);
6497             double[] r = av.toDoubleArray();
6498             assertArraysEquals(r, a, i);
6499         }
6500     }
6501 
6502     @Test(dataProvider = "intUnaryOpProvider")
6503     static void toStringInt64VectorTestsSmokeTest(IntFunction<int[]> fa) {
6504         int[] a = fa.apply(SPECIES.length());
6505 
6506         for (int i = 0; i < a.length; i += SPECIES.length()) {
6507             IntVector av = IntVector.fromArray(SPECIES, a, i);
6508             String str = av.toString();
6509 
6510             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6511             Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
6512         }
6513     }
6514 
6515     @Test(dataProvider = "intUnaryOpProvider")
6516     static void hashCodeInt64VectorTestsSmokeTest(IntFunction<int[]> fa) {
6517         int[] a = fa.apply(SPECIES.length());
6518 
6519         for (int i = 0; i < a.length; i += SPECIES.length()) {
6520             IntVector av = IntVector.fromArray(SPECIES, a, i);
6521             int hash = av.hashCode();
6522 
6523             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6524             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
6525             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
6526         }
6527     }
6528 
6529 
6530     static long ADDReduceLong(int[] a, int idx) {
6531         int res = 0;
6532         for (int i = idx; i < (idx + SPECIES.length()); i++) {
6533             res += a[i];
6534         }
6535 
6536         return (long)res;
6537     }
6538 
6539     static long ADDReduceAllLong(int[] a) {
6540         long res = 0;
6541         for (int i = 0; i < a.length; i += SPECIES.length()) {
6542             res += ADDReduceLong(a, i);
6543         }
6544 
6545         return res;
6546     }
6547 
6548     @Test(dataProvider = "intUnaryOpProvider")
6549     static void ADDReduceLongInt64VectorTests(IntFunction<int[]> fa) {
6550         int[] a = fa.apply(SPECIES.length());
6551         long[] r = lfr.apply(SPECIES.length());
6552         long ra = 0;
6553 
6554         for (int i = 0; i < a.length; i += SPECIES.length()) {
6555             IntVector av = IntVector.fromArray(SPECIES, a, i);
6556             r[i] = av.reduceLanesToLong(VectorOperators.ADD);
6557         }
6558 
6559         ra = 0;
6560         for (int i = 0; i < a.length; i ++) {
6561             ra += r[i];
6562         }
6563 
6564         assertReductionLongArraysEquals(r, ra, a,
6565                 Int64VectorTests::ADDReduceLong, Int64VectorTests::ADDReduceAllLong);
6566     }
6567 
6568     static long ADDReduceLongMasked(int[] a, int idx, boolean[] mask) {
6569         int res = 0;
6570         for (int i = idx; i < (idx + SPECIES.length()); i++) {
6571             if(mask[i % SPECIES.length()])
6572                 res += a[i];
6573         }
6574 
6575         return (long)res;
6576     }
6577 
6578     static long ADDReduceAllLongMasked(int[] a, boolean[] mask) {
6579         long res = 0;
6580         for (int i = 0; i < a.length; i += SPECIES.length()) {
6581             res += ADDReduceLongMasked(a, i, mask);
6582         }
6583 
6584         return res;
6585     }
6586 
6587     @Test(dataProvider = "intUnaryOpMaskProvider")
6588     static void ADDReduceLongInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
6589         int[] a = fa.apply(SPECIES.length());
6590         long[] r = lfr.apply(SPECIES.length());
6591         boolean[] mask = fm.apply(SPECIES.length());
6592         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6593         long ra = 0;
6594 
6595         for (int i = 0; i < a.length; i += SPECIES.length()) {
6596             IntVector av = IntVector.fromArray(SPECIES, a, i);
6597             r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
6598         }
6599 
6600         ra = 0;
6601         for (int i = 0; i < a.length; i ++) {
6602             ra += r[i];
6603         }
6604 
6605         assertReductionLongArraysEqualsMasked(r, ra, a, mask,
6606                 Int64VectorTests::ADDReduceLongMasked, Int64VectorTests::ADDReduceAllLongMasked);
6607     }
6608 
6609     @Test(dataProvider = "intUnaryOpProvider")
6610     static void BroadcastLongInt64VectorTestsSmokeTest(IntFunction<int[]> fa) {
6611         int[] a = fa.apply(SPECIES.length());
6612         int[] r = new int[a.length];
6613 
6614         for (int i = 0; i < a.length; i += SPECIES.length()) {
6615             IntVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
6616         }
6617         assertBroadcastArraysEquals(r, a);
6618     }
6619 
6620     @Test(dataProvider = "intBinaryOpMaskProvider")
6621     static void blendInt64VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
6622                                           IntFunction<boolean[]> fm) {
6623         int[] a = fa.apply(SPECIES.length());
6624         int[] b = fb.apply(SPECIES.length());
6625         int[] r = fr.apply(SPECIES.length());
6626         boolean[] mask = fm.apply(SPECIES.length());
6627         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6628 
6629         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6630             for (int i = 0; i < a.length; i += SPECIES.length()) {
6631                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6632                 av.blend((long)b[i], vmask).intoArray(r, i);
6633             }
6634         }
6635         assertBroadcastLongArraysEquals(r, a, b, mask, Int64VectorTests::blend);
6636     }
6637 
6638 
6639     @Test(dataProvider = "intUnaryOpShuffleProvider")
6640     static void SelectFromInt64VectorTests(IntFunction<int[]> fa,
6641                                            BiFunction<Integer,Integer,int[]> fs) {
6642         int[] a = fa.apply(SPECIES.length());
6643         int[] order = fs.apply(a.length, SPECIES.length());
6644         int[] r = fr.apply(SPECIES.length());
6645 
6646         for (int i = 0; i < a.length; i += SPECIES.length()) {
6647             IntVector av = IntVector.fromArray(SPECIES, a, i);
6648             IntVector bv = IntVector.fromArray(SPECIES, order, i);
6649             bv.selectFrom(av).intoArray(r, i);
6650         }
6651 
6652         assertSelectFromArraysEquals(r, a, order, SPECIES.length());
6653     }
6654 
6655     @Test(dataProvider = "intSelectFromTwoVectorOpProvider")
6656     static void SelectFromTwoVectorInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
6657         int[] a = fa.apply(SPECIES.length());
6658         int[] b = fb.apply(SPECIES.length());
6659         int[] idx = fc.apply(SPECIES.length());
6660         int[] r = fr.apply(SPECIES.length());
6661 
6662         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6663             for (int i = 0; i < idx.length; i += SPECIES.length()) {
6664                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6665                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
6666                 IntVector idxv = IntVector.fromArray(SPECIES, idx, i);
6667                 idxv.selectFrom(av, bv).intoArray(r, i);
6668             }
6669         }
6670         assertSelectFromTwoVectorEquals(r, idx, a, b, SPECIES.length());
6671     }
6672 
6673     @Test(dataProvider = "intUnaryOpShuffleMaskProvider")
6674     static void SelectFromInt64VectorTestsMaskedSmokeTest(IntFunction<int[]> fa,
6675                                                            BiFunction<Integer,Integer,int[]> fs,
6676                                                            IntFunction<boolean[]> fm) {
6677         int[] a = fa.apply(SPECIES.length());
6678         int[] order = fs.apply(a.length, SPECIES.length());
6679         int[] r = fr.apply(SPECIES.length());
6680         boolean[] mask = fm.apply(SPECIES.length());
6681         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6682 
6683         for (int i = 0; i < a.length; i += SPECIES.length()) {
6684             IntVector av = IntVector.fromArray(SPECIES, a, i);
6685             IntVector bv = IntVector.fromArray(SPECIES, order, i);
6686             bv.selectFrom(av, vmask).intoArray(r, i);
6687         }
6688 
6689         assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
6690     }
6691 
6692     @Test(dataProvider = "shuffleProvider")
6693     static void shuffleMiscellaneousInt64VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
6694         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6695 
6696         for (int i = 0; i < a.length; i += SPECIES.length()) {
6697             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
6698             int hash = shuffle.hashCode();
6699             int length = shuffle.length();
6700 
6701             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6702             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
6703             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
6704             Assert.assertEquals(length, SPECIES.length());
6705         }
6706     }
6707 
6708     @Test(dataProvider = "shuffleProvider")
6709     static void shuffleToStringInt64VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
6710         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6711 
6712         for (int i = 0; i < a.length; i += SPECIES.length()) {
6713             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
6714             String str = shuffle.toString();
6715 
6716             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6717             Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
6718                 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
6719         }
6720     }
6721 
6722     @Test(dataProvider = "shuffleCompareOpProvider")
6723     static void shuffleEqualsInt64VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
6724         int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6725         int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6726 
6727         for (int i = 0; i < a.length; i += SPECIES.length()) {
6728             var av = VectorShuffle.fromArray(SPECIES, a, i);
6729             var bv = VectorShuffle.fromArray(SPECIES, b, i);
6730             boolean eq = av.equals(bv);
6731             int to = i + SPECIES.length();
6732             Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
6733         }
6734     }
6735 
6736     @Test(dataProvider = "maskCompareOpProvider")
6737     static void maskEqualsInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6738         boolean[] a = fa.apply(SPECIES.length());
6739         boolean[] b = fb.apply(SPECIES.length());
6740 
6741         for (int i = 0; i < a.length; i += SPECIES.length()) {
6742             var av = SPECIES.loadMask(a, i);
6743             var bv = SPECIES.loadMask(b, i);
6744             boolean equals = av.equals(bv);
6745             int to = i + SPECIES.length();
6746             Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
6747         }
6748     }
6749 
6750     static boolean band(boolean a, boolean b) {
6751         return a & b;
6752     }
6753 
6754     @Test(dataProvider = "maskCompareOpProvider")
6755     static void maskAndInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6756         boolean[] a = fa.apply(SPECIES.length());
6757         boolean[] b = fb.apply(SPECIES.length());
6758         boolean[] r = new boolean[a.length];
6759 
6760         for (int i = 0; i < a.length; i += SPECIES.length()) {
6761             var av = SPECIES.loadMask(a, i);
6762             var bv = SPECIES.loadMask(b, i);
6763             var cv = av.and(bv);
6764             cv.intoArray(r, i);
6765         }
6766         assertArraysEquals(r, a, b, Int64VectorTests::band);
6767     }
6768 
6769     static boolean bor(boolean a, boolean b) {
6770         return a | b;
6771     }
6772 
6773     @Test(dataProvider = "maskCompareOpProvider")
6774     static void maskOrInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6775         boolean[] a = fa.apply(SPECIES.length());
6776         boolean[] b = fb.apply(SPECIES.length());
6777         boolean[] r = new boolean[a.length];
6778 
6779         for (int i = 0; i < a.length; i += SPECIES.length()) {
6780             var av = SPECIES.loadMask(a, i);
6781             var bv = SPECIES.loadMask(b, i);
6782             var cv = av.or(bv);
6783             cv.intoArray(r, i);
6784         }
6785         assertArraysEquals(r, a, b, Int64VectorTests::bor);
6786     }
6787 
6788     static boolean bxor(boolean a, boolean b) {
6789         return a != b;
6790     }
6791 
6792     @Test(dataProvider = "maskCompareOpProvider")
6793     static void maskXorInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6794         boolean[] a = fa.apply(SPECIES.length());
6795         boolean[] b = fb.apply(SPECIES.length());
6796         boolean[] r = new boolean[a.length];
6797 
6798         for (int i = 0; i < a.length; i += SPECIES.length()) {
6799             var av = SPECIES.loadMask(a, i);
6800             var bv = SPECIES.loadMask(b, i);
6801             var cv = av.xor(bv);
6802             cv.intoArray(r, i);
6803         }
6804         assertArraysEquals(r, a, b, Int64VectorTests::bxor);
6805     }
6806 
6807     static boolean bandNot(boolean a, boolean b) {
6808         return a & !b;
6809     }
6810 
6811     @Test(dataProvider = "maskCompareOpProvider")
6812     static void maskAndNotInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6813         boolean[] a = fa.apply(SPECIES.length());
6814         boolean[] b = fb.apply(SPECIES.length());
6815         boolean[] r = new boolean[a.length];
6816 
6817         for (int i = 0; i < a.length; i += SPECIES.length()) {
6818             var av = SPECIES.loadMask(a, i);
6819             var bv = SPECIES.loadMask(b, i);
6820             var cv = av.andNot(bv);
6821             cv.intoArray(r, i);
6822         }
6823         assertArraysEquals(r, a, b, Int64VectorTests::bandNot);
6824     }
6825 
6826     static boolean beq(boolean a, boolean b) {
6827         return (a == b);
6828     }
6829 
6830     @Test(dataProvider = "maskCompareOpProvider")
6831     static void maskEqInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6832         boolean[] a = fa.apply(SPECIES.length());
6833         boolean[] b = fb.apply(SPECIES.length());
6834         boolean[] r = new boolean[a.length];
6835 
6836         for (int i = 0; i < a.length; i += SPECIES.length()) {
6837             var av = SPECIES.loadMask(a, i);
6838             var bv = SPECIES.loadMask(b, i);
6839             var cv = av.eq(bv);
6840             cv.intoArray(r, i);
6841         }
6842         assertArraysEquals(r, a, b, Int64VectorTests::beq);
6843     }
6844 
6845     @Test(dataProvider = "maskProvider")
6846     static void maskHashCodeInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6847         boolean[] a = fa.apply(SPECIES.length());
6848 
6849         for (int i = 0; i < a.length; i += SPECIES.length()) {
6850             var vmask = SPECIES.loadMask(a, i);
6851             int hash = vmask.hashCode();
6852 
6853             boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6854             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
6855             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
6856         }
6857     }
6858 
6859     static int maskTrueCount(boolean[] a, int idx) {
6860         int trueCount = 0;
6861         for (int i = idx; i < idx + SPECIES.length(); i++) {
6862             trueCount += a[i] ? 1 : 0;
6863         }
6864         return trueCount;
6865     }
6866 
6867     @Test(dataProvider = "maskProvider")
6868     static void maskTrueCountInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6869         boolean[] a = fa.apply(SPECIES.length());
6870         int[] r = new int[a.length];
6871 
6872         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6873             for (int i = 0; i < a.length; i += SPECIES.length()) {
6874                 var vmask = SPECIES.loadMask(a, i);
6875                 r[i] = vmask.trueCount();
6876             }
6877         }
6878 
6879         assertMaskReductionArraysEquals(r, a, Int64VectorTests::maskTrueCount);
6880     }
6881 
6882     static int maskLastTrue(boolean[] a, int idx) {
6883         int i = idx + SPECIES.length() - 1;
6884         for (; i >= idx; i--) {
6885             if (a[i]) {
6886                 break;
6887             }
6888         }
6889         return i - idx;
6890     }
6891 
6892     @Test(dataProvider = "maskProvider")
6893     static void maskLastTrueInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6894         boolean[] a = fa.apply(SPECIES.length());
6895         int[] r = new int[a.length];
6896 
6897         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6898             for (int i = 0; i < a.length; i += SPECIES.length()) {
6899                 var vmask = SPECIES.loadMask(a, i);
6900                 r[i] = vmask.lastTrue();
6901             }
6902         }
6903 
6904         assertMaskReductionArraysEquals(r, a, Int64VectorTests::maskLastTrue);
6905     }
6906 
6907     static int maskFirstTrue(boolean[] a, int idx) {
6908         int i = idx;
6909         for (; i < idx + SPECIES.length(); i++) {
6910             if (a[i]) {
6911                 break;
6912             }
6913         }
6914         return i - idx;
6915     }
6916 
6917     @Test(dataProvider = "maskProvider")
6918     static void maskFirstTrueInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6919         boolean[] a = fa.apply(SPECIES.length());
6920         int[] r = new int[a.length];
6921 
6922         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6923             for (int i = 0; i < a.length; i += SPECIES.length()) {
6924                 var vmask = SPECIES.loadMask(a, i);
6925                 r[i] = vmask.firstTrue();
6926             }
6927         }
6928 
6929         assertMaskReductionArraysEquals(r, a, Int64VectorTests::maskFirstTrue);
6930     }
6931 
6932     @Test(dataProvider = "maskProvider")
6933     static void maskCompressInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6934         int trueCount = 0;
6935         boolean[] a = fa.apply(SPECIES.length());
6936 
6937         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6938             for (int i = 0; i < a.length; i += SPECIES.length()) {
6939                 var vmask = SPECIES.loadMask(a, i);
6940                 trueCount = vmask.trueCount();
6941                 var rmask = vmask.compress();
6942                 for (int j = 0; j < SPECIES.length(); j++)  {
6943                     Assert.assertEquals(rmask.laneIsSet(j), j < trueCount);
6944                 }
6945             }
6946         }
6947     }
6948 
6949     @DataProvider
6950     public static Object[][] longMaskProvider() {
6951         return new Object[][]{
6952                 {0xFFFFFFFFFFFFFFFFL},
6953                 {0x0000000000000000L},
6954                 {0x5555555555555555L},
6955                 {0x0123456789abcdefL},
6956         };
6957     }
6958 
6959     @Test(dataProvider = "longMaskProvider")
6960     static void maskFromToLongInt64VectorTestsSmokeTest(long inputLong) {
6961         var vmask = VectorMask.fromLong(SPECIES, inputLong);
6962         long outputLong = vmask.toLong();
6963         Assert.assertEquals(outputLong, (inputLong & (((0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()))))));
6964     }
6965 
6966     @DataProvider
6967     public static Object[][] offsetProvider() {
6968         return new Object[][]{
6969                 {0},
6970                 {-1},
6971                 {+1},
6972                 {+2},
6973                 {-2},
6974         };
6975     }
6976 
6977     @Test(dataProvider = "offsetProvider")
6978     static void indexInRangeInt64VectorTestsSmokeTest(int offset) {
6979         int limit = SPECIES.length() * BUFFER_REPS;
6980         for (int i = 0; i < limit; i += SPECIES.length()) {
6981             var actualMask = SPECIES.indexInRange(i + offset, limit);
6982             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
6983             assert(actualMask.equals(expectedMask));
6984             for (int j = 0; j < SPECIES.length(); j++)  {
6985                 int index = i + j + offset;
6986                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
6987             }
6988         }
6989     }
6990 
6991     @Test(dataProvider = "offsetProvider")
6992     static void indexInRangeLongInt64VectorTestsSmokeTest(int offset) {
6993         long limit = SPECIES.length() * BUFFER_REPS;
6994         for (long i = 0; i < limit; i += SPECIES.length()) {
6995             var actualMask = SPECIES.indexInRange(i + offset, limit);
6996             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
6997             assert(actualMask.equals(expectedMask));
6998             for (int j = 0; j < SPECIES.length(); j++)  {
6999                 long index = i + j + offset;
7000                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
7001             }
7002         }
7003     }
7004 
7005     @DataProvider
7006     public static Object[][] lengthProvider() {
7007         return new Object[][]{
7008                 {0},
7009                 {1},
7010                 {32},
7011                 {37},
7012                 {1024},
7013                 {1024+1},
7014                 {1024+5},
7015         };
7016     }
7017 
7018     @Test(dataProvider = "lengthProvider")
7019     static void loopBoundInt64VectorTestsSmokeTest(int length) {
7020         int actualLoopBound = SPECIES.loopBound(length);
7021         int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
7022         Assert.assertEquals(actualLoopBound, expectedLoopBound);
7023     }
7024 
7025     @Test(dataProvider = "lengthProvider")
7026     static void loopBoundLongInt64VectorTestsSmokeTest(int _length) {
7027         long length = _length;
7028         long actualLoopBound = SPECIES.loopBound(length);
7029         long expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
7030         Assert.assertEquals(actualLoopBound, expectedLoopBound);
7031     }
7032 
7033     @Test
7034     static void ElementSizeInt64VectorTestsSmokeTest() {
7035         IntVector av = IntVector.zero(SPECIES);
7036         int elsize = av.elementSize();
7037         Assert.assertEquals(elsize, Integer.SIZE);
7038     }
7039 
7040     @Test
7041     static void VectorShapeInt64VectorTestsSmokeTest() {
7042         IntVector av = IntVector.zero(SPECIES);
7043         VectorShape vsh = av.shape();
7044         assert(vsh.equals(VectorShape.S_64_BIT));
7045     }
7046 
7047     @Test
7048     static void ShapeWithLanesInt64VectorTestsSmokeTest() {
7049         IntVector av = IntVector.zero(SPECIES);
7050         VectorShape vsh = av.shape();
7051         VectorSpecies species = vsh.withLanes(int.class);
7052         assert(species.equals(SPECIES));
7053     }
7054 
7055     @Test
7056     static void ElementTypeInt64VectorTestsSmokeTest() {
7057         IntVector av = IntVector.zero(SPECIES);
7058         assert(av.species().elementType() == int.class);
7059     }
7060 
7061     @Test
7062     static void SpeciesElementSizeInt64VectorTestsSmokeTest() {
7063         IntVector av = IntVector.zero(SPECIES);
7064         assert(av.species().elementSize() == Integer.SIZE);
7065     }
7066 
7067     @Test
7068     static void VectorTypeInt64VectorTestsSmokeTest() {
7069         IntVector av = IntVector.zero(SPECIES);
7070         assert(av.species().vectorType() == av.getClass());
7071     }
7072 
7073     @Test
7074     static void WithLanesInt64VectorTestsSmokeTest() {
7075         IntVector av = IntVector.zero(SPECIES);
7076         VectorSpecies species = av.species().withLanes(int.class);
7077         assert(species.equals(SPECIES));
7078     }
7079 
7080     @Test
7081     static void WithShapeInt64VectorTestsSmokeTest() {
7082         IntVector av = IntVector.zero(SPECIES);
7083         VectorShape vsh = av.shape();
7084         VectorSpecies species = av.species().withShape(vsh);
7085         assert(species.equals(SPECIES));
7086     }
7087 
7088     @Test
7089     static void MaskAllTrueInt64VectorTestsSmokeTest() {
7090         for (int ic = 0; ic < INVOC_COUNT; ic++) {
7091           Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
7092         }
7093     }
7094 }
--- EOF ---