1 /*
   2  * Copyright (c) 2018, 2022, 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  * @modules jdk.incubator.vector
  27  * @run testng/othervm -ea -esa -Xbatch -XX:-TieredCompilation Long256VectorTests
  28  */
  29 
  30 // -- This file was mechanically generated: Do not edit! -- //
  31 
  32 import jdk.incubator.vector.VectorShape;
  33 import jdk.incubator.vector.VectorSpecies;
  34 import jdk.incubator.vector.VectorShuffle;
  35 import jdk.incubator.vector.VectorMask;
  36 import jdk.incubator.vector.VectorOperators;
  37 import jdk.incubator.vector.Vector;
  38 
  39 import jdk.incubator.vector.LongVector;
  40 
  41 import org.testng.Assert;
  42 import org.testng.annotations.DataProvider;
  43 import org.testng.annotations.Test;
  44 
  45 import java.lang.Integer;
  46 import java.util.List;
  47 import java.util.Arrays;
  48 import java.util.function.BiFunction;
  49 import java.util.function.IntFunction;
  50 import java.util.Objects;
  51 import java.util.stream.Collectors;
  52 import java.util.stream.Stream;
  53 
  54 @Test
  55 public class Long256VectorTests extends AbstractVectorTest {
  56 
  57     static final VectorSpecies<Long> SPECIES =
  58                 LongVector.SPECIES_256;
  59 
  60     static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
  61 
  62 
  63     private static final long CONST_SHIFT = Long.SIZE / 2;
  64 
  65     static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 256);
  66 
  67     interface FUnOp {
  68         long apply(long a);
  69     }
  70 
  71     static void assertArraysEquals(long[] r, long[] a, FUnOp f) {
  72         int i = 0;
  73         try {
  74             for (; i < a.length; i++) {
  75                 Assert.assertEquals(r[i], f.apply(a[i]));
  76             }
  77         } catch (AssertionError e) {
  78             Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
  79         }
  80     }
  81 
  82     interface FUnArrayOp {
  83         long[] apply(long a);
  84     }
  85 
  86     static void assertArraysEquals(long[] r, long[] a, FUnArrayOp f) {
  87         int i = 0;
  88         try {
  89             for (; i < a.length; i += SPECIES.length()) {
  90                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
  91                   f.apply(a[i]));
  92             }
  93         } catch (AssertionError e) {
  94             long[] ref = f.apply(a[i]);
  95             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
  96             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
  97               + ", res: " + Arrays.toString(res)
  98               + "), at index #" + i);
  99         }
 100     }
 101 
 102     static void assertArraysEquals(long[] r, long[] a, boolean[] mask, FUnOp f) {
 103         int i = 0;
 104         try {
 105             for (; i < a.length; i++) {
 106                 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
 107             }
 108         } catch (AssertionError e) {
 109             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()]);
 110         }
 111     }
 112 
 113     interface FReductionOp {
 114         long apply(long[] a, int idx);
 115     }
 116 
 117     interface FReductionAllOp {
 118         long apply(long[] a);
 119     }
 120 
 121     static void assertReductionArraysEquals(long[] r, long rc, long[] a,
 122                                             FReductionOp f, FReductionAllOp fa) {
 123         int i = 0;
 124         try {
 125             Assert.assertEquals(rc, fa.apply(a));
 126             for (; i < a.length; i += SPECIES.length()) {
 127                 Assert.assertEquals(r[i], f.apply(a, i));
 128             }
 129         } catch (AssertionError e) {
 130             Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
 131             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 132         }
 133     }
 134 
 135     interface FReductionMaskedOp {
 136         long apply(long[] a, int idx, boolean[] mask);
 137     }
 138 
 139     interface FReductionAllMaskedOp {
 140         long apply(long[] a, boolean[] mask);
 141     }
 142 
 143     static void assertReductionArraysEqualsMasked(long[] r, long rc, long[] a, boolean[] mask,
 144                                             FReductionMaskedOp f, FReductionAllMaskedOp fa) {
 145         int i = 0;
 146         try {
 147             Assert.assertEquals(rc, fa.apply(a, mask));
 148             for (; i < a.length; i += SPECIES.length()) {
 149                 Assert.assertEquals(r[i], f.apply(a, i, mask));
 150             }
 151         } catch (AssertionError e) {
 152             Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
 153             Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
 154         }
 155     }
 156 
 157 
 158     interface FBoolReductionOp {
 159         boolean apply(boolean[] a, int idx);
 160     }
 161 
 162     static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) {
 163         int i = 0;
 164         try {
 165             for (; i < a.length; i += SPECIES.length()) {
 166                 Assert.assertEquals(r[i], f.apply(a, i));
 167             }
 168         } catch (AssertionError e) {
 169             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 170         }
 171     }
 172 
 173     interface FMaskReductionOp {
 174         int apply(boolean[] a, int idx);
 175     }
 176 
 177     static void assertMaskReductionArraysEquals(int[] r, boolean[] a, FMaskReductionOp f) {
 178         int i = 0;
 179         try {
 180             for (; i < a.length; i += SPECIES.length()) {
 181                 Assert.assertEquals(r[i], f.apply(a, i));
 182             }
 183         } catch (AssertionError e) {
 184             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 185         }
 186     }
 187 
 188     static void assertInsertArraysEquals(long[] r, long[] a, long element, int index, int start, int end) {
 189         int i = start;
 190         try {
 191             for (; i < end; i += 1) {
 192                 if(i%SPECIES.length() == index) {
 193                     Assert.assertEquals(r[i], element);
 194                 } else {
 195                     Assert.assertEquals(r[i], a[i]);
 196                 }
 197             }
 198         } catch (AssertionError e) {
 199             if (i%SPECIES.length() == index) {
 200                 Assert.assertEquals(r[i], element, "at index #" + i);
 201             } else {
 202                 Assert.assertEquals(r[i], a[i], "at index #" + i);
 203             }
 204         }
 205     }
 206 
 207     static void assertRearrangeArraysEquals(long[] r, long[] a, int[] order, int vector_len) {
 208         int i = 0, j = 0;
 209         try {
 210             for (; i < a.length; i += vector_len) {
 211                 for (j = 0; j < vector_len; j++) {
 212                     Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 213                 }
 214             }
 215         } catch (AssertionError e) {
 216             int idx = i + j;
 217             Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
 218         }
 219     }
 220 
 221     static void assertcompressArraysEquals(long[] r, long[] a, boolean[] m, int vector_len) {
 222         int i = 0, j = 0, k = 0;
 223         try {
 224             for (; i < a.length; i += vector_len) {
 225                 k = 0;
 226                 for (j = 0; j < vector_len; j++) {
 227                     if (m[(i + j) % SPECIES.length()]) {
 228                         Assert.assertEquals(r[i + k], a[i + j]);
 229                         k++;
 230                     }
 231                 }
 232                 for (; k < vector_len; k++) {
 233                     Assert.assertEquals(r[i + k], (long)0);
 234                 }
 235             }
 236         } catch (AssertionError e) {
 237             int idx = i + k;
 238             if (m[(i + j) % SPECIES.length()]) {
 239                 Assert.assertEquals(r[idx], a[i + j], "at index #" + idx);
 240             } else {
 241                 Assert.assertEquals(r[idx], (long)0, "at index #" + idx);
 242             }
 243         }
 244     }
 245 
 246     static void assertexpandArraysEquals(long[] r, long[] a, boolean[] m, int vector_len) {
 247         int i = 0, j = 0, k = 0;
 248         try {
 249             for (; i < a.length; i += vector_len) {
 250                 k = 0;
 251                 for (j = 0; j < vector_len; j++) {
 252                     if (m[(i + j) % SPECIES.length()]) {
 253                         Assert.assertEquals(r[i + j], a[i + k]);
 254                         k++;
 255                     } else {
 256                         Assert.assertEquals(r[i + j], (long)0);
 257                     }
 258                 }
 259             }
 260         } catch (AssertionError e) {
 261             int idx = i + j;
 262             if (m[idx % SPECIES.length()]) {
 263                 Assert.assertEquals(r[idx], a[i + k], "at index #" + idx);
 264             } else {
 265                 Assert.assertEquals(r[idx], (long)0, "at index #" + idx);
 266             }
 267         }
 268     }
 269 
 270     static void assertSelectFromArraysEquals(long[] r, long[] a, long[] order, int vector_len) {
 271         int i = 0, j = 0;
 272         try {
 273             for (; i < a.length; i += vector_len) {
 274                 for (j = 0; j < vector_len; j++) {
 275                     Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 276                 }
 277             }
 278         } catch (AssertionError e) {
 279             int idx = i + j;
 280             Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
 281         }
 282     }
 283 
 284     static void assertRearrangeArraysEquals(long[] r, long[] a, int[] order, boolean[] mask, int vector_len) {
 285         int i = 0, j = 0;
 286         try {
 287             for (; i < a.length; i += vector_len) {
 288                 for (j = 0; j < vector_len; j++) {
 289                     if (mask[j % SPECIES.length()])
 290                          Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 291                     else
 292                          Assert.assertEquals(r[i+j], (long)0);
 293                 }
 294             }
 295         } catch (AssertionError e) {
 296             int idx = i + j;
 297             if (mask[j % SPECIES.length()])
 298                 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 299             else
 300                 Assert.assertEquals(r[i+j], (long)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 301         }
 302     }
 303 
 304     static void assertSelectFromArraysEquals(long[] r, long[] a, long[] order, boolean[] mask, int vector_len) {
 305         int i = 0, j = 0;
 306         try {
 307             for (; i < a.length; i += vector_len) {
 308                 for (j = 0; j < vector_len; j++) {
 309                     if (mask[j % SPECIES.length()])
 310                          Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 311                     else
 312                          Assert.assertEquals(r[i+j], (long)0);
 313                 }
 314             }
 315         } catch (AssertionError e) {
 316             int idx = i + j;
 317             if (mask[j % SPECIES.length()])
 318                 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()]);
 319             else
 320                 Assert.assertEquals(r[i+j], (long)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 321         }
 322     }
 323 
 324     static void assertBroadcastArraysEquals(long[] r, long[] a) {
 325         int i = 0;
 326         for (; i < a.length; i += SPECIES.length()) {
 327             int idx = i;
 328             for (int j = idx; j < (idx + SPECIES.length()); j++)
 329                 a[j]=a[idx];
 330         }
 331 
 332         try {
 333             for (i = 0; i < a.length; i++) {
 334                 Assert.assertEquals(r[i], a[i]);
 335             }
 336         } catch (AssertionError e) {
 337             Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
 338         }
 339     }
 340 
 341     interface FBinOp {
 342         long apply(long a, long b);
 343     }
 344 
 345     interface FBinMaskOp {
 346         long apply(long a, long b, boolean m);
 347 
 348         static FBinMaskOp lift(FBinOp f) {
 349             return (a, b, m) -> m ? f.apply(a, b) : a;
 350         }
 351     }
 352 
 353     static void assertArraysEquals(long[] r, long[] a, long[] b, FBinOp f) {
 354         int i = 0;
 355         try {
 356             for (; i < a.length; i++) {
 357                 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
 358             }
 359         } catch (AssertionError e) {
 360             Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
 361         }
 362     }
 363 
 364     static void assertBroadcastArraysEquals(long[] r, long[] a, long[] b, FBinOp f) {
 365         int i = 0;
 366         try {
 367             for (; i < a.length; i++) {
 368                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
 369             }
 370         } catch (AssertionError e) {
 371             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
 372                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 373         }
 374     }
 375 
 376     static void assertBroadcastLongArraysEquals(long[] r, long[] a, long[] b, FBinOp f) {
 377         int i = 0;
 378         try {
 379             for (; i < a.length; i++) {
 380                 Assert.assertEquals(r[i], f.apply(a[i], (long)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
 381             }
 382         } catch (AssertionError e) {
 383             Assert.assertEquals(r[i], f.apply(a[i], (long)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
 384                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 385         }
 386     }
 387 
 388     static void assertArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinOp f) {
 389         assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 390     }
 391 
 392     static void assertArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinMaskOp f) {
 393         int i = 0;
 394         try {
 395             for (; i < a.length; i++) {
 396                 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
 397             }
 398         } catch (AssertionError err) {
 399             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()]);
 400         }
 401     }
 402 
 403     static void assertBroadcastArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinOp f) {
 404         assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 405     }
 406 
 407     static void assertBroadcastArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinMaskOp f) {
 408         int i = 0;
 409         try {
 410             for (; i < a.length; i++) {
 411                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 412             }
 413         } catch (AssertionError err) {
 414             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 415                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 416                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 417                                 mask[i % SPECIES.length()]);
 418         }
 419     }
 420 
 421     static void assertBroadcastLongArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinOp f) {
 422         assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 423     }
 424 
 425     static void assertBroadcastLongArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinMaskOp f) {
 426         int i = 0;
 427         try {
 428             for (; i < a.length; i++) {
 429                 Assert.assertEquals(r[i], f.apply(a[i], (long)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
 430             }
 431         } catch (AssertionError err) {
 432             Assert.assertEquals(r[i], f.apply(a[i], (long)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
 433                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 434                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 435                                 mask[i % SPECIES.length()]);
 436         }
 437     }
 438 
 439     static void assertShiftArraysEquals(long[] r, long[] a, long[] b, FBinOp f) {
 440         int i = 0;
 441         int j = 0;
 442         try {
 443             for (; j < a.length; j += SPECIES.length()) {
 444                 for (i = 0; i < SPECIES.length(); i++) {
 445                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
 446                 }
 447             }
 448         } catch (AssertionError e) {
 449             Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
 450         }
 451     }
 452 
 453     static void assertShiftArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinOp f) {
 454         assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 455     }
 456 
 457     static void assertShiftArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinMaskOp f) {
 458         int i = 0;
 459         int j = 0;
 460         try {
 461             for (; j < a.length; j += SPECIES.length()) {
 462                 for (i = 0; i < SPECIES.length(); i++) {
 463                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
 464                 }
 465             }
 466         } catch (AssertionError err) {
 467             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]);
 468         }
 469     }
 470 
 471     interface FBinConstOp {
 472         long apply(long a);
 473     }
 474 
 475     interface FBinConstMaskOp {
 476         long apply(long a, boolean m);
 477 
 478         static FBinConstMaskOp lift(FBinConstOp f) {
 479             return (a, m) -> m ? f.apply(a) : a;
 480         }
 481     }
 482 
 483     static void assertShiftConstEquals(long[] r, long[] a, FBinConstOp f) {
 484         int i = 0;
 485         int j = 0;
 486         try {
 487             for (; j < a.length; j += SPECIES.length()) {
 488                 for (i = 0; i < SPECIES.length(); i++) {
 489                     Assert.assertEquals(r[i+j], f.apply(a[i+j]));
 490                 }
 491             }
 492         } catch (AssertionError e) {
 493             Assert.assertEquals(r[i+j], f.apply(a[i+j]), "at index #" + i + ", " + j);
 494         }
 495     }
 496 
 497     static void assertShiftConstEquals(long[] r, long[] a, boolean[] mask, FBinConstOp f) {
 498         assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f));
 499     }
 500 
 501     static void assertShiftConstEquals(long[] r, long[] a, boolean[] mask, FBinConstMaskOp f) {
 502         int i = 0;
 503         int j = 0;
 504         try {
 505             for (; j < a.length; j += SPECIES.length()) {
 506                 for (i = 0; i < SPECIES.length(); i++) {
 507                     Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]));
 508                 }
 509             }
 510         } catch (AssertionError err) {
 511             Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", mask = " + mask[i]);
 512         }
 513     }
 514 
 515     interface FTernOp {
 516         long apply(long a, long b, long c);
 517     }
 518 
 519     interface FTernMaskOp {
 520         long apply(long a, long b, long c, boolean m);
 521 
 522         static FTernMaskOp lift(FTernOp f) {
 523             return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
 524         }
 525     }
 526 
 527     static void assertArraysEquals(long[] r, long[] a, long[] b, long[] c, FTernOp f) {
 528         int i = 0;
 529         try {
 530             for (; i < a.length; i++) {
 531                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
 532             }
 533         } catch (AssertionError e) {
 534             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 535         }
 536     }
 537 
 538     static void assertArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask, FTernOp f) {
 539         assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 540     }
 541 
 542     static void assertArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask, FTernMaskOp f) {
 543         int i = 0;
 544         try {
 545             for (; i < a.length; i++) {
 546                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
 547             }
 548         } catch (AssertionError err) {
 549             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
 550               + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 551         }
 552     }
 553 
 554     static void assertBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, FTernOp f) {
 555         int i = 0;
 556         try {
 557             for (; i < a.length; i++) {
 558                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
 559             }
 560         } catch (AssertionError e) {
 561             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
 562                                 i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
 563                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 564         }
 565     }
 566 
 567     static void assertAltBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, FTernOp f) {
 568         int i = 0;
 569         try {
 570             for (; i < a.length; i++) {
 571                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
 572             }
 573         } catch (AssertionError e) {
 574             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
 575                                 i + ", input1 = " + a[i] + ", input2 = " +
 576                                 b[(i / SPECIES.length()) * SPECIES.length()] + ",  input3 = " + c[i]);
 577         }
 578     }
 579 
 580     static void assertBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask,
 581                                             FTernOp f) {
 582         assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 583     }
 584 
 585     static void assertBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask,
 586                                             FTernMaskOp f) {
 587         int i = 0;
 588         try {
 589             for (; i < a.length; i++) {
 590                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 591                                     mask[i % SPECIES.length()]));
 592             }
 593         } catch (AssertionError err) {
 594             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 595                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
 596                                 b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 597                                 mask[i % SPECIES.length()]);
 598         }
 599     }
 600 
 601     static void assertAltBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask,
 602                                             FTernOp f) {
 603         assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 604     }
 605 
 606     static void assertAltBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask,
 607                                             FTernMaskOp f) {
 608         int i = 0;
 609         try {
 610             for (; i < a.length; i++) {
 611                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 612                                     mask[i % SPECIES.length()]));
 613             }
 614         } catch (AssertionError err) {
 615             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 616                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 617                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 618                                 ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 619         }
 620     }
 621 
 622     static void assertDoubleBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, FTernOp f) {
 623         int i = 0;
 624         try {
 625             for (; i < a.length; i++) {
 626                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 627                                     c[(i / SPECIES.length()) * SPECIES.length()]));
 628             }
 629         } catch (AssertionError e) {
 630             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 631                                 c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
 632                                 + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
 633                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 634         }
 635     }
 636 
 637     static void assertDoubleBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask,
 638                                                   FTernOp f) {
 639         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 640     }
 641 
 642     static void assertDoubleBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask,
 643                                                   FTernMaskOp f) {
 644         int i = 0;
 645         try {
 646             for (; i < a.length; i++) {
 647                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 648                                     c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 649             }
 650         } catch (AssertionError err) {
 651             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 652                                 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
 653                                 + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 654                                 ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 655                                 mask[i % SPECIES.length()]);
 656         }
 657     }
 658 
 659 
 660 
 661     interface FBinArrayOp {
 662         long apply(long[] a, int b);
 663     }
 664 
 665     static void assertArraysEquals(long[] r, long[] a, FBinArrayOp f) {
 666         int i = 0;
 667         try {
 668             for (; i < a.length; i++) {
 669                 Assert.assertEquals(r[i], f.apply(a, i));
 670             }
 671         } catch (AssertionError e) {
 672             Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i);
 673         }
 674     }
 675 
 676     interface FGatherScatterOp {
 677         long[] apply(long[] a, int ix, int[] b, int iy);
 678     }
 679 
 680     static void assertArraysEquals(long[] r, long[] a, int[] b, FGatherScatterOp f) {
 681         int i = 0;
 682         try {
 683             for (; i < a.length; i += SPECIES.length()) {
 684                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 685                   f.apply(a, i, b, i));
 686             }
 687         } catch (AssertionError e) {
 688             long[] ref = f.apply(a, i, b, i);
 689             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 690             Assert.assertEquals(res, ref,
 691               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 692               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 693               + ", b: "
 694               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 695               + " at index #" + i);
 696         }
 697     }
 698 
 699     interface FGatherMaskedOp {
 700         long[] apply(long[] a, int ix, boolean[] mask, int[] b, int iy);
 701     }
 702 
 703     interface FScatterMaskedOp {
 704         long[] apply(long[] r, long[] a, int ix, boolean[] mask, int[] b, int iy);
 705     }
 706 
 707     static void assertArraysEquals(long[] r, long[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
 708         int i = 0;
 709         try {
 710             for (; i < a.length; i += SPECIES.length()) {
 711                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 712                   f.apply(a, i, mask, b, i));
 713             }
 714         } catch (AssertionError e) {
 715             long[] ref = f.apply(a, i, mask, b, i);
 716             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 717             Assert.assertEquals(res, ref,
 718               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 719               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 720               + ", b: "
 721               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 722               + ", mask: "
 723               + Arrays.toString(mask)
 724               + " at index #" + i);
 725         }
 726     }
 727 
 728     static void assertArraysEquals(long[] r, long[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
 729         int i = 0;
 730         try {
 731             for (; i < a.length; i += SPECIES.length()) {
 732                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 733                   f.apply(r, a, i, mask, b, i));
 734             }
 735         } catch (AssertionError e) {
 736             long[] ref = f.apply(r, a, i, mask, b, i);
 737             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 738             Assert.assertEquals(res, ref,
 739               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 740               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 741               + ", b: "
 742               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 743               + ", r: "
 744               + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
 745               + ", mask: "
 746               + Arrays.toString(mask)
 747               + " at index #" + i);
 748         }
 749     }
 750 
 751     interface FLaneOp {
 752         long[] apply(long[] a, int origin, int idx);
 753     }
 754 
 755     static void assertArraysEquals(long[] r, long[] a, int origin, FLaneOp f) {
 756         int i = 0;
 757         try {
 758             for (; i < a.length; i += SPECIES.length()) {
 759                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 760                   f.apply(a, origin, i));
 761             }
 762         } catch (AssertionError e) {
 763             long[] ref = f.apply(a, origin, i);
 764             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 765             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 766               + ", res: " + Arrays.toString(res)
 767               + "), at index #" + i);
 768         }
 769     }
 770 
 771     interface FLaneBop {
 772         long[] apply(long[] a, long[] b, int origin, int idx);
 773     }
 774 
 775     static void assertArraysEquals(long[] r, long[] a, long[] b, int origin, FLaneBop f) {
 776         int i = 0;
 777         try {
 778             for (; i < a.length; i += SPECIES.length()) {
 779                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 780                   f.apply(a, b, origin, i));
 781             }
 782         } catch (AssertionError e) {
 783             long[] ref = f.apply(a, b, origin, i);
 784             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 785             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 786               + ", res: " + Arrays.toString(res)
 787               + "), at index #" + i
 788               + ", at origin #" + origin);
 789         }
 790     }
 791 
 792     interface FLaneMaskedBop {
 793         long[] apply(long[] a, long[] b, int origin, boolean[] mask, int idx);
 794     }
 795 
 796     static void assertArraysEquals(long[] r, long[] a, long[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
 797         int i = 0;
 798         try {
 799             for (; i < a.length; i += SPECIES.length()) {
 800                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 801                   f.apply(a, b, origin, mask, i));
 802             }
 803         } catch (AssertionError e) {
 804             long[] ref = f.apply(a, b, origin, mask, i);
 805             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 806             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 807               + ", res: " + Arrays.toString(res)
 808               + "), at index #" + i
 809               + ", at origin #" + origin);
 810         }
 811     }
 812 
 813     interface FLanePartBop {
 814         long[] apply(long[] a, long[] b, int origin, int part, int idx);
 815     }
 816 
 817     static void assertArraysEquals(long[] r, long[] a, long[] b, int origin, int part, FLanePartBop f) {
 818         int i = 0;
 819         try {
 820             for (; i < a.length; i += SPECIES.length()) {
 821                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 822                   f.apply(a, b, origin, part, i));
 823             }
 824         } catch (AssertionError e) {
 825             long[] ref = f.apply(a, b, origin, part, i);
 826             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 827             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 828               + ", res: " + Arrays.toString(res)
 829               + "), at index #" + i
 830               + ", at origin #" + origin
 831               + ", with part #" + part);
 832         }
 833     }
 834 
 835     interface FLanePartMaskedBop {
 836         long[] apply(long[] a, long[] b, int origin, int part, boolean[] mask, int idx);
 837     }
 838 
 839     static void assertArraysEquals(long[] r, long[] a, long[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
 840         int i = 0;
 841         try {
 842             for (; i < a.length; i += SPECIES.length()) {
 843                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 844                   f.apply(a, b, origin, part, mask, i));
 845             }
 846         } catch (AssertionError e) {
 847             long[] ref = f.apply(a, b, origin, part, mask, i);
 848             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 849             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 850               + ", res: " + Arrays.toString(res)
 851               + "), at index #" + i
 852               + ", at origin #" + origin
 853               + ", with part #" + part);
 854         }
 855     }
 856 
 857     static int intCornerCaseValue(int i) {
 858         switch(i % 5) {
 859             case 0:
 860                 return Integer.MAX_VALUE;
 861             case 1:
 862                 return Integer.MIN_VALUE;
 863             case 2:
 864                 return Integer.MIN_VALUE;
 865             case 3:
 866                 return Integer.MAX_VALUE;
 867             default:
 868                 return (int)0;
 869         }
 870     }
 871 
 872     static final List<IntFunction<long[]>> INT_LONG_GENERATORS = List.of(
 873             withToString("long[-i * 5]", (int s) -> {
 874                 return fill(s * BUFFER_REPS,
 875                             i -> (long)(-i * 5));
 876             }),
 877             withToString("long[i * 5]", (int s) -> {
 878                 return fill(s * BUFFER_REPS,
 879                             i -> (long)(i * 5));
 880             }),
 881             withToString("long[i + 1]", (int s) -> {
 882                 return fill(s * BUFFER_REPS,
 883                             i -> (((long)(i + 1) == 0) ? 1 : (long)(i + 1)));
 884             }),
 885             withToString("long[intCornerCaseValue(i)]", (int s) -> {
 886                 return fill(s * BUFFER_REPS,
 887                             i -> (long)intCornerCaseValue(i));
 888             })
 889     );
 890 
 891     static void assertArraysEquals(int[] r, long[] a, int offs) {
 892         int i = 0;
 893         try {
 894             for (; i < r.length; i++) {
 895                 Assert.assertEquals(r[i], (int)(a[i+offs]));
 896             }
 897         } catch (AssertionError e) {
 898             Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 899         }
 900     }
 901 
 902 
 903 
 904     static void assertArraysEquals(long[] r, long[] a, int offs) {
 905         int i = 0;
 906         try {
 907             for (; i < r.length; i++) {
 908                 Assert.assertEquals(r[i], (long)(a[i+offs]));
 909             }
 910         } catch (AssertionError e) {
 911             Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 912         }
 913     }
 914 
 915     static void assertArraysEquals(double[] r, long[] a, int offs) {
 916         int i = 0;
 917         try {
 918             for (; i < r.length; i++) {
 919                 Assert.assertEquals(r[i], (double)(a[i+offs]));
 920             }
 921         } catch (AssertionError e) {
 922             Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 923         }
 924     }
 925 
 926     static long bits(long e) {
 927         return  e;
 928     }
 929 
 930     static final List<IntFunction<long[]>> LONG_GENERATORS = List.of(
 931             withToString("long[-i * 5]", (int s) -> {
 932                 return fill(s * BUFFER_REPS,
 933                             i -> (long)(-i * 5));
 934             }),
 935             withToString("long[i * 5]", (int s) -> {
 936                 return fill(s * BUFFER_REPS,
 937                             i -> (long)(i * 5));
 938             }),
 939             withToString("long[i + 1]", (int s) -> {
 940                 return fill(s * BUFFER_REPS,
 941                             i -> (((long)(i + 1) == 0) ? 1 : (long)(i + 1)));
 942             }),
 943             withToString("long[cornerCaseValue(i)]", (int s) -> {
 944                 return fill(s * BUFFER_REPS,
 945                             i -> cornerCaseValue(i));
 946             })
 947     );
 948 
 949     // Create combinations of pairs
 950     // @@@ Might be sensitive to order e.g. div by 0
 951     static final List<List<IntFunction<long[]>>> LONG_GENERATOR_PAIRS =
 952         Stream.of(LONG_GENERATORS.get(0)).
 953                 flatMap(fa -> LONG_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
 954                 collect(Collectors.toList());
 955 
 956     @DataProvider
 957     public Object[][] boolUnaryOpProvider() {
 958         return BOOL_ARRAY_GENERATORS.stream().
 959                 map(f -> new Object[]{f}).
 960                 toArray(Object[][]::new);
 961     }
 962 
 963     static final List<List<IntFunction<long[]>>> LONG_GENERATOR_TRIPLES =
 964         LONG_GENERATOR_PAIRS.stream().
 965                 flatMap(pair -> LONG_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
 966                 collect(Collectors.toList());
 967 
 968     @DataProvider
 969     public Object[][] longBinaryOpProvider() {
 970         return LONG_GENERATOR_PAIRS.stream().map(List::toArray).
 971                 toArray(Object[][]::new);
 972     }
 973 
 974     @DataProvider
 975     public Object[][] longIndexedOpProvider() {
 976         return LONG_GENERATOR_PAIRS.stream().map(List::toArray).
 977                 toArray(Object[][]::new);
 978     }
 979 
 980     @DataProvider
 981     public Object[][] longBinaryOpMaskProvider() {
 982         return BOOLEAN_MASK_GENERATORS.stream().
 983                 flatMap(fm -> LONG_GENERATOR_PAIRS.stream().map(lfa -> {
 984                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
 985                 })).
 986                 toArray(Object[][]::new);
 987     }
 988 
 989     @DataProvider
 990     public Object[][] longTernaryOpProvider() {
 991         return LONG_GENERATOR_TRIPLES.stream().map(List::toArray).
 992                 toArray(Object[][]::new);
 993     }
 994 
 995     @DataProvider
 996     public Object[][] longTernaryOpMaskProvider() {
 997         return BOOLEAN_MASK_GENERATORS.stream().
 998                 flatMap(fm -> LONG_GENERATOR_TRIPLES.stream().map(lfa -> {
 999                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1000                 })).
1001                 toArray(Object[][]::new);
1002     }
1003 
1004     @DataProvider
1005     public Object[][] longUnaryOpProvider() {
1006         return LONG_GENERATORS.stream().
1007                 map(f -> new Object[]{f}).
1008                 toArray(Object[][]::new);
1009     }
1010 
1011     @DataProvider
1012     public Object[][] longUnaryOpMaskProvider() {
1013         return BOOLEAN_MASK_GENERATORS.stream().
1014                 flatMap(fm -> LONG_GENERATORS.stream().map(fa -> {
1015                     return new Object[] {fa, fm};
1016                 })).
1017                 toArray(Object[][]::new);
1018     }
1019 
1020     @DataProvider
1021     public Object[][] longtoIntUnaryOpProvider() {
1022         return INT_LONG_GENERATORS.stream().
1023                 map(f -> new Object[]{f}).
1024                 toArray(Object[][]::new);
1025     }
1026 
1027     @DataProvider
1028     public Object[][] maskProvider() {
1029         return BOOLEAN_MASK_GENERATORS.stream().
1030                 map(f -> new Object[]{f}).
1031                 toArray(Object[][]::new);
1032     }
1033 
1034     @DataProvider
1035     public Object[][] maskCompareOpProvider() {
1036         return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1037                 toArray(Object[][]::new);
1038     }
1039 
1040     @DataProvider
1041     public Object[][] shuffleProvider() {
1042         return INT_SHUFFLE_GENERATORS.stream().
1043                 map(f -> new Object[]{f}).
1044                 toArray(Object[][]::new);
1045     }
1046 
1047     @DataProvider
1048     public Object[][] shuffleCompareOpProvider() {
1049         return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1050                 toArray(Object[][]::new);
1051     }
1052 
1053     @DataProvider
1054     public Object[][] longUnaryOpShuffleProvider() {
1055         return INT_SHUFFLE_GENERATORS.stream().
1056                 flatMap(fs -> LONG_GENERATORS.stream().map(fa -> {
1057                     return new Object[] {fa, fs};
1058                 })).
1059                 toArray(Object[][]::new);
1060     }
1061 
1062     @DataProvider
1063     public Object[][] longUnaryOpShuffleMaskProvider() {
1064         return BOOLEAN_MASK_GENERATORS.stream().
1065                 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
1066                     flatMap(fs -> LONG_GENERATORS.stream().map(fa -> {
1067                         return new Object[] {fa, fs, fm};
1068                 }))).
1069                 toArray(Object[][]::new);
1070     }
1071 
1072     static final List<BiFunction<Integer,Integer,long[]>> LONG_SHUFFLE_GENERATORS = List.of(
1073             withToStringBi("shuffle[random]", (Integer l, Integer m) -> {
1074                 long[] a = new long[l];
1075                 int upper = m;
1076                 for (int i = 0; i < 1; i++) {
1077                     a[i] = (long)RAND.nextInt(upper);
1078                 }
1079                 return a;
1080             })
1081     );
1082 
1083     @DataProvider
1084     public Object[][] longUnaryOpSelectFromProvider() {
1085         return LONG_SHUFFLE_GENERATORS.stream().
1086                 flatMap(fs -> LONG_GENERATORS.stream().map(fa -> {
1087                     return new Object[] {fa, fs};
1088                 })).
1089                 toArray(Object[][]::new);
1090     }
1091 
1092     @DataProvider
1093     public Object[][] longUnaryOpSelectFromMaskProvider() {
1094         return BOOLEAN_MASK_GENERATORS.stream().
1095                 flatMap(fm -> LONG_SHUFFLE_GENERATORS.stream().
1096                     flatMap(fs -> LONG_GENERATORS.stream().map(fa -> {
1097                         return new Object[] {fa, fs, fm};
1098                 }))).
1099                 toArray(Object[][]::new);
1100     }
1101 
1102     static final List<IntFunction<long[]>> LONG_COMPARE_GENERATORS = List.of(
1103             withToString("long[i]", (int s) -> {
1104                 return fill(s * BUFFER_REPS,
1105                             i -> (long)i);
1106             }),
1107             withToString("long[i - length / 2]", (int s) -> {
1108                 return fill(s * BUFFER_REPS,
1109                             i -> (long)(i - (s * BUFFER_REPS / 2)));
1110             }),
1111             withToString("long[i + 1]", (int s) -> {
1112                 return fill(s * BUFFER_REPS,
1113                             i -> (long)(i + 1));
1114             }),
1115             withToString("long[i - 2]", (int s) -> {
1116                 return fill(s * BUFFER_REPS,
1117                             i -> (long)(i - 2));
1118             }),
1119             withToString("long[zigZag(i)]", (int s) -> {
1120                 return fill(s * BUFFER_REPS,
1121                             i -> i%3 == 0 ? (long)i : (i%3 == 1 ? (long)(i + 1) : (long)(i - 2)));
1122             }),
1123             withToString("long[cornerCaseValue(i)]", (int s) -> {
1124                 return fill(s * BUFFER_REPS,
1125                             i -> cornerCaseValue(i));
1126             })
1127     );
1128 
1129     static final List<List<IntFunction<long[]>>> LONG_TEST_GENERATOR_ARGS =
1130         LONG_COMPARE_GENERATORS.stream().
1131                 map(fa -> List.of(fa)).
1132                 collect(Collectors.toList());
1133 
1134     @DataProvider
1135     public Object[][] longTestOpProvider() {
1136         return LONG_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1137                 toArray(Object[][]::new);
1138     }
1139 
1140     @DataProvider
1141     public Object[][] longTestOpMaskProvider() {
1142         return BOOLEAN_MASK_GENERATORS.stream().
1143                 flatMap(fm -> LONG_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1144                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1145                 })).
1146                 toArray(Object[][]::new);
1147     }
1148 
1149     static final List<List<IntFunction<long[]>>> LONG_COMPARE_GENERATOR_PAIRS =
1150         LONG_COMPARE_GENERATORS.stream().
1151                 flatMap(fa -> LONG_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1152                 collect(Collectors.toList());
1153 
1154     @DataProvider
1155     public Object[][] longCompareOpProvider() {
1156         return LONG_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1157                 toArray(Object[][]::new);
1158     }
1159 
1160     @DataProvider
1161     public Object[][] longCompareOpMaskProvider() {
1162         return BOOLEAN_MASK_GENERATORS.stream().
1163                 flatMap(fm -> LONG_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1164                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1165                 })).
1166                 toArray(Object[][]::new);
1167     }
1168 
1169     interface ToLongF {
1170         long apply(int i);
1171     }
1172 
1173     static long[] fill(int s , ToLongF f) {
1174         return fill(new long[s], f);
1175     }
1176 
1177     static long[] fill(long[] a, ToLongF f) {
1178         for (int i = 0; i < a.length; i++) {
1179             a[i] = f.apply(i);
1180         }
1181         return a;
1182     }
1183 
1184     static long cornerCaseValue(int i) {
1185         switch(i % 5) {
1186             case 0:
1187                 return Long.MAX_VALUE;
1188             case 1:
1189                 return Long.MIN_VALUE;
1190             case 2:
1191                 return Long.MIN_VALUE;
1192             case 3:
1193                 return Long.MAX_VALUE;
1194             default:
1195                 return (long)0;
1196         }
1197     }
1198 
1199     static long get(long[] a, int i) {
1200         return (long) a[i];
1201     }
1202 
1203     static final IntFunction<long[]> fr = (vl) -> {
1204         int length = BUFFER_REPS * vl;
1205         return new long[length];
1206     };
1207 
1208     static final IntFunction<boolean[]> fmr = (vl) -> {
1209         int length = BUFFER_REPS * vl;
1210         return new boolean[length];
1211     };
1212 
1213     static void replaceZero(long[] a, long v) {
1214         for (int i = 0; i < a.length; i++) {
1215             if (a[i] == 0) {
1216                 a[i] = v;
1217             }
1218         }
1219     }
1220 
1221     static void replaceZero(long[] a, boolean[] mask, long v) {
1222         for (int i = 0; i < a.length; i++) {
1223             if (mask[i % mask.length] && a[i] == 0) {
1224                 a[i] = v;
1225             }
1226         }
1227     }
1228 
1229     static long ROL_scalar(long a, long b) {
1230         return Long.rotateLeft(a, ((int)b));
1231     }
1232 
1233     static long ROR_scalar(long a, long b) {
1234         return Long.rotateRight(a, ((int)b));
1235     }
1236 
1237     static long TRAILING_ZEROS_COUNT_scalar(long a) {
1238         return Long.numberOfTrailingZeros(a);
1239     }
1240 
1241     static long LEADING_ZEROS_COUNT_scalar(long a) {
1242         return Long.numberOfLeadingZeros(a);
1243     }
1244 
1245     static long REVERSE_scalar(long a) {
1246         return Long.reverse(a);
1247     }
1248 
1249     static boolean eq(long a, long b) {
1250         return a == b;
1251     }
1252 
1253     static boolean neq(long a, long b) {
1254         return a != b;
1255     }
1256 
1257     static boolean lt(long a, long b) {
1258         return a < b;
1259     }
1260 
1261     static boolean le(long a, long b) {
1262         return a <= b;
1263     }
1264 
1265     static boolean gt(long a, long b) {
1266         return a > b;
1267     }
1268 
1269     static boolean ge(long a, long b) {
1270         return a >= b;
1271     }
1272 
1273     static boolean ult(long a, long b) {
1274         return Long.compareUnsigned(a, b) < 0;
1275     }
1276 
1277     static boolean ule(long a, long b) {
1278         return Long.compareUnsigned(a, b) <= 0;
1279     }
1280 
1281     static boolean ugt(long a, long b) {
1282         return Long.compareUnsigned(a, b) > 0;
1283     }
1284 
1285     static boolean uge(long a, long b) {
1286         return Long.compareUnsigned(a, b) >= 0;
1287     }
1288 
1289     static long firstNonZero(long a, long b) {
1290         return Long.compare(a, (long) 0) != 0 ? a : b;
1291     }
1292 
1293     @Test
1294     static void smokeTest1() {
1295         LongVector three = LongVector.broadcast(SPECIES, (byte)-3);
1296         LongVector three2 = (LongVector) SPECIES.broadcast(-3);
1297         assert(three.eq(three2).allTrue());
1298         LongVector three3 = three2.broadcast(1).broadcast(-3);
1299         assert(three.eq(three3).allTrue());
1300         int scale = 2;
1301         Class<?> ETYPE = long.class;
1302         if (ETYPE == double.class || ETYPE == long.class)
1303             scale = 1000000;
1304         else if (ETYPE == byte.class && SPECIES.length() >= 64)
1305             scale = 1;
1306         LongVector higher = three.addIndex(scale);
1307         VectorMask<Long> m = three.compare(VectorOperators.LE, higher);
1308         assert(m.allTrue());
1309         m = higher.min((long)-1).test(VectorOperators.IS_NEGATIVE);
1310         assert(m.allTrue());
1311         long max = higher.reduceLanes(VectorOperators.MAX);
1312         assert(max == -3 + scale * (SPECIES.length()-1));
1313     }
1314 
1315     private static long[]
1316     bothToArray(LongVector a, LongVector b) {
1317         long[] r = new long[a.length() + b.length()];
1318         a.intoArray(r, 0);
1319         b.intoArray(r, a.length());
1320         return r;
1321     }
1322 
1323     @Test
1324     static void smokeTest2() {
1325         // Do some zipping and shuffling.
1326         LongVector io = (LongVector) SPECIES.broadcast(0).addIndex(1);
1327         LongVector io2 = (LongVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1328         Assert.assertEquals(io, io2);
1329         LongVector a = io.add((long)1); //[1,2]
1330         LongVector b = a.neg();  //[-1,-2]
1331         long[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1332         VectorShuffle<Long> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1333         VectorShuffle<Long> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1334         LongVector zab0 = a.rearrange(zip0,b); //[1,-1]
1335         LongVector zab1 = a.rearrange(zip1,b); //[2,-2]
1336         long[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1337         // manually zip
1338         long[] manual = new long[zabValues.length];
1339         for (int i = 0; i < manual.length; i += 2) {
1340             manual[i+0] = abValues[i/2];
1341             manual[i+1] = abValues[a.length() + i/2];
1342         }
1343         Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1344         VectorShuffle<Long> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1345         VectorShuffle<Long> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1346         LongVector uab0 = zab0.rearrange(unz0,zab1);
1347         LongVector uab1 = zab0.rearrange(unz1,zab1);
1348         long[] abValues1 = bothToArray(uab0, uab1);
1349         Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1350     }
1351 
1352     static void iotaShuffle() {
1353         LongVector io = (LongVector) SPECIES.broadcast(0).addIndex(1);
1354         LongVector io2 = (LongVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1355         Assert.assertEquals(io, io2);
1356     }
1357 
1358     @Test
1359     // Test all shuffle related operations.
1360     static void shuffleTest() {
1361         // To test backend instructions, make sure that C2 is used.
1362         for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1363             iotaShuffle();
1364         }
1365     }
1366 
1367     @Test
1368     void viewAsIntegeralLanesTest() {
1369         Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1370         Assert.assertEquals(asIntegral.species(), SPECIES);
1371     }
1372 
1373     @Test
1374     void viewAsFloatingLanesTest() {
1375         Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
1376         VectorSpecies<?> asFloatingSpecies = asFloating.species();
1377         Assert.assertNotEquals(asFloatingSpecies.elementType(), SPECIES.elementType());
1378         Assert.assertEquals(asFloatingSpecies.vectorShape(), SPECIES.vectorShape());
1379         Assert.assertEquals(asFloatingSpecies.length(), SPECIES.length());
1380         Assert.assertEquals(asFloating.viewAsIntegralLanes().species(), SPECIES);
1381     }
1382 
1383     @Test
1384     // Test div by 0.
1385     static void bitwiseDivByZeroSmokeTest() {
1386         try {
1387             LongVector a = (LongVector) SPECIES.broadcast(0).addIndex(1);
1388             LongVector b = (LongVector) SPECIES.broadcast(0);
1389             a.div(b);
1390             Assert.fail();
1391         } catch (ArithmeticException e) {
1392         }
1393 
1394         try {
1395             LongVector a = (LongVector) SPECIES.broadcast(0).addIndex(1);
1396             LongVector b = (LongVector) SPECIES.broadcast(0);
1397             VectorMask<Long> m = a.lt((long) 1);
1398             a.div(b, m);
1399             Assert.fail();
1400         } catch (ArithmeticException e) {
1401         }
1402     }
1403 
1404     static long ADD(long a, long b) {
1405         return (long)(a + b);
1406     }
1407 
1408     @Test(dataProvider = "longBinaryOpProvider")
1409     static void ADDLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1410         long[] a = fa.apply(SPECIES.length());
1411         long[] b = fb.apply(SPECIES.length());
1412         long[] r = fr.apply(SPECIES.length());
1413 
1414         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1415             for (int i = 0; i < a.length; i += SPECIES.length()) {
1416                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1417                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1418                 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
1419             }
1420         }
1421 
1422         assertArraysEquals(r, a, b, Long256VectorTests::ADD);
1423     }
1424 
1425     static long add(long a, long b) {
1426         return (long)(a + b);
1427     }
1428 
1429     @Test(dataProvider = "longBinaryOpProvider")
1430     static void addLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1431         long[] a = fa.apply(SPECIES.length());
1432         long[] b = fb.apply(SPECIES.length());
1433         long[] r = fr.apply(SPECIES.length());
1434 
1435         for (int i = 0; i < a.length; i += SPECIES.length()) {
1436             LongVector av = LongVector.fromArray(SPECIES, a, i);
1437             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1438             av.add(bv).intoArray(r, i);
1439         }
1440 
1441         assertArraysEquals(r, a, b, Long256VectorTests::add);
1442     }
1443 
1444     @Test(dataProvider = "longBinaryOpMaskProvider")
1445     static void ADDLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1446                                           IntFunction<boolean[]> fm) {
1447         long[] a = fa.apply(SPECIES.length());
1448         long[] b = fb.apply(SPECIES.length());
1449         long[] r = fr.apply(SPECIES.length());
1450         boolean[] mask = fm.apply(SPECIES.length());
1451         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1452 
1453         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1454             for (int i = 0; i < a.length; i += SPECIES.length()) {
1455                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1456                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1457                 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
1458             }
1459         }
1460 
1461         assertArraysEquals(r, a, b, mask, Long256VectorTests::ADD);
1462     }
1463 
1464     @Test(dataProvider = "longBinaryOpMaskProvider")
1465     static void addLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1466                                           IntFunction<boolean[]> fm) {
1467         long[] a = fa.apply(SPECIES.length());
1468         long[] b = fb.apply(SPECIES.length());
1469         long[] r = fr.apply(SPECIES.length());
1470         boolean[] mask = fm.apply(SPECIES.length());
1471         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1472 
1473         for (int i = 0; i < a.length; i += SPECIES.length()) {
1474             LongVector av = LongVector.fromArray(SPECIES, a, i);
1475             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1476             av.add(bv, vmask).intoArray(r, i);
1477         }
1478 
1479         assertArraysEquals(r, a, b, mask, Long256VectorTests::add);
1480     }
1481 
1482     static long SUB(long a, long b) {
1483         return (long)(a - b);
1484     }
1485 
1486     @Test(dataProvider = "longBinaryOpProvider")
1487     static void SUBLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1488         long[] a = fa.apply(SPECIES.length());
1489         long[] b = fb.apply(SPECIES.length());
1490         long[] r = fr.apply(SPECIES.length());
1491 
1492         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1493             for (int i = 0; i < a.length; i += SPECIES.length()) {
1494                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1495                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1496                 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1497             }
1498         }
1499 
1500         assertArraysEquals(r, a, b, Long256VectorTests::SUB);
1501     }
1502 
1503     static long sub(long a, long b) {
1504         return (long)(a - b);
1505     }
1506 
1507     @Test(dataProvider = "longBinaryOpProvider")
1508     static void subLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1509         long[] a = fa.apply(SPECIES.length());
1510         long[] b = fb.apply(SPECIES.length());
1511         long[] r = fr.apply(SPECIES.length());
1512 
1513         for (int i = 0; i < a.length; i += SPECIES.length()) {
1514             LongVector av = LongVector.fromArray(SPECIES, a, i);
1515             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1516             av.sub(bv).intoArray(r, i);
1517         }
1518 
1519         assertArraysEquals(r, a, b, Long256VectorTests::sub);
1520     }
1521 
1522     @Test(dataProvider = "longBinaryOpMaskProvider")
1523     static void SUBLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1524                                           IntFunction<boolean[]> fm) {
1525         long[] a = fa.apply(SPECIES.length());
1526         long[] b = fb.apply(SPECIES.length());
1527         long[] r = fr.apply(SPECIES.length());
1528         boolean[] mask = fm.apply(SPECIES.length());
1529         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1530 
1531         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1532             for (int i = 0; i < a.length; i += SPECIES.length()) {
1533                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1534                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1535                 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1536             }
1537         }
1538 
1539         assertArraysEquals(r, a, b, mask, Long256VectorTests::SUB);
1540     }
1541 
1542     @Test(dataProvider = "longBinaryOpMaskProvider")
1543     static void subLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1544                                           IntFunction<boolean[]> fm) {
1545         long[] a = fa.apply(SPECIES.length());
1546         long[] b = fb.apply(SPECIES.length());
1547         long[] r = fr.apply(SPECIES.length());
1548         boolean[] mask = fm.apply(SPECIES.length());
1549         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1550 
1551         for (int i = 0; i < a.length; i += SPECIES.length()) {
1552             LongVector av = LongVector.fromArray(SPECIES, a, i);
1553             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1554             av.sub(bv, vmask).intoArray(r, i);
1555         }
1556 
1557         assertArraysEquals(r, a, b, mask, Long256VectorTests::sub);
1558     }
1559 
1560     static long MUL(long a, long b) {
1561         return (long)(a * b);
1562     }
1563 
1564     @Test(dataProvider = "longBinaryOpProvider")
1565     static void MULLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1566         long[] a = fa.apply(SPECIES.length());
1567         long[] b = fb.apply(SPECIES.length());
1568         long[] r = fr.apply(SPECIES.length());
1569 
1570         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1571             for (int i = 0; i < a.length; i += SPECIES.length()) {
1572                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1573                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1574                 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1575             }
1576         }
1577 
1578         assertArraysEquals(r, a, b, Long256VectorTests::MUL);
1579     }
1580 
1581     static long mul(long a, long b) {
1582         return (long)(a * b);
1583     }
1584 
1585     @Test(dataProvider = "longBinaryOpProvider")
1586     static void mulLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1587         long[] a = fa.apply(SPECIES.length());
1588         long[] b = fb.apply(SPECIES.length());
1589         long[] r = fr.apply(SPECIES.length());
1590 
1591         for (int i = 0; i < a.length; i += SPECIES.length()) {
1592             LongVector av = LongVector.fromArray(SPECIES, a, i);
1593             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1594             av.mul(bv).intoArray(r, i);
1595         }
1596 
1597         assertArraysEquals(r, a, b, Long256VectorTests::mul);
1598     }
1599 
1600     @Test(dataProvider = "longBinaryOpMaskProvider")
1601     static void MULLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1602                                           IntFunction<boolean[]> fm) {
1603         long[] a = fa.apply(SPECIES.length());
1604         long[] b = fb.apply(SPECIES.length());
1605         long[] r = fr.apply(SPECIES.length());
1606         boolean[] mask = fm.apply(SPECIES.length());
1607         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1608 
1609         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1610             for (int i = 0; i < a.length; i += SPECIES.length()) {
1611                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1612                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1613                 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1614             }
1615         }
1616 
1617         assertArraysEquals(r, a, b, mask, Long256VectorTests::MUL);
1618     }
1619 
1620     @Test(dataProvider = "longBinaryOpMaskProvider")
1621     static void mulLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1622                                           IntFunction<boolean[]> fm) {
1623         long[] a = fa.apply(SPECIES.length());
1624         long[] b = fb.apply(SPECIES.length());
1625         long[] r = fr.apply(SPECIES.length());
1626         boolean[] mask = fm.apply(SPECIES.length());
1627         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1628 
1629         for (int i = 0; i < a.length; i += SPECIES.length()) {
1630             LongVector av = LongVector.fromArray(SPECIES, a, i);
1631             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1632             av.mul(bv, vmask).intoArray(r, i);
1633         }
1634 
1635         assertArraysEquals(r, a, b, mask, Long256VectorTests::mul);
1636     }
1637 
1638     static long DIV(long a, long b) {
1639         return (long)(a / b);
1640     }
1641 
1642     @Test(dataProvider = "longBinaryOpProvider")
1643     static void DIVLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1644         long[] a = fa.apply(SPECIES.length());
1645         long[] b = fb.apply(SPECIES.length());
1646         long[] r = fr.apply(SPECIES.length());
1647 
1648         replaceZero(b, (long) 1);
1649 
1650         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1651             for (int i = 0; i < a.length; i += SPECIES.length()) {
1652                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1653                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1654                 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1655             }
1656         }
1657 
1658         assertArraysEquals(r, a, b, Long256VectorTests::DIV);
1659     }
1660 
1661     static long div(long a, long b) {
1662         return (long)(a / b);
1663     }
1664 
1665     @Test(dataProvider = "longBinaryOpProvider")
1666     static void divLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1667         long[] a = fa.apply(SPECIES.length());
1668         long[] b = fb.apply(SPECIES.length());
1669         long[] r = fr.apply(SPECIES.length());
1670 
1671         replaceZero(b, (long) 1);
1672 
1673         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1674             for (int i = 0; i < a.length; i += SPECIES.length()) {
1675                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1676                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1677                 av.div(bv).intoArray(r, i);
1678             }
1679         }
1680 
1681         assertArraysEquals(r, a, b, Long256VectorTests::div);
1682     }
1683 
1684     @Test(dataProvider = "longBinaryOpMaskProvider")
1685     static void DIVLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1686                                           IntFunction<boolean[]> fm) {
1687         long[] a = fa.apply(SPECIES.length());
1688         long[] b = fb.apply(SPECIES.length());
1689         long[] r = fr.apply(SPECIES.length());
1690         boolean[] mask = fm.apply(SPECIES.length());
1691         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1692 
1693         replaceZero(b, mask, (long) 1);
1694 
1695         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1696             for (int i = 0; i < a.length; i += SPECIES.length()) {
1697                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1698                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1699                 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1700             }
1701         }
1702 
1703         assertArraysEquals(r, a, b, mask, Long256VectorTests::DIV);
1704     }
1705 
1706     @Test(dataProvider = "longBinaryOpMaskProvider")
1707     static void divLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1708                                           IntFunction<boolean[]> fm) {
1709         long[] a = fa.apply(SPECIES.length());
1710         long[] b = fb.apply(SPECIES.length());
1711         long[] r = fr.apply(SPECIES.length());
1712         boolean[] mask = fm.apply(SPECIES.length());
1713         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1714 
1715         replaceZero(b, mask, (long) 1);
1716 
1717         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1718             for (int i = 0; i < a.length; i += SPECIES.length()) {
1719                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1720                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1721                 av.div(bv, vmask).intoArray(r, i);
1722             }
1723         }
1724 
1725         assertArraysEquals(r, a, b, mask, Long256VectorTests::div);
1726     }
1727 
1728     static long FIRST_NONZERO(long a, long b) {
1729         return (long)((a)!=0?a:b);
1730     }
1731 
1732     @Test(dataProvider = "longBinaryOpProvider")
1733     static void FIRST_NONZEROLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1734         long[] a = fa.apply(SPECIES.length());
1735         long[] b = fb.apply(SPECIES.length());
1736         long[] r = fr.apply(SPECIES.length());
1737 
1738         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1739             for (int i = 0; i < a.length; i += SPECIES.length()) {
1740                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1741                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1742                 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1743             }
1744         }
1745 
1746         assertArraysEquals(r, a, b, Long256VectorTests::FIRST_NONZERO);
1747     }
1748 
1749     @Test(dataProvider = "longBinaryOpMaskProvider")
1750     static void FIRST_NONZEROLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1751                                           IntFunction<boolean[]> fm) {
1752         long[] a = fa.apply(SPECIES.length());
1753         long[] b = fb.apply(SPECIES.length());
1754         long[] r = fr.apply(SPECIES.length());
1755         boolean[] mask = fm.apply(SPECIES.length());
1756         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1757 
1758         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1759             for (int i = 0; i < a.length; i += SPECIES.length()) {
1760                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1761                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1762                 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1763             }
1764         }
1765 
1766         assertArraysEquals(r, a, b, mask, Long256VectorTests::FIRST_NONZERO);
1767     }
1768 
1769     static long AND(long a, long b) {
1770         return (long)(a & b);
1771     }
1772 
1773     @Test(dataProvider = "longBinaryOpProvider")
1774     static void ANDLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1775         long[] a = fa.apply(SPECIES.length());
1776         long[] b = fb.apply(SPECIES.length());
1777         long[] r = fr.apply(SPECIES.length());
1778 
1779         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1780             for (int i = 0; i < a.length; i += SPECIES.length()) {
1781                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1782                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1783                 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1784             }
1785         }
1786 
1787         assertArraysEquals(r, a, b, Long256VectorTests::AND);
1788     }
1789 
1790     static long and(long a, long b) {
1791         return (long)(a & b);
1792     }
1793 
1794     @Test(dataProvider = "longBinaryOpProvider")
1795     static void andLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1796         long[] a = fa.apply(SPECIES.length());
1797         long[] b = fb.apply(SPECIES.length());
1798         long[] r = fr.apply(SPECIES.length());
1799 
1800         for (int i = 0; i < a.length; i += SPECIES.length()) {
1801             LongVector av = LongVector.fromArray(SPECIES, a, i);
1802             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1803             av.and(bv).intoArray(r, i);
1804         }
1805 
1806         assertArraysEquals(r, a, b, Long256VectorTests::and);
1807     }
1808 
1809     @Test(dataProvider = "longBinaryOpMaskProvider")
1810     static void ANDLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1811                                           IntFunction<boolean[]> fm) {
1812         long[] a = fa.apply(SPECIES.length());
1813         long[] b = fb.apply(SPECIES.length());
1814         long[] r = fr.apply(SPECIES.length());
1815         boolean[] mask = fm.apply(SPECIES.length());
1816         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1817 
1818         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1819             for (int i = 0; i < a.length; i += SPECIES.length()) {
1820                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1821                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1822                 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
1823             }
1824         }
1825 
1826         assertArraysEquals(r, a, b, mask, Long256VectorTests::AND);
1827     }
1828 
1829     static long AND_NOT(long a, long b) {
1830         return (long)(a & ~b);
1831     }
1832 
1833     @Test(dataProvider = "longBinaryOpProvider")
1834     static void AND_NOTLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1835         long[] a = fa.apply(SPECIES.length());
1836         long[] b = fb.apply(SPECIES.length());
1837         long[] r = fr.apply(SPECIES.length());
1838 
1839         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1840             for (int i = 0; i < a.length; i += SPECIES.length()) {
1841                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1842                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1843                 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
1844             }
1845         }
1846 
1847         assertArraysEquals(r, a, b, Long256VectorTests::AND_NOT);
1848     }
1849 
1850     @Test(dataProvider = "longBinaryOpMaskProvider")
1851     static void AND_NOTLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1852                                           IntFunction<boolean[]> fm) {
1853         long[] a = fa.apply(SPECIES.length());
1854         long[] b = fb.apply(SPECIES.length());
1855         long[] r = fr.apply(SPECIES.length());
1856         boolean[] mask = fm.apply(SPECIES.length());
1857         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1858 
1859         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1860             for (int i = 0; i < a.length; i += SPECIES.length()) {
1861                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1862                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1863                 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
1864             }
1865         }
1866 
1867         assertArraysEquals(r, a, b, mask, Long256VectorTests::AND_NOT);
1868     }
1869 
1870     static long OR(long a, long b) {
1871         return (long)(a | b);
1872     }
1873 
1874     @Test(dataProvider = "longBinaryOpProvider")
1875     static void ORLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1876         long[] a = fa.apply(SPECIES.length());
1877         long[] b = fb.apply(SPECIES.length());
1878         long[] r = fr.apply(SPECIES.length());
1879 
1880         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1881             for (int i = 0; i < a.length; i += SPECIES.length()) {
1882                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1883                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1884                 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
1885             }
1886         }
1887 
1888         assertArraysEquals(r, a, b, Long256VectorTests::OR);
1889     }
1890 
1891     static long or(long a, long b) {
1892         return (long)(a | b);
1893     }
1894 
1895     @Test(dataProvider = "longBinaryOpProvider")
1896     static void orLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1897         long[] a = fa.apply(SPECIES.length());
1898         long[] b = fb.apply(SPECIES.length());
1899         long[] r = fr.apply(SPECIES.length());
1900 
1901         for (int i = 0; i < a.length; i += SPECIES.length()) {
1902             LongVector av = LongVector.fromArray(SPECIES, a, i);
1903             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1904             av.or(bv).intoArray(r, i);
1905         }
1906 
1907         assertArraysEquals(r, a, b, Long256VectorTests::or);
1908     }
1909 
1910     @Test(dataProvider = "longBinaryOpMaskProvider")
1911     static void ORLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1912                                           IntFunction<boolean[]> fm) {
1913         long[] a = fa.apply(SPECIES.length());
1914         long[] b = fb.apply(SPECIES.length());
1915         long[] r = fr.apply(SPECIES.length());
1916         boolean[] mask = fm.apply(SPECIES.length());
1917         VectorMask<Long> 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                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1922                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1923                 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
1924             }
1925         }
1926 
1927         assertArraysEquals(r, a, b, mask, Long256VectorTests::OR);
1928     }
1929 
1930     static long XOR(long a, long b) {
1931         return (long)(a ^ b);
1932     }
1933 
1934     @Test(dataProvider = "longBinaryOpProvider")
1935     static void XORLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1936         long[] a = fa.apply(SPECIES.length());
1937         long[] b = fb.apply(SPECIES.length());
1938         long[] 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                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1943                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1944                 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
1945             }
1946         }
1947 
1948         assertArraysEquals(r, a, b, Long256VectorTests::XOR);
1949     }
1950 
1951     @Test(dataProvider = "longBinaryOpMaskProvider")
1952     static void XORLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1953                                           IntFunction<boolean[]> fm) {
1954         long[] a = fa.apply(SPECIES.length());
1955         long[] b = fb.apply(SPECIES.length());
1956         long[] r = fr.apply(SPECIES.length());
1957         boolean[] mask = fm.apply(SPECIES.length());
1958         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1959 
1960         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1961             for (int i = 0; i < a.length; i += SPECIES.length()) {
1962                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1963                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1964                 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
1965             }
1966         }
1967 
1968         assertArraysEquals(r, a, b, mask, Long256VectorTests::XOR);
1969     }
1970 
1971     static long COMPRESS_BITS(long a, long b) {
1972         return (long)(Long.compress(a, b));
1973     }
1974 
1975     @Test(dataProvider = "longBinaryOpProvider")
1976     static void COMPRESS_BITSLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1977         long[] a = fa.apply(SPECIES.length());
1978         long[] b = fb.apply(SPECIES.length());
1979         long[] r = fr.apply(SPECIES.length());
1980 
1981         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1982             for (int i = 0; i < a.length; i += SPECIES.length()) {
1983                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1984                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1985                 av.lanewise(VectorOperators.COMPRESS_BITS, bv).intoArray(r, i);
1986             }
1987         }
1988 
1989         assertArraysEquals(r, a, b, Long256VectorTests::COMPRESS_BITS);
1990     }
1991 
1992     @Test(dataProvider = "longBinaryOpMaskProvider")
1993     static void COMPRESS_BITSLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1994                                           IntFunction<boolean[]> fm) {
1995         long[] a = fa.apply(SPECIES.length());
1996         long[] b = fb.apply(SPECIES.length());
1997         long[] r = fr.apply(SPECIES.length());
1998         boolean[] mask = fm.apply(SPECIES.length());
1999         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2000 
2001         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2002             for (int i = 0; i < a.length; i += SPECIES.length()) {
2003                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2004                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2005                 av.lanewise(VectorOperators.COMPRESS_BITS, bv, vmask).intoArray(r, i);
2006             }
2007         }
2008 
2009         assertArraysEquals(r, a, b, mask, Long256VectorTests::COMPRESS_BITS);
2010     }
2011 
2012     static long EXPAND_BITS(long a, long b) {
2013         return (long)(Long.expand(a, b));
2014     }
2015 
2016     @Test(dataProvider = "longBinaryOpProvider")
2017     static void EXPAND_BITSLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2018         long[] a = fa.apply(SPECIES.length());
2019         long[] b = fb.apply(SPECIES.length());
2020         long[] r = fr.apply(SPECIES.length());
2021 
2022         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2023             for (int i = 0; i < a.length; i += SPECIES.length()) {
2024                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2025                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2026                 av.lanewise(VectorOperators.EXPAND_BITS, bv).intoArray(r, i);
2027             }
2028         }
2029 
2030         assertArraysEquals(r, a, b, Long256VectorTests::EXPAND_BITS);
2031     }
2032 
2033     @Test(dataProvider = "longBinaryOpMaskProvider")
2034     static void EXPAND_BITSLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2035                                           IntFunction<boolean[]> fm) {
2036         long[] a = fa.apply(SPECIES.length());
2037         long[] b = fb.apply(SPECIES.length());
2038         long[] r = fr.apply(SPECIES.length());
2039         boolean[] mask = fm.apply(SPECIES.length());
2040         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2041 
2042         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2043             for (int i = 0; i < a.length; i += SPECIES.length()) {
2044                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2045                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2046                 av.lanewise(VectorOperators.EXPAND_BITS, bv, vmask).intoArray(r, i);
2047             }
2048         }
2049 
2050         assertArraysEquals(r, a, b, mask, Long256VectorTests::EXPAND_BITS);
2051     }
2052 
2053     @Test(dataProvider = "longBinaryOpProvider")
2054     static void addLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2055         long[] a = fa.apply(SPECIES.length());
2056         long[] b = fb.apply(SPECIES.length());
2057         long[] r = fr.apply(SPECIES.length());
2058 
2059         for (int i = 0; i < a.length; i += SPECIES.length()) {
2060             LongVector av = LongVector.fromArray(SPECIES, a, i);
2061             av.add(b[i]).intoArray(r, i);
2062         }
2063 
2064         assertBroadcastArraysEquals(r, a, b, Long256VectorTests::add);
2065     }
2066 
2067     @Test(dataProvider = "longBinaryOpMaskProvider")
2068     static void addLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2069                                           IntFunction<boolean[]> fm) {
2070         long[] a = fa.apply(SPECIES.length());
2071         long[] b = fb.apply(SPECIES.length());
2072         long[] r = fr.apply(SPECIES.length());
2073         boolean[] mask = fm.apply(SPECIES.length());
2074         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2075 
2076         for (int i = 0; i < a.length; i += SPECIES.length()) {
2077             LongVector av = LongVector.fromArray(SPECIES, a, i);
2078             av.add(b[i], vmask).intoArray(r, i);
2079         }
2080 
2081         assertBroadcastArraysEquals(r, a, b, mask, Long256VectorTests::add);
2082     }
2083 
2084     @Test(dataProvider = "longBinaryOpProvider")
2085     static void subLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2086         long[] a = fa.apply(SPECIES.length());
2087         long[] b = fb.apply(SPECIES.length());
2088         long[] r = fr.apply(SPECIES.length());
2089 
2090         for (int i = 0; i < a.length; i += SPECIES.length()) {
2091             LongVector av = LongVector.fromArray(SPECIES, a, i);
2092             av.sub(b[i]).intoArray(r, i);
2093         }
2094 
2095         assertBroadcastArraysEquals(r, a, b, Long256VectorTests::sub);
2096     }
2097 
2098     @Test(dataProvider = "longBinaryOpMaskProvider")
2099     static void subLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2100                                           IntFunction<boolean[]> fm) {
2101         long[] a = fa.apply(SPECIES.length());
2102         long[] b = fb.apply(SPECIES.length());
2103         long[] r = fr.apply(SPECIES.length());
2104         boolean[] mask = fm.apply(SPECIES.length());
2105         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2106 
2107         for (int i = 0; i < a.length; i += SPECIES.length()) {
2108             LongVector av = LongVector.fromArray(SPECIES, a, i);
2109             av.sub(b[i], vmask).intoArray(r, i);
2110         }
2111 
2112         assertBroadcastArraysEquals(r, a, b, mask, Long256VectorTests::sub);
2113     }
2114 
2115     @Test(dataProvider = "longBinaryOpProvider")
2116     static void mulLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2117         long[] a = fa.apply(SPECIES.length());
2118         long[] b = fb.apply(SPECIES.length());
2119         long[] r = fr.apply(SPECIES.length());
2120 
2121         for (int i = 0; i < a.length; i += SPECIES.length()) {
2122             LongVector av = LongVector.fromArray(SPECIES, a, i);
2123             av.mul(b[i]).intoArray(r, i);
2124         }
2125 
2126         assertBroadcastArraysEquals(r, a, b, Long256VectorTests::mul);
2127     }
2128 
2129     @Test(dataProvider = "longBinaryOpMaskProvider")
2130     static void mulLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2131                                           IntFunction<boolean[]> fm) {
2132         long[] a = fa.apply(SPECIES.length());
2133         long[] b = fb.apply(SPECIES.length());
2134         long[] r = fr.apply(SPECIES.length());
2135         boolean[] mask = fm.apply(SPECIES.length());
2136         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2137 
2138         for (int i = 0; i < a.length; i += SPECIES.length()) {
2139             LongVector av = LongVector.fromArray(SPECIES, a, i);
2140             av.mul(b[i], vmask).intoArray(r, i);
2141         }
2142 
2143         assertBroadcastArraysEquals(r, a, b, mask, Long256VectorTests::mul);
2144     }
2145 
2146     @Test(dataProvider = "longBinaryOpProvider")
2147     static void divLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2148         long[] a = fa.apply(SPECIES.length());
2149         long[] b = fb.apply(SPECIES.length());
2150         long[] r = fr.apply(SPECIES.length());
2151 
2152         replaceZero(b, (long) 1);
2153 
2154         for (int i = 0; i < a.length; i += SPECIES.length()) {
2155             LongVector av = LongVector.fromArray(SPECIES, a, i);
2156             av.div(b[i]).intoArray(r, i);
2157         }
2158 
2159         assertBroadcastArraysEquals(r, a, b, Long256VectorTests::div);
2160     }
2161 
2162     @Test(dataProvider = "longBinaryOpMaskProvider")
2163     static void divLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2164                                           IntFunction<boolean[]> fm) {
2165         long[] a = fa.apply(SPECIES.length());
2166         long[] b = fb.apply(SPECIES.length());
2167         long[] r = fr.apply(SPECIES.length());
2168         boolean[] mask = fm.apply(SPECIES.length());
2169         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2170 
2171         replaceZero(b, (long) 1);
2172 
2173         for (int i = 0; i < a.length; i += SPECIES.length()) {
2174             LongVector av = LongVector.fromArray(SPECIES, a, i);
2175             av.div(b[i], vmask).intoArray(r, i);
2176         }
2177 
2178         assertBroadcastArraysEquals(r, a, b, mask, Long256VectorTests::div);
2179     }
2180 
2181     @Test(dataProvider = "longBinaryOpProvider")
2182     static void ORLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2183         long[] a = fa.apply(SPECIES.length());
2184         long[] b = fb.apply(SPECIES.length());
2185         long[] r = fr.apply(SPECIES.length());
2186 
2187         for (int i = 0; i < a.length; i += SPECIES.length()) {
2188             LongVector av = LongVector.fromArray(SPECIES, a, i);
2189             av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
2190         }
2191 
2192         assertBroadcastArraysEquals(r, a, b, Long256VectorTests::OR);
2193     }
2194 
2195     @Test(dataProvider = "longBinaryOpProvider")
2196     static void orLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2197         long[] a = fa.apply(SPECIES.length());
2198         long[] b = fb.apply(SPECIES.length());
2199         long[] r = fr.apply(SPECIES.length());
2200 
2201         for (int i = 0; i < a.length; i += SPECIES.length()) {
2202             LongVector av = LongVector.fromArray(SPECIES, a, i);
2203             av.or(b[i]).intoArray(r, i);
2204         }
2205 
2206         assertBroadcastArraysEquals(r, a, b, Long256VectorTests::or);
2207     }
2208 
2209     @Test(dataProvider = "longBinaryOpMaskProvider")
2210     static void ORLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2211                                           IntFunction<boolean[]> fm) {
2212         long[] a = fa.apply(SPECIES.length());
2213         long[] b = fb.apply(SPECIES.length());
2214         long[] r = fr.apply(SPECIES.length());
2215         boolean[] mask = fm.apply(SPECIES.length());
2216         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2217 
2218         for (int i = 0; i < a.length; i += SPECIES.length()) {
2219             LongVector av = LongVector.fromArray(SPECIES, a, i);
2220             av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
2221         }
2222 
2223         assertBroadcastArraysEquals(r, a, b, mask, Long256VectorTests::OR);
2224     }
2225 
2226     @Test(dataProvider = "longBinaryOpProvider")
2227     static void ANDLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2228         long[] a = fa.apply(SPECIES.length());
2229         long[] b = fb.apply(SPECIES.length());
2230         long[] r = fr.apply(SPECIES.length());
2231 
2232         for (int i = 0; i < a.length; i += SPECIES.length()) {
2233             LongVector av = LongVector.fromArray(SPECIES, a, i);
2234             av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i);
2235         }
2236 
2237         assertBroadcastArraysEquals(r, a, b, Long256VectorTests::AND);
2238     }
2239 
2240     @Test(dataProvider = "longBinaryOpProvider")
2241     static void andLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2242         long[] a = fa.apply(SPECIES.length());
2243         long[] b = fb.apply(SPECIES.length());
2244         long[] r = fr.apply(SPECIES.length());
2245 
2246         for (int i = 0; i < a.length; i += SPECIES.length()) {
2247             LongVector av = LongVector.fromArray(SPECIES, a, i);
2248             av.and(b[i]).intoArray(r, i);
2249         }
2250 
2251         assertBroadcastArraysEquals(r, a, b, Long256VectorTests::and);
2252     }
2253 
2254     @Test(dataProvider = "longBinaryOpMaskProvider")
2255     static void ANDLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2256                                           IntFunction<boolean[]> fm) {
2257         long[] a = fa.apply(SPECIES.length());
2258         long[] b = fb.apply(SPECIES.length());
2259         long[] r = fr.apply(SPECIES.length());
2260         boolean[] mask = fm.apply(SPECIES.length());
2261         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2262 
2263         for (int i = 0; i < a.length; i += SPECIES.length()) {
2264             LongVector av = LongVector.fromArray(SPECIES, a, i);
2265             av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i);
2266         }
2267 
2268         assertBroadcastArraysEquals(r, a, b, mask, Long256VectorTests::AND);
2269     }
2270 
2271     @Test(dataProvider = "longBinaryOpProvider")
2272     static void ORLong256VectorTestsBroadcastLongSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2273         long[] a = fa.apply(SPECIES.length());
2274         long[] b = fb.apply(SPECIES.length());
2275         long[] r = fr.apply(SPECIES.length());
2276 
2277         for (int i = 0; i < a.length; i += SPECIES.length()) {
2278             LongVector av = LongVector.fromArray(SPECIES, a, i);
2279             av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i);
2280         }
2281 
2282         assertBroadcastLongArraysEquals(r, a, b, Long256VectorTests::OR);
2283     }
2284 
2285     @Test(dataProvider = "longBinaryOpMaskProvider")
2286     static void ORLong256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2287                                           IntFunction<boolean[]> fm) {
2288         long[] a = fa.apply(SPECIES.length());
2289         long[] b = fb.apply(SPECIES.length());
2290         long[] r = fr.apply(SPECIES.length());
2291         boolean[] mask = fm.apply(SPECIES.length());
2292         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2293 
2294         for (int i = 0; i < a.length; i += SPECIES.length()) {
2295             LongVector av = LongVector.fromArray(SPECIES, a, i);
2296             av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i);
2297         }
2298 
2299         assertBroadcastLongArraysEquals(r, a, b, mask, Long256VectorTests::OR);
2300     }
2301 
2302     @Test(dataProvider = "longBinaryOpProvider")
2303     static void ADDLong256VectorTestsBroadcastLongSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2304         long[] a = fa.apply(SPECIES.length());
2305         long[] b = fb.apply(SPECIES.length());
2306         long[] r = fr.apply(SPECIES.length());
2307 
2308         for (int i = 0; i < a.length; i += SPECIES.length()) {
2309             LongVector av = LongVector.fromArray(SPECIES, a, i);
2310             av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
2311         }
2312 
2313         assertBroadcastLongArraysEquals(r, a, b, Long256VectorTests::ADD);
2314     }
2315 
2316     @Test(dataProvider = "longBinaryOpMaskProvider")
2317     static void ADDLong256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2318                                           IntFunction<boolean[]> fm) {
2319         long[] a = fa.apply(SPECIES.length());
2320         long[] b = fb.apply(SPECIES.length());
2321         long[] r = fr.apply(SPECIES.length());
2322         boolean[] mask = fm.apply(SPECIES.length());
2323         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2324 
2325         for (int i = 0; i < a.length; i += SPECIES.length()) {
2326             LongVector av = LongVector.fromArray(SPECIES, a, i);
2327             av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
2328         }
2329 
2330         assertBroadcastLongArraysEquals(r, a, b, mask, Long256VectorTests::ADD);
2331     }
2332 
2333     static long LSHL(long a, long b) {
2334         return (long)((a << b));
2335     }
2336 
2337     @Test(dataProvider = "longBinaryOpProvider")
2338     static void LSHLLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2339         long[] a = fa.apply(SPECIES.length());
2340         long[] b = fb.apply(SPECIES.length());
2341         long[] r = fr.apply(SPECIES.length());
2342 
2343         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2344             for (int i = 0; i < a.length; i += SPECIES.length()) {
2345                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2346                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2347                 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
2348             }
2349         }
2350 
2351         assertArraysEquals(r, a, b, Long256VectorTests::LSHL);
2352     }
2353 
2354     @Test(dataProvider = "longBinaryOpMaskProvider")
2355     static void LSHLLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2356                                           IntFunction<boolean[]> fm) {
2357         long[] a = fa.apply(SPECIES.length());
2358         long[] b = fb.apply(SPECIES.length());
2359         long[] r = fr.apply(SPECIES.length());
2360         boolean[] mask = fm.apply(SPECIES.length());
2361         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2362 
2363         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2364             for (int i = 0; i < a.length; i += SPECIES.length()) {
2365                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2366                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2367                 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
2368             }
2369         }
2370 
2371         assertArraysEquals(r, a, b, mask, Long256VectorTests::LSHL);
2372     }
2373 
2374     static long ASHR(long a, long b) {
2375         return (long)((a >> b));
2376     }
2377 
2378     @Test(dataProvider = "longBinaryOpProvider")
2379     static void ASHRLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2380         long[] a = fa.apply(SPECIES.length());
2381         long[] b = fb.apply(SPECIES.length());
2382         long[] r = fr.apply(SPECIES.length());
2383 
2384         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2385             for (int i = 0; i < a.length; i += SPECIES.length()) {
2386                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2387                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2388                 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
2389             }
2390         }
2391 
2392         assertArraysEquals(r, a, b, Long256VectorTests::ASHR);
2393     }
2394 
2395     @Test(dataProvider = "longBinaryOpMaskProvider")
2396     static void ASHRLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2397                                           IntFunction<boolean[]> fm) {
2398         long[] a = fa.apply(SPECIES.length());
2399         long[] b = fb.apply(SPECIES.length());
2400         long[] r = fr.apply(SPECIES.length());
2401         boolean[] mask = fm.apply(SPECIES.length());
2402         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2403 
2404         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2405             for (int i = 0; i < a.length; i += SPECIES.length()) {
2406                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2407                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2408                 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
2409             }
2410         }
2411 
2412         assertArraysEquals(r, a, b, mask, Long256VectorTests::ASHR);
2413     }
2414 
2415     static long LSHR(long a, long b) {
2416         return (long)((a >>> b));
2417     }
2418 
2419     @Test(dataProvider = "longBinaryOpProvider")
2420     static void LSHRLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2421         long[] a = fa.apply(SPECIES.length());
2422         long[] b = fb.apply(SPECIES.length());
2423         long[] r = fr.apply(SPECIES.length());
2424 
2425         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2426             for (int i = 0; i < a.length; i += SPECIES.length()) {
2427                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2428                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2429                 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
2430             }
2431         }
2432 
2433         assertArraysEquals(r, a, b, Long256VectorTests::LSHR);
2434     }
2435 
2436     @Test(dataProvider = "longBinaryOpMaskProvider")
2437     static void LSHRLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2438                                           IntFunction<boolean[]> fm) {
2439         long[] a = fa.apply(SPECIES.length());
2440         long[] b = fb.apply(SPECIES.length());
2441         long[] r = fr.apply(SPECIES.length());
2442         boolean[] mask = fm.apply(SPECIES.length());
2443         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2444 
2445         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2446             for (int i = 0; i < a.length; i += SPECIES.length()) {
2447                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2448                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2449                 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
2450             }
2451         }
2452 
2453         assertArraysEquals(r, a, b, mask, Long256VectorTests::LSHR);
2454     }
2455 
2456     static long LSHL_unary(long a, long b) {
2457         return (long)((a << b));
2458     }
2459 
2460     @Test(dataProvider = "longBinaryOpProvider")
2461     static void LSHLLong256VectorTestsScalarShift(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2462         long[] a = fa.apply(SPECIES.length());
2463         long[] b = fb.apply(SPECIES.length());
2464         long[] r = fr.apply(SPECIES.length());
2465 
2466         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2467             for (int i = 0; i < a.length; i += SPECIES.length()) {
2468                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2469                 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
2470             }
2471         }
2472 
2473         assertShiftArraysEquals(r, a, b, Long256VectorTests::LSHL_unary);
2474     }
2475 
2476     @Test(dataProvider = "longBinaryOpMaskProvider")
2477     static void LSHLLong256VectorTestsScalarShiftMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2478                                           IntFunction<boolean[]> fm) {
2479         long[] a = fa.apply(SPECIES.length());
2480         long[] b = fb.apply(SPECIES.length());
2481         long[] r = fr.apply(SPECIES.length());
2482         boolean[] mask = fm.apply(SPECIES.length());
2483         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2484 
2485         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2486             for (int i = 0; i < a.length; i += SPECIES.length()) {
2487                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2488                 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
2489             }
2490         }
2491 
2492         assertShiftArraysEquals(r, a, b, mask, Long256VectorTests::LSHL_unary);
2493     }
2494 
2495     static long LSHR_unary(long a, long b) {
2496         return (long)((a >>> b));
2497     }
2498 
2499     @Test(dataProvider = "longBinaryOpProvider")
2500     static void LSHRLong256VectorTestsScalarShift(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2501         long[] a = fa.apply(SPECIES.length());
2502         long[] b = fb.apply(SPECIES.length());
2503         long[] r = fr.apply(SPECIES.length());
2504 
2505         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2506             for (int i = 0; i < a.length; i += SPECIES.length()) {
2507                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2508                 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
2509             }
2510         }
2511 
2512         assertShiftArraysEquals(r, a, b, Long256VectorTests::LSHR_unary);
2513     }
2514 
2515     @Test(dataProvider = "longBinaryOpMaskProvider")
2516     static void LSHRLong256VectorTestsScalarShiftMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2517                                           IntFunction<boolean[]> fm) {
2518         long[] a = fa.apply(SPECIES.length());
2519         long[] b = fb.apply(SPECIES.length());
2520         long[] r = fr.apply(SPECIES.length());
2521         boolean[] mask = fm.apply(SPECIES.length());
2522         VectorMask<Long> 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                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2527                 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
2528             }
2529         }
2530 
2531         assertShiftArraysEquals(r, a, b, mask, Long256VectorTests::LSHR_unary);
2532     }
2533 
2534     static long ASHR_unary(long a, long b) {
2535         return (long)((a >> b));
2536     }
2537 
2538     @Test(dataProvider = "longBinaryOpProvider")
2539     static void ASHRLong256VectorTestsScalarShift(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2540         long[] a = fa.apply(SPECIES.length());
2541         long[] b = fb.apply(SPECIES.length());
2542         long[] r = fr.apply(SPECIES.length());
2543 
2544         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2545             for (int i = 0; i < a.length; i += SPECIES.length()) {
2546                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2547                 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
2548             }
2549         }
2550 
2551         assertShiftArraysEquals(r, a, b, Long256VectorTests::ASHR_unary);
2552     }
2553 
2554     @Test(dataProvider = "longBinaryOpMaskProvider")
2555     static void ASHRLong256VectorTestsScalarShiftMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2556                                           IntFunction<boolean[]> fm) {
2557         long[] a = fa.apply(SPECIES.length());
2558         long[] b = fb.apply(SPECIES.length());
2559         long[] r = fr.apply(SPECIES.length());
2560         boolean[] mask = fm.apply(SPECIES.length());
2561         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2562 
2563         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2564             for (int i = 0; i < a.length; i += SPECIES.length()) {
2565                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2566                 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
2567             }
2568         }
2569 
2570         assertShiftArraysEquals(r, a, b, mask, Long256VectorTests::ASHR_unary);
2571     }
2572 
2573     static long ROR(long a, long b) {
2574         return (long)(ROR_scalar(a,b));
2575     }
2576 
2577     @Test(dataProvider = "longBinaryOpProvider")
2578     static void RORLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2579         long[] a = fa.apply(SPECIES.length());
2580         long[] b = fb.apply(SPECIES.length());
2581         long[] r = fr.apply(SPECIES.length());
2582 
2583         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2584             for (int i = 0; i < a.length; i += SPECIES.length()) {
2585                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2586                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2587                 av.lanewise(VectorOperators.ROR, bv).intoArray(r, i);
2588             }
2589         }
2590 
2591         assertArraysEquals(r, a, b, Long256VectorTests::ROR);
2592     }
2593 
2594     @Test(dataProvider = "longBinaryOpMaskProvider")
2595     static void RORLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2596                                           IntFunction<boolean[]> fm) {
2597         long[] a = fa.apply(SPECIES.length());
2598         long[] b = fb.apply(SPECIES.length());
2599         long[] r = fr.apply(SPECIES.length());
2600         boolean[] mask = fm.apply(SPECIES.length());
2601         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2602 
2603         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2604             for (int i = 0; i < a.length; i += SPECIES.length()) {
2605                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2606                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2607                 av.lanewise(VectorOperators.ROR, bv, vmask).intoArray(r, i);
2608             }
2609         }
2610 
2611         assertArraysEquals(r, a, b, mask, Long256VectorTests::ROR);
2612     }
2613 
2614     static long ROL(long a, long b) {
2615         return (long)(ROL_scalar(a,b));
2616     }
2617 
2618     @Test(dataProvider = "longBinaryOpProvider")
2619     static void ROLLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2620         long[] a = fa.apply(SPECIES.length());
2621         long[] b = fb.apply(SPECIES.length());
2622         long[] r = fr.apply(SPECIES.length());
2623 
2624         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2625             for (int i = 0; i < a.length; i += SPECIES.length()) {
2626                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2627                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2628                 av.lanewise(VectorOperators.ROL, bv).intoArray(r, i);
2629             }
2630         }
2631 
2632         assertArraysEquals(r, a, b, Long256VectorTests::ROL);
2633     }
2634 
2635     @Test(dataProvider = "longBinaryOpMaskProvider")
2636     static void ROLLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2637                                           IntFunction<boolean[]> fm) {
2638         long[] a = fa.apply(SPECIES.length());
2639         long[] b = fb.apply(SPECIES.length());
2640         long[] r = fr.apply(SPECIES.length());
2641         boolean[] mask = fm.apply(SPECIES.length());
2642         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2643 
2644         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2645             for (int i = 0; i < a.length; i += SPECIES.length()) {
2646                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2647                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2648                 av.lanewise(VectorOperators.ROL, bv, vmask).intoArray(r, i);
2649             }
2650         }
2651 
2652         assertArraysEquals(r, a, b, mask, Long256VectorTests::ROL);
2653     }
2654 
2655     static long ROR_unary(long a, long b) {
2656         return (long)(ROR_scalar(a, b));
2657     }
2658 
2659     @Test(dataProvider = "longBinaryOpProvider")
2660     static void RORLong256VectorTestsScalarShift(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2661         long[] a = fa.apply(SPECIES.length());
2662         long[] b = fb.apply(SPECIES.length());
2663         long[] r = fr.apply(SPECIES.length());
2664 
2665         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2666             for (int i = 0; i < a.length; i += SPECIES.length()) {
2667                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2668                 av.lanewise(VectorOperators.ROR, (int)b[i]).intoArray(r, i);
2669             }
2670         }
2671 
2672         assertShiftArraysEquals(r, a, b, Long256VectorTests::ROR_unary);
2673     }
2674 
2675     @Test(dataProvider = "longBinaryOpMaskProvider")
2676     static void RORLong256VectorTestsScalarShiftMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2677                                           IntFunction<boolean[]> fm) {
2678         long[] a = fa.apply(SPECIES.length());
2679         long[] b = fb.apply(SPECIES.length());
2680         long[] r = fr.apply(SPECIES.length());
2681         boolean[] mask = fm.apply(SPECIES.length());
2682         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2683 
2684         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2685             for (int i = 0; i < a.length; i += SPECIES.length()) {
2686                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2687                 av.lanewise(VectorOperators.ROR, (int)b[i], vmask).intoArray(r, i);
2688             }
2689         }
2690 
2691         assertShiftArraysEquals(r, a, b, mask, Long256VectorTests::ROR_unary);
2692     }
2693 
2694     static long ROL_unary(long a, long b) {
2695         return (long)(ROL_scalar(a, b));
2696     }
2697 
2698     @Test(dataProvider = "longBinaryOpProvider")
2699     static void ROLLong256VectorTestsScalarShift(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2700         long[] a = fa.apply(SPECIES.length());
2701         long[] b = fb.apply(SPECIES.length());
2702         long[] r = fr.apply(SPECIES.length());
2703 
2704         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2705             for (int i = 0; i < a.length; i += SPECIES.length()) {
2706                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2707                 av.lanewise(VectorOperators.ROL, (int)b[i]).intoArray(r, i);
2708             }
2709         }
2710 
2711         assertShiftArraysEquals(r, a, b, Long256VectorTests::ROL_unary);
2712     }
2713 
2714     @Test(dataProvider = "longBinaryOpMaskProvider")
2715     static void ROLLong256VectorTestsScalarShiftMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2716                                           IntFunction<boolean[]> fm) {
2717         long[] a = fa.apply(SPECIES.length());
2718         long[] b = fb.apply(SPECIES.length());
2719         long[] r = fr.apply(SPECIES.length());
2720         boolean[] mask = fm.apply(SPECIES.length());
2721         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2722 
2723         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2724             for (int i = 0; i < a.length; i += SPECIES.length()) {
2725                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2726                 av.lanewise(VectorOperators.ROL, (int)b[i], vmask).intoArray(r, i);
2727             }
2728         }
2729 
2730         assertShiftArraysEquals(r, a, b, mask, Long256VectorTests::ROL_unary);
2731     }
2732     static long LSHR_binary_const(long a) {
2733         return (long)((a >>> CONST_SHIFT));
2734     }
2735 
2736     @Test(dataProvider = "longUnaryOpProvider")
2737     static void LSHRLong256VectorTestsScalarShiftConst(IntFunction<long[]> fa) {
2738         long[] a = fa.apply(SPECIES.length());
2739         long[] r = fr.apply(SPECIES.length());
2740 
2741         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2742             for (int i = 0; i < a.length; i += SPECIES.length()) {
2743                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2744                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT).intoArray(r, i);
2745             }
2746         }
2747 
2748         assertShiftConstEquals(r, a, Long256VectorTests::LSHR_binary_const);
2749     }
2750 
2751     @Test(dataProvider = "longUnaryOpMaskProvider")
2752     static void LSHRLong256VectorTestsScalarShiftMaskedConst(IntFunction<long[]> fa,
2753                                           IntFunction<boolean[]> fm) {
2754         long[] a = fa.apply(SPECIES.length());
2755         long[] r = fr.apply(SPECIES.length());
2756         boolean[] mask = fm.apply(SPECIES.length());
2757         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2758 
2759         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2760             for (int i = 0; i < a.length; i += SPECIES.length()) {
2761                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2762                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT, vmask).intoArray(r, i);
2763             }
2764         }
2765 
2766         assertShiftConstEquals(r, a, mask, Long256VectorTests::LSHR_binary_const);
2767     }
2768 
2769     static long LSHL_binary_const(long a) {
2770         return (long)((a << CONST_SHIFT));
2771     }
2772 
2773     @Test(dataProvider = "longUnaryOpProvider")
2774     static void LSHLLong256VectorTestsScalarShiftConst(IntFunction<long[]> fa) {
2775         long[] a = fa.apply(SPECIES.length());
2776         long[] r = fr.apply(SPECIES.length());
2777 
2778         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2779             for (int i = 0; i < a.length; i += SPECIES.length()) {
2780                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2781                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT).intoArray(r, i);
2782             }
2783         }
2784 
2785         assertShiftConstEquals(r, a, Long256VectorTests::LSHL_binary_const);
2786     }
2787 
2788     @Test(dataProvider = "longUnaryOpMaskProvider")
2789     static void LSHLLong256VectorTestsScalarShiftMaskedConst(IntFunction<long[]> fa,
2790                                           IntFunction<boolean[]> fm) {
2791         long[] a = fa.apply(SPECIES.length());
2792         long[] r = fr.apply(SPECIES.length());
2793         boolean[] mask = fm.apply(SPECIES.length());
2794         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2795 
2796         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2797             for (int i = 0; i < a.length; i += SPECIES.length()) {
2798                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2799                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT, vmask).intoArray(r, i);
2800             }
2801         }
2802 
2803         assertShiftConstEquals(r, a, mask, Long256VectorTests::LSHL_binary_const);
2804     }
2805 
2806     static long ASHR_binary_const(long a) {
2807         return (long)((a >> CONST_SHIFT));
2808     }
2809 
2810     @Test(dataProvider = "longUnaryOpProvider")
2811     static void ASHRLong256VectorTestsScalarShiftConst(IntFunction<long[]> fa) {
2812         long[] a = fa.apply(SPECIES.length());
2813         long[] r = fr.apply(SPECIES.length());
2814 
2815         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2816             for (int i = 0; i < a.length; i += SPECIES.length()) {
2817                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2818                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT).intoArray(r, i);
2819             }
2820         }
2821 
2822         assertShiftConstEquals(r, a, Long256VectorTests::ASHR_binary_const);
2823     }
2824 
2825     @Test(dataProvider = "longUnaryOpMaskProvider")
2826     static void ASHRLong256VectorTestsScalarShiftMaskedConst(IntFunction<long[]> fa,
2827                                           IntFunction<boolean[]> fm) {
2828         long[] a = fa.apply(SPECIES.length());
2829         long[] r = fr.apply(SPECIES.length());
2830         boolean[] mask = fm.apply(SPECIES.length());
2831         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2832 
2833         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2834             for (int i = 0; i < a.length; i += SPECIES.length()) {
2835                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2836                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT, vmask).intoArray(r, i);
2837             }
2838         }
2839 
2840         assertShiftConstEquals(r, a, mask, Long256VectorTests::ASHR_binary_const);
2841     }
2842 
2843     static long ROR_binary_const(long a) {
2844         return (long)(ROR_scalar(a, CONST_SHIFT));
2845     }
2846 
2847     @Test(dataProvider = "longUnaryOpProvider")
2848     static void RORLong256VectorTestsScalarShiftConst(IntFunction<long[]> fa) {
2849         long[] a = fa.apply(SPECIES.length());
2850         long[] r = fr.apply(SPECIES.length());
2851 
2852         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2853             for (int i = 0; i < a.length; i += SPECIES.length()) {
2854                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2855                 av.lanewise(VectorOperators.ROR, CONST_SHIFT).intoArray(r, i);
2856             }
2857         }
2858 
2859         assertShiftConstEquals(r, a, Long256VectorTests::ROR_binary_const);
2860     }
2861 
2862     @Test(dataProvider = "longUnaryOpMaskProvider")
2863     static void RORLong256VectorTestsScalarShiftMaskedConst(IntFunction<long[]> fa,
2864                                           IntFunction<boolean[]> fm) {
2865         long[] a = fa.apply(SPECIES.length());
2866         long[] r = fr.apply(SPECIES.length());
2867         boolean[] mask = fm.apply(SPECIES.length());
2868         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2869 
2870         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2871             for (int i = 0; i < a.length; i += SPECIES.length()) {
2872                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2873                 av.lanewise(VectorOperators.ROR, CONST_SHIFT, vmask).intoArray(r, i);
2874             }
2875         }
2876 
2877         assertShiftConstEquals(r, a, mask, Long256VectorTests::ROR_binary_const);
2878     }
2879 
2880     static long ROL_binary_const(long a) {
2881         return (long)(ROL_scalar(a, CONST_SHIFT));
2882     }
2883 
2884     @Test(dataProvider = "longUnaryOpProvider")
2885     static void ROLLong256VectorTestsScalarShiftConst(IntFunction<long[]> fa) {
2886         long[] a = fa.apply(SPECIES.length());
2887         long[] r = fr.apply(SPECIES.length());
2888 
2889         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2890             for (int i = 0; i < a.length; i += SPECIES.length()) {
2891                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2892                 av.lanewise(VectorOperators.ROL, CONST_SHIFT).intoArray(r, i);
2893             }
2894         }
2895 
2896         assertShiftConstEquals(r, a, Long256VectorTests::ROL_binary_const);
2897     }
2898 
2899     @Test(dataProvider = "longUnaryOpMaskProvider")
2900     static void ROLLong256VectorTestsScalarShiftMaskedConst(IntFunction<long[]> fa,
2901                                           IntFunction<boolean[]> fm) {
2902         long[] a = fa.apply(SPECIES.length());
2903         long[] r = fr.apply(SPECIES.length());
2904         boolean[] mask = fm.apply(SPECIES.length());
2905         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2906 
2907         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2908             for (int i = 0; i < a.length; i += SPECIES.length()) {
2909                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2910                 av.lanewise(VectorOperators.ROL, CONST_SHIFT, vmask).intoArray(r, i);
2911             }
2912         }
2913 
2914         assertShiftConstEquals(r, a, mask, Long256VectorTests::ROL_binary_const);
2915     }
2916 
2917 
2918     static long MIN(long a, long b) {
2919         return (long)(Math.min(a, b));
2920     }
2921 
2922     @Test(dataProvider = "longBinaryOpProvider")
2923     static void MINLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2924         long[] a = fa.apply(SPECIES.length());
2925         long[] b = fb.apply(SPECIES.length());
2926         long[] r = fr.apply(SPECIES.length());
2927 
2928         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2929             for (int i = 0; i < a.length; i += SPECIES.length()) {
2930                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2931                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2932                 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
2933             }
2934         }
2935 
2936         assertArraysEquals(r, a, b, Long256VectorTests::MIN);
2937     }
2938 
2939     static long min(long a, long b) {
2940         return (long)(Math.min(a, b));
2941     }
2942 
2943     @Test(dataProvider = "longBinaryOpProvider")
2944     static void minLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2945         long[] a = fa.apply(SPECIES.length());
2946         long[] b = fb.apply(SPECIES.length());
2947         long[] r = fr.apply(SPECIES.length());
2948 
2949         for (int i = 0; i < a.length; i += SPECIES.length()) {
2950             LongVector av = LongVector.fromArray(SPECIES, a, i);
2951             LongVector bv = LongVector.fromArray(SPECIES, b, i);
2952             av.min(bv).intoArray(r, i);
2953         }
2954 
2955         assertArraysEquals(r, a, b, Long256VectorTests::min);
2956     }
2957 
2958     static long MAX(long a, long b) {
2959         return (long)(Math.max(a, b));
2960     }
2961 
2962     @Test(dataProvider = "longBinaryOpProvider")
2963     static void MAXLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2964         long[] a = fa.apply(SPECIES.length());
2965         long[] b = fb.apply(SPECIES.length());
2966         long[] r = fr.apply(SPECIES.length());
2967 
2968         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2969             for (int i = 0; i < a.length; i += SPECIES.length()) {
2970                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2971                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2972                 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
2973             }
2974         }
2975 
2976         assertArraysEquals(r, a, b, Long256VectorTests::MAX);
2977     }
2978 
2979     static long max(long a, long b) {
2980         return (long)(Math.max(a, b));
2981     }
2982 
2983     @Test(dataProvider = "longBinaryOpProvider")
2984     static void maxLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2985         long[] a = fa.apply(SPECIES.length());
2986         long[] b = fb.apply(SPECIES.length());
2987         long[] r = fr.apply(SPECIES.length());
2988 
2989         for (int i = 0; i < a.length; i += SPECIES.length()) {
2990             LongVector av = LongVector.fromArray(SPECIES, a, i);
2991             LongVector bv = LongVector.fromArray(SPECIES, b, i);
2992             av.max(bv).intoArray(r, i);
2993         }
2994 
2995         assertArraysEquals(r, a, b, Long256VectorTests::max);
2996     }
2997 
2998     @Test(dataProvider = "longBinaryOpProvider")
2999     static void MINLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3000         long[] a = fa.apply(SPECIES.length());
3001         long[] b = fb.apply(SPECIES.length());
3002         long[] r = fr.apply(SPECIES.length());
3003 
3004         for (int i = 0; i < a.length; i += SPECIES.length()) {
3005             LongVector av = LongVector.fromArray(SPECIES, a, i);
3006             av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
3007         }
3008 
3009         assertBroadcastArraysEquals(r, a, b, Long256VectorTests::MIN);
3010     }
3011 
3012     @Test(dataProvider = "longBinaryOpProvider")
3013     static void minLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3014         long[] a = fa.apply(SPECIES.length());
3015         long[] b = fb.apply(SPECIES.length());
3016         long[] r = fr.apply(SPECIES.length());
3017 
3018         for (int i = 0; i < a.length; i += SPECIES.length()) {
3019             LongVector av = LongVector.fromArray(SPECIES, a, i);
3020             av.min(b[i]).intoArray(r, i);
3021         }
3022 
3023         assertBroadcastArraysEquals(r, a, b, Long256VectorTests::min);
3024     }
3025 
3026     @Test(dataProvider = "longBinaryOpProvider")
3027     static void MAXLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3028         long[] a = fa.apply(SPECIES.length());
3029         long[] b = fb.apply(SPECIES.length());
3030         long[] r = fr.apply(SPECIES.length());
3031 
3032         for (int i = 0; i < a.length; i += SPECIES.length()) {
3033             LongVector av = LongVector.fromArray(SPECIES, a, i);
3034             av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
3035         }
3036 
3037         assertBroadcastArraysEquals(r, a, b, Long256VectorTests::MAX);
3038     }
3039 
3040     @Test(dataProvider = "longBinaryOpProvider")
3041     static void maxLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3042         long[] a = fa.apply(SPECIES.length());
3043         long[] b = fb.apply(SPECIES.length());
3044         long[] r = fr.apply(SPECIES.length());
3045 
3046         for (int i = 0; i < a.length; i += SPECIES.length()) {
3047             LongVector av = LongVector.fromArray(SPECIES, a, i);
3048             av.max(b[i]).intoArray(r, i);
3049         }
3050 
3051         assertBroadcastArraysEquals(r, a, b, Long256VectorTests::max);
3052     }
3053 
3054     static long ANDReduce(long[] a, int idx) {
3055         long res = -1;
3056         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3057             res &= a[i];
3058         }
3059 
3060         return res;
3061     }
3062 
3063     static long ANDReduceAll(long[] a) {
3064         long res = -1;
3065         for (int i = 0; i < a.length; i += SPECIES.length()) {
3066             res &= ANDReduce(a, i);
3067         }
3068 
3069         return res;
3070     }
3071 
3072     @Test(dataProvider = "longUnaryOpProvider")
3073     static void ANDReduceLong256VectorTests(IntFunction<long[]> fa) {
3074         long[] a = fa.apply(SPECIES.length());
3075         long[] r = fr.apply(SPECIES.length());
3076         long ra = -1;
3077 
3078         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3079             for (int i = 0; i < a.length; i += SPECIES.length()) {
3080                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3081                 r[i] = av.reduceLanes(VectorOperators.AND);
3082             }
3083         }
3084 
3085         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3086             ra = -1;
3087             for (int i = 0; i < a.length; i += SPECIES.length()) {
3088                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3089                 ra &= av.reduceLanes(VectorOperators.AND);
3090             }
3091         }
3092 
3093         assertReductionArraysEquals(r, ra, a,
3094                 Long256VectorTests::ANDReduce, Long256VectorTests::ANDReduceAll);
3095     }
3096 
3097     static long ANDReduceMasked(long[] a, int idx, boolean[] mask) {
3098         long res = -1;
3099         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3100             if (mask[i % SPECIES.length()])
3101                 res &= a[i];
3102         }
3103 
3104         return res;
3105     }
3106 
3107     static long ANDReduceAllMasked(long[] a, boolean[] mask) {
3108         long res = -1;
3109         for (int i = 0; i < a.length; i += SPECIES.length()) {
3110             res &= ANDReduceMasked(a, i, mask);
3111         }
3112 
3113         return res;
3114     }
3115 
3116     @Test(dataProvider = "longUnaryOpMaskProvider")
3117     static void ANDReduceLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3118         long[] a = fa.apply(SPECIES.length());
3119         long[] r = fr.apply(SPECIES.length());
3120         boolean[] mask = fm.apply(SPECIES.length());
3121         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3122         long ra = -1;
3123 
3124         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3125             for (int i = 0; i < a.length; i += SPECIES.length()) {
3126                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3127                 r[i] = av.reduceLanes(VectorOperators.AND, vmask);
3128             }
3129         }
3130 
3131         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3132             ra = -1;
3133             for (int i = 0; i < a.length; i += SPECIES.length()) {
3134                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3135                 ra &= av.reduceLanes(VectorOperators.AND, vmask);
3136             }
3137         }
3138 
3139         assertReductionArraysEqualsMasked(r, ra, a, mask,
3140                 Long256VectorTests::ANDReduceMasked, Long256VectorTests::ANDReduceAllMasked);
3141     }
3142 
3143     static long ORReduce(long[] a, int idx) {
3144         long res = 0;
3145         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3146             res |= a[i];
3147         }
3148 
3149         return res;
3150     }
3151 
3152     static long ORReduceAll(long[] a) {
3153         long res = 0;
3154         for (int i = 0; i < a.length; i += SPECIES.length()) {
3155             res |= ORReduce(a, i);
3156         }
3157 
3158         return res;
3159     }
3160 
3161     @Test(dataProvider = "longUnaryOpProvider")
3162     static void ORReduceLong256VectorTests(IntFunction<long[]> fa) {
3163         long[] a = fa.apply(SPECIES.length());
3164         long[] r = fr.apply(SPECIES.length());
3165         long ra = 0;
3166 
3167         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3168             for (int i = 0; i < a.length; i += SPECIES.length()) {
3169                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3170                 r[i] = av.reduceLanes(VectorOperators.OR);
3171             }
3172         }
3173 
3174         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3175             ra = 0;
3176             for (int i = 0; i < a.length; i += SPECIES.length()) {
3177                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3178                 ra |= av.reduceLanes(VectorOperators.OR);
3179             }
3180         }
3181 
3182         assertReductionArraysEquals(r, ra, a,
3183                 Long256VectorTests::ORReduce, Long256VectorTests::ORReduceAll);
3184     }
3185 
3186     static long ORReduceMasked(long[] a, int idx, boolean[] mask) {
3187         long res = 0;
3188         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3189             if (mask[i % SPECIES.length()])
3190                 res |= a[i];
3191         }
3192 
3193         return res;
3194     }
3195 
3196     static long ORReduceAllMasked(long[] a, boolean[] mask) {
3197         long res = 0;
3198         for (int i = 0; i < a.length; i += SPECIES.length()) {
3199             res |= ORReduceMasked(a, i, mask);
3200         }
3201 
3202         return res;
3203     }
3204 
3205     @Test(dataProvider = "longUnaryOpMaskProvider")
3206     static void ORReduceLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3207         long[] a = fa.apply(SPECIES.length());
3208         long[] r = fr.apply(SPECIES.length());
3209         boolean[] mask = fm.apply(SPECIES.length());
3210         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3211         long ra = 0;
3212 
3213         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3214             for (int i = 0; i < a.length; i += SPECIES.length()) {
3215                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3216                 r[i] = av.reduceLanes(VectorOperators.OR, vmask);
3217             }
3218         }
3219 
3220         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3221             ra = 0;
3222             for (int i = 0; i < a.length; i += SPECIES.length()) {
3223                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3224                 ra |= av.reduceLanes(VectorOperators.OR, vmask);
3225             }
3226         }
3227 
3228         assertReductionArraysEqualsMasked(r, ra, a, mask,
3229                 Long256VectorTests::ORReduceMasked, Long256VectorTests::ORReduceAllMasked);
3230     }
3231 
3232     static long XORReduce(long[] a, int idx) {
3233         long res = 0;
3234         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3235             res ^= a[i];
3236         }
3237 
3238         return res;
3239     }
3240 
3241     static long XORReduceAll(long[] a) {
3242         long res = 0;
3243         for (int i = 0; i < a.length; i += SPECIES.length()) {
3244             res ^= XORReduce(a, i);
3245         }
3246 
3247         return res;
3248     }
3249 
3250     @Test(dataProvider = "longUnaryOpProvider")
3251     static void XORReduceLong256VectorTests(IntFunction<long[]> fa) {
3252         long[] a = fa.apply(SPECIES.length());
3253         long[] r = fr.apply(SPECIES.length());
3254         long ra = 0;
3255 
3256         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3257             for (int i = 0; i < a.length; i += SPECIES.length()) {
3258                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3259                 r[i] = av.reduceLanes(VectorOperators.XOR);
3260             }
3261         }
3262 
3263         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3264             ra = 0;
3265             for (int i = 0; i < a.length; i += SPECIES.length()) {
3266                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3267                 ra ^= av.reduceLanes(VectorOperators.XOR);
3268             }
3269         }
3270 
3271         assertReductionArraysEquals(r, ra, a,
3272                 Long256VectorTests::XORReduce, Long256VectorTests::XORReduceAll);
3273     }
3274 
3275     static long XORReduceMasked(long[] a, int idx, boolean[] mask) {
3276         long res = 0;
3277         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3278             if (mask[i % SPECIES.length()])
3279                 res ^= a[i];
3280         }
3281 
3282         return res;
3283     }
3284 
3285     static long XORReduceAllMasked(long[] a, boolean[] mask) {
3286         long res = 0;
3287         for (int i = 0; i < a.length; i += SPECIES.length()) {
3288             res ^= XORReduceMasked(a, i, mask);
3289         }
3290 
3291         return res;
3292     }
3293 
3294     @Test(dataProvider = "longUnaryOpMaskProvider")
3295     static void XORReduceLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3296         long[] a = fa.apply(SPECIES.length());
3297         long[] r = fr.apply(SPECIES.length());
3298         boolean[] mask = fm.apply(SPECIES.length());
3299         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3300         long ra = 0;
3301 
3302         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3303             for (int i = 0; i < a.length; i += SPECIES.length()) {
3304                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3305                 r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
3306             }
3307         }
3308 
3309         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3310             ra = 0;
3311             for (int i = 0; i < a.length; i += SPECIES.length()) {
3312                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3313                 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
3314             }
3315         }
3316 
3317         assertReductionArraysEqualsMasked(r, ra, a, mask,
3318                 Long256VectorTests::XORReduceMasked, Long256VectorTests::XORReduceAllMasked);
3319     }
3320 
3321     static long ADDReduce(long[] a, int idx) {
3322         long res = 0;
3323         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3324             res += a[i];
3325         }
3326 
3327         return res;
3328     }
3329 
3330     static long ADDReduceAll(long[] a) {
3331         long res = 0;
3332         for (int i = 0; i < a.length; i += SPECIES.length()) {
3333             res += ADDReduce(a, i);
3334         }
3335 
3336         return res;
3337     }
3338 
3339     @Test(dataProvider = "longUnaryOpProvider")
3340     static void ADDReduceLong256VectorTests(IntFunction<long[]> fa) {
3341         long[] a = fa.apply(SPECIES.length());
3342         long[] r = fr.apply(SPECIES.length());
3343         long ra = 0;
3344 
3345         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3346             for (int i = 0; i < a.length; i += SPECIES.length()) {
3347                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3348                 r[i] = av.reduceLanes(VectorOperators.ADD);
3349             }
3350         }
3351 
3352         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3353             ra = 0;
3354             for (int i = 0; i < a.length; i += SPECIES.length()) {
3355                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3356                 ra += av.reduceLanes(VectorOperators.ADD);
3357             }
3358         }
3359 
3360         assertReductionArraysEquals(r, ra, a,
3361                 Long256VectorTests::ADDReduce, Long256VectorTests::ADDReduceAll);
3362     }
3363 
3364     static long ADDReduceMasked(long[] a, int idx, boolean[] mask) {
3365         long res = 0;
3366         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3367             if (mask[i % SPECIES.length()])
3368                 res += a[i];
3369         }
3370 
3371         return res;
3372     }
3373 
3374     static long ADDReduceAllMasked(long[] a, boolean[] mask) {
3375         long res = 0;
3376         for (int i = 0; i < a.length; i += SPECIES.length()) {
3377             res += ADDReduceMasked(a, i, mask);
3378         }
3379 
3380         return res;
3381     }
3382 
3383     @Test(dataProvider = "longUnaryOpMaskProvider")
3384     static void ADDReduceLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3385         long[] a = fa.apply(SPECIES.length());
3386         long[] r = fr.apply(SPECIES.length());
3387         boolean[] mask = fm.apply(SPECIES.length());
3388         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3389         long ra = 0;
3390 
3391         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3392             for (int i = 0; i < a.length; i += SPECIES.length()) {
3393                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3394                 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
3395             }
3396         }
3397 
3398         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3399             ra = 0;
3400             for (int i = 0; i < a.length; i += SPECIES.length()) {
3401                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3402                 ra += av.reduceLanes(VectorOperators.ADD, vmask);
3403             }
3404         }
3405 
3406         assertReductionArraysEqualsMasked(r, ra, a, mask,
3407                 Long256VectorTests::ADDReduceMasked, Long256VectorTests::ADDReduceAllMasked);
3408     }
3409 
3410     static long MULReduce(long[] a, int idx) {
3411         long res = 1;
3412         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3413             res *= a[i];
3414         }
3415 
3416         return res;
3417     }
3418 
3419     static long MULReduceAll(long[] a) {
3420         long res = 1;
3421         for (int i = 0; i < a.length; i += SPECIES.length()) {
3422             res *= MULReduce(a, i);
3423         }
3424 
3425         return res;
3426     }
3427 
3428     @Test(dataProvider = "longUnaryOpProvider")
3429     static void MULReduceLong256VectorTests(IntFunction<long[]> fa) {
3430         long[] a = fa.apply(SPECIES.length());
3431         long[] r = fr.apply(SPECIES.length());
3432         long ra = 1;
3433 
3434         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3435             for (int i = 0; i < a.length; i += SPECIES.length()) {
3436                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3437                 r[i] = av.reduceLanes(VectorOperators.MUL);
3438             }
3439         }
3440 
3441         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3442             ra = 1;
3443             for (int i = 0; i < a.length; i += SPECIES.length()) {
3444                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3445                 ra *= av.reduceLanes(VectorOperators.MUL);
3446             }
3447         }
3448 
3449         assertReductionArraysEquals(r, ra, a,
3450                 Long256VectorTests::MULReduce, Long256VectorTests::MULReduceAll);
3451     }
3452 
3453     static long MULReduceMasked(long[] a, int idx, boolean[] mask) {
3454         long res = 1;
3455         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3456             if (mask[i % SPECIES.length()])
3457                 res *= a[i];
3458         }
3459 
3460         return res;
3461     }
3462 
3463     static long MULReduceAllMasked(long[] a, boolean[] mask) {
3464         long res = 1;
3465         for (int i = 0; i < a.length; i += SPECIES.length()) {
3466             res *= MULReduceMasked(a, i, mask);
3467         }
3468 
3469         return res;
3470     }
3471 
3472     @Test(dataProvider = "longUnaryOpMaskProvider")
3473     static void MULReduceLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3474         long[] a = fa.apply(SPECIES.length());
3475         long[] r = fr.apply(SPECIES.length());
3476         boolean[] mask = fm.apply(SPECIES.length());
3477         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3478         long ra = 1;
3479 
3480         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3481             for (int i = 0; i < a.length; i += SPECIES.length()) {
3482                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3483                 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
3484             }
3485         }
3486 
3487         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3488             ra = 1;
3489             for (int i = 0; i < a.length; i += SPECIES.length()) {
3490                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3491                 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
3492             }
3493         }
3494 
3495         assertReductionArraysEqualsMasked(r, ra, a, mask,
3496                 Long256VectorTests::MULReduceMasked, Long256VectorTests::MULReduceAllMasked);
3497     }
3498 
3499     static long MINReduce(long[] a, int idx) {
3500         long res = Long.MAX_VALUE;
3501         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3502             res = (long) Math.min(res, a[i]);
3503         }
3504 
3505         return res;
3506     }
3507 
3508     static long MINReduceAll(long[] a) {
3509         long res = Long.MAX_VALUE;
3510         for (int i = 0; i < a.length; i += SPECIES.length()) {
3511             res = (long) Math.min(res, MINReduce(a, i));
3512         }
3513 
3514         return res;
3515     }
3516 
3517     @Test(dataProvider = "longUnaryOpProvider")
3518     static void MINReduceLong256VectorTests(IntFunction<long[]> fa) {
3519         long[] a = fa.apply(SPECIES.length());
3520         long[] r = fr.apply(SPECIES.length());
3521         long ra = Long.MAX_VALUE;
3522 
3523         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3524             for (int i = 0; i < a.length; i += SPECIES.length()) {
3525                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3526                 r[i] = av.reduceLanes(VectorOperators.MIN);
3527             }
3528         }
3529 
3530         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3531             ra = Long.MAX_VALUE;
3532             for (int i = 0; i < a.length; i += SPECIES.length()) {
3533                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3534                 ra = (long) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
3535             }
3536         }
3537 
3538         assertReductionArraysEquals(r, ra, a,
3539                 Long256VectorTests::MINReduce, Long256VectorTests::MINReduceAll);
3540     }
3541 
3542     static long MINReduceMasked(long[] a, int idx, boolean[] mask) {
3543         long res = Long.MAX_VALUE;
3544         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3545             if (mask[i % SPECIES.length()])
3546                 res = (long) Math.min(res, a[i]);
3547         }
3548 
3549         return res;
3550     }
3551 
3552     static long MINReduceAllMasked(long[] a, boolean[] mask) {
3553         long res = Long.MAX_VALUE;
3554         for (int i = 0; i < a.length; i += SPECIES.length()) {
3555             res = (long) Math.min(res, MINReduceMasked(a, i, mask));
3556         }
3557 
3558         return res;
3559     }
3560 
3561     @Test(dataProvider = "longUnaryOpMaskProvider")
3562     static void MINReduceLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3563         long[] a = fa.apply(SPECIES.length());
3564         long[] r = fr.apply(SPECIES.length());
3565         boolean[] mask = fm.apply(SPECIES.length());
3566         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3567         long ra = Long.MAX_VALUE;
3568 
3569         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3570             for (int i = 0; i < a.length; i += SPECIES.length()) {
3571                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3572                 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
3573             }
3574         }
3575 
3576         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3577             ra = Long.MAX_VALUE;
3578             for (int i = 0; i < a.length; i += SPECIES.length()) {
3579                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3580                 ra = (long) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
3581             }
3582         }
3583 
3584         assertReductionArraysEqualsMasked(r, ra, a, mask,
3585                 Long256VectorTests::MINReduceMasked, Long256VectorTests::MINReduceAllMasked);
3586     }
3587 
3588     static long MAXReduce(long[] a, int idx) {
3589         long res = Long.MIN_VALUE;
3590         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3591             res = (long) Math.max(res, a[i]);
3592         }
3593 
3594         return res;
3595     }
3596 
3597     static long MAXReduceAll(long[] a) {
3598         long res = Long.MIN_VALUE;
3599         for (int i = 0; i < a.length; i += SPECIES.length()) {
3600             res = (long) Math.max(res, MAXReduce(a, i));
3601         }
3602 
3603         return res;
3604     }
3605 
3606     @Test(dataProvider = "longUnaryOpProvider")
3607     static void MAXReduceLong256VectorTests(IntFunction<long[]> fa) {
3608         long[] a = fa.apply(SPECIES.length());
3609         long[] r = fr.apply(SPECIES.length());
3610         long ra = Long.MIN_VALUE;
3611 
3612         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3613             for (int i = 0; i < a.length; i += SPECIES.length()) {
3614                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3615                 r[i] = av.reduceLanes(VectorOperators.MAX);
3616             }
3617         }
3618 
3619         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3620             ra = Long.MIN_VALUE;
3621             for (int i = 0; i < a.length; i += SPECIES.length()) {
3622                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3623                 ra = (long) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
3624             }
3625         }
3626 
3627         assertReductionArraysEquals(r, ra, a,
3628                 Long256VectorTests::MAXReduce, Long256VectorTests::MAXReduceAll);
3629     }
3630 
3631     static long MAXReduceMasked(long[] a, int idx, boolean[] mask) {
3632         long res = Long.MIN_VALUE;
3633         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3634             if (mask[i % SPECIES.length()])
3635                 res = (long) Math.max(res, a[i]);
3636         }
3637 
3638         return res;
3639     }
3640 
3641     static long MAXReduceAllMasked(long[] a, boolean[] mask) {
3642         long res = Long.MIN_VALUE;
3643         for (int i = 0; i < a.length; i += SPECIES.length()) {
3644             res = (long) Math.max(res, MAXReduceMasked(a, i, mask));
3645         }
3646 
3647         return res;
3648     }
3649 
3650     @Test(dataProvider = "longUnaryOpMaskProvider")
3651     static void MAXReduceLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3652         long[] a = fa.apply(SPECIES.length());
3653         long[] r = fr.apply(SPECIES.length());
3654         boolean[] mask = fm.apply(SPECIES.length());
3655         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3656         long ra = Long.MIN_VALUE;
3657 
3658         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3659             for (int i = 0; i < a.length; i += SPECIES.length()) {
3660                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3661                 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
3662             }
3663         }
3664 
3665         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3666             ra = Long.MIN_VALUE;
3667             for (int i = 0; i < a.length; i += SPECIES.length()) {
3668                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3669                 ra = (long) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
3670             }
3671         }
3672 
3673         assertReductionArraysEqualsMasked(r, ra, a, mask,
3674                 Long256VectorTests::MAXReduceMasked, Long256VectorTests::MAXReduceAllMasked);
3675     }
3676 
3677     static long FIRST_NONZEROReduce(long[] a, int idx) {
3678         long res = (long) 0;
3679         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3680             res = firstNonZero(res, a[i]);
3681         }
3682 
3683         return res;
3684     }
3685 
3686     static long FIRST_NONZEROReduceAll(long[] a) {
3687         long res = (long) 0;
3688         for (int i = 0; i < a.length; i += SPECIES.length()) {
3689             res = firstNonZero(res, FIRST_NONZEROReduce(a, i));
3690         }
3691 
3692         return res;
3693     }
3694 
3695     @Test(dataProvider = "longUnaryOpProvider")
3696     static void FIRST_NONZEROReduceLong256VectorTests(IntFunction<long[]> fa) {
3697         long[] a = fa.apply(SPECIES.length());
3698         long[] r = fr.apply(SPECIES.length());
3699         long ra = (long) 0;
3700 
3701         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3702             for (int i = 0; i < a.length; i += SPECIES.length()) {
3703                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3704                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO);
3705             }
3706         }
3707 
3708         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3709             ra = (long) 0;
3710             for (int i = 0; i < a.length; i += SPECIES.length()) {
3711                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3712                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
3713             }
3714         }
3715 
3716         assertReductionArraysEquals(r, ra, a,
3717                 Long256VectorTests::FIRST_NONZEROReduce, Long256VectorTests::FIRST_NONZEROReduceAll);
3718     }
3719 
3720     static long FIRST_NONZEROReduceMasked(long[] a, int idx, boolean[] mask) {
3721         long res = (long) 0;
3722         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3723             if (mask[i % SPECIES.length()])
3724                 res = firstNonZero(res, a[i]);
3725         }
3726 
3727         return res;
3728     }
3729 
3730     static long FIRST_NONZEROReduceAllMasked(long[] a, boolean[] mask) {
3731         long res = (long) 0;
3732         for (int i = 0; i < a.length; i += SPECIES.length()) {
3733             res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask));
3734         }
3735 
3736         return res;
3737     }
3738 
3739     @Test(dataProvider = "longUnaryOpMaskProvider")
3740     static void FIRST_NONZEROReduceLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3741         long[] a = fa.apply(SPECIES.length());
3742         long[] r = fr.apply(SPECIES.length());
3743         boolean[] mask = fm.apply(SPECIES.length());
3744         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3745         long ra = (long) 0;
3746 
3747         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3748             for (int i = 0; i < a.length; i += SPECIES.length()) {
3749                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3750                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask);
3751             }
3752         }
3753 
3754         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3755             ra = (long) 0;
3756             for (int i = 0; i < a.length; i += SPECIES.length()) {
3757                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3758                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
3759             }
3760         }
3761 
3762         assertReductionArraysEqualsMasked(r, ra, a, mask,
3763                 Long256VectorTests::FIRST_NONZEROReduceMasked, Long256VectorTests::FIRST_NONZEROReduceAllMasked);
3764     }
3765 
3766     static boolean anyTrue(boolean[] a, int idx) {
3767         boolean res = false;
3768         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3769             res |= a[i];
3770         }
3771 
3772         return res;
3773     }
3774 
3775     @Test(dataProvider = "boolUnaryOpProvider")
3776     static void anyTrueLong256VectorTests(IntFunction<boolean[]> fm) {
3777         boolean[] mask = fm.apply(SPECIES.length());
3778         boolean[] r = fmr.apply(SPECIES.length());
3779 
3780         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3781             for (int i = 0; i < mask.length; i += SPECIES.length()) {
3782                 VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, i);
3783                 r[i] = vmask.anyTrue();
3784             }
3785         }
3786 
3787         assertReductionBoolArraysEquals(r, mask, Long256VectorTests::anyTrue);
3788     }
3789 
3790     static boolean allTrue(boolean[] a, int idx) {
3791         boolean res = true;
3792         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3793             res &= a[i];
3794         }
3795 
3796         return res;
3797     }
3798 
3799     @Test(dataProvider = "boolUnaryOpProvider")
3800     static void allTrueLong256VectorTests(IntFunction<boolean[]> fm) {
3801         boolean[] mask = fm.apply(SPECIES.length());
3802         boolean[] r = fmr.apply(SPECIES.length());
3803 
3804         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3805             for (int i = 0; i < mask.length; i += SPECIES.length()) {
3806                 VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, i);
3807                 r[i] = vmask.allTrue();
3808             }
3809         }
3810 
3811         assertReductionBoolArraysEquals(r, mask, Long256VectorTests::allTrue);
3812     }
3813 
3814     @Test(dataProvider = "longUnaryOpProvider")
3815     static void withLong256VectorTests(IntFunction<long []> fa) {
3816         long[] a = fa.apply(SPECIES.length());
3817         long[] r = fr.apply(SPECIES.length());
3818 
3819         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3820             for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
3821                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3822                 av.withLane((j++ & (SPECIES.length()-1)), (long)(65535+i)).intoArray(r, i);
3823             }
3824         }
3825 
3826 
3827         for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
3828             assertInsertArraysEquals(r, a, (long)(65535+i), (j++ & (SPECIES.length()-1)), i , i + SPECIES.length());
3829         }
3830     }
3831 
3832     static boolean testIS_DEFAULT(long a) {
3833         return bits(a)==0;
3834     }
3835 
3836     @Test(dataProvider = "longTestOpProvider")
3837     static void IS_DEFAULTLong256VectorTests(IntFunction<long[]> fa) {
3838         long[] a = fa.apply(SPECIES.length());
3839 
3840         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3841             for (int i = 0; i < a.length; i += SPECIES.length()) {
3842                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3843                 VectorMask<Long> mv = av.test(VectorOperators.IS_DEFAULT);
3844 
3845                 // Check results as part of computation.
3846                 for (int j = 0; j < SPECIES.length(); j++) {
3847                     Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
3848                 }
3849             }
3850         }
3851     }
3852 
3853     @Test(dataProvider = "longTestOpMaskProvider")
3854     static void IS_DEFAULTMaskedLong256VectorTests(IntFunction<long[]> fa,
3855                                           IntFunction<boolean[]> fm) {
3856         long[] a = fa.apply(SPECIES.length());
3857         boolean[] mask = fm.apply(SPECIES.length());
3858         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3859 
3860         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3861             for (int i = 0; i < a.length; i += SPECIES.length()) {
3862                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3863                 VectorMask<Long> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
3864 
3865                 // Check results as part of computation.
3866                 for (int j = 0; j < SPECIES.length(); j++) {
3867                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
3868                 }
3869             }
3870         }
3871     }
3872 
3873     static boolean testIS_NEGATIVE(long a) {
3874         return bits(a)<0;
3875     }
3876 
3877     @Test(dataProvider = "longTestOpProvider")
3878     static void IS_NEGATIVELong256VectorTests(IntFunction<long[]> fa) {
3879         long[] a = fa.apply(SPECIES.length());
3880 
3881         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3882             for (int i = 0; i < a.length; i += SPECIES.length()) {
3883                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3884                 VectorMask<Long> mv = av.test(VectorOperators.IS_NEGATIVE);
3885 
3886                 // Check results as part of computation.
3887                 for (int j = 0; j < SPECIES.length(); j++) {
3888                     Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
3889                 }
3890             }
3891         }
3892     }
3893 
3894     @Test(dataProvider = "longTestOpMaskProvider")
3895     static void IS_NEGATIVEMaskedLong256VectorTests(IntFunction<long[]> fa,
3896                                           IntFunction<boolean[]> fm) {
3897         long[] a = fa.apply(SPECIES.length());
3898         boolean[] mask = fm.apply(SPECIES.length());
3899         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3900 
3901         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3902             for (int i = 0; i < a.length; i += SPECIES.length()) {
3903                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3904                 VectorMask<Long> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
3905 
3906                 // Check results as part of computation.
3907                 for (int j = 0; j < SPECIES.length(); j++) {
3908                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
3909                 }
3910             }
3911         }
3912     }
3913 
3914     @Test(dataProvider = "longCompareOpProvider")
3915     static void LTLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3916         long[] a = fa.apply(SPECIES.length());
3917         long[] b = fb.apply(SPECIES.length());
3918 
3919         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3920             for (int i = 0; i < a.length; i += SPECIES.length()) {
3921                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3922                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
3923                 VectorMask<Long> mv = av.compare(VectorOperators.LT, bv);
3924 
3925                 // Check results as part of computation.
3926                 for (int j = 0; j < SPECIES.length(); j++) {
3927                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3928                 }
3929             }
3930         }
3931     }
3932 
3933     @Test(dataProvider = "longCompareOpProvider")
3934     static void ltLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3935         long[] a = fa.apply(SPECIES.length());
3936         long[] b = fb.apply(SPECIES.length());
3937 
3938         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3939             for (int i = 0; i < a.length; i += SPECIES.length()) {
3940                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3941                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
3942                 VectorMask<Long> mv = av.lt(bv);
3943 
3944                 // Check results as part of computation.
3945                 for (int j = 0; j < SPECIES.length(); j++) {
3946                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3947                 }
3948             }
3949         }
3950     }
3951 
3952     @Test(dataProvider = "longCompareOpMaskProvider")
3953     static void LTLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
3954                                                 IntFunction<boolean[]> fm) {
3955         long[] a = fa.apply(SPECIES.length());
3956         long[] b = fb.apply(SPECIES.length());
3957         boolean[] mask = fm.apply(SPECIES.length());
3958 
3959         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3960 
3961         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3962             for (int i = 0; i < a.length; i += SPECIES.length()) {
3963                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3964                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
3965                 VectorMask<Long> mv = av.compare(VectorOperators.LT, bv, vmask);
3966 
3967                 // Check results as part of computation.
3968                 for (int j = 0; j < SPECIES.length(); j++) {
3969                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
3970                 }
3971             }
3972         }
3973     }
3974 
3975     @Test(dataProvider = "longCompareOpProvider")
3976     static void GTLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3977         long[] a = fa.apply(SPECIES.length());
3978         long[] b = fb.apply(SPECIES.length());
3979 
3980         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3981             for (int i = 0; i < a.length; i += SPECIES.length()) {
3982                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3983                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
3984                 VectorMask<Long> mv = av.compare(VectorOperators.GT, bv);
3985 
3986                 // Check results as part of computation.
3987                 for (int j = 0; j < SPECIES.length(); j++) {
3988                     Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
3989                 }
3990             }
3991         }
3992     }
3993 
3994     @Test(dataProvider = "longCompareOpMaskProvider")
3995     static void GTLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
3996                                                 IntFunction<boolean[]> fm) {
3997         long[] a = fa.apply(SPECIES.length());
3998         long[] b = fb.apply(SPECIES.length());
3999         boolean[] mask = fm.apply(SPECIES.length());
4000 
4001         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4002 
4003         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4004             for (int i = 0; i < a.length; i += SPECIES.length()) {
4005                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4006                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4007                 VectorMask<Long> mv = av.compare(VectorOperators.GT, bv, vmask);
4008 
4009                 // Check results as part of computation.
4010                 for (int j = 0; j < SPECIES.length(); j++) {
4011                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
4012                 }
4013             }
4014         }
4015     }
4016 
4017     @Test(dataProvider = "longCompareOpProvider")
4018     static void EQLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4019         long[] a = fa.apply(SPECIES.length());
4020         long[] b = fb.apply(SPECIES.length());
4021 
4022         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4023             for (int i = 0; i < a.length; i += SPECIES.length()) {
4024                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4025                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4026                 VectorMask<Long> mv = av.compare(VectorOperators.EQ, bv);
4027 
4028                 // Check results as part of computation.
4029                 for (int j = 0; j < SPECIES.length(); j++) {
4030                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
4031                 }
4032             }
4033         }
4034     }
4035 
4036     @Test(dataProvider = "longCompareOpProvider")
4037     static void eqLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4038         long[] a = fa.apply(SPECIES.length());
4039         long[] b = fb.apply(SPECIES.length());
4040 
4041         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4042             for (int i = 0; i < a.length; i += SPECIES.length()) {
4043                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4044                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4045                 VectorMask<Long> mv = av.eq(bv);
4046 
4047                 // Check results as part of computation.
4048                 for (int j = 0; j < SPECIES.length(); j++) {
4049                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
4050                 }
4051             }
4052         }
4053     }
4054 
4055     @Test(dataProvider = "longCompareOpMaskProvider")
4056     static void EQLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4057                                                 IntFunction<boolean[]> fm) {
4058         long[] a = fa.apply(SPECIES.length());
4059         long[] b = fb.apply(SPECIES.length());
4060         boolean[] mask = fm.apply(SPECIES.length());
4061 
4062         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4063 
4064         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4065             for (int i = 0; i < a.length; i += SPECIES.length()) {
4066                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4067                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4068                 VectorMask<Long> mv = av.compare(VectorOperators.EQ, bv, vmask);
4069 
4070                 // Check results as part of computation.
4071                 for (int j = 0; j < SPECIES.length(); j++) {
4072                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
4073                 }
4074             }
4075         }
4076     }
4077 
4078     @Test(dataProvider = "longCompareOpProvider")
4079     static void NELong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4080         long[] a = fa.apply(SPECIES.length());
4081         long[] b = fb.apply(SPECIES.length());
4082 
4083         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4084             for (int i = 0; i < a.length; i += SPECIES.length()) {
4085                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4086                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4087                 VectorMask<Long> mv = av.compare(VectorOperators.NE, bv);
4088 
4089                 // Check results as part of computation.
4090                 for (int j = 0; j < SPECIES.length(); j++) {
4091                     Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
4092                 }
4093             }
4094         }
4095     }
4096 
4097     @Test(dataProvider = "longCompareOpMaskProvider")
4098     static void NELong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4099                                                 IntFunction<boolean[]> fm) {
4100         long[] a = fa.apply(SPECIES.length());
4101         long[] b = fb.apply(SPECIES.length());
4102         boolean[] mask = fm.apply(SPECIES.length());
4103 
4104         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4105 
4106         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4107             for (int i = 0; i < a.length; i += SPECIES.length()) {
4108                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4109                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4110                 VectorMask<Long> mv = av.compare(VectorOperators.NE, bv, vmask);
4111 
4112                 // Check results as part of computation.
4113                 for (int j = 0; j < SPECIES.length(); j++) {
4114                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
4115                 }
4116             }
4117         }
4118     }
4119 
4120     @Test(dataProvider = "longCompareOpProvider")
4121     static void LELong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4122         long[] a = fa.apply(SPECIES.length());
4123         long[] b = fb.apply(SPECIES.length());
4124 
4125         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4126             for (int i = 0; i < a.length; i += SPECIES.length()) {
4127                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4128                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4129                 VectorMask<Long> mv = av.compare(VectorOperators.LE, bv);
4130 
4131                 // Check results as part of computation.
4132                 for (int j = 0; j < SPECIES.length(); j++) {
4133                     Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
4134                 }
4135             }
4136         }
4137     }
4138 
4139     @Test(dataProvider = "longCompareOpMaskProvider")
4140     static void LELong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4141                                                 IntFunction<boolean[]> fm) {
4142         long[] a = fa.apply(SPECIES.length());
4143         long[] b = fb.apply(SPECIES.length());
4144         boolean[] mask = fm.apply(SPECIES.length());
4145 
4146         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4147 
4148         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4149             for (int i = 0; i < a.length; i += SPECIES.length()) {
4150                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4151                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4152                 VectorMask<Long> mv = av.compare(VectorOperators.LE, bv, vmask);
4153 
4154                 // Check results as part of computation.
4155                 for (int j = 0; j < SPECIES.length(); j++) {
4156                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
4157                 }
4158             }
4159         }
4160     }
4161 
4162     @Test(dataProvider = "longCompareOpProvider")
4163     static void GELong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4164         long[] a = fa.apply(SPECIES.length());
4165         long[] b = fb.apply(SPECIES.length());
4166 
4167         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4168             for (int i = 0; i < a.length; i += SPECIES.length()) {
4169                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4170                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4171                 VectorMask<Long> mv = av.compare(VectorOperators.GE, bv);
4172 
4173                 // Check results as part of computation.
4174                 for (int j = 0; j < SPECIES.length(); j++) {
4175                     Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
4176                 }
4177             }
4178         }
4179     }
4180 
4181     @Test(dataProvider = "longCompareOpMaskProvider")
4182     static void GELong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4183                                                 IntFunction<boolean[]> fm) {
4184         long[] a = fa.apply(SPECIES.length());
4185         long[] b = fb.apply(SPECIES.length());
4186         boolean[] mask = fm.apply(SPECIES.length());
4187 
4188         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4189 
4190         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4191             for (int i = 0; i < a.length; i += SPECIES.length()) {
4192                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4193                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4194                 VectorMask<Long> mv = av.compare(VectorOperators.GE, bv, vmask);
4195 
4196                 // Check results as part of computation.
4197                 for (int j = 0; j < SPECIES.length(); j++) {
4198                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
4199                 }
4200             }
4201         }
4202     }
4203 
4204     @Test(dataProvider = "longCompareOpProvider")
4205     static void UNSIGNED_LTLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4206         long[] a = fa.apply(SPECIES.length());
4207         long[] b = fb.apply(SPECIES.length());
4208 
4209         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4210             for (int i = 0; i < a.length; i += SPECIES.length()) {
4211                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4212                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4213                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_LT, bv);
4214 
4215                 // Check results as part of computation.
4216                 for (int j = 0; j < SPECIES.length(); j++) {
4217                     Assert.assertEquals(mv.laneIsSet(j), ult(a[i + j], b[i + j]));
4218                 }
4219             }
4220         }
4221     }
4222 
4223     @Test(dataProvider = "longCompareOpMaskProvider")
4224     static void UNSIGNED_LTLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4225                                                 IntFunction<boolean[]> fm) {
4226         long[] a = fa.apply(SPECIES.length());
4227         long[] b = fb.apply(SPECIES.length());
4228         boolean[] mask = fm.apply(SPECIES.length());
4229 
4230         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4231 
4232         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4233             for (int i = 0; i < a.length; i += SPECIES.length()) {
4234                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4235                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4236                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_LT, bv, vmask);
4237 
4238                 // Check results as part of computation.
4239                 for (int j = 0; j < SPECIES.length(); j++) {
4240                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ult(a[i + j], b[i + j]));
4241                 }
4242             }
4243         }
4244     }
4245 
4246     @Test(dataProvider = "longCompareOpProvider")
4247     static void UNSIGNED_GTLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4248         long[] a = fa.apply(SPECIES.length());
4249         long[] b = fb.apply(SPECIES.length());
4250 
4251         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4252             for (int i = 0; i < a.length; i += SPECIES.length()) {
4253                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4254                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4255                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_GT, bv);
4256 
4257                 // Check results as part of computation.
4258                 for (int j = 0; j < SPECIES.length(); j++) {
4259                     Assert.assertEquals(mv.laneIsSet(j), ugt(a[i + j], b[i + j]));
4260                 }
4261             }
4262         }
4263     }
4264 
4265     @Test(dataProvider = "longCompareOpMaskProvider")
4266     static void UNSIGNED_GTLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4267                                                 IntFunction<boolean[]> fm) {
4268         long[] a = fa.apply(SPECIES.length());
4269         long[] b = fb.apply(SPECIES.length());
4270         boolean[] mask = fm.apply(SPECIES.length());
4271 
4272         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4273 
4274         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4275             for (int i = 0; i < a.length; i += SPECIES.length()) {
4276                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4277                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4278                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_GT, bv, vmask);
4279 
4280                 // Check results as part of computation.
4281                 for (int j = 0; j < SPECIES.length(); j++) {
4282                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ugt(a[i + j], b[i + j]));
4283                 }
4284             }
4285         }
4286     }
4287 
4288     @Test(dataProvider = "longCompareOpProvider")
4289     static void UNSIGNED_LELong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4290         long[] a = fa.apply(SPECIES.length());
4291         long[] b = fb.apply(SPECIES.length());
4292 
4293         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4294             for (int i = 0; i < a.length; i += SPECIES.length()) {
4295                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4296                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4297                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_LE, bv);
4298 
4299                 // Check results as part of computation.
4300                 for (int j = 0; j < SPECIES.length(); j++) {
4301                     Assert.assertEquals(mv.laneIsSet(j), ule(a[i + j], b[i + j]));
4302                 }
4303             }
4304         }
4305     }
4306 
4307     @Test(dataProvider = "longCompareOpMaskProvider")
4308     static void UNSIGNED_LELong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4309                                                 IntFunction<boolean[]> fm) {
4310         long[] a = fa.apply(SPECIES.length());
4311         long[] b = fb.apply(SPECIES.length());
4312         boolean[] mask = fm.apply(SPECIES.length());
4313 
4314         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4315 
4316         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4317             for (int i = 0; i < a.length; i += SPECIES.length()) {
4318                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4319                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4320                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_LE, bv, vmask);
4321 
4322                 // Check results as part of computation.
4323                 for (int j = 0; j < SPECIES.length(); j++) {
4324                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ule(a[i + j], b[i + j]));
4325                 }
4326             }
4327         }
4328     }
4329 
4330     @Test(dataProvider = "longCompareOpProvider")
4331     static void UNSIGNED_GELong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4332         long[] a = fa.apply(SPECIES.length());
4333         long[] b = fb.apply(SPECIES.length());
4334 
4335         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4336             for (int i = 0; i < a.length; i += SPECIES.length()) {
4337                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4338                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4339                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_GE, bv);
4340 
4341                 // Check results as part of computation.
4342                 for (int j = 0; j < SPECIES.length(); j++) {
4343                     Assert.assertEquals(mv.laneIsSet(j), uge(a[i + j], b[i + j]));
4344                 }
4345             }
4346         }
4347     }
4348 
4349     @Test(dataProvider = "longCompareOpMaskProvider")
4350     static void UNSIGNED_GELong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4351                                                 IntFunction<boolean[]> fm) {
4352         long[] a = fa.apply(SPECIES.length());
4353         long[] b = fb.apply(SPECIES.length());
4354         boolean[] mask = fm.apply(SPECIES.length());
4355 
4356         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4357 
4358         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4359             for (int i = 0; i < a.length; i += SPECIES.length()) {
4360                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4361                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4362                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_GE, bv, vmask);
4363 
4364                 // Check results as part of computation.
4365                 for (int j = 0; j < SPECIES.length(); j++) {
4366                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && uge(a[i + j], b[i + j]));
4367                 }
4368             }
4369         }
4370     }
4371 
4372     @Test(dataProvider = "longCompareOpProvider")
4373     static void LTLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4374         long[] a = fa.apply(SPECIES.length());
4375         long[] b = fb.apply(SPECIES.length());
4376 
4377         for (int i = 0; i < a.length; i += SPECIES.length()) {
4378             LongVector av = LongVector.fromArray(SPECIES, a, i);
4379             VectorMask<Long> mv = av.compare(VectorOperators.LT, b[i]);
4380 
4381             // Check results as part of computation.
4382             for (int j = 0; j < SPECIES.length(); j++) {
4383                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
4384             }
4385         }
4386     }
4387 
4388     @Test(dataProvider = "longCompareOpMaskProvider")
4389     static void LTLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa,
4390                                 IntFunction<long[]> fb, IntFunction<boolean[]> fm) {
4391         long[] a = fa.apply(SPECIES.length());
4392         long[] b = fb.apply(SPECIES.length());
4393         boolean[] mask = fm.apply(SPECIES.length());
4394 
4395         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4396 
4397         for (int i = 0; i < a.length; i += SPECIES.length()) {
4398             LongVector av = LongVector.fromArray(SPECIES, a, i);
4399             VectorMask<Long> mv = av.compare(VectorOperators.LT, b[i], vmask);
4400 
4401             // Check results as part of computation.
4402             for (int j = 0; j < SPECIES.length(); j++) {
4403                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
4404             }
4405         }
4406     }
4407 
4408 
4409     @Test(dataProvider = "longCompareOpProvider")
4410     static void EQLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4411         long[] a = fa.apply(SPECIES.length());
4412         long[] b = fb.apply(SPECIES.length());
4413 
4414         for (int i = 0; i < a.length; i += SPECIES.length()) {
4415             LongVector av = LongVector.fromArray(SPECIES, a, i);
4416             VectorMask<Long> mv = av.compare(VectorOperators.EQ, b[i]);
4417 
4418             // Check results as part of computation.
4419             for (int j = 0; j < SPECIES.length(); j++) {
4420                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
4421             }
4422         }
4423     }
4424 
4425     @Test(dataProvider = "longCompareOpMaskProvider")
4426     static void EQLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa,
4427                                 IntFunction<long[]> fb, IntFunction<boolean[]> fm) {
4428         long[] a = fa.apply(SPECIES.length());
4429         long[] b = fb.apply(SPECIES.length());
4430         boolean[] mask = fm.apply(SPECIES.length());
4431 
4432         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4433 
4434         for (int i = 0; i < a.length; i += SPECIES.length()) {
4435             LongVector av = LongVector.fromArray(SPECIES, a, i);
4436             VectorMask<Long> mv = av.compare(VectorOperators.EQ, b[i], vmask);
4437 
4438             // Check results as part of computation.
4439             for (int j = 0; j < SPECIES.length(); j++) {
4440                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
4441             }
4442         }
4443     }
4444 
4445 
4446     static long blend(long a, long b, boolean mask) {
4447         return mask ? b : a;
4448     }
4449 
4450     @Test(dataProvider = "longBinaryOpMaskProvider")
4451     static void blendLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb,
4452                                           IntFunction<boolean[]> fm) {
4453         long[] a = fa.apply(SPECIES.length());
4454         long[] b = fb.apply(SPECIES.length());
4455         long[] r = fr.apply(SPECIES.length());
4456         boolean[] mask = fm.apply(SPECIES.length());
4457         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4458 
4459         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4460             for (int i = 0; i < a.length; i += SPECIES.length()) {
4461                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4462                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4463                 av.blend(bv, vmask).intoArray(r, i);
4464             }
4465         }
4466 
4467         assertArraysEquals(r, a, b, mask, Long256VectorTests::blend);
4468     }
4469 
4470     @Test(dataProvider = "longUnaryOpShuffleProvider")
4471     static void RearrangeLong256VectorTests(IntFunction<long[]> fa,
4472                                            BiFunction<Integer,Integer,int[]> fs) {
4473         long[] a = fa.apply(SPECIES.length());
4474         int[] order = fs.apply(a.length, SPECIES.length());
4475         long[] r = fr.apply(SPECIES.length());
4476 
4477         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4478             for (int i = 0; i < a.length; i += SPECIES.length()) {
4479                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4480                 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
4481             }
4482         }
4483 
4484         assertRearrangeArraysEquals(r, a, order, SPECIES.length());
4485     }
4486 
4487     @Test(dataProvider = "longUnaryOpShuffleMaskProvider")
4488     static void RearrangeLong256VectorTestsMaskedSmokeTest(IntFunction<long[]> fa,
4489                                                           BiFunction<Integer,Integer,int[]> fs,
4490                                                           IntFunction<boolean[]> fm) {
4491         long[] a = fa.apply(SPECIES.length());
4492         int[] order = fs.apply(a.length, SPECIES.length());
4493         long[] r = fr.apply(SPECIES.length());
4494         boolean[] mask = fm.apply(SPECIES.length());
4495         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4496 
4497         for (int i = 0; i < a.length; i += SPECIES.length()) {
4498             LongVector av = LongVector.fromArray(SPECIES, a, i);
4499             av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
4500         }
4501 
4502         assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
4503     }
4504 
4505     @Test(dataProvider = "longUnaryOpMaskProvider")
4506     static void compressLong256VectorTests(IntFunction<long[]> fa,
4507                                                 IntFunction<boolean[]> fm) {
4508         long[] a = fa.apply(SPECIES.length());
4509         long[] r = fr.apply(SPECIES.length());
4510         boolean[] mask = fm.apply(SPECIES.length());
4511         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4512 
4513         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4514             for (int i = 0; i < a.length; i += SPECIES.length()) {
4515                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4516                 av.compress(vmask).intoArray(r, i);
4517             }
4518         }
4519 
4520         assertcompressArraysEquals(r, a, mask, SPECIES.length());
4521     }
4522 
4523     @Test(dataProvider = "longUnaryOpMaskProvider")
4524     static void expandLong256VectorTests(IntFunction<long[]> fa,
4525                                                 IntFunction<boolean[]> fm) {
4526         long[] a = fa.apply(SPECIES.length());
4527         long[] r = fr.apply(SPECIES.length());
4528         boolean[] mask = fm.apply(SPECIES.length());
4529         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4530 
4531         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4532             for (int i = 0; i < a.length; i += SPECIES.length()) {
4533                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4534                 av.expand(vmask).intoArray(r, i);
4535             }
4536         }
4537 
4538         assertexpandArraysEquals(r, a, mask, SPECIES.length());
4539     }
4540 
4541     @Test(dataProvider = "longUnaryOpProvider")
4542     static void getLong256VectorTests(IntFunction<long[]> fa) {
4543         long[] a = fa.apply(SPECIES.length());
4544         long[] r = fr.apply(SPECIES.length());
4545 
4546         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4547             for (int i = 0; i < a.length; i += SPECIES.length()) {
4548                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4549                 int num_lanes = SPECIES.length();
4550                 // Manually unroll because full unroll happens after intrinsification.
4551                 // Unroll is needed because get intrinsic requires for index to be a known constant.
4552                 if (num_lanes == 1) {
4553                     r[i]=av.lane(0);
4554                 } else if (num_lanes == 2) {
4555                     r[i]=av.lane(0);
4556                     r[i+1]=av.lane(1);
4557                 } else if (num_lanes == 4) {
4558                     r[i]=av.lane(0);
4559                     r[i+1]=av.lane(1);
4560                     r[i+2]=av.lane(2);
4561                     r[i+3]=av.lane(3);
4562                 } else if (num_lanes == 8) {
4563                     r[i]=av.lane(0);
4564                     r[i+1]=av.lane(1);
4565                     r[i+2]=av.lane(2);
4566                     r[i+3]=av.lane(3);
4567                     r[i+4]=av.lane(4);
4568                     r[i+5]=av.lane(5);
4569                     r[i+6]=av.lane(6);
4570                     r[i+7]=av.lane(7);
4571                 } else if (num_lanes == 16) {
4572                     r[i]=av.lane(0);
4573                     r[i+1]=av.lane(1);
4574                     r[i+2]=av.lane(2);
4575                     r[i+3]=av.lane(3);
4576                     r[i+4]=av.lane(4);
4577                     r[i+5]=av.lane(5);
4578                     r[i+6]=av.lane(6);
4579                     r[i+7]=av.lane(7);
4580                     r[i+8]=av.lane(8);
4581                     r[i+9]=av.lane(9);
4582                     r[i+10]=av.lane(10);
4583                     r[i+11]=av.lane(11);
4584                     r[i+12]=av.lane(12);
4585                     r[i+13]=av.lane(13);
4586                     r[i+14]=av.lane(14);
4587                     r[i+15]=av.lane(15);
4588                 } else if (num_lanes == 32) {
4589                     r[i]=av.lane(0);
4590                     r[i+1]=av.lane(1);
4591                     r[i+2]=av.lane(2);
4592                     r[i+3]=av.lane(3);
4593                     r[i+4]=av.lane(4);
4594                     r[i+5]=av.lane(5);
4595                     r[i+6]=av.lane(6);
4596                     r[i+7]=av.lane(7);
4597                     r[i+8]=av.lane(8);
4598                     r[i+9]=av.lane(9);
4599                     r[i+10]=av.lane(10);
4600                     r[i+11]=av.lane(11);
4601                     r[i+12]=av.lane(12);
4602                     r[i+13]=av.lane(13);
4603                     r[i+14]=av.lane(14);
4604                     r[i+15]=av.lane(15);
4605                     r[i+16]=av.lane(16);
4606                     r[i+17]=av.lane(17);
4607                     r[i+18]=av.lane(18);
4608                     r[i+19]=av.lane(19);
4609                     r[i+20]=av.lane(20);
4610                     r[i+21]=av.lane(21);
4611                     r[i+22]=av.lane(22);
4612                     r[i+23]=av.lane(23);
4613                     r[i+24]=av.lane(24);
4614                     r[i+25]=av.lane(25);
4615                     r[i+26]=av.lane(26);
4616                     r[i+27]=av.lane(27);
4617                     r[i+28]=av.lane(28);
4618                     r[i+29]=av.lane(29);
4619                     r[i+30]=av.lane(30);
4620                     r[i+31]=av.lane(31);
4621                 } else if (num_lanes == 64) {
4622                     r[i]=av.lane(0);
4623                     r[i+1]=av.lane(1);
4624                     r[i+2]=av.lane(2);
4625                     r[i+3]=av.lane(3);
4626                     r[i+4]=av.lane(4);
4627                     r[i+5]=av.lane(5);
4628                     r[i+6]=av.lane(6);
4629                     r[i+7]=av.lane(7);
4630                     r[i+8]=av.lane(8);
4631                     r[i+9]=av.lane(9);
4632                     r[i+10]=av.lane(10);
4633                     r[i+11]=av.lane(11);
4634                     r[i+12]=av.lane(12);
4635                     r[i+13]=av.lane(13);
4636                     r[i+14]=av.lane(14);
4637                     r[i+15]=av.lane(15);
4638                     r[i+16]=av.lane(16);
4639                     r[i+17]=av.lane(17);
4640                     r[i+18]=av.lane(18);
4641                     r[i+19]=av.lane(19);
4642                     r[i+20]=av.lane(20);
4643                     r[i+21]=av.lane(21);
4644                     r[i+22]=av.lane(22);
4645                     r[i+23]=av.lane(23);
4646                     r[i+24]=av.lane(24);
4647                     r[i+25]=av.lane(25);
4648                     r[i+26]=av.lane(26);
4649                     r[i+27]=av.lane(27);
4650                     r[i+28]=av.lane(28);
4651                     r[i+29]=av.lane(29);
4652                     r[i+30]=av.lane(30);
4653                     r[i+31]=av.lane(31);
4654                     r[i+32]=av.lane(32);
4655                     r[i+33]=av.lane(33);
4656                     r[i+34]=av.lane(34);
4657                     r[i+35]=av.lane(35);
4658                     r[i+36]=av.lane(36);
4659                     r[i+37]=av.lane(37);
4660                     r[i+38]=av.lane(38);
4661                     r[i+39]=av.lane(39);
4662                     r[i+40]=av.lane(40);
4663                     r[i+41]=av.lane(41);
4664                     r[i+42]=av.lane(42);
4665                     r[i+43]=av.lane(43);
4666                     r[i+44]=av.lane(44);
4667                     r[i+45]=av.lane(45);
4668                     r[i+46]=av.lane(46);
4669                     r[i+47]=av.lane(47);
4670                     r[i+48]=av.lane(48);
4671                     r[i+49]=av.lane(49);
4672                     r[i+50]=av.lane(50);
4673                     r[i+51]=av.lane(51);
4674                     r[i+52]=av.lane(52);
4675                     r[i+53]=av.lane(53);
4676                     r[i+54]=av.lane(54);
4677                     r[i+55]=av.lane(55);
4678                     r[i+56]=av.lane(56);
4679                     r[i+57]=av.lane(57);
4680                     r[i+58]=av.lane(58);
4681                     r[i+59]=av.lane(59);
4682                     r[i+60]=av.lane(60);
4683                     r[i+61]=av.lane(61);
4684                     r[i+62]=av.lane(62);
4685                     r[i+63]=av.lane(63);
4686                 } else {
4687                     for (int j = 0; j < SPECIES.length(); j++) {
4688                         r[i+j]=av.lane(j);
4689                     }
4690                 }
4691             }
4692         }
4693 
4694         assertArraysEquals(r, a, Long256VectorTests::get);
4695     }
4696 
4697     @Test(dataProvider = "longUnaryOpProvider")
4698     static void BroadcastLong256VectorTests(IntFunction<long[]> fa) {
4699         long[] a = fa.apply(SPECIES.length());
4700         long[] r = new long[a.length];
4701 
4702         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4703             for (int i = 0; i < a.length; i += SPECIES.length()) {
4704                 LongVector.broadcast(SPECIES, a[i]).intoArray(r, i);
4705             }
4706         }
4707 
4708         assertBroadcastArraysEquals(r, a);
4709     }
4710 
4711     @Test(dataProvider = "longUnaryOpProvider")
4712     static void ZeroLong256VectorTests(IntFunction<long[]> fa) {
4713         long[] a = fa.apply(SPECIES.length());
4714         long[] r = new long[a.length];
4715 
4716         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4717             for (int i = 0; i < a.length; i += SPECIES.length()) {
4718                 LongVector.zero(SPECIES).intoArray(a, i);
4719             }
4720         }
4721 
4722         Assert.assertEquals(a, r);
4723     }
4724 
4725     static long[] sliceUnary(long[] a, int origin, int idx) {
4726         long[] res = new long[SPECIES.length()];
4727         for (int i = 0; i < SPECIES.length(); i++){
4728             if(i+origin < SPECIES.length())
4729                 res[i] = a[idx+i+origin];
4730             else
4731                 res[i] = (long)0;
4732         }
4733         return res;
4734     }
4735 
4736     @Test(dataProvider = "longUnaryOpProvider")
4737     static void sliceUnaryLong256VectorTests(IntFunction<long[]> fa) {
4738         long[] a = fa.apply(SPECIES.length());
4739         long[] r = new long[a.length];
4740         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4741         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4742             for (int i = 0; i < a.length; i += SPECIES.length()) {
4743                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4744                 av.slice(origin).intoArray(r, i);
4745             }
4746         }
4747 
4748         assertArraysEquals(r, a, origin, Long256VectorTests::sliceUnary);
4749     }
4750 
4751     static long[] sliceBinary(long[] a, long[] b, int origin, int idx) {
4752         long[] res = new long[SPECIES.length()];
4753         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4754             if(i+origin < SPECIES.length())
4755                 res[i] = a[idx+i+origin];
4756             else {
4757                 res[i] = b[idx+j];
4758                 j++;
4759             }
4760         }
4761         return res;
4762     }
4763 
4764     @Test(dataProvider = "longBinaryOpProvider")
4765     static void sliceBinaryLong256VectorTestsBinary(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4766         long[] a = fa.apply(SPECIES.length());
4767         long[] b = fb.apply(SPECIES.length());
4768         long[] r = new long[a.length];
4769         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4770         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4771             for (int i = 0; i < a.length; i += SPECIES.length()) {
4772                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4773                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4774                 av.slice(origin, bv).intoArray(r, i);
4775             }
4776         }
4777 
4778         assertArraysEquals(r, a, b, origin, Long256VectorTests::sliceBinary);
4779     }
4780 
4781     static long[] slice(long[] a, long[] b, int origin, boolean[] mask, int idx) {
4782         long[] res = new long[SPECIES.length()];
4783         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4784             if(i+origin < SPECIES.length())
4785                 res[i] = mask[i] ? a[idx+i+origin] : (long)0;
4786             else {
4787                 res[i] = mask[i] ? b[idx+j] : (long)0;
4788                 j++;
4789             }
4790         }
4791         return res;
4792     }
4793 
4794     @Test(dataProvider = "longBinaryOpMaskProvider")
4795     static void sliceLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4796     IntFunction<boolean[]> fm) {
4797         long[] a = fa.apply(SPECIES.length());
4798         long[] b = fb.apply(SPECIES.length());
4799         boolean[] mask = fm.apply(SPECIES.length());
4800         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4801 
4802         long[] r = new long[a.length];
4803         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4804         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4805             for (int i = 0; i < a.length; i += SPECIES.length()) {
4806                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4807                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4808                 av.slice(origin, bv, vmask).intoArray(r, i);
4809             }
4810         }
4811 
4812         assertArraysEquals(r, a, b, origin, mask, Long256VectorTests::slice);
4813     }
4814 
4815     static long[] unsliceUnary(long[] a, int origin, int idx) {
4816         long[] res = new long[SPECIES.length()];
4817         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4818             if(i < origin)
4819                 res[i] = (long)0;
4820             else {
4821                 res[i] = a[idx+j];
4822                 j++;
4823             }
4824         }
4825         return res;
4826     }
4827 
4828     @Test(dataProvider = "longUnaryOpProvider")
4829     static void unsliceUnaryLong256VectorTests(IntFunction<long[]> fa) {
4830         long[] a = fa.apply(SPECIES.length());
4831         long[] r = new long[a.length];
4832         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4833         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4834             for (int i = 0; i < a.length; i += SPECIES.length()) {
4835                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4836                 av.unslice(origin).intoArray(r, i);
4837             }
4838         }
4839 
4840         assertArraysEquals(r, a, origin, Long256VectorTests::unsliceUnary);
4841     }
4842 
4843     static long[] unsliceBinary(long[] a, long[] b, int origin, int part, int idx) {
4844         long[] res = new long[SPECIES.length()];
4845         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4846             if (part == 0) {
4847                 if (i < origin)
4848                     res[i] = b[idx+i];
4849                 else {
4850                     res[i] = a[idx+j];
4851                     j++;
4852                 }
4853             } else if (part == 1) {
4854                 if (i < origin)
4855                     res[i] = a[idx+SPECIES.length()-origin+i];
4856                 else {
4857                     res[i] = b[idx+origin+j];
4858                     j++;
4859                 }
4860             }
4861         }
4862         return res;
4863     }
4864 
4865     @Test(dataProvider = "longBinaryOpProvider")
4866     static void unsliceBinaryLong256VectorTestsBinary(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4867         long[] a = fa.apply(SPECIES.length());
4868         long[] b = fb.apply(SPECIES.length());
4869         long[] r = new long[a.length];
4870         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4871         int part = (new java.util.Random()).nextInt(2);
4872         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4873             for (int i = 0; i < a.length; i += SPECIES.length()) {
4874                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4875                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4876                 av.unslice(origin, bv, part).intoArray(r, i);
4877             }
4878         }
4879 
4880         assertArraysEquals(r, a, b, origin, part, Long256VectorTests::unsliceBinary);
4881     }
4882 
4883     static long[] unslice(long[] a, long[] b, int origin, int part, boolean[] mask, int idx) {
4884         long[] res = new long[SPECIES.length()];
4885         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4886             if(i+origin < SPECIES.length())
4887                 res[i] = b[idx+i+origin];
4888             else {
4889                 res[i] = b[idx+j];
4890                 j++;
4891             }
4892         }
4893         for (int i = 0; i < SPECIES.length(); i++){
4894             res[i] = mask[i] ? a[idx+i] : res[i];
4895         }
4896         long[] res1 = new long[SPECIES.length()];
4897         if (part == 0) {
4898             for (int i = 0, j = 0; i < SPECIES.length(); i++){
4899                 if (i < origin)
4900                     res1[i] = b[idx+i];
4901                 else {
4902                    res1[i] = res[j];
4903                    j++;
4904                 }
4905             }
4906         } else if (part == 1) {
4907             for (int i = 0, j = 0; i < SPECIES.length(); i++){
4908                 if (i < origin)
4909                     res1[i] = res[SPECIES.length()-origin+i];
4910                 else {
4911                     res1[i] = b[idx+origin+j];
4912                     j++;
4913                 }
4914             }
4915         }
4916         return res1;
4917     }
4918 
4919     @Test(dataProvider = "longBinaryOpMaskProvider")
4920     static void unsliceLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4921     IntFunction<boolean[]> fm) {
4922         long[] a = fa.apply(SPECIES.length());
4923         long[] b = fb.apply(SPECIES.length());
4924         boolean[] mask = fm.apply(SPECIES.length());
4925         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4926         long[] r = new long[a.length];
4927         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4928         int part = (new java.util.Random()).nextInt(2);
4929         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4930             for (int i = 0; i < a.length; i += SPECIES.length()) {
4931                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4932                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4933                 av.unslice(origin, bv, part, vmask).intoArray(r, i);
4934             }
4935         }
4936 
4937         assertArraysEquals(r, a, b, origin, part, mask, Long256VectorTests::unslice);
4938     }
4939 
4940     static long BITWISE_BLEND(long a, long b, long c) {
4941         return (long)((a&~(c))|(b&c));
4942     }
4943 
4944     static long bitwiseBlend(long a, long b, long c) {
4945         return (long)((a&~(c))|(b&c));
4946     }
4947 
4948     @Test(dataProvider = "longTernaryOpProvider")
4949     static void BITWISE_BLENDLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
4950         long[] a = fa.apply(SPECIES.length());
4951         long[] b = fb.apply(SPECIES.length());
4952         long[] c = fc.apply(SPECIES.length());
4953         long[] r = fr.apply(SPECIES.length());
4954 
4955         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4956             for (int i = 0; i < a.length; i += SPECIES.length()) {
4957                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4958                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4959                 LongVector cv = LongVector.fromArray(SPECIES, c, i);
4960                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
4961             }
4962         }
4963 
4964         assertArraysEquals(r, a, b, c, Long256VectorTests::BITWISE_BLEND);
4965     }
4966 
4967     @Test(dataProvider = "longTernaryOpProvider")
4968     static void bitwiseBlendLong256VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
4969         long[] a = fa.apply(SPECIES.length());
4970         long[] b = fb.apply(SPECIES.length());
4971         long[] c = fc.apply(SPECIES.length());
4972         long[] r = fr.apply(SPECIES.length());
4973 
4974         for (int i = 0; i < a.length; i += SPECIES.length()) {
4975             LongVector av = LongVector.fromArray(SPECIES, a, i);
4976             LongVector bv = LongVector.fromArray(SPECIES, b, i);
4977             LongVector cv = LongVector.fromArray(SPECIES, c, i);
4978             av.bitwiseBlend(bv, cv).intoArray(r, i);
4979         }
4980 
4981         assertArraysEquals(r, a, b, c, Long256VectorTests::bitwiseBlend);
4982     }
4983 
4984     @Test(dataProvider = "longTernaryOpMaskProvider")
4985     static void BITWISE_BLENDLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4986                                           IntFunction<long[]> fc, IntFunction<boolean[]> fm) {
4987         long[] a = fa.apply(SPECIES.length());
4988         long[] b = fb.apply(SPECIES.length());
4989         long[] c = fc.apply(SPECIES.length());
4990         long[] r = fr.apply(SPECIES.length());
4991         boolean[] mask = fm.apply(SPECIES.length());
4992         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4993 
4994         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4995             for (int i = 0; i < a.length; i += SPECIES.length()) {
4996                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4997                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4998                 LongVector cv = LongVector.fromArray(SPECIES, c, i);
4999                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
5000             }
5001         }
5002 
5003         assertArraysEquals(r, a, b, c, mask, Long256VectorTests::BITWISE_BLEND);
5004     }
5005 
5006     @Test(dataProvider = "longTernaryOpProvider")
5007     static void BITWISE_BLENDLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
5008         long[] a = fa.apply(SPECIES.length());
5009         long[] b = fb.apply(SPECIES.length());
5010         long[] c = fc.apply(SPECIES.length());
5011         long[] r = fr.apply(SPECIES.length());
5012 
5013         for (int i = 0; i < a.length; i += SPECIES.length()) {
5014             LongVector av = LongVector.fromArray(SPECIES, a, i);
5015             LongVector bv = LongVector.fromArray(SPECIES, b, i);
5016             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i);
5017         }
5018         assertBroadcastArraysEquals(r, a, b, c, Long256VectorTests::BITWISE_BLEND);
5019     }
5020 
5021     @Test(dataProvider = "longTernaryOpProvider")
5022     static void BITWISE_BLENDLong256VectorTestsAltBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
5023         long[] a = fa.apply(SPECIES.length());
5024         long[] b = fb.apply(SPECIES.length());
5025         long[] c = fc.apply(SPECIES.length());
5026         long[] r = fr.apply(SPECIES.length());
5027 
5028         for (int i = 0; i < a.length; i += SPECIES.length()) {
5029             LongVector av = LongVector.fromArray(SPECIES, a, i);
5030             LongVector cv = LongVector.fromArray(SPECIES, c, i);
5031             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i);
5032         }
5033         assertAltBroadcastArraysEquals(r, a, b, c, Long256VectorTests::BITWISE_BLEND);
5034     }
5035 
5036     @Test(dataProvider = "longTernaryOpProvider")
5037     static void bitwiseBlendLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
5038         long[] a = fa.apply(SPECIES.length());
5039         long[] b = fb.apply(SPECIES.length());
5040         long[] c = fc.apply(SPECIES.length());
5041         long[] r = fr.apply(SPECIES.length());
5042 
5043         for (int i = 0; i < a.length; i += SPECIES.length()) {
5044             LongVector av = LongVector.fromArray(SPECIES, a, i);
5045             LongVector bv = LongVector.fromArray(SPECIES, b, i);
5046             av.bitwiseBlend(bv, c[i]).intoArray(r, i);
5047         }
5048         assertBroadcastArraysEquals(r, a, b, c, Long256VectorTests::bitwiseBlend);
5049     }
5050 
5051     @Test(dataProvider = "longTernaryOpProvider")
5052     static void bitwiseBlendLong256VectorTestsAltBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
5053         long[] a = fa.apply(SPECIES.length());
5054         long[] b = fb.apply(SPECIES.length());
5055         long[] c = fc.apply(SPECIES.length());
5056         long[] r = fr.apply(SPECIES.length());
5057 
5058         for (int i = 0; i < a.length; i += SPECIES.length()) {
5059             LongVector av = LongVector.fromArray(SPECIES, a, i);
5060             LongVector cv = LongVector.fromArray(SPECIES, c, i);
5061             av.bitwiseBlend(b[i], cv).intoArray(r, i);
5062         }
5063         assertAltBroadcastArraysEquals(r, a, b, c, Long256VectorTests::bitwiseBlend);
5064     }
5065 
5066     @Test(dataProvider = "longTernaryOpMaskProvider")
5067     static void BITWISE_BLENDLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
5068                                           IntFunction<long[]> fc, IntFunction<boolean[]> fm) {
5069         long[] a = fa.apply(SPECIES.length());
5070         long[] b = fb.apply(SPECIES.length());
5071         long[] c = fc.apply(SPECIES.length());
5072         long[] r = fr.apply(SPECIES.length());
5073         boolean[] mask = fm.apply(SPECIES.length());
5074         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5075 
5076         for (int i = 0; i < a.length; i += SPECIES.length()) {
5077             LongVector av = LongVector.fromArray(SPECIES, a, i);
5078             LongVector bv = LongVector.fromArray(SPECIES, b, i);
5079             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i);
5080         }
5081 
5082         assertBroadcastArraysEquals(r, a, b, c, mask, Long256VectorTests::BITWISE_BLEND);
5083     }
5084 
5085     @Test(dataProvider = "longTernaryOpMaskProvider")
5086     static void BITWISE_BLENDLong256VectorTestsAltBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
5087                                           IntFunction<long[]> fc, IntFunction<boolean[]> fm) {
5088         long[] a = fa.apply(SPECIES.length());
5089         long[] b = fb.apply(SPECIES.length());
5090         long[] c = fc.apply(SPECIES.length());
5091         long[] r = fr.apply(SPECIES.length());
5092         boolean[] mask = fm.apply(SPECIES.length());
5093         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5094 
5095         for (int i = 0; i < a.length; i += SPECIES.length()) {
5096             LongVector av = LongVector.fromArray(SPECIES, a, i);
5097             LongVector cv = LongVector.fromArray(SPECIES, c, i);
5098             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i);
5099         }
5100 
5101         assertAltBroadcastArraysEquals(r, a, b, c, mask, Long256VectorTests::BITWISE_BLEND);
5102     }
5103 
5104     @Test(dataProvider = "longTernaryOpProvider")
5105     static void BITWISE_BLENDLong256VectorTestsDoubleBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
5106         long[] a = fa.apply(SPECIES.length());
5107         long[] b = fb.apply(SPECIES.length());
5108         long[] c = fc.apply(SPECIES.length());
5109         long[] r = fr.apply(SPECIES.length());
5110 
5111         for (int i = 0; i < a.length; i += SPECIES.length()) {
5112             LongVector av = LongVector.fromArray(SPECIES, a, i);
5113             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i);
5114         }
5115 
5116         assertDoubleBroadcastArraysEquals(r, a, b, c, Long256VectorTests::BITWISE_BLEND);
5117     }
5118 
5119     @Test(dataProvider = "longTernaryOpProvider")
5120     static void bitwiseBlendLong256VectorTestsDoubleBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
5121         long[] a = fa.apply(SPECIES.length());
5122         long[] b = fb.apply(SPECIES.length());
5123         long[] c = fc.apply(SPECIES.length());
5124         long[] r = fr.apply(SPECIES.length());
5125 
5126         for (int i = 0; i < a.length; i += SPECIES.length()) {
5127             LongVector av = LongVector.fromArray(SPECIES, a, i);
5128             av.bitwiseBlend(b[i], c[i]).intoArray(r, i);
5129         }
5130 
5131         assertDoubleBroadcastArraysEquals(r, a, b, c, Long256VectorTests::bitwiseBlend);
5132     }
5133 
5134     @Test(dataProvider = "longTernaryOpMaskProvider")
5135     static void BITWISE_BLENDLong256VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
5136                                           IntFunction<long[]> fc, IntFunction<boolean[]> fm) {
5137         long[] a = fa.apply(SPECIES.length());
5138         long[] b = fb.apply(SPECIES.length());
5139         long[] c = fc.apply(SPECIES.length());
5140         long[] r = fr.apply(SPECIES.length());
5141         boolean[] mask = fm.apply(SPECIES.length());
5142         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5143 
5144         for (int i = 0; i < a.length; i += SPECIES.length()) {
5145             LongVector av = LongVector.fromArray(SPECIES, a, i);
5146             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i);
5147         }
5148 
5149         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Long256VectorTests::BITWISE_BLEND);
5150     }
5151 
5152     static long NEG(long a) {
5153         return (long)(-((long)a));
5154     }
5155 
5156     static long neg(long a) {
5157         return (long)(-((long)a));
5158     }
5159 
5160     @Test(dataProvider = "longUnaryOpProvider")
5161     static void NEGLong256VectorTests(IntFunction<long[]> fa) {
5162         long[] a = fa.apply(SPECIES.length());
5163         long[] r = fr.apply(SPECIES.length());
5164 
5165         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5166             for (int i = 0; i < a.length; i += SPECIES.length()) {
5167                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5168                 av.lanewise(VectorOperators.NEG).intoArray(r, i);
5169             }
5170         }
5171 
5172         assertArraysEquals(r, a, Long256VectorTests::NEG);
5173     }
5174 
5175     @Test(dataProvider = "longUnaryOpProvider")
5176     static void negLong256VectorTests(IntFunction<long[]> fa) {
5177         long[] a = fa.apply(SPECIES.length());
5178         long[] r = fr.apply(SPECIES.length());
5179 
5180         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5181             for (int i = 0; i < a.length; i += SPECIES.length()) {
5182                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5183                 av.neg().intoArray(r, i);
5184             }
5185         }
5186 
5187         assertArraysEquals(r, a, Long256VectorTests::neg);
5188     }
5189 
5190     @Test(dataProvider = "longUnaryOpMaskProvider")
5191     static void NEGMaskedLong256VectorTests(IntFunction<long[]> fa,
5192                                                 IntFunction<boolean[]> fm) {
5193         long[] a = fa.apply(SPECIES.length());
5194         long[] r = fr.apply(SPECIES.length());
5195         boolean[] mask = fm.apply(SPECIES.length());
5196         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5197 
5198         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5199             for (int i = 0; i < a.length; i += SPECIES.length()) {
5200                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5201                 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
5202             }
5203         }
5204 
5205         assertArraysEquals(r, a, mask, Long256VectorTests::NEG);
5206     }
5207 
5208     static long ABS(long a) {
5209         return (long)(Math.abs((long)a));
5210     }
5211 
5212     static long abs(long a) {
5213         return (long)(Math.abs((long)a));
5214     }
5215 
5216     @Test(dataProvider = "longUnaryOpProvider")
5217     static void ABSLong256VectorTests(IntFunction<long[]> fa) {
5218         long[] a = fa.apply(SPECIES.length());
5219         long[] r = fr.apply(SPECIES.length());
5220 
5221         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5222             for (int i = 0; i < a.length; i += SPECIES.length()) {
5223                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5224                 av.lanewise(VectorOperators.ABS).intoArray(r, i);
5225             }
5226         }
5227 
5228         assertArraysEquals(r, a, Long256VectorTests::ABS);
5229     }
5230 
5231     @Test(dataProvider = "longUnaryOpProvider")
5232     static void absLong256VectorTests(IntFunction<long[]> fa) {
5233         long[] a = fa.apply(SPECIES.length());
5234         long[] r = fr.apply(SPECIES.length());
5235 
5236         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5237             for (int i = 0; i < a.length; i += SPECIES.length()) {
5238                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5239                 av.abs().intoArray(r, i);
5240             }
5241         }
5242 
5243         assertArraysEquals(r, a, Long256VectorTests::abs);
5244     }
5245 
5246     @Test(dataProvider = "longUnaryOpMaskProvider")
5247     static void ABSMaskedLong256VectorTests(IntFunction<long[]> fa,
5248                                                 IntFunction<boolean[]> fm) {
5249         long[] a = fa.apply(SPECIES.length());
5250         long[] r = fr.apply(SPECIES.length());
5251         boolean[] mask = fm.apply(SPECIES.length());
5252         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5253 
5254         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5255             for (int i = 0; i < a.length; i += SPECIES.length()) {
5256                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5257                 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
5258             }
5259         }
5260 
5261         assertArraysEquals(r, a, mask, Long256VectorTests::ABS);
5262     }
5263 
5264     static long NOT(long a) {
5265         return (long)(~((long)a));
5266     }
5267 
5268     static long not(long a) {
5269         return (long)(~((long)a));
5270     }
5271 
5272     @Test(dataProvider = "longUnaryOpProvider")
5273     static void NOTLong256VectorTests(IntFunction<long[]> fa) {
5274         long[] a = fa.apply(SPECIES.length());
5275         long[] r = fr.apply(SPECIES.length());
5276 
5277         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5278             for (int i = 0; i < a.length; i += SPECIES.length()) {
5279                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5280                 av.lanewise(VectorOperators.NOT).intoArray(r, i);
5281             }
5282         }
5283 
5284         assertArraysEquals(r, a, Long256VectorTests::NOT);
5285     }
5286 
5287     @Test(dataProvider = "longUnaryOpProvider")
5288     static void notLong256VectorTests(IntFunction<long[]> fa) {
5289         long[] a = fa.apply(SPECIES.length());
5290         long[] r = fr.apply(SPECIES.length());
5291 
5292         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5293             for (int i = 0; i < a.length; i += SPECIES.length()) {
5294                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5295                 av.not().intoArray(r, i);
5296             }
5297         }
5298 
5299         assertArraysEquals(r, a, Long256VectorTests::not);
5300     }
5301 
5302     @Test(dataProvider = "longUnaryOpMaskProvider")
5303     static void NOTMaskedLong256VectorTests(IntFunction<long[]> fa,
5304                                                 IntFunction<boolean[]> fm) {
5305         long[] a = fa.apply(SPECIES.length());
5306         long[] r = fr.apply(SPECIES.length());
5307         boolean[] mask = fm.apply(SPECIES.length());
5308         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5309 
5310         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5311             for (int i = 0; i < a.length; i += SPECIES.length()) {
5312                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5313                 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
5314             }
5315         }
5316 
5317         assertArraysEquals(r, a, mask, Long256VectorTests::NOT);
5318     }
5319 
5320     static long ZOMO(long a) {
5321         return (long)((a==0?0:-1));
5322     }
5323 
5324     @Test(dataProvider = "longUnaryOpProvider")
5325     static void ZOMOLong256VectorTests(IntFunction<long[]> fa) {
5326         long[] a = fa.apply(SPECIES.length());
5327         long[] r = fr.apply(SPECIES.length());
5328 
5329         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5330             for (int i = 0; i < a.length; i += SPECIES.length()) {
5331                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5332                 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
5333             }
5334         }
5335 
5336         assertArraysEquals(r, a, Long256VectorTests::ZOMO);
5337     }
5338 
5339     @Test(dataProvider = "longUnaryOpMaskProvider")
5340     static void ZOMOMaskedLong256VectorTests(IntFunction<long[]> fa,
5341                                                 IntFunction<boolean[]> fm) {
5342         long[] a = fa.apply(SPECIES.length());
5343         long[] r = fr.apply(SPECIES.length());
5344         boolean[] mask = fm.apply(SPECIES.length());
5345         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5346 
5347         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5348             for (int i = 0; i < a.length; i += SPECIES.length()) {
5349                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5350                 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
5351             }
5352         }
5353 
5354         assertArraysEquals(r, a, mask, Long256VectorTests::ZOMO);
5355     }
5356 
5357     static long BIT_COUNT(long a) {
5358         return (long)(Long.bitCount(a));
5359     }
5360 
5361     @Test(dataProvider = "longUnaryOpProvider")
5362     static void BIT_COUNTLong256VectorTests(IntFunction<long[]> fa) {
5363         long[] a = fa.apply(SPECIES.length());
5364         long[] r = fr.apply(SPECIES.length());
5365 
5366         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5367             for (int i = 0; i < a.length; i += SPECIES.length()) {
5368                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5369                 av.lanewise(VectorOperators.BIT_COUNT).intoArray(r, i);
5370             }
5371         }
5372 
5373         assertArraysEquals(r, a, Long256VectorTests::BIT_COUNT);
5374     }
5375 
5376     @Test(dataProvider = "longUnaryOpMaskProvider")
5377     static void BIT_COUNTMaskedLong256VectorTests(IntFunction<long[]> fa,
5378                                                 IntFunction<boolean[]> fm) {
5379         long[] a = fa.apply(SPECIES.length());
5380         long[] r = fr.apply(SPECIES.length());
5381         boolean[] mask = fm.apply(SPECIES.length());
5382         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5383 
5384         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5385             for (int i = 0; i < a.length; i += SPECIES.length()) {
5386                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5387                 av.lanewise(VectorOperators.BIT_COUNT, vmask).intoArray(r, i);
5388             }
5389         }
5390 
5391         assertArraysEquals(r, a, mask, Long256VectorTests::BIT_COUNT);
5392     }
5393 
5394     static long TRAILING_ZEROS_COUNT(long a) {
5395         return (long)(TRAILING_ZEROS_COUNT_scalar(a));
5396     }
5397 
5398     @Test(dataProvider = "longUnaryOpProvider")
5399     static void TRAILING_ZEROS_COUNTLong256VectorTests(IntFunction<long[]> fa) {
5400         long[] a = fa.apply(SPECIES.length());
5401         long[] r = fr.apply(SPECIES.length());
5402 
5403         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5404             for (int i = 0; i < a.length; i += SPECIES.length()) {
5405                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5406                 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT).intoArray(r, i);
5407             }
5408         }
5409 
5410         assertArraysEquals(r, a, Long256VectorTests::TRAILING_ZEROS_COUNT);
5411     }
5412 
5413     @Test(dataProvider = "longUnaryOpMaskProvider")
5414     static void TRAILING_ZEROS_COUNTMaskedLong256VectorTests(IntFunction<long[]> fa,
5415                                                 IntFunction<boolean[]> fm) {
5416         long[] a = fa.apply(SPECIES.length());
5417         long[] r = fr.apply(SPECIES.length());
5418         boolean[] mask = fm.apply(SPECIES.length());
5419         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5420 
5421         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5422             for (int i = 0; i < a.length; i += SPECIES.length()) {
5423                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5424                 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT, vmask).intoArray(r, i);
5425             }
5426         }
5427 
5428         assertArraysEquals(r, a, mask, Long256VectorTests::TRAILING_ZEROS_COUNT);
5429     }
5430 
5431     static long LEADING_ZEROS_COUNT(long a) {
5432         return (long)(LEADING_ZEROS_COUNT_scalar(a));
5433     }
5434 
5435     @Test(dataProvider = "longUnaryOpProvider")
5436     static void LEADING_ZEROS_COUNTLong256VectorTests(IntFunction<long[]> fa) {
5437         long[] a = fa.apply(SPECIES.length());
5438         long[] r = fr.apply(SPECIES.length());
5439 
5440         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5441             for (int i = 0; i < a.length; i += SPECIES.length()) {
5442                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5443                 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT).intoArray(r, i);
5444             }
5445         }
5446 
5447         assertArraysEquals(r, a, Long256VectorTests::LEADING_ZEROS_COUNT);
5448     }
5449 
5450     @Test(dataProvider = "longUnaryOpMaskProvider")
5451     static void LEADING_ZEROS_COUNTMaskedLong256VectorTests(IntFunction<long[]> fa,
5452                                                 IntFunction<boolean[]> fm) {
5453         long[] a = fa.apply(SPECIES.length());
5454         long[] r = fr.apply(SPECIES.length());
5455         boolean[] mask = fm.apply(SPECIES.length());
5456         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5457 
5458         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5459             for (int i = 0; i < a.length; i += SPECIES.length()) {
5460                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5461                 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT, vmask).intoArray(r, i);
5462             }
5463         }
5464 
5465         assertArraysEquals(r, a, mask, Long256VectorTests::LEADING_ZEROS_COUNT);
5466     }
5467 
5468     static long REVERSE(long a) {
5469         return (long)(REVERSE_scalar(a));
5470     }
5471 
5472     @Test(dataProvider = "longUnaryOpProvider")
5473     static void REVERSELong256VectorTests(IntFunction<long[]> fa) {
5474         long[] a = fa.apply(SPECIES.length());
5475         long[] r = fr.apply(SPECIES.length());
5476 
5477         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5478             for (int i = 0; i < a.length; i += SPECIES.length()) {
5479                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5480                 av.lanewise(VectorOperators.REVERSE).intoArray(r, i);
5481             }
5482         }
5483 
5484         assertArraysEquals(r, a, Long256VectorTests::REVERSE);
5485     }
5486 
5487     @Test(dataProvider = "longUnaryOpMaskProvider")
5488     static void REVERSEMaskedLong256VectorTests(IntFunction<long[]> fa,
5489                                                 IntFunction<boolean[]> fm) {
5490         long[] a = fa.apply(SPECIES.length());
5491         long[] r = fr.apply(SPECIES.length());
5492         boolean[] mask = fm.apply(SPECIES.length());
5493         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5494 
5495         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5496             for (int i = 0; i < a.length; i += SPECIES.length()) {
5497                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5498                 av.lanewise(VectorOperators.REVERSE, vmask).intoArray(r, i);
5499             }
5500         }
5501 
5502         assertArraysEquals(r, a, mask, Long256VectorTests::REVERSE);
5503     }
5504 
5505     static long REVERSE_BYTES(long a) {
5506         return (long)(Long.reverseBytes(a));
5507     }
5508 
5509     @Test(dataProvider = "longUnaryOpProvider")
5510     static void REVERSE_BYTESLong256VectorTests(IntFunction<long[]> fa) {
5511         long[] a = fa.apply(SPECIES.length());
5512         long[] r = fr.apply(SPECIES.length());
5513 
5514         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5515             for (int i = 0; i < a.length; i += SPECIES.length()) {
5516                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5517                 av.lanewise(VectorOperators.REVERSE_BYTES).intoArray(r, i);
5518             }
5519         }
5520 
5521         assertArraysEquals(r, a, Long256VectorTests::REVERSE_BYTES);
5522     }
5523 
5524     @Test(dataProvider = "longUnaryOpMaskProvider")
5525     static void REVERSE_BYTESMaskedLong256VectorTests(IntFunction<long[]> fa,
5526                                                 IntFunction<boolean[]> fm) {
5527         long[] a = fa.apply(SPECIES.length());
5528         long[] r = fr.apply(SPECIES.length());
5529         boolean[] mask = fm.apply(SPECIES.length());
5530         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5531 
5532         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5533             for (int i = 0; i < a.length; i += SPECIES.length()) {
5534                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5535                 av.lanewise(VectorOperators.REVERSE_BYTES, vmask).intoArray(r, i);
5536             }
5537         }
5538 
5539         assertArraysEquals(r, a, mask, Long256VectorTests::REVERSE_BYTES);
5540     }
5541 
5542     @Test(dataProvider = "longCompareOpProvider")
5543     static void ltLong256VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
5544         long[] a = fa.apply(SPECIES.length());
5545         long[] b = fb.apply(SPECIES.length());
5546 
5547         for (int i = 0; i < a.length; i += SPECIES.length()) {
5548             LongVector av = LongVector.fromArray(SPECIES, a, i);
5549             VectorMask<Long> mv = av.lt(b[i]);
5550 
5551             // Check results as part of computation.
5552             for (int j = 0; j < SPECIES.length(); j++) {
5553                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
5554             }
5555         }
5556     }
5557 
5558     @Test(dataProvider = "longCompareOpProvider")
5559     static void eqLong256VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
5560         long[] a = fa.apply(SPECIES.length());
5561         long[] b = fb.apply(SPECIES.length());
5562 
5563         for (int i = 0; i < a.length; i += SPECIES.length()) {
5564             LongVector av = LongVector.fromArray(SPECIES, a, i);
5565             VectorMask<Long> mv = av.eq(b[i]);
5566 
5567             // Check results as part of computation.
5568             for (int j = 0; j < SPECIES.length(); j++) {
5569                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
5570             }
5571         }
5572     }
5573 
5574     @Test(dataProvider = "longtoIntUnaryOpProvider")
5575     static void toIntArrayLong256VectorTestsSmokeTest(IntFunction<long[]> fa) {
5576         long[] a = fa.apply(SPECIES.length());
5577 
5578         for (int i = 0; i < a.length; i += SPECIES.length()) {
5579             LongVector av = LongVector.fromArray(SPECIES, a, i);
5580             int[] r = av.toIntArray();
5581             assertArraysEquals(r, a, i);
5582         }
5583     }
5584 
5585     @Test(dataProvider = "longUnaryOpProvider")
5586     static void toLongArrayLong256VectorTestsSmokeTest(IntFunction<long[]> fa) {
5587         long[] a = fa.apply(SPECIES.length());
5588 
5589         for (int i = 0; i < a.length; i += SPECIES.length()) {
5590             LongVector av = LongVector.fromArray(SPECIES, a, i);
5591             long[] r = av.toLongArray();
5592             assertArraysEquals(r, a, i);
5593         }
5594     }
5595 
5596     @Test(dataProvider = "longUnaryOpProvider")
5597     static void toDoubleArrayLong256VectorTestsSmokeTest(IntFunction<long[]> fa) {
5598         long[] a = fa.apply(SPECIES.length());
5599 
5600         for (int i = 0; i < a.length; i += SPECIES.length()) {
5601             LongVector av = LongVector.fromArray(SPECIES, a, i);
5602             double[] r = av.toDoubleArray();
5603             assertArraysEquals(r, a, i);
5604         }
5605     }
5606 
5607     @Test(dataProvider = "longUnaryOpProvider")
5608     static void toStringLong256VectorTestsSmokeTest(IntFunction<long[]> fa) {
5609         long[] a = fa.apply(SPECIES.length());
5610 
5611         for (int i = 0; i < a.length; i += SPECIES.length()) {
5612             LongVector av = LongVector.fromArray(SPECIES, a, i);
5613             String str = av.toString();
5614 
5615             long subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5616             Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5617         }
5618     }
5619 
5620     @Test(dataProvider = "longUnaryOpProvider")
5621     static void hashCodeLong256VectorTestsSmokeTest(IntFunction<long[]> fa) {
5622         long[] a = fa.apply(SPECIES.length());
5623 
5624         for (int i = 0; i < a.length; i += SPECIES.length()) {
5625             LongVector av = LongVector.fromArray(SPECIES, a, i);
5626             int hash = av.hashCode();
5627 
5628             long subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5629             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5630             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5631         }
5632     }
5633 
5634 
5635 
5636     @Test(dataProvider = "longUnaryOpProvider")
5637     static void ADDReduceLongLong256VectorTests(IntFunction<long[]> fa) {
5638         long[] a = fa.apply(SPECIES.length());
5639         long[] r = fr.apply(SPECIES.length());
5640         long ra = 0;
5641 
5642         for (int i = 0; i < a.length; i += SPECIES.length()) {
5643             LongVector av = LongVector.fromArray(SPECIES, a, i);
5644             r[i] = av.reduceLanesToLong(VectorOperators.ADD);
5645         }
5646 
5647         ra = 0;
5648         for (int i = 0; i < a.length; i ++) {
5649             ra += r[i];
5650         }
5651 
5652         assertReductionArraysEquals(r, ra, a,
5653                 Long256VectorTests::ADDReduce, Long256VectorTests::ADDReduceAll);
5654     }
5655 
5656     @Test(dataProvider = "longUnaryOpMaskProvider")
5657     static void ADDReduceLongLong256VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
5658         long[] a = fa.apply(SPECIES.length());
5659         long[] r = fr.apply(SPECIES.length());
5660         boolean[] mask = fm.apply(SPECIES.length());
5661         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5662         long ra = 0;
5663 
5664         for (int i = 0; i < a.length; i += SPECIES.length()) {
5665             LongVector av = LongVector.fromArray(SPECIES, a, i);
5666             r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
5667         }
5668 
5669         ra = 0;
5670         for (int i = 0; i < a.length; i ++) {
5671             ra += r[i];
5672         }
5673 
5674         assertReductionArraysEqualsMasked(r, ra, a, mask,
5675                 Long256VectorTests::ADDReduceMasked, Long256VectorTests::ADDReduceAllMasked);
5676     }
5677 
5678     @Test(dataProvider = "longUnaryOpSelectFromProvider")
5679     static void SelectFromLong256VectorTests(IntFunction<long[]> fa,
5680                                            BiFunction<Integer,Integer,long[]> fs) {
5681         long[] a = fa.apply(SPECIES.length());
5682         long[] order = fs.apply(a.length, SPECIES.length());
5683         long[] r = fr.apply(SPECIES.length());
5684 
5685         for (int i = 0; i < a.length; i += SPECIES.length()) {
5686             LongVector av = LongVector.fromArray(SPECIES, a, i);
5687             LongVector bv = LongVector.fromArray(SPECIES, order, i);
5688             bv.selectFrom(av).intoArray(r, i);
5689         }
5690 
5691         assertSelectFromArraysEquals(r, a, order, SPECIES.length());
5692     }
5693 
5694     @Test(dataProvider = "longUnaryOpSelectFromMaskProvider")
5695     static void SelectFromLong256VectorTestsMaskedSmokeTest(IntFunction<long[]> fa,
5696                                                            BiFunction<Integer,Integer,long[]> fs,
5697                                                            IntFunction<boolean[]> fm) {
5698         long[] a = fa.apply(SPECIES.length());
5699         long[] order = fs.apply(a.length, SPECIES.length());
5700         long[] r = fr.apply(SPECIES.length());
5701         boolean[] mask = fm.apply(SPECIES.length());
5702         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5703 
5704         for (int i = 0; i < a.length; i += SPECIES.length()) {
5705             LongVector av = LongVector.fromArray(SPECIES, a, i);
5706             LongVector bv = LongVector.fromArray(SPECIES, order, i);
5707             bv.selectFrom(av, vmask).intoArray(r, i);
5708         }
5709 
5710         assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
5711     }
5712 
5713     @Test(dataProvider = "shuffleProvider")
5714     static void shuffleMiscellaneousLong256VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5715         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5716 
5717         for (int i = 0; i < a.length; i += SPECIES.length()) {
5718             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5719             int hash = shuffle.hashCode();
5720             int length = shuffle.length();
5721 
5722             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5723             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5724             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5725             Assert.assertEquals(length, SPECIES.length());
5726         }
5727     }
5728 
5729     @Test(dataProvider = "shuffleProvider")
5730     static void shuffleToStringLong256VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5731         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5732 
5733         for (int i = 0; i < a.length; i += SPECIES.length()) {
5734             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5735             String str = shuffle.toString();
5736 
5737             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5738             Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
5739                 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5740         }
5741     }
5742 
5743     @Test(dataProvider = "shuffleCompareOpProvider")
5744     static void shuffleEqualsLong256VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
5745         int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5746         int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5747 
5748         for (int i = 0; i < a.length; i += SPECIES.length()) {
5749             var av = VectorShuffle.fromArray(SPECIES, a, i);
5750             var bv = VectorShuffle.fromArray(SPECIES, b, i);
5751             boolean eq = av.equals(bv);
5752             int to = i + SPECIES.length();
5753             Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
5754         }
5755     }
5756 
5757     @Test(dataProvider = "maskCompareOpProvider")
5758     static void maskEqualsLong256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5759         boolean[] a = fa.apply(SPECIES.length());
5760         boolean[] b = fb.apply(SPECIES.length());
5761 
5762         for (int i = 0; i < a.length; i += SPECIES.length()) {
5763             var av = SPECIES.loadMask(a, i);
5764             var bv = SPECIES.loadMask(b, i);
5765             boolean equals = av.equals(bv);
5766             int to = i + SPECIES.length();
5767             Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
5768         }
5769     }
5770 
5771     static boolean beq(boolean a, boolean b) {
5772         return (a == b);
5773     }
5774 
5775     @Test(dataProvider = "maskCompareOpProvider")
5776     static void maskEqLong256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5777         boolean[] a = fa.apply(SPECIES.length());
5778         boolean[] b = fb.apply(SPECIES.length());
5779         boolean[] r = new boolean[a.length];
5780 
5781         for (int i = 0; i < a.length; i += SPECIES.length()) {
5782             var av = SPECIES.loadMask(a, i);
5783             var bv = SPECIES.loadMask(b, i);
5784             var cv = av.eq(bv);
5785             cv.intoArray(r, i);
5786         }
5787         assertArraysEquals(r, a, b, Long256VectorTests::beq);
5788     }
5789 
5790     @Test(dataProvider = "maskProvider")
5791     static void maskHashCodeLong256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5792         boolean[] a = fa.apply(SPECIES.length());
5793 
5794         for (int i = 0; i < a.length; i += SPECIES.length()) {
5795             var vmask = SPECIES.loadMask(a, i);
5796             int hash = vmask.hashCode();
5797 
5798             boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5799             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5800             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5801         }
5802     }
5803 
5804     static int maskTrueCount(boolean[] a, int idx) {
5805         int trueCount = 0;
5806         for (int i = idx; i < idx + SPECIES.length(); i++) {
5807             trueCount += a[i] ? 1 : 0;
5808         }
5809         return trueCount;
5810     }
5811 
5812     @Test(dataProvider = "maskProvider")
5813     static void maskTrueCountLong256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5814         boolean[] a = fa.apply(SPECIES.length());
5815         int[] r = new int[a.length];
5816 
5817         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5818             for (int i = 0; i < a.length; i += SPECIES.length()) {
5819                 var vmask = SPECIES.loadMask(a, i);
5820                 r[i] = vmask.trueCount();
5821             }
5822         }
5823 
5824         assertMaskReductionArraysEquals(r, a, Long256VectorTests::maskTrueCount);
5825     }
5826 
5827     static int maskLastTrue(boolean[] a, int idx) {
5828         int i = idx + SPECIES.length() - 1;
5829         for (; i >= idx; i--) {
5830             if (a[i]) {
5831                 break;
5832             }
5833         }
5834         return i - idx;
5835     }
5836 
5837     @Test(dataProvider = "maskProvider")
5838     static void maskLastTrueLong256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5839         boolean[] a = fa.apply(SPECIES.length());
5840         int[] r = new int[a.length];
5841 
5842         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5843             for (int i = 0; i < a.length; i += SPECIES.length()) {
5844                 var vmask = SPECIES.loadMask(a, i);
5845                 r[i] = vmask.lastTrue();
5846             }
5847         }
5848 
5849         assertMaskReductionArraysEquals(r, a, Long256VectorTests::maskLastTrue);
5850     }
5851 
5852     static int maskFirstTrue(boolean[] a, int idx) {
5853         int i = idx;
5854         for (; i < idx + SPECIES.length(); i++) {
5855             if (a[i]) {
5856                 break;
5857             }
5858         }
5859         return i - idx;
5860     }
5861 
5862     @Test(dataProvider = "maskProvider")
5863     static void maskFirstTrueLong256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5864         boolean[] a = fa.apply(SPECIES.length());
5865         int[] r = new int[a.length];
5866 
5867         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5868             for (int i = 0; i < a.length; i += SPECIES.length()) {
5869                 var vmask = SPECIES.loadMask(a, i);
5870                 r[i] = vmask.firstTrue();
5871             }
5872         }
5873 
5874         assertMaskReductionArraysEquals(r, a, Long256VectorTests::maskFirstTrue);
5875     }
5876 
5877     @Test(dataProvider = "maskProvider")
5878     static void maskCompressLong256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5879         int trueCount = 0;
5880         boolean[] a = fa.apply(SPECIES.length());
5881 
5882         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5883             for (int i = 0; i < a.length; i += SPECIES.length()) {
5884                 var vmask = SPECIES.loadMask(a, i);
5885                 trueCount = vmask.trueCount();
5886                 var rmask = vmask.compress();
5887                 for (int j = 0; j < SPECIES.length(); j++)  {
5888                     Assert.assertEquals(rmask.laneIsSet(j), j < trueCount);
5889                 }
5890             }
5891         }
5892     }
5893 
5894     @DataProvider
5895     public static Object[][] longMaskProvider() {
5896         return new Object[][]{
5897                 {0xFFFFFFFFFFFFFFFFL},
5898                 {0x0000000000000000L},
5899                 {0x5555555555555555L},
5900                 {0x0123456789abcdefL},
5901         };
5902     }
5903 
5904     @Test(dataProvider = "longMaskProvider")
5905     static void maskFromToLongLong256VectorTestsSmokeTest(long inputLong) {
5906         var vmask = VectorMask.fromLong(SPECIES, inputLong);
5907         long outputLong = vmask.toLong();
5908         Assert.assertEquals(outputLong, (inputLong & (((0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()))))));
5909     }
5910 
5911     @DataProvider
5912     public static Object[][] offsetProvider() {
5913         return new Object[][]{
5914                 {0},
5915                 {-1},
5916                 {+1},
5917                 {+2},
5918                 {-2},
5919         };
5920     }
5921 
5922     @Test(dataProvider = "offsetProvider")
5923     static void indexInRangeLong256VectorTestsSmokeTest(int offset) {
5924         int limit = SPECIES.length() * BUFFER_REPS;
5925         for (int i = 0; i < limit; i += SPECIES.length()) {
5926             var actualMask = SPECIES.indexInRange(i + offset, limit);
5927             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
5928             assert(actualMask.equals(expectedMask));
5929             for (int j = 0; j < SPECIES.length(); j++)  {
5930                 int index = i + j + offset;
5931                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
5932             }
5933         }
5934     }
5935 
5936     @Test(dataProvider = "offsetProvider")
5937     static void indexInRangeLongLong256VectorTestsSmokeTest(int offset) {
5938         long limit = SPECIES.length() * BUFFER_REPS;
5939         for (long i = 0; i < limit; i += SPECIES.length()) {
5940             var actualMask = SPECIES.indexInRange(i + offset, limit);
5941             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
5942             assert(actualMask.equals(expectedMask));
5943             for (int j = 0; j < SPECIES.length(); j++)  {
5944                 long index = i + j + offset;
5945                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
5946             }
5947         }
5948     }
5949 
5950     @DataProvider
5951     public static Object[][] lengthProvider() {
5952         return new Object[][]{
5953                 {0},
5954                 {1},
5955                 {32},
5956                 {37},
5957                 {1024},
5958                 {1024+1},
5959                 {1024+5},
5960         };
5961     }
5962 
5963     @Test(dataProvider = "lengthProvider")
5964     static void loopBoundLong256VectorTestsSmokeTest(int length) {
5965         int actualLoopBound = SPECIES.loopBound(length);
5966         int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
5967         Assert.assertEquals(actualLoopBound, expectedLoopBound);
5968     }
5969 
5970     @Test(dataProvider = "lengthProvider")
5971     static void loopBoundLongLong256VectorTestsSmokeTest(int _length) {
5972         long length = _length;
5973         long actualLoopBound = SPECIES.loopBound(length);
5974         long expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
5975         Assert.assertEquals(actualLoopBound, expectedLoopBound);
5976     }
5977 
5978     @Test
5979     static void ElementSizeLong256VectorTestsSmokeTest() {
5980         LongVector av = LongVector.zero(SPECIES);
5981         int elsize = av.elementSize();
5982         Assert.assertEquals(elsize, Long.SIZE);
5983     }
5984 
5985     @Test
5986     static void VectorShapeLong256VectorTestsSmokeTest() {
5987         LongVector av = LongVector.zero(SPECIES);
5988         VectorShape vsh = av.shape();
5989         assert(vsh.equals(VectorShape.S_256_BIT));
5990     }
5991 
5992     @Test
5993     static void ShapeWithLanesLong256VectorTestsSmokeTest() {
5994         LongVector av = LongVector.zero(SPECIES);
5995         VectorShape vsh = av.shape();
5996         VectorSpecies species = vsh.withLanes(long.class);
5997         assert(species.equals(SPECIES));
5998     }
5999 
6000     @Test
6001     static void ElementTypeLong256VectorTestsSmokeTest() {
6002         LongVector av = LongVector.zero(SPECIES);
6003         assert(av.species().elementType() == long.class);
6004     }
6005 
6006     @Test
6007     static void SpeciesElementSizeLong256VectorTestsSmokeTest() {
6008         LongVector av = LongVector.zero(SPECIES);
6009         assert(av.species().elementSize() == Long.SIZE);
6010     }
6011 
6012     @Test
6013     static void VectorTypeLong256VectorTestsSmokeTest() {
6014         LongVector av = LongVector.zero(SPECIES);
6015         assert(av.species().vectorType() == av.getClass());
6016     }
6017 
6018     @Test
6019     static void WithLanesLong256VectorTestsSmokeTest() {
6020         LongVector av = LongVector.zero(SPECIES);
6021         VectorSpecies species = av.species().withLanes(long.class);
6022         assert(species.equals(SPECIES));
6023     }
6024 
6025     @Test
6026     static void WithShapeLong256VectorTestsSmokeTest() {
6027         LongVector av = LongVector.zero(SPECIES);
6028         VectorShape vsh = av.shape();
6029         VectorSpecies species = av.species().withShape(vsh);
6030         assert(species.equals(SPECIES));
6031     }
6032 
6033     @Test
6034     static void MaskAllTrueLong256VectorTestsSmokeTest() {
6035         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6036           Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
6037         }
6038     }
6039 }