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 Long512VectorTests
  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 Long512VectorTests extends AbstractVectorTest {
  56 
  57     static final VectorSpecies<Long> SPECIES =
  58                 LongVector.SPECIES_512;
  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 / 512);
  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 assertSelectFromArraysEquals(long[] r, long[] a, long[] order, int vector_len) {
 222         int i = 0, j = 0;
 223         try {
 224             for (; i < a.length; i += vector_len) {
 225                 for (j = 0; j < vector_len; j++) {
 226                     Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 227                 }
 228             }
 229         } catch (AssertionError e) {
 230             int idx = i + j;
 231             Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
 232         }
 233     }
 234 
 235     static void assertRearrangeArraysEquals(long[] r, long[] a, int[] order, boolean[] mask, int vector_len) {
 236         int i = 0, j = 0;
 237         try {
 238             for (; i < a.length; i += vector_len) {
 239                 for (j = 0; j < vector_len; j++) {
 240                     if (mask[j % SPECIES.length()])
 241                          Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 242                     else
 243                          Assert.assertEquals(r[i+j], (long)0);
 244                 }
 245             }
 246         } catch (AssertionError e) {
 247             int idx = i + j;
 248             if (mask[j % SPECIES.length()])
 249                 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 250             else
 251                 Assert.assertEquals(r[i+j], (long)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 252         }
 253     }
 254 
 255     static void assertSelectFromArraysEquals(long[] r, long[] a, long[] order, boolean[] mask, int vector_len) {
 256         int i = 0, j = 0;
 257         try {
 258             for (; i < a.length; i += vector_len) {
 259                 for (j = 0; j < vector_len; j++) {
 260                     if (mask[j % SPECIES.length()])
 261                          Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 262                     else
 263                          Assert.assertEquals(r[i+j], (long)0);
 264                 }
 265             }
 266         } catch (AssertionError e) {
 267             int idx = i + j;
 268             if (mask[j % SPECIES.length()])
 269                 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()]);
 270             else
 271                 Assert.assertEquals(r[i+j], (long)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 272         }
 273     }
 274 
 275     static void assertBroadcastArraysEquals(long[] r, long[] a) {
 276         int i = 0;
 277         for (; i < a.length; i += SPECIES.length()) {
 278             int idx = i;
 279             for (int j = idx; j < (idx + SPECIES.length()); j++)
 280                 a[j]=a[idx];
 281         }
 282 
 283         try {
 284             for (i = 0; i < a.length; i++) {
 285                 Assert.assertEquals(r[i], a[i]);
 286             }
 287         } catch (AssertionError e) {
 288             Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
 289         }
 290     }
 291 
 292     interface FBinOp {
 293         long apply(long a, long b);
 294     }
 295 
 296     interface FBinMaskOp {
 297         long apply(long a, long b, boolean m);
 298 
 299         static FBinMaskOp lift(FBinOp f) {
 300             return (a, b, m) -> m ? f.apply(a, b) : a;
 301         }
 302     }
 303 
 304     static void assertArraysEquals(long[] r, long[] a, long[] b, FBinOp f) {
 305         int i = 0;
 306         try {
 307             for (; i < a.length; i++) {
 308                 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
 309             }
 310         } catch (AssertionError e) {
 311             Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
 312         }
 313     }
 314 
 315     static void assertBroadcastArraysEquals(long[] r, long[] a, long[] b, FBinOp f) {
 316         int i = 0;
 317         try {
 318             for (; i < a.length; i++) {
 319                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
 320             }
 321         } catch (AssertionError e) {
 322             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
 323                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 324         }
 325     }
 326 
 327     static void assertBroadcastLongArraysEquals(long[] r, long[] a, long[] b, FBinOp f) {
 328         int i = 0;
 329         try {
 330             for (; i < a.length; i++) {
 331                 Assert.assertEquals(r[i], f.apply(a[i], (long)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
 332             }
 333         } catch (AssertionError e) {
 334             Assert.assertEquals(r[i], f.apply(a[i], (long)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
 335                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 336         }
 337     }
 338 
 339     static void assertArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinOp f) {
 340         assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 341     }
 342 
 343     static void assertArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinMaskOp f) {
 344         int i = 0;
 345         try {
 346             for (; i < a.length; i++) {
 347                 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
 348             }
 349         } catch (AssertionError err) {
 350             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()]);
 351         }
 352     }
 353 
 354     static void assertBroadcastArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinOp f) {
 355         assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 356     }
 357 
 358     static void assertBroadcastArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinMaskOp f) {
 359         int i = 0;
 360         try {
 361             for (; i < a.length; i++) {
 362                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 363             }
 364         } catch (AssertionError err) {
 365             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 366                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 367                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 368                                 mask[i % SPECIES.length()]);
 369         }
 370     }
 371 
 372     static void assertBroadcastLongArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinOp f) {
 373         assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 374     }
 375 
 376     static void assertBroadcastLongArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinMaskOp 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()]), mask[i % SPECIES.length()]));
 381             }
 382         } catch (AssertionError err) {
 383             Assert.assertEquals(r[i], f.apply(a[i], (long)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
 384                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 385                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 386                                 mask[i % SPECIES.length()]);
 387         }
 388     }
 389 
 390     static void assertShiftArraysEquals(long[] r, long[] a, long[] b, FBinOp f) {
 391         int i = 0;
 392         int j = 0;
 393         try {
 394             for (; j < a.length; j += SPECIES.length()) {
 395                 for (i = 0; i < SPECIES.length(); i++) {
 396                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
 397                 }
 398             }
 399         } catch (AssertionError e) {
 400             Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
 401         }
 402     }
 403 
 404     static void assertShiftArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinOp f) {
 405         assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 406     }
 407 
 408     static void assertShiftArraysEquals(long[] r, long[] a, long[] b, boolean[] mask, FBinMaskOp f) {
 409         int i = 0;
 410         int j = 0;
 411         try {
 412             for (; j < a.length; j += SPECIES.length()) {
 413                 for (i = 0; i < SPECIES.length(); i++) {
 414                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
 415                 }
 416             }
 417         } catch (AssertionError err) {
 418             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]);
 419         }
 420     }
 421 
 422     interface FBinConstOp {
 423         long apply(long a);
 424     }
 425 
 426     interface FBinConstMaskOp {
 427         long apply(long a, boolean m);
 428 
 429         static FBinConstMaskOp lift(FBinConstOp f) {
 430             return (a, m) -> m ? f.apply(a) : a;
 431         }
 432     }
 433 
 434     static void assertShiftConstEquals(long[] r, long[] a, FBinConstOp f) {
 435         int i = 0;
 436         int j = 0;
 437         try {
 438             for (; j < a.length; j += SPECIES.length()) {
 439                 for (i = 0; i < SPECIES.length(); i++) {
 440                     Assert.assertEquals(r[i+j], f.apply(a[i+j]));
 441                 }
 442             }
 443         } catch (AssertionError e) {
 444             Assert.assertEquals(r[i+j], f.apply(a[i+j]), "at index #" + i + ", " + j);
 445         }
 446     }
 447 
 448     static void assertShiftConstEquals(long[] r, long[] a, boolean[] mask, FBinConstOp f) {
 449         assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f));
 450     }
 451 
 452     static void assertShiftConstEquals(long[] r, long[] a, boolean[] mask, FBinConstMaskOp f) {
 453         int i = 0;
 454         int j = 0;
 455         try {
 456             for (; j < a.length; j += SPECIES.length()) {
 457                 for (i = 0; i < SPECIES.length(); i++) {
 458                     Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]));
 459                 }
 460             }
 461         } catch (AssertionError err) {
 462             Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", mask = " + mask[i]);
 463         }
 464     }
 465 
 466     interface FTernOp {
 467         long apply(long a, long b, long c);
 468     }
 469 
 470     interface FTernMaskOp {
 471         long apply(long a, long b, long c, boolean m);
 472 
 473         static FTernMaskOp lift(FTernOp f) {
 474             return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
 475         }
 476     }
 477 
 478     static void assertArraysEquals(long[] r, long[] a, long[] b, long[] c, FTernOp f) {
 479         int i = 0;
 480         try {
 481             for (; i < a.length; i++) {
 482                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
 483             }
 484         } catch (AssertionError e) {
 485             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 486         }
 487     }
 488 
 489     static void assertArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask, FTernOp f) {
 490         assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 491     }
 492 
 493     static void assertArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask, FTernMaskOp f) {
 494         int i = 0;
 495         try {
 496             for (; i < a.length; i++) {
 497                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
 498             }
 499         } catch (AssertionError err) {
 500             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
 501               + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 502         }
 503     }
 504 
 505     static void assertBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, FTernOp f) {
 506         int i = 0;
 507         try {
 508             for (; i < a.length; i++) {
 509                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
 510             }
 511         } catch (AssertionError e) {
 512             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
 513                                 i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
 514                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 515         }
 516     }
 517 
 518     static void assertAltBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, FTernOp f) {
 519         int i = 0;
 520         try {
 521             for (; i < a.length; i++) {
 522                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
 523             }
 524         } catch (AssertionError e) {
 525             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
 526                                 i + ", input1 = " + a[i] + ", input2 = " +
 527                                 b[(i / SPECIES.length()) * SPECIES.length()] + ",  input3 = " + c[i]);
 528         }
 529     }
 530 
 531     static void assertBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask,
 532                                             FTernOp f) {
 533         assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 534     }
 535 
 536     static void assertBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask,
 537                                             FTernMaskOp f) {
 538         int i = 0;
 539         try {
 540             for (; i < a.length; i++) {
 541                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 542                                     mask[i % SPECIES.length()]));
 543             }
 544         } catch (AssertionError err) {
 545             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 546                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
 547                                 b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 548                                 mask[i % SPECIES.length()]);
 549         }
 550     }
 551 
 552     static void assertAltBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask,
 553                                             FTernOp f) {
 554         assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 555     }
 556 
 557     static void assertAltBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask,
 558                                             FTernMaskOp f) {
 559         int i = 0;
 560         try {
 561             for (; i < a.length; i++) {
 562                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 563                                     mask[i % SPECIES.length()]));
 564             }
 565         } catch (AssertionError err) {
 566             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 567                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 568                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 569                                 ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 570         }
 571     }
 572 
 573     static void assertDoubleBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, FTernOp f) {
 574         int i = 0;
 575         try {
 576             for (; i < a.length; i++) {
 577                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 578                                     c[(i / SPECIES.length()) * SPECIES.length()]));
 579             }
 580         } catch (AssertionError e) {
 581             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 582                                 c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
 583                                 + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
 584                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 585         }
 586     }
 587 
 588     static void assertDoubleBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask,
 589                                                   FTernOp f) {
 590         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 591     }
 592 
 593     static void assertDoubleBroadcastArraysEquals(long[] r, long[] a, long[] b, long[] c, boolean[] mask,
 594                                                   FTernMaskOp f) {
 595         int i = 0;
 596         try {
 597             for (; i < a.length; i++) {
 598                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 599                                     c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 600             }
 601         } catch (AssertionError err) {
 602             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 603                                 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
 604                                 + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 605                                 ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 606                                 mask[i % SPECIES.length()]);
 607         }
 608     }
 609 
 610 
 611 
 612     interface FBinArrayOp {
 613         long apply(long[] a, int b);
 614     }
 615 
 616     static void assertArraysEquals(long[] r, long[] a, FBinArrayOp f) {
 617         int i = 0;
 618         try {
 619             for (; i < a.length; i++) {
 620                 Assert.assertEquals(r[i], f.apply(a, i));
 621             }
 622         } catch (AssertionError e) {
 623             Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i);
 624         }
 625     }
 626 
 627     interface FGatherScatterOp {
 628         long[] apply(long[] a, int ix, int[] b, int iy);
 629     }
 630 
 631     static void assertArraysEquals(long[] r, long[] a, int[] b, FGatherScatterOp f) {
 632         int i = 0;
 633         try {
 634             for (; i < a.length; i += SPECIES.length()) {
 635                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 636                   f.apply(a, i, b, i));
 637             }
 638         } catch (AssertionError e) {
 639             long[] ref = f.apply(a, i, b, i);
 640             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 641             Assert.assertEquals(res, ref,
 642               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 643               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 644               + ", b: "
 645               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 646               + " at index #" + i);
 647         }
 648     }
 649 
 650     interface FGatherMaskedOp {
 651         long[] apply(long[] a, int ix, boolean[] mask, int[] b, int iy);
 652     }
 653 
 654     interface FScatterMaskedOp {
 655         long[] apply(long[] r, long[] a, int ix, boolean[] mask, int[] b, int iy);
 656     }
 657 
 658     static void assertArraysEquals(long[] r, long[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
 659         int i = 0;
 660         try {
 661             for (; i < a.length; i += SPECIES.length()) {
 662                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 663                   f.apply(a, i, mask, b, i));
 664             }
 665         } catch (AssertionError e) {
 666             long[] ref = f.apply(a, i, mask, b, i);
 667             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 668             Assert.assertEquals(res, ref,
 669               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 670               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 671               + ", b: "
 672               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 673               + ", mask: "
 674               + Arrays.toString(mask)
 675               + " at index #" + i);
 676         }
 677     }
 678 
 679     static void assertArraysEquals(long[] r, long[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
 680         int i = 0;
 681         try {
 682             for (; i < a.length; i += SPECIES.length()) {
 683                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 684                   f.apply(r, a, i, mask, b, i));
 685             }
 686         } catch (AssertionError e) {
 687             long[] ref = f.apply(r, a, i, mask, b, i);
 688             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 689             Assert.assertEquals(res, ref,
 690               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 691               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 692               + ", b: "
 693               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 694               + ", r: "
 695               + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
 696               + ", mask: "
 697               + Arrays.toString(mask)
 698               + " at index #" + i);
 699         }
 700     }
 701 
 702     interface FLaneOp {
 703         long[] apply(long[] a, int origin, int idx);
 704     }
 705 
 706     static void assertArraysEquals(long[] r, long[] a, int origin, FLaneOp f) {
 707         int i = 0;
 708         try {
 709             for (; i < a.length; i += SPECIES.length()) {
 710                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 711                   f.apply(a, origin, i));
 712             }
 713         } catch (AssertionError e) {
 714             long[] ref = f.apply(a, origin, i);
 715             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 716             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 717               + ", res: " + Arrays.toString(res)
 718               + "), at index #" + i);
 719         }
 720     }
 721 
 722     interface FLaneBop {
 723         long[] apply(long[] a, long[] b, int origin, int idx);
 724     }
 725 
 726     static void assertArraysEquals(long[] r, long[] a, long[] b, int origin, FLaneBop f) {
 727         int i = 0;
 728         try {
 729             for (; i < a.length; i += SPECIES.length()) {
 730                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 731                   f.apply(a, b, origin, i));
 732             }
 733         } catch (AssertionError e) {
 734             long[] ref = f.apply(a, b, origin, i);
 735             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 736             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 737               + ", res: " + Arrays.toString(res)
 738               + "), at index #" + i
 739               + ", at origin #" + origin);
 740         }
 741     }
 742 
 743     interface FLaneMaskedBop {
 744         long[] apply(long[] a, long[] b, int origin, boolean[] mask, int idx);
 745     }
 746 
 747     static void assertArraysEquals(long[] r, long[] a, long[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
 748         int i = 0;
 749         try {
 750             for (; i < a.length; i += SPECIES.length()) {
 751                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 752                   f.apply(a, b, origin, mask, i));
 753             }
 754         } catch (AssertionError e) {
 755             long[] ref = f.apply(a, b, origin, mask, i);
 756             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 757             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 758               + ", res: " + Arrays.toString(res)
 759               + "), at index #" + i
 760               + ", at origin #" + origin);
 761         }
 762     }
 763 
 764     interface FLanePartBop {
 765         long[] apply(long[] a, long[] b, int origin, int part, int idx);
 766     }
 767 
 768     static void assertArraysEquals(long[] r, long[] a, long[] b, int origin, int part, FLanePartBop f) {
 769         int i = 0;
 770         try {
 771             for (; i < a.length; i += SPECIES.length()) {
 772                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 773                   f.apply(a, b, origin, part, i));
 774             }
 775         } catch (AssertionError e) {
 776             long[] ref = f.apply(a, b, origin, part, i);
 777             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 778             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 779               + ", res: " + Arrays.toString(res)
 780               + "), at index #" + i
 781               + ", at origin #" + origin
 782               + ", with part #" + part);
 783         }
 784     }
 785 
 786     interface FLanePartMaskedBop {
 787         long[] apply(long[] a, long[] b, int origin, int part, boolean[] mask, int idx);
 788     }
 789 
 790     static void assertArraysEquals(long[] r, long[] a, long[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
 791         int i = 0;
 792         try {
 793             for (; i < a.length; i += SPECIES.length()) {
 794                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 795                   f.apply(a, b, origin, part, mask, i));
 796             }
 797         } catch (AssertionError e) {
 798             long[] ref = f.apply(a, b, origin, part, mask, i);
 799             long[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 800             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 801               + ", res: " + Arrays.toString(res)
 802               + "), at index #" + i
 803               + ", at origin #" + origin
 804               + ", with part #" + part);
 805         }
 806     }
 807 
 808     static int intCornerCaseValue(int i) {
 809         switch(i % 5) {
 810             case 0:
 811                 return Integer.MAX_VALUE;
 812             case 1:
 813                 return Integer.MIN_VALUE;
 814             case 2:
 815                 return Integer.MIN_VALUE;
 816             case 3:
 817                 return Integer.MAX_VALUE;
 818             default:
 819                 return (int)0;
 820         }
 821     }
 822 
 823     static final List<IntFunction<long[]>> INT_LONG_GENERATORS = List.of(
 824             withToString("long[-i * 5]", (int s) -> {
 825                 return fill(s * BUFFER_REPS,
 826                             i -> (long)(-i * 5));
 827             }),
 828             withToString("long[i * 5]", (int s) -> {
 829                 return fill(s * BUFFER_REPS,
 830                             i -> (long)(i * 5));
 831             }),
 832             withToString("long[i + 1]", (int s) -> {
 833                 return fill(s * BUFFER_REPS,
 834                             i -> (((long)(i + 1) == 0) ? 1 : (long)(i + 1)));
 835             }),
 836             withToString("long[intCornerCaseValue(i)]", (int s) -> {
 837                 return fill(s * BUFFER_REPS,
 838                             i -> (long)intCornerCaseValue(i));
 839             })
 840     );
 841 
 842     static void assertArraysEquals(int[] r, long[] a, int offs) {
 843         int i = 0;
 844         try {
 845             for (; i < r.length; i++) {
 846                 Assert.assertEquals(r[i], (int)(a[i+offs]));
 847             }
 848         } catch (AssertionError e) {
 849             Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 850         }
 851     }
 852 
 853 
 854 
 855     static void assertArraysEquals(long[] r, long[] a, int offs) {
 856         int i = 0;
 857         try {
 858             for (; i < r.length; i++) {
 859                 Assert.assertEquals(r[i], (long)(a[i+offs]));
 860             }
 861         } catch (AssertionError e) {
 862             Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 863         }
 864     }
 865 
 866     static void assertArraysEquals(double[] r, long[] a, int offs) {
 867         int i = 0;
 868         try {
 869             for (; i < r.length; i++) {
 870                 Assert.assertEquals(r[i], (double)(a[i+offs]));
 871             }
 872         } catch (AssertionError e) {
 873             Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 874         }
 875     }
 876 
 877 
 878     static long bits(long e) {
 879         return  e;
 880     }
 881 
 882     static final List<IntFunction<long[]>> LONG_GENERATORS = List.of(
 883             withToString("long[-i * 5]", (int s) -> {
 884                 return fill(s * BUFFER_REPS,
 885                             i -> (long)(-i * 5));
 886             }),
 887             withToString("long[i * 5]", (int s) -> {
 888                 return fill(s * BUFFER_REPS,
 889                             i -> (long)(i * 5));
 890             }),
 891             withToString("long[i + 1]", (int s) -> {
 892                 return fill(s * BUFFER_REPS,
 893                             i -> (((long)(i + 1) == 0) ? 1 : (long)(i + 1)));
 894             }),
 895             withToString("long[cornerCaseValue(i)]", (int s) -> {
 896                 return fill(s * BUFFER_REPS,
 897                             i -> cornerCaseValue(i));
 898             })
 899     );
 900 
 901     // Create combinations of pairs
 902     // @@@ Might be sensitive to order e.g. div by 0
 903     static final List<List<IntFunction<long[]>>> LONG_GENERATOR_PAIRS =
 904         Stream.of(LONG_GENERATORS.get(0)).
 905                 flatMap(fa -> LONG_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
 906                 collect(Collectors.toList());
 907 
 908     @DataProvider
 909     public Object[][] boolUnaryOpProvider() {
 910         return BOOL_ARRAY_GENERATORS.stream().
 911                 map(f -> new Object[]{f}).
 912                 toArray(Object[][]::new);
 913     }
 914 
 915     static final List<List<IntFunction<long[]>>> LONG_GENERATOR_TRIPLES =
 916         LONG_GENERATOR_PAIRS.stream().
 917                 flatMap(pair -> LONG_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
 918                 collect(Collectors.toList());
 919 
 920     @DataProvider
 921     public Object[][] longBinaryOpProvider() {
 922         return LONG_GENERATOR_PAIRS.stream().map(List::toArray).
 923                 toArray(Object[][]::new);
 924     }
 925 
 926     @DataProvider
 927     public Object[][] longIndexedOpProvider() {
 928         return LONG_GENERATOR_PAIRS.stream().map(List::toArray).
 929                 toArray(Object[][]::new);
 930     }
 931 
 932     @DataProvider
 933     public Object[][] longBinaryOpMaskProvider() {
 934         return BOOLEAN_MASK_GENERATORS.stream().
 935                 flatMap(fm -> LONG_GENERATOR_PAIRS.stream().map(lfa -> {
 936                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
 937                 })).
 938                 toArray(Object[][]::new);
 939     }
 940 
 941     @DataProvider
 942     public Object[][] longTernaryOpProvider() {
 943         return LONG_GENERATOR_TRIPLES.stream().map(List::toArray).
 944                 toArray(Object[][]::new);
 945     }
 946 
 947     @DataProvider
 948     public Object[][] longTernaryOpMaskProvider() {
 949         return BOOLEAN_MASK_GENERATORS.stream().
 950                 flatMap(fm -> LONG_GENERATOR_TRIPLES.stream().map(lfa -> {
 951                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
 952                 })).
 953                 toArray(Object[][]::new);
 954     }
 955 
 956     @DataProvider
 957     public Object[][] longUnaryOpProvider() {
 958         return LONG_GENERATORS.stream().
 959                 map(f -> new Object[]{f}).
 960                 toArray(Object[][]::new);
 961     }
 962 
 963     @DataProvider
 964     public Object[][] longUnaryOpMaskProvider() {
 965         return BOOLEAN_MASK_GENERATORS.stream().
 966                 flatMap(fm -> LONG_GENERATORS.stream().map(fa -> {
 967                     return new Object[] {fa, fm};
 968                 })).
 969                 toArray(Object[][]::new);
 970     }
 971 
 972     @DataProvider
 973     public Object[][] longtoIntUnaryOpProvider() {
 974         return INT_LONG_GENERATORS.stream().
 975                 map(f -> new Object[]{f}).
 976                 toArray(Object[][]::new);
 977     }
 978 
 979 
 980     @DataProvider
 981     public Object[][] maskProvider() {
 982         return BOOLEAN_MASK_GENERATORS.stream().
 983                 map(f -> new Object[]{f}).
 984                 toArray(Object[][]::new);
 985     }
 986 
 987     @DataProvider
 988     public Object[][] maskCompareOpProvider() {
 989         return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
 990                 toArray(Object[][]::new);
 991     }
 992 
 993     @DataProvider
 994     public Object[][] shuffleProvider() {
 995         return INT_SHUFFLE_GENERATORS.stream().
 996                 map(f -> new Object[]{f}).
 997                 toArray(Object[][]::new);
 998     }
 999 
1000     @DataProvider
1001     public Object[][] shuffleCompareOpProvider() {
1002         return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1003                 toArray(Object[][]::new);
1004     }
1005 
1006     @DataProvider
1007     public Object[][] longUnaryOpShuffleProvider() {
1008         return INT_SHUFFLE_GENERATORS.stream().
1009                 flatMap(fs -> LONG_GENERATORS.stream().map(fa -> {
1010                     return new Object[] {fa, fs};
1011                 })).
1012                 toArray(Object[][]::new);
1013     }
1014 
1015     @DataProvider
1016     public Object[][] longUnaryOpShuffleMaskProvider() {
1017         return BOOLEAN_MASK_GENERATORS.stream().
1018                 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
1019                     flatMap(fs -> LONG_GENERATORS.stream().map(fa -> {
1020                         return new Object[] {fa, fs, fm};
1021                 }))).
1022                 toArray(Object[][]::new);
1023     }
1024 
1025     static final List<BiFunction<Integer,Integer,long[]>> LONG_SHUFFLE_GENERATORS = List.of(
1026             withToStringBi("shuffle[random]", (Integer l, Integer m) -> {
1027                 long[] a = new long[l];
1028                 int upper = m;
1029                 for (int i = 0; i < 1; i++) {
1030                     a[i] = (long)RAND.nextInt(upper);
1031                 }
1032                 return a;
1033             })
1034     );
1035 
1036     @DataProvider
1037     public Object[][] longUnaryOpSelectFromProvider() {
1038         return LONG_SHUFFLE_GENERATORS.stream().
1039                 flatMap(fs -> LONG_GENERATORS.stream().map(fa -> {
1040                     return new Object[] {fa, fs};
1041                 })).
1042                 toArray(Object[][]::new);
1043     }
1044 
1045     @DataProvider
1046     public Object[][] longUnaryOpSelectFromMaskProvider() {
1047         return BOOLEAN_MASK_GENERATORS.stream().
1048                 flatMap(fm -> LONG_SHUFFLE_GENERATORS.stream().
1049                     flatMap(fs -> LONG_GENERATORS.stream().map(fa -> {
1050                         return new Object[] {fa, fs, fm};
1051                 }))).
1052                 toArray(Object[][]::new);
1053     }
1054 
1055 
1056     static final List<IntFunction<long[]>> LONG_COMPARE_GENERATORS = List.of(
1057             withToString("long[i]", (int s) -> {
1058                 return fill(s * BUFFER_REPS,
1059                             i -> (long)i);
1060             }),
1061             withToString("long[i - length / 2]", (int s) -> {
1062                 return fill(s * BUFFER_REPS,
1063                             i -> (long)(i - (s * BUFFER_REPS / 2)));
1064             }),
1065             withToString("long[i + 1]", (int s) -> {
1066                 return fill(s * BUFFER_REPS,
1067                             i -> (long)(i + 1));
1068             }),
1069             withToString("long[i - 2]", (int s) -> {
1070                 return fill(s * BUFFER_REPS,
1071                             i -> (long)(i - 2));
1072             }),
1073             withToString("long[zigZag(i)]", (int s) -> {
1074                 return fill(s * BUFFER_REPS,
1075                             i -> i%3 == 0 ? (long)i : (i%3 == 1 ? (long)(i + 1) : (long)(i - 2)));
1076             }),
1077             withToString("long[cornerCaseValue(i)]", (int s) -> {
1078                 return fill(s * BUFFER_REPS,
1079                             i -> cornerCaseValue(i));
1080             })
1081     );
1082 
1083     static final List<List<IntFunction<long[]>>> LONG_TEST_GENERATOR_ARGS =
1084         LONG_COMPARE_GENERATORS.stream().
1085                 map(fa -> List.of(fa)).
1086                 collect(Collectors.toList());
1087 
1088     @DataProvider
1089     public Object[][] longTestOpProvider() {
1090         return LONG_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1091                 toArray(Object[][]::new);
1092     }
1093 
1094     @DataProvider
1095     public Object[][] longTestOpMaskProvider() {
1096         return BOOLEAN_MASK_GENERATORS.stream().
1097                 flatMap(fm -> LONG_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1098                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1099                 })).
1100                 toArray(Object[][]::new);
1101     }
1102 
1103     static final List<List<IntFunction<long[]>>> LONG_COMPARE_GENERATOR_PAIRS =
1104         LONG_COMPARE_GENERATORS.stream().
1105                 flatMap(fa -> LONG_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1106                 collect(Collectors.toList());
1107 
1108     @DataProvider
1109     public Object[][] longCompareOpProvider() {
1110         return LONG_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1111                 toArray(Object[][]::new);
1112     }
1113 
1114     @DataProvider
1115     public Object[][] longCompareOpMaskProvider() {
1116         return BOOLEAN_MASK_GENERATORS.stream().
1117                 flatMap(fm -> LONG_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1118                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1119                 })).
1120                 toArray(Object[][]::new);
1121     }
1122 
1123     interface ToLongF {
1124         long apply(int i);
1125     }
1126 
1127     static long[] fill(int s , ToLongF f) {
1128         return fill(new long[s], f);
1129     }
1130 
1131     static long[] fill(long[] a, ToLongF f) {
1132         for (int i = 0; i < a.length; i++) {
1133             a[i] = f.apply(i);
1134         }
1135         return a;
1136     }
1137 
1138     static long cornerCaseValue(int i) {
1139         switch(i % 5) {
1140             case 0:
1141                 return Long.MAX_VALUE;
1142             case 1:
1143                 return Long.MIN_VALUE;
1144             case 2:
1145                 return Long.MIN_VALUE;
1146             case 3:
1147                 return Long.MAX_VALUE;
1148             default:
1149                 return (long)0;
1150         }
1151     }
1152 
1153     static long get(long[] a, int i) {
1154         return (long) a[i];
1155     }
1156 
1157     static final IntFunction<long[]> fr = (vl) -> {
1158         int length = BUFFER_REPS * vl;
1159         return new long[length];
1160     };
1161 
1162     static final IntFunction<boolean[]> fmr = (vl) -> {
1163         int length = BUFFER_REPS * vl;
1164         return new boolean[length];
1165     };
1166 
1167 
1168     static void replaceZero(long[] a, long v) {
1169         for (int i = 0; i < a.length; i++) {
1170             if (a[i] == 0) {
1171                 a[i] = v;
1172             }
1173         }
1174     }
1175 
1176     static void replaceZero(long[] a, boolean[] mask, long v) {
1177         for (int i = 0; i < a.length; i++) {
1178             if (mask[i % mask.length] && a[i] == 0) {
1179                 a[i] = v;
1180             }
1181         }
1182     }
1183 
1184     static long ROL_scalar(long a, long b) {
1185         return Long.rotateLeft(a, ((int)b));
1186     }
1187 
1188     static long ROR_scalar(long a, long b) {
1189         return Long.rotateRight(a, ((int)b));
1190     }
1191 












1192     static boolean eq(long a, long b) {
1193         return a == b;
1194     }
1195 
1196     static boolean neq(long a, long b) {
1197         return a != b;
1198     }
1199 
1200     static boolean lt(long a, long b) {
1201         return a < b;
1202     }
1203 
1204     static boolean le(long a, long b) {
1205         return a <= b;
1206     }
1207 
1208     static boolean gt(long a, long b) {
1209         return a > b;
1210     }
1211 
1212     static boolean ge(long a, long b) {
1213         return a >= b;
1214     }
1215 
1216     static boolean ult(long a, long b) {
1217         return Long.compareUnsigned(a, b) < 0;
1218     }
1219 
1220     static boolean ule(long a, long b) {
1221         return Long.compareUnsigned(a, b) <= 0;
1222     }
1223 
1224     static boolean ugt(long a, long b) {
1225         return Long.compareUnsigned(a, b) > 0;
1226     }
1227 
1228     static boolean uge(long a, long b) {
1229         return Long.compareUnsigned(a, b) >= 0;
1230     }
1231 
1232     static long firstNonZero(long a, long b) {
1233         return Long.compare(a, (long) 0) != 0 ? a : b;
1234     }
1235 
1236     @Test
1237     static void smokeTest1() {
1238         LongVector three = LongVector.broadcast(SPECIES, (byte)-3);
1239         LongVector three2 = (LongVector) SPECIES.broadcast(-3);
1240         assert(three.eq(three2).allTrue());
1241         LongVector three3 = three2.broadcast(1).broadcast(-3);
1242         assert(three.eq(three3).allTrue());
1243         int scale = 2;
1244         Class<?> ETYPE = long.class;
1245         if (ETYPE == double.class || ETYPE == long.class)
1246             scale = 1000000;
1247         else if (ETYPE == byte.class && SPECIES.length() >= 64)
1248             scale = 1;
1249         LongVector higher = three.addIndex(scale);
1250         VectorMask<Long> m = three.compare(VectorOperators.LE, higher);
1251         assert(m.allTrue());
1252         m = higher.min((long)-1).test(VectorOperators.IS_NEGATIVE);
1253         assert(m.allTrue());
1254         long max = higher.reduceLanes(VectorOperators.MAX);
1255         assert(max == -3 + scale * (SPECIES.length()-1));
1256     }
1257 
1258     private static long[]
1259     bothToArray(LongVector a, LongVector b) {
1260         long[] r = new long[a.length() + b.length()];
1261         a.intoArray(r, 0);
1262         b.intoArray(r, a.length());
1263         return r;
1264     }
1265 
1266     @Test
1267     static void smokeTest2() {
1268         // Do some zipping and shuffling.
1269         LongVector io = (LongVector) SPECIES.broadcast(0).addIndex(1);
1270         LongVector io2 = (LongVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1271         Assert.assertEquals(io, io2);
1272         LongVector a = io.add((long)1); //[1,2]
1273         LongVector b = a.neg();  //[-1,-2]
1274         long[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1275         VectorShuffle<Long> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1276         VectorShuffle<Long> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1277         LongVector zab0 = a.rearrange(zip0,b); //[1,-1]
1278         LongVector zab1 = a.rearrange(zip1,b); //[2,-2]
1279         long[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1280         // manually zip
1281         long[] manual = new long[zabValues.length];
1282         for (int i = 0; i < manual.length; i += 2) {
1283             manual[i+0] = abValues[i/2];
1284             manual[i+1] = abValues[a.length() + i/2];
1285         }
1286         Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1287         VectorShuffle<Long> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1288         VectorShuffle<Long> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1289         LongVector uab0 = zab0.rearrange(unz0,zab1);
1290         LongVector uab1 = zab0.rearrange(unz1,zab1);
1291         long[] abValues1 = bothToArray(uab0, uab1);
1292         Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1293     }
1294 
1295     static void iotaShuffle() {
1296         LongVector io = (LongVector) SPECIES.broadcast(0).addIndex(1);
1297         LongVector io2 = (LongVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1298         Assert.assertEquals(io, io2);
1299     }
1300 
1301     @Test
1302     // Test all shuffle related operations.
1303     static void shuffleTest() {
1304         // To test backend instructions, make sure that C2 is used.
1305         for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1306             iotaShuffle();
1307         }
1308     }
1309 
1310     @Test
1311     void viewAsIntegeralLanesTest() {
1312         Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1313         Assert.assertEquals(asIntegral.species(), SPECIES);
1314     }
1315 
1316     @Test
1317     void viewAsFloatingLanesTest() {
1318         Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
1319         VectorSpecies<?> asFloatingSpecies = asFloating.species();
1320         Assert.assertNotEquals(asFloatingSpecies.elementType(), SPECIES.elementType());
1321         Assert.assertEquals(asFloatingSpecies.vectorShape(), SPECIES.vectorShape());
1322         Assert.assertEquals(asFloatingSpecies.length(), SPECIES.length());
1323         Assert.assertEquals(asFloating.viewAsIntegralLanes().species(), SPECIES);
1324     }
1325 
1326     @Test
1327     // Test div by 0.
1328     static void bitwiseDivByZeroSmokeTest() {
1329         try {
1330             LongVector a = (LongVector) SPECIES.broadcast(0).addIndex(1);
1331             LongVector b = (LongVector) SPECIES.broadcast(0);
1332             a.div(b);
1333             Assert.fail();
1334         } catch (ArithmeticException e) {
1335         }
1336 
1337         try {
1338             LongVector a = (LongVector) SPECIES.broadcast(0).addIndex(1);
1339             LongVector b = (LongVector) SPECIES.broadcast(0);
1340             VectorMask<Long> m = a.lt((long) 1);
1341             a.div(b, m);
1342             Assert.fail();
1343         } catch (ArithmeticException e) {
1344         }
1345     }

1346     static long ADD(long a, long b) {
1347         return (long)(a + b);
1348     }
1349 
1350     @Test(dataProvider = "longBinaryOpProvider")
1351     static void ADDLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1352         long[] a = fa.apply(SPECIES.length());
1353         long[] b = fb.apply(SPECIES.length());
1354         long[] r = fr.apply(SPECIES.length());
1355 
1356         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1357             for (int i = 0; i < a.length; i += SPECIES.length()) {
1358                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1359                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1360                 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
1361             }
1362         }
1363 
1364         assertArraysEquals(r, a, b, Long512VectorTests::ADD);
1365     }

1366     static long add(long a, long b) {
1367         return (long)(a + b);
1368     }
1369 
1370     @Test(dataProvider = "longBinaryOpProvider")
1371     static void addLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1372         long[] a = fa.apply(SPECIES.length());
1373         long[] b = fb.apply(SPECIES.length());
1374         long[] r = fr.apply(SPECIES.length());
1375 
1376         for (int i = 0; i < a.length; i += SPECIES.length()) {
1377             LongVector av = LongVector.fromArray(SPECIES, a, i);
1378             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1379             av.add(bv).intoArray(r, i);
1380         }
1381 
1382         assertArraysEquals(r, a, b, Long512VectorTests::add);
1383     }
1384 
1385     @Test(dataProvider = "longBinaryOpMaskProvider")
1386     static void ADDLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1387                                           IntFunction<boolean[]> fm) {
1388         long[] a = fa.apply(SPECIES.length());
1389         long[] b = fb.apply(SPECIES.length());
1390         long[] r = fr.apply(SPECIES.length());
1391         boolean[] mask = fm.apply(SPECIES.length());
1392         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1393 
1394         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1395             for (int i = 0; i < a.length; i += SPECIES.length()) {
1396                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1397                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1398                 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
1399             }
1400         }
1401 
1402         assertArraysEquals(r, a, b, mask, Long512VectorTests::ADD);
1403     }
1404 
1405     @Test(dataProvider = "longBinaryOpMaskProvider")
1406     static void addLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1407                                           IntFunction<boolean[]> fm) {
1408         long[] a = fa.apply(SPECIES.length());
1409         long[] b = fb.apply(SPECIES.length());
1410         long[] r = fr.apply(SPECIES.length());
1411         boolean[] mask = fm.apply(SPECIES.length());
1412         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1413 
1414         for (int i = 0; i < a.length; i += SPECIES.length()) {
1415             LongVector av = LongVector.fromArray(SPECIES, a, i);
1416             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1417             av.add(bv, vmask).intoArray(r, i);
1418         }
1419 
1420         assertArraysEquals(r, a, b, mask, Long512VectorTests::add);
1421     }

1422     static long SUB(long a, long b) {
1423         return (long)(a - b);
1424     }
1425 
1426     @Test(dataProvider = "longBinaryOpProvider")
1427     static void SUBLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1428         long[] a = fa.apply(SPECIES.length());
1429         long[] b = fb.apply(SPECIES.length());
1430         long[] r = fr.apply(SPECIES.length());
1431 
1432         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1433             for (int i = 0; i < a.length; i += SPECIES.length()) {
1434                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1435                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1436                 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1437             }
1438         }
1439 
1440         assertArraysEquals(r, a, b, Long512VectorTests::SUB);
1441     }

1442     static long sub(long a, long b) {
1443         return (long)(a - b);
1444     }
1445 
1446     @Test(dataProvider = "longBinaryOpProvider")
1447     static void subLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1448         long[] a = fa.apply(SPECIES.length());
1449         long[] b = fb.apply(SPECIES.length());
1450         long[] r = fr.apply(SPECIES.length());
1451 
1452         for (int i = 0; i < a.length; i += SPECIES.length()) {
1453             LongVector av = LongVector.fromArray(SPECIES, a, i);
1454             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1455             av.sub(bv).intoArray(r, i);
1456         }
1457 
1458         assertArraysEquals(r, a, b, Long512VectorTests::sub);
1459     }
1460 
1461     @Test(dataProvider = "longBinaryOpMaskProvider")
1462     static void SUBLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1463                                           IntFunction<boolean[]> fm) {
1464         long[] a = fa.apply(SPECIES.length());
1465         long[] b = fb.apply(SPECIES.length());
1466         long[] r = fr.apply(SPECIES.length());
1467         boolean[] mask = fm.apply(SPECIES.length());
1468         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1469 
1470         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1471             for (int i = 0; i < a.length; i += SPECIES.length()) {
1472                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1473                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1474                 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1475             }
1476         }
1477 
1478         assertArraysEquals(r, a, b, mask, Long512VectorTests::SUB);
1479     }
1480 
1481     @Test(dataProvider = "longBinaryOpMaskProvider")
1482     static void subLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1483                                           IntFunction<boolean[]> fm) {
1484         long[] a = fa.apply(SPECIES.length());
1485         long[] b = fb.apply(SPECIES.length());
1486         long[] r = fr.apply(SPECIES.length());
1487         boolean[] mask = fm.apply(SPECIES.length());
1488         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1489 
1490         for (int i = 0; i < a.length; i += SPECIES.length()) {
1491             LongVector av = LongVector.fromArray(SPECIES, a, i);
1492             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1493             av.sub(bv, vmask).intoArray(r, i);
1494         }
1495 
1496         assertArraysEquals(r, a, b, mask, Long512VectorTests::sub);
1497     }

1498     static long MUL(long a, long b) {
1499         return (long)(a * b);
1500     }
1501 
1502     @Test(dataProvider = "longBinaryOpProvider")
1503     static void MULLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1504         long[] a = fa.apply(SPECIES.length());
1505         long[] b = fb.apply(SPECIES.length());
1506         long[] r = fr.apply(SPECIES.length());
1507 
1508         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1509             for (int i = 0; i < a.length; i += SPECIES.length()) {
1510                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1511                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1512                 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1513             }
1514         }
1515 
1516         assertArraysEquals(r, a, b, Long512VectorTests::MUL);
1517     }

1518     static long mul(long a, long b) {
1519         return (long)(a * b);
1520     }
1521 
1522     @Test(dataProvider = "longBinaryOpProvider")
1523     static void mulLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1524         long[] a = fa.apply(SPECIES.length());
1525         long[] b = fb.apply(SPECIES.length());
1526         long[] r = fr.apply(SPECIES.length());
1527 
1528         for (int i = 0; i < a.length; i += SPECIES.length()) {
1529             LongVector av = LongVector.fromArray(SPECIES, a, i);
1530             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1531             av.mul(bv).intoArray(r, i);
1532         }
1533 
1534         assertArraysEquals(r, a, b, Long512VectorTests::mul);
1535     }
1536 
1537     @Test(dataProvider = "longBinaryOpMaskProvider")
1538     static void MULLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1539                                           IntFunction<boolean[]> fm) {
1540         long[] a = fa.apply(SPECIES.length());
1541         long[] b = fb.apply(SPECIES.length());
1542         long[] r = fr.apply(SPECIES.length());
1543         boolean[] mask = fm.apply(SPECIES.length());
1544         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1545 
1546         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1547             for (int i = 0; i < a.length; i += SPECIES.length()) {
1548                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1549                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1550                 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1551             }
1552         }
1553 
1554         assertArraysEquals(r, a, b, mask, Long512VectorTests::MUL);
1555     }
1556 
1557     @Test(dataProvider = "longBinaryOpMaskProvider")
1558     static void mulLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1559                                           IntFunction<boolean[]> fm) {
1560         long[] a = fa.apply(SPECIES.length());
1561         long[] b = fb.apply(SPECIES.length());
1562         long[] r = fr.apply(SPECIES.length());
1563         boolean[] mask = fm.apply(SPECIES.length());
1564         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1565 
1566         for (int i = 0; i < a.length; i += SPECIES.length()) {
1567             LongVector av = LongVector.fromArray(SPECIES, a, i);
1568             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1569             av.mul(bv, vmask).intoArray(r, i);
1570         }
1571 
1572         assertArraysEquals(r, a, b, mask, Long512VectorTests::mul);
1573     }
1574 
1575 
1576 
1577     static long DIV(long a, long b) {
1578         return (long)(a / b);
1579     }
1580 
1581     @Test(dataProvider = "longBinaryOpProvider")
1582     static void DIVLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1583         long[] a = fa.apply(SPECIES.length());
1584         long[] b = fb.apply(SPECIES.length());
1585         long[] r = fr.apply(SPECIES.length());
1586 
1587         replaceZero(b, (long) 1);
1588 
1589         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1590             for (int i = 0; i < a.length; i += SPECIES.length()) {
1591                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1592                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1593                 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1594             }
1595         }
1596 
1597         assertArraysEquals(r, a, b, Long512VectorTests::DIV);
1598     }

1599     static long div(long a, long b) {
1600         return (long)(a / b);
1601     }
1602 
1603     @Test(dataProvider = "longBinaryOpProvider")
1604     static void divLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1605         long[] a = fa.apply(SPECIES.length());
1606         long[] b = fb.apply(SPECIES.length());
1607         long[] r = fr.apply(SPECIES.length());
1608 
1609         replaceZero(b, (long) 1);
1610 
1611         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1612             for (int i = 0; i < a.length; i += SPECIES.length()) {
1613                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1614                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1615                 av.div(bv).intoArray(r, i);
1616             }
1617         }
1618 
1619         assertArraysEquals(r, a, b, Long512VectorTests::div);
1620     }
1621 
1622 
1623 
1624     @Test(dataProvider = "longBinaryOpMaskProvider")
1625     static void DIVLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1626                                           IntFunction<boolean[]> fm) {
1627         long[] a = fa.apply(SPECIES.length());
1628         long[] b = fb.apply(SPECIES.length());
1629         long[] r = fr.apply(SPECIES.length());
1630         boolean[] mask = fm.apply(SPECIES.length());
1631         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1632 
1633         replaceZero(b, mask, (long) 1);
1634 
1635         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1636             for (int i = 0; i < a.length; i += SPECIES.length()) {
1637                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1638                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1639                 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1640             }
1641         }
1642 
1643         assertArraysEquals(r, a, b, mask, Long512VectorTests::DIV);
1644     }
1645 
1646     @Test(dataProvider = "longBinaryOpMaskProvider")
1647     static void divLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1648                                           IntFunction<boolean[]> fm) {
1649         long[] a = fa.apply(SPECIES.length());
1650         long[] b = fb.apply(SPECIES.length());
1651         long[] r = fr.apply(SPECIES.length());
1652         boolean[] mask = fm.apply(SPECIES.length());
1653         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1654 
1655         replaceZero(b, mask, (long) 1);
1656 
1657         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1658             for (int i = 0; i < a.length; i += SPECIES.length()) {
1659                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1660                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1661                 av.div(bv, vmask).intoArray(r, i);
1662             }
1663         }
1664 
1665         assertArraysEquals(r, a, b, mask, Long512VectorTests::div);
1666     }
1667 
1668     static long FIRST_NONZERO(long a, long b) {
1669         return (long)((a)!=0?a:b);
1670     }
1671 
1672     @Test(dataProvider = "longBinaryOpProvider")
1673     static void FIRST_NONZEROLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1674         long[] a = fa.apply(SPECIES.length());
1675         long[] b = fb.apply(SPECIES.length());
1676         long[] r = fr.apply(SPECIES.length());
1677 
1678         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1679             for (int i = 0; i < a.length; i += SPECIES.length()) {
1680                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1681                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1682                 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1683             }
1684         }
1685 
1686         assertArraysEquals(r, a, b, Long512VectorTests::FIRST_NONZERO);
1687     }
1688 
1689     @Test(dataProvider = "longBinaryOpMaskProvider")
1690     static void FIRST_NONZEROLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1691                                           IntFunction<boolean[]> fm) {
1692         long[] a = fa.apply(SPECIES.length());
1693         long[] b = fb.apply(SPECIES.length());
1694         long[] r = fr.apply(SPECIES.length());
1695         boolean[] mask = fm.apply(SPECIES.length());
1696         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1697 
1698         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1699             for (int i = 0; i < a.length; i += SPECIES.length()) {
1700                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1701                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1702                 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1703             }
1704         }
1705 
1706         assertArraysEquals(r, a, b, mask, Long512VectorTests::FIRST_NONZERO);
1707     }
1708 
1709     static long AND(long a, long b) {
1710         return (long)(a & b);
1711     }
1712 
1713     @Test(dataProvider = "longBinaryOpProvider")
1714     static void ANDLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1715         long[] a = fa.apply(SPECIES.length());
1716         long[] b = fb.apply(SPECIES.length());
1717         long[] r = fr.apply(SPECIES.length());
1718 
1719         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1720             for (int i = 0; i < a.length; i += SPECIES.length()) {
1721                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1722                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1723                 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1724             }
1725         }
1726 
1727         assertArraysEquals(r, a, b, Long512VectorTests::AND);
1728     }

1729     static long and(long a, long b) {
1730         return (long)(a & b);
1731     }
1732 
1733     @Test(dataProvider = "longBinaryOpProvider")
1734     static void andLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1735         long[] a = fa.apply(SPECIES.length());
1736         long[] b = fb.apply(SPECIES.length());
1737         long[] r = fr.apply(SPECIES.length());
1738 
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.and(bv).intoArray(r, i);
1743         }
1744 
1745         assertArraysEquals(r, a, b, Long512VectorTests::and);
1746     }
1747 
1748 
1749 
1750     @Test(dataProvider = "longBinaryOpMaskProvider")
1751     static void ANDLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1752                                           IntFunction<boolean[]> fm) {
1753         long[] a = fa.apply(SPECIES.length());
1754         long[] b = fb.apply(SPECIES.length());
1755         long[] r = fr.apply(SPECIES.length());
1756         boolean[] mask = fm.apply(SPECIES.length());
1757         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1758 
1759         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1760             for (int i = 0; i < a.length; i += SPECIES.length()) {
1761                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1762                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1763                 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
1764             }
1765         }
1766 
1767         assertArraysEquals(r, a, b, mask, Long512VectorTests::AND);
1768     }
1769 
1770 
1771     static long AND_NOT(long a, long b) {
1772         return (long)(a & ~b);
1773     }
1774 
1775     @Test(dataProvider = "longBinaryOpProvider")
1776     static void AND_NOTLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1777         long[] a = fa.apply(SPECIES.length());
1778         long[] b = fb.apply(SPECIES.length());
1779         long[] r = fr.apply(SPECIES.length());
1780 
1781         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1782             for (int i = 0; i < a.length; i += SPECIES.length()) {
1783                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1784                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1785                 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
1786             }
1787         }
1788 
1789         assertArraysEquals(r, a, b, Long512VectorTests::AND_NOT);
1790     }
1791 
1792 
1793 
1794     @Test(dataProvider = "longBinaryOpMaskProvider")
1795     static void AND_NOTLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1796                                           IntFunction<boolean[]> fm) {
1797         long[] a = fa.apply(SPECIES.length());
1798         long[] b = fb.apply(SPECIES.length());
1799         long[] r = fr.apply(SPECIES.length());
1800         boolean[] mask = fm.apply(SPECIES.length());
1801         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1802 
1803         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1804             for (int i = 0; i < a.length; i += SPECIES.length()) {
1805                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1806                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1807                 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
1808             }
1809         }
1810 
1811         assertArraysEquals(r, a, b, mask, Long512VectorTests::AND_NOT);
1812     }
1813 
1814 
1815     static long OR(long a, long b) {
1816         return (long)(a | b);
1817     }
1818 
1819     @Test(dataProvider = "longBinaryOpProvider")
1820     static void ORLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1821         long[] a = fa.apply(SPECIES.length());
1822         long[] b = fb.apply(SPECIES.length());
1823         long[] r = fr.apply(SPECIES.length());
1824 
1825         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1826             for (int i = 0; i < a.length; i += SPECIES.length()) {
1827                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1828                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1829                 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
1830             }
1831         }
1832 
1833         assertArraysEquals(r, a, b, Long512VectorTests::OR);
1834     }

1835     static long or(long a, long b) {
1836         return (long)(a | b);
1837     }
1838 
1839     @Test(dataProvider = "longBinaryOpProvider")
1840     static void orLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1841         long[] a = fa.apply(SPECIES.length());
1842         long[] b = fb.apply(SPECIES.length());
1843         long[] r = fr.apply(SPECIES.length());
1844 
1845         for (int i = 0; i < a.length; i += SPECIES.length()) {
1846             LongVector av = LongVector.fromArray(SPECIES, a, i);
1847             LongVector bv = LongVector.fromArray(SPECIES, b, i);
1848             av.or(bv).intoArray(r, i);
1849         }
1850 
1851         assertArraysEquals(r, a, b, Long512VectorTests::or);
1852     }
1853 
1854 
1855 
1856     @Test(dataProvider = "longBinaryOpMaskProvider")
1857     static void ORLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1858                                           IntFunction<boolean[]> fm) {
1859         long[] a = fa.apply(SPECIES.length());
1860         long[] b = fb.apply(SPECIES.length());
1861         long[] r = fr.apply(SPECIES.length());
1862         boolean[] mask = fm.apply(SPECIES.length());
1863         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1864 
1865         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1866             for (int i = 0; i < a.length; i += SPECIES.length()) {
1867                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1868                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1869                 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
1870             }
1871         }
1872 
1873         assertArraysEquals(r, a, b, mask, Long512VectorTests::OR);
1874     }
1875 
1876 
1877     static long XOR(long a, long b) {
1878         return (long)(a ^ b);
1879     }
1880 
1881     @Test(dataProvider = "longBinaryOpProvider")
1882     static void XORLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1883         long[] a = fa.apply(SPECIES.length());
1884         long[] b = fb.apply(SPECIES.length());
1885         long[] r = fr.apply(SPECIES.length());
1886 
1887         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1888             for (int i = 0; i < a.length; i += SPECIES.length()) {
1889                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1890                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1891                 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
1892             }
1893         }
1894 
1895         assertArraysEquals(r, a, b, Long512VectorTests::XOR);
1896     }
1897 
1898 
1899 
1900     @Test(dataProvider = "longBinaryOpMaskProvider")
1901     static void XORLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
1902                                           IntFunction<boolean[]> fm) {
1903         long[] a = fa.apply(SPECIES.length());
1904         long[] b = fb.apply(SPECIES.length());
1905         long[] r = fr.apply(SPECIES.length());
1906         boolean[] mask = fm.apply(SPECIES.length());
1907         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1908 
1909         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1910             for (int i = 0; i < a.length; i += SPECIES.length()) {
1911                 LongVector av = LongVector.fromArray(SPECIES, a, i);
1912                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
1913                 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
1914             }
1915         }
1916 
1917         assertArraysEquals(r, a, b, mask, Long512VectorTests::XOR);
1918     }
1919 

















































































1920 
1921     @Test(dataProvider = "longBinaryOpProvider")
1922     static void addLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1923         long[] a = fa.apply(SPECIES.length());
1924         long[] b = fb.apply(SPECIES.length());
1925         long[] r = fr.apply(SPECIES.length());
1926 
1927         for (int i = 0; i < a.length; i += SPECIES.length()) {
1928             LongVector av = LongVector.fromArray(SPECIES, a, i);
1929             av.add(b[i]).intoArray(r, i);
1930         }
1931 
1932         assertBroadcastArraysEquals(r, a, b, Long512VectorTests::add);
1933     }
1934 
1935     @Test(dataProvider = "longBinaryOpMaskProvider")
1936     static void addLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
1937                                           IntFunction<boolean[]> fm) {
1938         long[] a = fa.apply(SPECIES.length());
1939         long[] b = fb.apply(SPECIES.length());
1940         long[] r = fr.apply(SPECIES.length());
1941         boolean[] mask = fm.apply(SPECIES.length());
1942         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1943 
1944         for (int i = 0; i < a.length; i += SPECIES.length()) {
1945             LongVector av = LongVector.fromArray(SPECIES, a, i);
1946             av.add(b[i], vmask).intoArray(r, i);
1947         }
1948 
1949         assertBroadcastArraysEquals(r, a, b, mask, Long512VectorTests::add);
1950     }
1951 
1952     @Test(dataProvider = "longBinaryOpProvider")
1953     static void subLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1954         long[] a = fa.apply(SPECIES.length());
1955         long[] b = fb.apply(SPECIES.length());
1956         long[] r = fr.apply(SPECIES.length());
1957 
1958         for (int i = 0; i < a.length; i += SPECIES.length()) {
1959             LongVector av = LongVector.fromArray(SPECIES, a, i);
1960             av.sub(b[i]).intoArray(r, i);
1961         }
1962 
1963         assertBroadcastArraysEquals(r, a, b, Long512VectorTests::sub);
1964     }
1965 
1966     @Test(dataProvider = "longBinaryOpMaskProvider")
1967     static void subLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
1968                                           IntFunction<boolean[]> fm) {
1969         long[] a = fa.apply(SPECIES.length());
1970         long[] b = fb.apply(SPECIES.length());
1971         long[] r = fr.apply(SPECIES.length());
1972         boolean[] mask = fm.apply(SPECIES.length());
1973         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1974 
1975         for (int i = 0; i < a.length; i += SPECIES.length()) {
1976             LongVector av = LongVector.fromArray(SPECIES, a, i);
1977             av.sub(b[i], vmask).intoArray(r, i);
1978         }
1979 
1980         assertBroadcastArraysEquals(r, a, b, mask, Long512VectorTests::sub);
1981     }
1982 
1983     @Test(dataProvider = "longBinaryOpProvider")
1984     static void mulLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
1985         long[] a = fa.apply(SPECIES.length());
1986         long[] b = fb.apply(SPECIES.length());
1987         long[] r = fr.apply(SPECIES.length());
1988 
1989         for (int i = 0; i < a.length; i += SPECIES.length()) {
1990             LongVector av = LongVector.fromArray(SPECIES, a, i);
1991             av.mul(b[i]).intoArray(r, i);
1992         }
1993 
1994         assertBroadcastArraysEquals(r, a, b, Long512VectorTests::mul);
1995     }
1996 
1997     @Test(dataProvider = "longBinaryOpMaskProvider")
1998     static void mulLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
1999                                           IntFunction<boolean[]> fm) {
2000         long[] a = fa.apply(SPECIES.length());
2001         long[] b = fb.apply(SPECIES.length());
2002         long[] r = fr.apply(SPECIES.length());
2003         boolean[] mask = fm.apply(SPECIES.length());
2004         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2005 
2006         for (int i = 0; i < a.length; i += SPECIES.length()) {
2007             LongVector av = LongVector.fromArray(SPECIES, a, i);
2008             av.mul(b[i], vmask).intoArray(r, i);
2009         }
2010 
2011         assertBroadcastArraysEquals(r, a, b, mask, Long512VectorTests::mul);
2012     }
2013 
2014 
2015 
2016 
2017     @Test(dataProvider = "longBinaryOpProvider")
2018     static void divLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2019         long[] a = fa.apply(SPECIES.length());
2020         long[] b = fb.apply(SPECIES.length());
2021         long[] r = fr.apply(SPECIES.length());
2022 
2023         replaceZero(b, (long) 1);
2024 
2025         for (int i = 0; i < a.length; i += SPECIES.length()) {
2026             LongVector av = LongVector.fromArray(SPECIES, a, i);
2027             av.div(b[i]).intoArray(r, i);
2028         }
2029 
2030         assertBroadcastArraysEquals(r, a, b, Long512VectorTests::div);
2031     }
2032 
2033 
2034 
2035     @Test(dataProvider = "longBinaryOpMaskProvider")
2036     static void divLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2037                                           IntFunction<boolean[]> fm) {
2038         long[] a = fa.apply(SPECIES.length());
2039         long[] b = fb.apply(SPECIES.length());
2040         long[] r = fr.apply(SPECIES.length());
2041         boolean[] mask = fm.apply(SPECIES.length());
2042         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2043 
2044         replaceZero(b, (long) 1);
2045 
2046         for (int i = 0; i < a.length; i += SPECIES.length()) {
2047             LongVector av = LongVector.fromArray(SPECIES, a, i);
2048             av.div(b[i], vmask).intoArray(r, i);
2049         }
2050 
2051         assertBroadcastArraysEquals(r, a, b, mask, Long512VectorTests::div);
2052     }
2053 
2054 
2055 
2056     @Test(dataProvider = "longBinaryOpProvider")
2057     static void ORLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2058         long[] a = fa.apply(SPECIES.length());
2059         long[] b = fb.apply(SPECIES.length());
2060         long[] r = fr.apply(SPECIES.length());
2061 
2062         for (int i = 0; i < a.length; i += SPECIES.length()) {
2063             LongVector av = LongVector.fromArray(SPECIES, a, i);
2064             av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
2065         }
2066 
2067         assertBroadcastArraysEquals(r, a, b, Long512VectorTests::OR);
2068     }
2069 
2070     @Test(dataProvider = "longBinaryOpProvider")
2071     static void orLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2072         long[] a = fa.apply(SPECIES.length());
2073         long[] b = fb.apply(SPECIES.length());
2074         long[] r = fr.apply(SPECIES.length());
2075 
2076         for (int i = 0; i < a.length; i += SPECIES.length()) {
2077             LongVector av = LongVector.fromArray(SPECIES, a, i);
2078             av.or(b[i]).intoArray(r, i);
2079         }
2080 
2081         assertBroadcastArraysEquals(r, a, b, Long512VectorTests::or);
2082     }
2083 
2084 
2085 
2086     @Test(dataProvider = "longBinaryOpMaskProvider")
2087     static void ORLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2088                                           IntFunction<boolean[]> fm) {
2089         long[] a = fa.apply(SPECIES.length());
2090         long[] b = fb.apply(SPECIES.length());
2091         long[] r = fr.apply(SPECIES.length());
2092         boolean[] mask = fm.apply(SPECIES.length());
2093         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2094 
2095         for (int i = 0; i < a.length; i += SPECIES.length()) {
2096             LongVector av = LongVector.fromArray(SPECIES, a, i);
2097             av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
2098         }
2099 
2100         assertBroadcastArraysEquals(r, a, b, mask, Long512VectorTests::OR);
2101     }
2102 
2103 
2104 
2105     @Test(dataProvider = "longBinaryOpProvider")
2106     static void ANDLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2107         long[] a = fa.apply(SPECIES.length());
2108         long[] b = fb.apply(SPECIES.length());
2109         long[] r = fr.apply(SPECIES.length());
2110 
2111         for (int i = 0; i < a.length; i += SPECIES.length()) {
2112             LongVector av = LongVector.fromArray(SPECIES, a, i);
2113             av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i);
2114         }
2115 
2116         assertBroadcastArraysEquals(r, a, b, Long512VectorTests::AND);
2117     }
2118 
2119     @Test(dataProvider = "longBinaryOpProvider")
2120     static void andLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2121         long[] a = fa.apply(SPECIES.length());
2122         long[] b = fb.apply(SPECIES.length());
2123         long[] r = fr.apply(SPECIES.length());
2124 
2125         for (int i = 0; i < a.length; i += SPECIES.length()) {
2126             LongVector av = LongVector.fromArray(SPECIES, a, i);
2127             av.and(b[i]).intoArray(r, i);
2128         }
2129 
2130         assertBroadcastArraysEquals(r, a, b, Long512VectorTests::and);
2131     }
2132 
2133 
2134 
2135     @Test(dataProvider = "longBinaryOpMaskProvider")
2136     static void ANDLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2137                                           IntFunction<boolean[]> fm) {
2138         long[] a = fa.apply(SPECIES.length());
2139         long[] b = fb.apply(SPECIES.length());
2140         long[] r = fr.apply(SPECIES.length());
2141         boolean[] mask = fm.apply(SPECIES.length());
2142         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2143 
2144         for (int i = 0; i < a.length; i += SPECIES.length()) {
2145             LongVector av = LongVector.fromArray(SPECIES, a, i);
2146             av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i);
2147         }
2148 
2149         assertBroadcastArraysEquals(r, a, b, mask, Long512VectorTests::AND);
2150     }
2151 
2152 
2153 
2154     @Test(dataProvider = "longBinaryOpProvider")
2155     static void ORLong512VectorTestsBroadcastLongSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2156         long[] a = fa.apply(SPECIES.length());
2157         long[] b = fb.apply(SPECIES.length());
2158         long[] r = fr.apply(SPECIES.length());
2159 
2160         for (int i = 0; i < a.length; i += SPECIES.length()) {
2161             LongVector av = LongVector.fromArray(SPECIES, a, i);
2162             av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i);
2163         }
2164 
2165         assertBroadcastLongArraysEquals(r, a, b, Long512VectorTests::OR);
2166     }
2167 
2168 
2169 
2170     @Test(dataProvider = "longBinaryOpMaskProvider")
2171     static void ORLong512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2172                                           IntFunction<boolean[]> fm) {
2173         long[] a = fa.apply(SPECIES.length());
2174         long[] b = fb.apply(SPECIES.length());
2175         long[] r = fr.apply(SPECIES.length());
2176         boolean[] mask = fm.apply(SPECIES.length());
2177         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2178 
2179         for (int i = 0; i < a.length; i += SPECIES.length()) {
2180             LongVector av = LongVector.fromArray(SPECIES, a, i);
2181             av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i);
2182         }
2183 
2184         assertBroadcastLongArraysEquals(r, a, b, mask, Long512VectorTests::OR);
2185     }
2186 
2187 
2188     @Test(dataProvider = "longBinaryOpProvider")
2189     static void ADDLong512VectorTestsBroadcastLongSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2190         long[] a = fa.apply(SPECIES.length());
2191         long[] b = fb.apply(SPECIES.length());
2192         long[] r = fr.apply(SPECIES.length());
2193 
2194         for (int i = 0; i < a.length; i += SPECIES.length()) {
2195             LongVector av = LongVector.fromArray(SPECIES, a, i);
2196             av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
2197         }
2198 
2199         assertBroadcastLongArraysEquals(r, a, b, Long512VectorTests::ADD);
2200     }
2201 
2202     @Test(dataProvider = "longBinaryOpMaskProvider")
2203     static void ADDLong512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
2204                                           IntFunction<boolean[]> fm) {
2205         long[] a = fa.apply(SPECIES.length());
2206         long[] b = fb.apply(SPECIES.length());
2207         long[] r = fr.apply(SPECIES.length());
2208         boolean[] mask = fm.apply(SPECIES.length());
2209         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2210 
2211         for (int i = 0; i < a.length; i += SPECIES.length()) {
2212             LongVector av = LongVector.fromArray(SPECIES, a, i);
2213             av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
2214         }
2215 
2216         assertBroadcastLongArraysEquals(r, a, b, mask, Long512VectorTests::ADD);
2217     }
2218 
2219     static long LSHL(long a, long b) {
2220         return (long)((a << b));
2221     }
2222 
2223     @Test(dataProvider = "longBinaryOpProvider")
2224     static void LSHLLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2225         long[] a = fa.apply(SPECIES.length());
2226         long[] b = fb.apply(SPECIES.length());
2227         long[] r = fr.apply(SPECIES.length());
2228 
2229         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2230             for (int i = 0; i < a.length; i += SPECIES.length()) {
2231                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2232                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2233                 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
2234             }
2235         }
2236 
2237         assertArraysEquals(r, a, b, Long512VectorTests::LSHL);
2238     }
2239 
2240 
2241 
2242     @Test(dataProvider = "longBinaryOpMaskProvider")
2243     static void LSHLLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2244                                           IntFunction<boolean[]> fm) {
2245         long[] a = fa.apply(SPECIES.length());
2246         long[] b = fb.apply(SPECIES.length());
2247         long[] r = fr.apply(SPECIES.length());
2248         boolean[] mask = fm.apply(SPECIES.length());
2249         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2250 
2251         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2252             for (int i = 0; i < a.length; i += SPECIES.length()) {
2253                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2254                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2255                 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
2256             }
2257         }
2258 
2259         assertArraysEquals(r, a, b, mask, Long512VectorTests::LSHL);
2260     }
2261 
2262 
2263 
2264 
2265 
2266 
2267     static long ASHR(long a, long b) {
2268         return (long)((a >> b));
2269     }
2270 
2271     @Test(dataProvider = "longBinaryOpProvider")
2272     static void ASHRLong512VectorTests(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 ic = 0; ic < INVOC_COUNT; ic++) {
2278             for (int i = 0; i < a.length; i += SPECIES.length()) {
2279                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2280                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2281                 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
2282             }
2283         }
2284 
2285         assertArraysEquals(r, a, b, Long512VectorTests::ASHR);
2286     }
2287 
2288 
2289 
2290     @Test(dataProvider = "longBinaryOpMaskProvider")
2291     static void ASHRLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2292                                           IntFunction<boolean[]> fm) {
2293         long[] a = fa.apply(SPECIES.length());
2294         long[] b = fb.apply(SPECIES.length());
2295         long[] r = fr.apply(SPECIES.length());
2296         boolean[] mask = fm.apply(SPECIES.length());
2297         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2298 
2299         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2300             for (int i = 0; i < a.length; i += SPECIES.length()) {
2301                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2302                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2303                 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
2304             }
2305         }
2306 
2307         assertArraysEquals(r, a, b, mask, Long512VectorTests::ASHR);
2308     }
2309 
2310 
2311 
2312 
2313 
2314 
2315     static long LSHR(long a, long b) {
2316         return (long)((a >>> b));
2317     }
2318 
2319     @Test(dataProvider = "longBinaryOpProvider")
2320     static void LSHRLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2321         long[] a = fa.apply(SPECIES.length());
2322         long[] b = fb.apply(SPECIES.length());
2323         long[] r = fr.apply(SPECIES.length());
2324 
2325         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2326             for (int i = 0; i < a.length; i += SPECIES.length()) {
2327                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2328                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2329                 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
2330             }
2331         }
2332 
2333         assertArraysEquals(r, a, b, Long512VectorTests::LSHR);
2334     }
2335 
2336 
2337 
2338     @Test(dataProvider = "longBinaryOpMaskProvider")
2339     static void LSHRLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2340                                           IntFunction<boolean[]> fm) {
2341         long[] a = fa.apply(SPECIES.length());
2342         long[] b = fb.apply(SPECIES.length());
2343         long[] r = fr.apply(SPECIES.length());
2344         boolean[] mask = fm.apply(SPECIES.length());
2345         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2346 
2347         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2348             for (int i = 0; i < a.length; i += SPECIES.length()) {
2349                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2350                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2351                 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
2352             }
2353         }
2354 
2355         assertArraysEquals(r, a, b, mask, Long512VectorTests::LSHR);
2356     }
2357 
2358 
2359 
2360 
2361 
2362 
2363     static long LSHL_unary(long a, long b) {
2364         return (long)((a << b));
2365     }
2366 
2367     @Test(dataProvider = "longBinaryOpProvider")
2368     static void LSHLLong512VectorTestsScalarShift(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2369         long[] a = fa.apply(SPECIES.length());
2370         long[] b = fb.apply(SPECIES.length());
2371         long[] r = fr.apply(SPECIES.length());
2372 
2373         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2374             for (int i = 0; i < a.length; i += SPECIES.length()) {
2375                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2376                 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
2377             }
2378         }
2379 
2380         assertShiftArraysEquals(r, a, b, Long512VectorTests::LSHL_unary);
2381     }
2382 
2383 
2384 
2385     @Test(dataProvider = "longBinaryOpMaskProvider")
2386     static void LSHLLong512VectorTestsScalarShiftMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2387                                           IntFunction<boolean[]> fm) {
2388         long[] a = fa.apply(SPECIES.length());
2389         long[] b = fb.apply(SPECIES.length());
2390         long[] r = fr.apply(SPECIES.length());
2391         boolean[] mask = fm.apply(SPECIES.length());
2392         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2393 
2394         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2395             for (int i = 0; i < a.length; i += SPECIES.length()) {
2396                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2397                 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
2398             }
2399         }
2400 
2401         assertShiftArraysEquals(r, a, b, mask, Long512VectorTests::LSHL_unary);
2402     }
2403 
2404 
2405 
2406 
2407 
2408 
2409     static long LSHR_unary(long a, long b) {
2410         return (long)((a >>> b));
2411     }
2412 
2413     @Test(dataProvider = "longBinaryOpProvider")
2414     static void LSHRLong512VectorTestsScalarShift(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2415         long[] a = fa.apply(SPECIES.length());
2416         long[] b = fb.apply(SPECIES.length());
2417         long[] r = fr.apply(SPECIES.length());
2418 
2419         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2420             for (int i = 0; i < a.length; i += SPECIES.length()) {
2421                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2422                 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
2423             }
2424         }
2425 
2426         assertShiftArraysEquals(r, a, b, Long512VectorTests::LSHR_unary);
2427     }
2428 
2429 
2430 
2431     @Test(dataProvider = "longBinaryOpMaskProvider")
2432     static void LSHRLong512VectorTestsScalarShiftMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2433                                           IntFunction<boolean[]> fm) {
2434         long[] a = fa.apply(SPECIES.length());
2435         long[] b = fb.apply(SPECIES.length());
2436         long[] r = fr.apply(SPECIES.length());
2437         boolean[] mask = fm.apply(SPECIES.length());
2438         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2439 
2440         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2441             for (int i = 0; i < a.length; i += SPECIES.length()) {
2442                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2443                 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
2444             }
2445         }
2446 
2447         assertShiftArraysEquals(r, a, b, mask, Long512VectorTests::LSHR_unary);
2448     }
2449 
2450 
2451 
2452 
2453 
2454 
2455     static long ASHR_unary(long a, long b) {
2456         return (long)((a >> b));
2457     }
2458 
2459     @Test(dataProvider = "longBinaryOpProvider")
2460     static void ASHRLong512VectorTestsScalarShift(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2461         long[] a = fa.apply(SPECIES.length());
2462         long[] b = fb.apply(SPECIES.length());
2463         long[] r = fr.apply(SPECIES.length());
2464 
2465         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2466             for (int i = 0; i < a.length; i += SPECIES.length()) {
2467                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2468                 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
2469             }
2470         }
2471 
2472         assertShiftArraysEquals(r, a, b, Long512VectorTests::ASHR_unary);
2473     }
2474 
2475 
2476 
2477     @Test(dataProvider = "longBinaryOpMaskProvider")
2478     static void ASHRLong512VectorTestsScalarShiftMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2479                                           IntFunction<boolean[]> fm) {
2480         long[] a = fa.apply(SPECIES.length());
2481         long[] b = fb.apply(SPECIES.length());
2482         long[] r = fr.apply(SPECIES.length());
2483         boolean[] mask = fm.apply(SPECIES.length());
2484         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2485 
2486         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2487             for (int i = 0; i < a.length; i += SPECIES.length()) {
2488                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2489                 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
2490             }
2491         }
2492 
2493         assertShiftArraysEquals(r, a, b, mask, Long512VectorTests::ASHR_unary);
2494     }
2495 
2496 
2497 
2498 
2499 
2500 
2501     static long ROR(long a, long b) {
2502         return (long)(ROR_scalar(a,b));
2503     }
2504 
2505     @Test(dataProvider = "longBinaryOpProvider")
2506     static void RORLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2507         long[] a = fa.apply(SPECIES.length());
2508         long[] b = fb.apply(SPECIES.length());
2509         long[] r = fr.apply(SPECIES.length());
2510 
2511         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2512             for (int i = 0; i < a.length; i += SPECIES.length()) {
2513                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2514                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2515                 av.lanewise(VectorOperators.ROR, bv).intoArray(r, i);
2516             }
2517         }
2518 
2519         assertArraysEquals(r, a, b, Long512VectorTests::ROR);
2520     }
2521 
2522 
2523 
2524     @Test(dataProvider = "longBinaryOpMaskProvider")
2525     static void RORLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2526                                           IntFunction<boolean[]> fm) {
2527         long[] a = fa.apply(SPECIES.length());
2528         long[] b = fb.apply(SPECIES.length());
2529         long[] r = fr.apply(SPECIES.length());
2530         boolean[] mask = fm.apply(SPECIES.length());
2531         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2532 
2533         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2534             for (int i = 0; i < a.length; i += SPECIES.length()) {
2535                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2536                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2537                 av.lanewise(VectorOperators.ROR, bv, vmask).intoArray(r, i);
2538             }
2539         }
2540 
2541         assertArraysEquals(r, a, b, mask, Long512VectorTests::ROR);
2542     }
2543 
2544 
2545     static long ROL(long a, long b) {
2546         return (long)(ROL_scalar(a,b));
2547     }
2548 
2549     @Test(dataProvider = "longBinaryOpProvider")
2550     static void ROLLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2551         long[] a = fa.apply(SPECIES.length());
2552         long[] b = fb.apply(SPECIES.length());
2553         long[] r = fr.apply(SPECIES.length());
2554 
2555         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2556             for (int i = 0; i < a.length; i += SPECIES.length()) {
2557                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2558                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2559                 av.lanewise(VectorOperators.ROL, bv).intoArray(r, i);
2560             }
2561         }
2562 
2563         assertArraysEquals(r, a, b, Long512VectorTests::ROL);
2564     }
2565 
2566 
2567 
2568     @Test(dataProvider = "longBinaryOpMaskProvider")
2569     static void ROLLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2570                                           IntFunction<boolean[]> fm) {
2571         long[] a = fa.apply(SPECIES.length());
2572         long[] b = fb.apply(SPECIES.length());
2573         long[] r = fr.apply(SPECIES.length());
2574         boolean[] mask = fm.apply(SPECIES.length());
2575         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2576 
2577         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2578             for (int i = 0; i < a.length; i += SPECIES.length()) {
2579                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2580                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2581                 av.lanewise(VectorOperators.ROL, bv, vmask).intoArray(r, i);
2582             }
2583         }
2584 
2585         assertArraysEquals(r, a, b, mask, Long512VectorTests::ROL);
2586     }
2587 
2588 
2589     static long ROR_unary(long a, long b) {
2590         return (long)(ROR_scalar(a, b));
2591     }
2592 
2593     @Test(dataProvider = "longBinaryOpProvider")
2594     static void RORLong512VectorTestsScalarShift(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2595         long[] a = fa.apply(SPECIES.length());
2596         long[] b = fb.apply(SPECIES.length());
2597         long[] r = fr.apply(SPECIES.length());
2598 
2599         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2600             for (int i = 0; i < a.length; i += SPECIES.length()) {
2601                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2602                 av.lanewise(VectorOperators.ROR, (int)b[i]).intoArray(r, i);
2603             }
2604         }
2605 
2606         assertShiftArraysEquals(r, a, b, Long512VectorTests::ROR_unary);
2607     }
2608 
2609 
2610 
2611     @Test(dataProvider = "longBinaryOpMaskProvider")
2612     static void RORLong512VectorTestsScalarShiftMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2613                                           IntFunction<boolean[]> fm) {
2614         long[] a = fa.apply(SPECIES.length());
2615         long[] b = fb.apply(SPECIES.length());
2616         long[] r = fr.apply(SPECIES.length());
2617         boolean[] mask = fm.apply(SPECIES.length());
2618         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2619 
2620         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2621             for (int i = 0; i < a.length; i += SPECIES.length()) {
2622                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2623                 av.lanewise(VectorOperators.ROR, (int)b[i], vmask).intoArray(r, i);
2624             }
2625         }
2626 
2627         assertShiftArraysEquals(r, a, b, mask, Long512VectorTests::ROR_unary);
2628     }
2629 
2630 
2631     static long ROL_unary(long a, long b) {
2632         return (long)(ROL_scalar(a, b));
2633     }
2634 
2635     @Test(dataProvider = "longBinaryOpProvider")
2636     static void ROLLong512VectorTestsScalarShift(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2637         long[] a = fa.apply(SPECIES.length());
2638         long[] b = fb.apply(SPECIES.length());
2639         long[] r = fr.apply(SPECIES.length());
2640 
2641         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2642             for (int i = 0; i < a.length; i += SPECIES.length()) {
2643                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2644                 av.lanewise(VectorOperators.ROL, (int)b[i]).intoArray(r, i);
2645             }
2646         }
2647 
2648         assertShiftArraysEquals(r, a, b, Long512VectorTests::ROL_unary);
2649     }
2650 
2651 
2652 
2653     @Test(dataProvider = "longBinaryOpMaskProvider")
2654     static void ROLLong512VectorTestsScalarShiftMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
2655                                           IntFunction<boolean[]> fm) {
2656         long[] a = fa.apply(SPECIES.length());
2657         long[] b = fb.apply(SPECIES.length());
2658         long[] r = fr.apply(SPECIES.length());
2659         boolean[] mask = fm.apply(SPECIES.length());
2660         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2661 
2662         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2663             for (int i = 0; i < a.length; i += SPECIES.length()) {
2664                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2665                 av.lanewise(VectorOperators.ROL, (int)b[i], vmask).intoArray(r, i);
2666             }
2667         }
2668 
2669         assertShiftArraysEquals(r, a, b, mask, Long512VectorTests::ROL_unary);
2670     }
2671 
2672 
2673     static long LSHR_binary_const(long a) {
2674         return (long)((a >>> CONST_SHIFT));
2675     }
2676 
2677     @Test(dataProvider = "longUnaryOpProvider")
2678     static void LSHRLong512VectorTestsScalarShiftConst(IntFunction<long[]> fa) {
2679         long[] a = fa.apply(SPECIES.length());
2680         long[] r = fr.apply(SPECIES.length());
2681 
2682         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2683             for (int i = 0; i < a.length; i += SPECIES.length()) {
2684                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2685                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT).intoArray(r, i);
2686             }
2687         }
2688 
2689         assertShiftConstEquals(r, a, Long512VectorTests::LSHR_binary_const);
2690     }
2691 
2692 
2693 
2694     @Test(dataProvider = "longUnaryOpMaskProvider")
2695     static void LSHRLong512VectorTestsScalarShiftMaskedConst(IntFunction<long[]> fa,
2696                                           IntFunction<boolean[]> fm) {
2697         long[] a = fa.apply(SPECIES.length());
2698         long[] r = fr.apply(SPECIES.length());
2699         boolean[] mask = fm.apply(SPECIES.length());
2700         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2701 
2702         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2703             for (int i = 0; i < a.length; i += SPECIES.length()) {
2704                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2705                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT, vmask).intoArray(r, i);
2706             }
2707         }
2708 
2709         assertShiftConstEquals(r, a, mask, Long512VectorTests::LSHR_binary_const);
2710     }
2711 
2712 
2713 
2714 
2715 
2716 
2717 
2718     static long LSHL_binary_const(long a) {
2719         return (long)((a << CONST_SHIFT));
2720     }
2721 
2722     @Test(dataProvider = "longUnaryOpProvider")
2723     static void LSHLLong512VectorTestsScalarShiftConst(IntFunction<long[]> fa) {
2724         long[] a = fa.apply(SPECIES.length());
2725         long[] r = fr.apply(SPECIES.length());
2726 
2727         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2728             for (int i = 0; i < a.length; i += SPECIES.length()) {
2729                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2730                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT).intoArray(r, i);
2731             }
2732         }
2733 
2734         assertShiftConstEquals(r, a, Long512VectorTests::LSHL_binary_const);
2735     }
2736 
2737 
2738 
2739     @Test(dataProvider = "longUnaryOpMaskProvider")
2740     static void LSHLLong512VectorTestsScalarShiftMaskedConst(IntFunction<long[]> fa,
2741                                           IntFunction<boolean[]> fm) {
2742         long[] a = fa.apply(SPECIES.length());
2743         long[] r = fr.apply(SPECIES.length());
2744         boolean[] mask = fm.apply(SPECIES.length());
2745         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2746 
2747         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2748             for (int i = 0; i < a.length; i += SPECIES.length()) {
2749                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2750                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT, vmask).intoArray(r, i);
2751             }
2752         }
2753 
2754         assertShiftConstEquals(r, a, mask, Long512VectorTests::LSHL_binary_const);
2755     }
2756 
2757 
2758 
2759     static long ASHR_binary_const(long a) {
2760         return (long)((a >> CONST_SHIFT));
2761     }
2762 
2763     @Test(dataProvider = "longUnaryOpProvider")
2764     static void ASHRLong512VectorTestsScalarShiftConst(IntFunction<long[]> fa) {
2765         long[] a = fa.apply(SPECIES.length());
2766         long[] r = fr.apply(SPECIES.length());
2767 
2768         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2769             for (int i = 0; i < a.length; i += SPECIES.length()) {
2770                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2771                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT).intoArray(r, i);
2772             }
2773         }
2774 
2775         assertShiftConstEquals(r, a, Long512VectorTests::ASHR_binary_const);
2776     }
2777 
2778 
2779 
2780     @Test(dataProvider = "longUnaryOpMaskProvider")
2781     static void ASHRLong512VectorTestsScalarShiftMaskedConst(IntFunction<long[]> fa,
2782                                           IntFunction<boolean[]> fm) {
2783         long[] a = fa.apply(SPECIES.length());
2784         long[] r = fr.apply(SPECIES.length());
2785         boolean[] mask = fm.apply(SPECIES.length());
2786         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2787 
2788         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2789             for (int i = 0; i < a.length; i += SPECIES.length()) {
2790                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2791                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT, vmask).intoArray(r, i);
2792             }
2793         }
2794 
2795         assertShiftConstEquals(r, a, mask, Long512VectorTests::ASHR_binary_const);
2796     }
2797 
2798 
2799 
2800     static long ROR_binary_const(long a) {
2801         return (long)(ROR_scalar(a, CONST_SHIFT));
2802     }
2803 
2804     @Test(dataProvider = "longUnaryOpProvider")
2805     static void RORLong512VectorTestsScalarShiftConst(IntFunction<long[]> fa) {
2806         long[] a = fa.apply(SPECIES.length());
2807         long[] r = fr.apply(SPECIES.length());
2808 
2809         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2810             for (int i = 0; i < a.length; i += SPECIES.length()) {
2811                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2812                 av.lanewise(VectorOperators.ROR, CONST_SHIFT).intoArray(r, i);
2813             }
2814         }
2815 
2816         assertShiftConstEquals(r, a, Long512VectorTests::ROR_binary_const);
2817     }
2818 
2819 
2820 
2821     @Test(dataProvider = "longUnaryOpMaskProvider")
2822     static void RORLong512VectorTestsScalarShiftMaskedConst(IntFunction<long[]> fa,
2823                                           IntFunction<boolean[]> fm) {
2824         long[] a = fa.apply(SPECIES.length());
2825         long[] r = fr.apply(SPECIES.length());
2826         boolean[] mask = fm.apply(SPECIES.length());
2827         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2828 
2829         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2830             for (int i = 0; i < a.length; i += SPECIES.length()) {
2831                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2832                 av.lanewise(VectorOperators.ROR, CONST_SHIFT, vmask).intoArray(r, i);
2833             }
2834         }
2835 
2836         assertShiftConstEquals(r, a, mask, Long512VectorTests::ROR_binary_const);
2837     }
2838 
2839 
2840 
2841     static long ROL_binary_const(long a) {
2842         return (long)(ROL_scalar(a, CONST_SHIFT));
2843     }
2844 
2845     @Test(dataProvider = "longUnaryOpProvider")
2846     static void ROLLong512VectorTestsScalarShiftConst(IntFunction<long[]> fa) {
2847         long[] a = fa.apply(SPECIES.length());
2848         long[] r = fr.apply(SPECIES.length());
2849 
2850         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2851             for (int i = 0; i < a.length; i += SPECIES.length()) {
2852                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2853                 av.lanewise(VectorOperators.ROL, CONST_SHIFT).intoArray(r, i);
2854             }
2855         }
2856 
2857         assertShiftConstEquals(r, a, Long512VectorTests::ROL_binary_const);
2858     }
2859 
2860 
2861 
2862     @Test(dataProvider = "longUnaryOpMaskProvider")
2863     static void ROLLong512VectorTestsScalarShiftMaskedConst(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.ROL, CONST_SHIFT, vmask).intoArray(r, i);
2874             }
2875         }
2876 
2877         assertShiftConstEquals(r, a, mask, Long512VectorTests::ROL_binary_const);
2878     }
2879 
2880 
2881     static long MIN(long a, long b) {
2882         return (long)(Math.min(a, b));
2883     }
2884 
2885     @Test(dataProvider = "longBinaryOpProvider")
2886     static void MINLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2887         long[] a = fa.apply(SPECIES.length());
2888         long[] b = fb.apply(SPECIES.length());
2889         long[] r = fr.apply(SPECIES.length());
2890 
2891         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2892             for (int i = 0; i < a.length; i += SPECIES.length()) {
2893                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2894                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2895                 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
2896             }
2897         }
2898 
2899         assertArraysEquals(r, a, b, Long512VectorTests::MIN);
2900     }

2901     static long min(long a, long b) {
2902         return (long)(Math.min(a, b));
2903     }
2904 
2905     @Test(dataProvider = "longBinaryOpProvider")
2906     static void minLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2907         long[] a = fa.apply(SPECIES.length());
2908         long[] b = fb.apply(SPECIES.length());
2909         long[] r = fr.apply(SPECIES.length());
2910 
2911         for (int i = 0; i < a.length; i += SPECIES.length()) {
2912             LongVector av = LongVector.fromArray(SPECIES, a, i);
2913             LongVector bv = LongVector.fromArray(SPECIES, b, i);
2914             av.min(bv).intoArray(r, i);
2915         }
2916 
2917         assertArraysEquals(r, a, b, Long512VectorTests::min);
2918     }

2919     static long MAX(long a, long b) {
2920         return (long)(Math.max(a, b));
2921     }
2922 
2923     @Test(dataProvider = "longBinaryOpProvider")
2924     static void MAXLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2925         long[] a = fa.apply(SPECIES.length());
2926         long[] b = fb.apply(SPECIES.length());
2927         long[] r = fr.apply(SPECIES.length());
2928 
2929         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2930             for (int i = 0; i < a.length; i += SPECIES.length()) {
2931                 LongVector av = LongVector.fromArray(SPECIES, a, i);
2932                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
2933                 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
2934             }
2935         }
2936 
2937         assertArraysEquals(r, a, b, Long512VectorTests::MAX);
2938     }

2939     static long max(long a, long b) {
2940         return (long)(Math.max(a, b));
2941     }
2942 
2943     @Test(dataProvider = "longBinaryOpProvider")
2944     static void maxLong512VectorTests(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.max(bv).intoArray(r, i);
2953         }
2954 
2955         assertArraysEquals(r, a, b, Long512VectorTests::max);
2956     }
2957 
2958     @Test(dataProvider = "longBinaryOpProvider")
2959     static void MINLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2960         long[] a = fa.apply(SPECIES.length());
2961         long[] b = fb.apply(SPECIES.length());
2962         long[] r = fr.apply(SPECIES.length());
2963 
2964         for (int i = 0; i < a.length; i += SPECIES.length()) {
2965             LongVector av = LongVector.fromArray(SPECIES, a, i);
2966             av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
2967         }
2968 
2969         assertBroadcastArraysEquals(r, a, b, Long512VectorTests::MIN);
2970     }
2971 
2972     @Test(dataProvider = "longBinaryOpProvider")
2973     static void minLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2974         long[] a = fa.apply(SPECIES.length());
2975         long[] b = fb.apply(SPECIES.length());
2976         long[] r = fr.apply(SPECIES.length());
2977 
2978         for (int i = 0; i < a.length; i += SPECIES.length()) {
2979             LongVector av = LongVector.fromArray(SPECIES, a, i);
2980             av.min(b[i]).intoArray(r, i);
2981         }
2982 
2983         assertBroadcastArraysEquals(r, a, b, Long512VectorTests::min);
2984     }
2985 
2986     @Test(dataProvider = "longBinaryOpProvider")
2987     static void MAXLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
2988         long[] a = fa.apply(SPECIES.length());
2989         long[] b = fb.apply(SPECIES.length());
2990         long[] r = fr.apply(SPECIES.length());
2991 
2992         for (int i = 0; i < a.length; i += SPECIES.length()) {
2993             LongVector av = LongVector.fromArray(SPECIES, a, i);
2994             av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
2995         }
2996 
2997         assertBroadcastArraysEquals(r, a, b, Long512VectorTests::MAX);
2998     }
2999 
3000     @Test(dataProvider = "longBinaryOpProvider")
3001     static void maxLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3002         long[] a = fa.apply(SPECIES.length());
3003         long[] b = fb.apply(SPECIES.length());
3004         long[] r = fr.apply(SPECIES.length());
3005 
3006         for (int i = 0; i < a.length; i += SPECIES.length()) {
3007             LongVector av = LongVector.fromArray(SPECIES, a, i);
3008             av.max(b[i]).intoArray(r, i);
3009         }
3010 
3011         assertBroadcastArraysEquals(r, a, b, Long512VectorTests::max);
3012     }
3013 
3014     static long ANDReduce(long[] a, int idx) {
3015         long res = -1;
3016         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3017             res &= a[i];
3018         }
3019 
3020         return res;
3021     }
3022 
3023     static long ANDReduceAll(long[] a) {
3024         long res = -1;
3025         for (int i = 0; i < a.length; i += SPECIES.length()) {
3026             res &= ANDReduce(a, i);
3027         }
3028 
3029         return res;
3030     }
3031 
3032 
3033     @Test(dataProvider = "longUnaryOpProvider")
3034     static void ANDReduceLong512VectorTests(IntFunction<long[]> fa) {
3035         long[] a = fa.apply(SPECIES.length());
3036         long[] r = fr.apply(SPECIES.length());
3037         long ra = -1;
3038 
3039         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3040             for (int i = 0; i < a.length; i += SPECIES.length()) {
3041                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3042                 r[i] = av.reduceLanes(VectorOperators.AND);
3043             }
3044         }
3045 
3046         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3047             ra = -1;
3048             for (int i = 0; i < a.length; i += SPECIES.length()) {
3049                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3050                 ra &= av.reduceLanes(VectorOperators.AND);
3051             }
3052         }
3053 
3054         assertReductionArraysEquals(r, ra, a,
3055                 Long512VectorTests::ANDReduce, Long512VectorTests::ANDReduceAll);
3056     }
3057 
3058 
3059     static long ANDReduceMasked(long[] a, int idx, boolean[] mask) {
3060         long res = -1;
3061         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3062             if (mask[i % SPECIES.length()])
3063                 res &= a[i];
3064         }
3065 
3066         return res;
3067     }
3068 
3069     static long ANDReduceAllMasked(long[] a, boolean[] mask) {
3070         long res = -1;
3071         for (int i = 0; i < a.length; i += SPECIES.length()) {
3072             res &= ANDReduceMasked(a, i, mask);
3073         }
3074 
3075         return res;
3076     }
3077 
3078 
3079     @Test(dataProvider = "longUnaryOpMaskProvider")
3080     static void ANDReduceLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3081         long[] a = fa.apply(SPECIES.length());
3082         long[] r = fr.apply(SPECIES.length());
3083         boolean[] mask = fm.apply(SPECIES.length());
3084         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3085         long ra = -1;
3086 
3087         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3088             for (int i = 0; i < a.length; i += SPECIES.length()) {
3089                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3090                 r[i] = av.reduceLanes(VectorOperators.AND, vmask);
3091             }
3092         }
3093 
3094         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3095             ra = -1;
3096             for (int i = 0; i < a.length; i += SPECIES.length()) {
3097                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3098                 ra &= av.reduceLanes(VectorOperators.AND, vmask);
3099             }
3100         }
3101 
3102         assertReductionArraysEqualsMasked(r, ra, a, mask,
3103                 Long512VectorTests::ANDReduceMasked, Long512VectorTests::ANDReduceAllMasked);
3104     }
3105 
3106 
3107     static long ORReduce(long[] a, int idx) {
3108         long res = 0;
3109         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3110             res |= a[i];
3111         }
3112 
3113         return res;
3114     }
3115 
3116     static long ORReduceAll(long[] a) {
3117         long res = 0;
3118         for (int i = 0; i < a.length; i += SPECIES.length()) {
3119             res |= ORReduce(a, i);
3120         }
3121 
3122         return res;
3123     }
3124 
3125 
3126     @Test(dataProvider = "longUnaryOpProvider")
3127     static void ORReduceLong512VectorTests(IntFunction<long[]> fa) {
3128         long[] a = fa.apply(SPECIES.length());
3129         long[] r = fr.apply(SPECIES.length());
3130         long ra = 0;
3131 
3132         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3133             for (int i = 0; i < a.length; i += SPECIES.length()) {
3134                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3135                 r[i] = av.reduceLanes(VectorOperators.OR);
3136             }
3137         }
3138 
3139         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3140             ra = 0;
3141             for (int i = 0; i < a.length; i += SPECIES.length()) {
3142                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3143                 ra |= av.reduceLanes(VectorOperators.OR);
3144             }
3145         }
3146 
3147         assertReductionArraysEquals(r, ra, a,
3148                 Long512VectorTests::ORReduce, Long512VectorTests::ORReduceAll);
3149     }
3150 
3151 
3152     static long ORReduceMasked(long[] a, int idx, boolean[] mask) {
3153         long res = 0;
3154         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3155             if (mask[i % SPECIES.length()])
3156                 res |= a[i];
3157         }
3158 
3159         return res;
3160     }
3161 
3162     static long ORReduceAllMasked(long[] a, boolean[] mask) {
3163         long res = 0;
3164         for (int i = 0; i < a.length; i += SPECIES.length()) {
3165             res |= ORReduceMasked(a, i, mask);
3166         }
3167 
3168         return res;
3169     }
3170 
3171 
3172     @Test(dataProvider = "longUnaryOpMaskProvider")
3173     static void ORReduceLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3174         long[] a = fa.apply(SPECIES.length());
3175         long[] r = fr.apply(SPECIES.length());
3176         boolean[] mask = fm.apply(SPECIES.length());
3177         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3178         long ra = 0;
3179 
3180         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3181             for (int i = 0; i < a.length; i += SPECIES.length()) {
3182                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3183                 r[i] = av.reduceLanes(VectorOperators.OR, vmask);
3184             }
3185         }
3186 
3187         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3188             ra = 0;
3189             for (int i = 0; i < a.length; i += SPECIES.length()) {
3190                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3191                 ra |= av.reduceLanes(VectorOperators.OR, vmask);
3192             }
3193         }
3194 
3195         assertReductionArraysEqualsMasked(r, ra, a, mask,
3196                 Long512VectorTests::ORReduceMasked, Long512VectorTests::ORReduceAllMasked);
3197     }
3198 
3199 
3200     static long XORReduce(long[] a, int idx) {
3201         long res = 0;
3202         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3203             res ^= a[i];
3204         }
3205 
3206         return res;
3207     }
3208 
3209     static long XORReduceAll(long[] a) {
3210         long res = 0;
3211         for (int i = 0; i < a.length; i += SPECIES.length()) {
3212             res ^= XORReduce(a, i);
3213         }
3214 
3215         return res;
3216     }
3217 
3218 
3219     @Test(dataProvider = "longUnaryOpProvider")
3220     static void XORReduceLong512VectorTests(IntFunction<long[]> fa) {
3221         long[] a = fa.apply(SPECIES.length());
3222         long[] r = fr.apply(SPECIES.length());
3223         long ra = 0;
3224 
3225         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3226             for (int i = 0; i < a.length; i += SPECIES.length()) {
3227                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3228                 r[i] = av.reduceLanes(VectorOperators.XOR);
3229             }
3230         }
3231 
3232         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3233             ra = 0;
3234             for (int i = 0; i < a.length; i += SPECIES.length()) {
3235                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3236                 ra ^= av.reduceLanes(VectorOperators.XOR);
3237             }
3238         }
3239 
3240         assertReductionArraysEquals(r, ra, a,
3241                 Long512VectorTests::XORReduce, Long512VectorTests::XORReduceAll);
3242     }
3243 
3244 
3245     static long XORReduceMasked(long[] a, int idx, boolean[] mask) {
3246         long res = 0;
3247         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3248             if (mask[i % SPECIES.length()])
3249                 res ^= a[i];
3250         }
3251 
3252         return res;
3253     }
3254 
3255     static long XORReduceAllMasked(long[] a, boolean[] mask) {
3256         long res = 0;
3257         for (int i = 0; i < a.length; i += SPECIES.length()) {
3258             res ^= XORReduceMasked(a, i, mask);
3259         }
3260 
3261         return res;
3262     }
3263 
3264 
3265     @Test(dataProvider = "longUnaryOpMaskProvider")
3266     static void XORReduceLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3267         long[] a = fa.apply(SPECIES.length());
3268         long[] r = fr.apply(SPECIES.length());
3269         boolean[] mask = fm.apply(SPECIES.length());
3270         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3271         long ra = 0;
3272 
3273         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3274             for (int i = 0; i < a.length; i += SPECIES.length()) {
3275                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3276                 r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
3277             }
3278         }
3279 
3280         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3281             ra = 0;
3282             for (int i = 0; i < a.length; i += SPECIES.length()) {
3283                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3284                 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
3285             }
3286         }
3287 
3288         assertReductionArraysEqualsMasked(r, ra, a, mask,
3289                 Long512VectorTests::XORReduceMasked, Long512VectorTests::XORReduceAllMasked);
3290     }
3291 
3292     static long ADDReduce(long[] a, int idx) {
3293         long res = 0;
3294         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3295             res += a[i];
3296         }
3297 
3298         return res;
3299     }
3300 
3301     static long ADDReduceAll(long[] a) {
3302         long res = 0;
3303         for (int i = 0; i < a.length; i += SPECIES.length()) {
3304             res += ADDReduce(a, i);
3305         }
3306 
3307         return res;
3308     }

3309     @Test(dataProvider = "longUnaryOpProvider")
3310     static void ADDReduceLong512VectorTests(IntFunction<long[]> fa) {
3311         long[] a = fa.apply(SPECIES.length());
3312         long[] r = fr.apply(SPECIES.length());
3313         long ra = 0;
3314 
3315         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3316             for (int i = 0; i < a.length; i += SPECIES.length()) {
3317                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3318                 r[i] = av.reduceLanes(VectorOperators.ADD);
3319             }
3320         }
3321 
3322         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3323             ra = 0;
3324             for (int i = 0; i < a.length; i += SPECIES.length()) {
3325                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3326                 ra += av.reduceLanes(VectorOperators.ADD);
3327             }
3328         }
3329 
3330         assertReductionArraysEquals(r, ra, a,
3331                 Long512VectorTests::ADDReduce, Long512VectorTests::ADDReduceAll);
3332     }

3333     static long ADDReduceMasked(long[] a, int idx, boolean[] mask) {
3334         long res = 0;
3335         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3336             if (mask[i % SPECIES.length()])
3337                 res += a[i];
3338         }
3339 
3340         return res;
3341     }
3342 
3343     static long ADDReduceAllMasked(long[] a, boolean[] mask) {
3344         long res = 0;
3345         for (int i = 0; i < a.length; i += SPECIES.length()) {
3346             res += ADDReduceMasked(a, i, mask);
3347         }
3348 
3349         return res;
3350     }

3351     @Test(dataProvider = "longUnaryOpMaskProvider")
3352     static void ADDReduceLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3353         long[] a = fa.apply(SPECIES.length());
3354         long[] r = fr.apply(SPECIES.length());
3355         boolean[] mask = fm.apply(SPECIES.length());
3356         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3357         long ra = 0;
3358 
3359         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3360             for (int i = 0; i < a.length; i += SPECIES.length()) {
3361                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3362                 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
3363             }
3364         }
3365 
3366         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3367             ra = 0;
3368             for (int i = 0; i < a.length; i += SPECIES.length()) {
3369                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3370                 ra += av.reduceLanes(VectorOperators.ADD, vmask);
3371             }
3372         }
3373 
3374         assertReductionArraysEqualsMasked(r, ra, a, mask,
3375                 Long512VectorTests::ADDReduceMasked, Long512VectorTests::ADDReduceAllMasked);
3376     }

3377     static long MULReduce(long[] a, int idx) {
3378         long res = 1;
3379         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3380             res *= a[i];
3381         }
3382 
3383         return res;
3384     }
3385 
3386     static long MULReduceAll(long[] a) {
3387         long res = 1;
3388         for (int i = 0; i < a.length; i += SPECIES.length()) {
3389             res *= MULReduce(a, i);
3390         }
3391 
3392         return res;
3393     }

3394     @Test(dataProvider = "longUnaryOpProvider")
3395     static void MULReduceLong512VectorTests(IntFunction<long[]> fa) {
3396         long[] a = fa.apply(SPECIES.length());
3397         long[] r = fr.apply(SPECIES.length());
3398         long ra = 1;
3399 
3400         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3401             for (int i = 0; i < a.length; i += SPECIES.length()) {
3402                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3403                 r[i] = av.reduceLanes(VectorOperators.MUL);
3404             }
3405         }
3406 
3407         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3408             ra = 1;
3409             for (int i = 0; i < a.length; i += SPECIES.length()) {
3410                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3411                 ra *= av.reduceLanes(VectorOperators.MUL);
3412             }
3413         }
3414 
3415         assertReductionArraysEquals(r, ra, a,
3416                 Long512VectorTests::MULReduce, Long512VectorTests::MULReduceAll);
3417     }

3418     static long MULReduceMasked(long[] a, int idx, boolean[] mask) {
3419         long res = 1;
3420         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3421             if (mask[i % SPECIES.length()])
3422                 res *= a[i];
3423         }
3424 
3425         return res;
3426     }
3427 
3428     static long MULReduceAllMasked(long[] a, boolean[] mask) {
3429         long res = 1;
3430         for (int i = 0; i < a.length; i += SPECIES.length()) {
3431             res *= MULReduceMasked(a, i, mask);
3432         }
3433 
3434         return res;
3435     }

3436     @Test(dataProvider = "longUnaryOpMaskProvider")
3437     static void MULReduceLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3438         long[] a = fa.apply(SPECIES.length());
3439         long[] r = fr.apply(SPECIES.length());
3440         boolean[] mask = fm.apply(SPECIES.length());
3441         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3442         long ra = 1;
3443 
3444         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3445             for (int i = 0; i < a.length; i += SPECIES.length()) {
3446                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3447                 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
3448             }
3449         }
3450 
3451         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3452             ra = 1;
3453             for (int i = 0; i < a.length; i += SPECIES.length()) {
3454                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3455                 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
3456             }
3457         }
3458 
3459         assertReductionArraysEqualsMasked(r, ra, a, mask,
3460                 Long512VectorTests::MULReduceMasked, Long512VectorTests::MULReduceAllMasked);
3461     }

3462     static long MINReduce(long[] a, int idx) {
3463         long res = Long.MAX_VALUE;
3464         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3465             res = (long) Math.min(res, a[i]);
3466         }
3467 
3468         return res;
3469     }
3470 
3471     static long MINReduceAll(long[] a) {
3472         long res = Long.MAX_VALUE;
3473         for (int i = 0; i < a.length; i += SPECIES.length()) {
3474             res = (long) Math.min(res, MINReduce(a, i));
3475         }
3476 
3477         return res;
3478     }

3479     @Test(dataProvider = "longUnaryOpProvider")
3480     static void MINReduceLong512VectorTests(IntFunction<long[]> fa) {
3481         long[] a = fa.apply(SPECIES.length());
3482         long[] r = fr.apply(SPECIES.length());
3483         long ra = Long.MAX_VALUE;
3484 
3485         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3486             for (int i = 0; i < a.length; i += SPECIES.length()) {
3487                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3488                 r[i] = av.reduceLanes(VectorOperators.MIN);
3489             }
3490         }
3491 
3492         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3493             ra = Long.MAX_VALUE;
3494             for (int i = 0; i < a.length; i += SPECIES.length()) {
3495                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3496                 ra = (long) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
3497             }
3498         }
3499 
3500         assertReductionArraysEquals(r, ra, a,
3501                 Long512VectorTests::MINReduce, Long512VectorTests::MINReduceAll);
3502     }

3503     static long MINReduceMasked(long[] a, int idx, boolean[] mask) {
3504         long res = Long.MAX_VALUE;
3505         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3506             if (mask[i % SPECIES.length()])
3507                 res = (long) Math.min(res, a[i]);
3508         }
3509 
3510         return res;
3511     }
3512 
3513     static long MINReduceAllMasked(long[] a, boolean[] mask) {
3514         long res = Long.MAX_VALUE;
3515         for (int i = 0; i < a.length; i += SPECIES.length()) {
3516             res = (long) Math.min(res, MINReduceMasked(a, i, mask));
3517         }
3518 
3519         return res;
3520     }

3521     @Test(dataProvider = "longUnaryOpMaskProvider")
3522     static void MINReduceLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3523         long[] a = fa.apply(SPECIES.length());
3524         long[] r = fr.apply(SPECIES.length());
3525         boolean[] mask = fm.apply(SPECIES.length());
3526         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3527         long ra = Long.MAX_VALUE;
3528 
3529         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3530             for (int i = 0; i < a.length; i += SPECIES.length()) {
3531                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3532                 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
3533             }
3534         }
3535 
3536         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3537             ra = Long.MAX_VALUE;
3538             for (int i = 0; i < a.length; i += SPECIES.length()) {
3539                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3540                 ra = (long) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
3541             }
3542         }
3543 
3544         assertReductionArraysEqualsMasked(r, ra, a, mask,
3545                 Long512VectorTests::MINReduceMasked, Long512VectorTests::MINReduceAllMasked);
3546     }

3547     static long MAXReduce(long[] a, int idx) {
3548         long res = Long.MIN_VALUE;
3549         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3550             res = (long) Math.max(res, a[i]);
3551         }
3552 
3553         return res;
3554     }
3555 
3556     static long MAXReduceAll(long[] a) {
3557         long res = Long.MIN_VALUE;
3558         for (int i = 0; i < a.length; i += SPECIES.length()) {
3559             res = (long) Math.max(res, MAXReduce(a, i));
3560         }
3561 
3562         return res;
3563     }

3564     @Test(dataProvider = "longUnaryOpProvider")
3565     static void MAXReduceLong512VectorTests(IntFunction<long[]> fa) {
3566         long[] a = fa.apply(SPECIES.length());
3567         long[] r = fr.apply(SPECIES.length());
3568         long ra = Long.MIN_VALUE;
3569 
3570         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3571             for (int i = 0; i < a.length; i += SPECIES.length()) {
3572                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3573                 r[i] = av.reduceLanes(VectorOperators.MAX);
3574             }
3575         }
3576 
3577         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3578             ra = Long.MIN_VALUE;
3579             for (int i = 0; i < a.length; i += SPECIES.length()) {
3580                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3581                 ra = (long) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
3582             }
3583         }
3584 
3585         assertReductionArraysEquals(r, ra, a,
3586                 Long512VectorTests::MAXReduce, Long512VectorTests::MAXReduceAll);
3587     }

3588     static long MAXReduceMasked(long[] a, int idx, boolean[] mask) {
3589         long res = Long.MIN_VALUE;
3590         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3591             if (mask[i % SPECIES.length()])
3592                 res = (long) Math.max(res, a[i]);
3593         }
3594 
3595         return res;
3596     }
3597 
3598     static long MAXReduceAllMasked(long[] a, boolean[] mask) {
3599         long res = Long.MIN_VALUE;
3600         for (int i = 0; i < a.length; i += SPECIES.length()) {
3601             res = (long) Math.max(res, MAXReduceMasked(a, i, mask));
3602         }
3603 
3604         return res;
3605     }

3606     @Test(dataProvider = "longUnaryOpMaskProvider")
3607     static void MAXReduceLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3608         long[] a = fa.apply(SPECIES.length());
3609         long[] r = fr.apply(SPECIES.length());
3610         boolean[] mask = fm.apply(SPECIES.length());
3611         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3612         long ra = Long.MIN_VALUE;
3613 
3614         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3615             for (int i = 0; i < a.length; i += SPECIES.length()) {
3616                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3617                 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
3618             }
3619         }
3620 
3621         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3622             ra = Long.MIN_VALUE;
3623             for (int i = 0; i < a.length; i += SPECIES.length()) {
3624                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3625                 ra = (long) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
3626             }
3627         }
3628 
3629         assertReductionArraysEqualsMasked(r, ra, a, mask,
3630                 Long512VectorTests::MAXReduceMasked, Long512VectorTests::MAXReduceAllMasked);
3631     }

3632     static long FIRST_NONZEROReduce(long[] a, int idx) {
3633         long res = (long) 0;
3634         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3635             res = firstNonZero(res, a[i]);
3636         }
3637 
3638         return res;
3639     }
3640 
3641     static long FIRST_NONZEROReduceAll(long[] a) {
3642         long res = (long) 0;
3643         for (int i = 0; i < a.length; i += SPECIES.length()) {
3644             res = firstNonZero(res, FIRST_NONZEROReduce(a, i));
3645         }
3646 
3647         return res;
3648     }

3649     @Test(dataProvider = "longUnaryOpProvider")
3650     static void FIRST_NONZEROReduceLong512VectorTests(IntFunction<long[]> fa) {
3651         long[] a = fa.apply(SPECIES.length());
3652         long[] r = fr.apply(SPECIES.length());
3653         long ra = (long) 0;
3654 
3655         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3656             for (int i = 0; i < a.length; i += SPECIES.length()) {
3657                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3658                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO);
3659             }
3660         }
3661 
3662         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3663             ra = (long) 0;
3664             for (int i = 0; i < a.length; i += SPECIES.length()) {
3665                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3666                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
3667             }
3668         }
3669 
3670         assertReductionArraysEquals(r, ra, a,
3671                 Long512VectorTests::FIRST_NONZEROReduce, Long512VectorTests::FIRST_NONZEROReduceAll);
3672     }

3673     static long FIRST_NONZEROReduceMasked(long[] a, int idx, boolean[] mask) {
3674         long res = (long) 0;
3675         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3676             if (mask[i % SPECIES.length()])
3677                 res = firstNonZero(res, a[i]);
3678         }
3679 
3680         return res;
3681     }
3682 
3683     static long FIRST_NONZEROReduceAllMasked(long[] a, boolean[] mask) {
3684         long res = (long) 0;
3685         for (int i = 0; i < a.length; i += SPECIES.length()) {
3686             res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask));
3687         }
3688 
3689         return res;
3690     }

3691     @Test(dataProvider = "longUnaryOpMaskProvider")
3692     static void FIRST_NONZEROReduceLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
3693         long[] a = fa.apply(SPECIES.length());
3694         long[] r = fr.apply(SPECIES.length());
3695         boolean[] mask = fm.apply(SPECIES.length());
3696         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3697         long ra = (long) 0;
3698 
3699         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3700             for (int i = 0; i < a.length; i += SPECIES.length()) {
3701                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3702                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask);
3703             }
3704         }
3705 
3706         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3707             ra = (long) 0;
3708             for (int i = 0; i < a.length; i += SPECIES.length()) {
3709                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3710                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
3711             }
3712         }
3713 
3714         assertReductionArraysEqualsMasked(r, ra, a, mask,
3715                 Long512VectorTests::FIRST_NONZEROReduceMasked, Long512VectorTests::FIRST_NONZEROReduceAllMasked);
3716     }
3717 
3718     static boolean anyTrue(boolean[] a, int idx) {
3719         boolean res = false;
3720         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3721             res |= a[i];
3722         }
3723 
3724         return res;
3725     }
3726 
3727 
3728     @Test(dataProvider = "boolUnaryOpProvider")
3729     static void anyTrueLong512VectorTests(IntFunction<boolean[]> fm) {
3730         boolean[] mask = fm.apply(SPECIES.length());
3731         boolean[] r = fmr.apply(SPECIES.length());
3732 
3733         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3734             for (int i = 0; i < mask.length; i += SPECIES.length()) {
3735                 VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, i);
3736                 r[i] = vmask.anyTrue();
3737             }
3738         }
3739 
3740         assertReductionBoolArraysEquals(r, mask, Long512VectorTests::anyTrue);
3741     }
3742 
3743 
3744     static boolean allTrue(boolean[] a, int idx) {
3745         boolean res = true;
3746         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3747             res &= a[i];
3748         }
3749 
3750         return res;
3751     }
3752 
3753 
3754     @Test(dataProvider = "boolUnaryOpProvider")
3755     static void allTrueLong512VectorTests(IntFunction<boolean[]> fm) {
3756         boolean[] mask = fm.apply(SPECIES.length());
3757         boolean[] r = fmr.apply(SPECIES.length());
3758 
3759         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3760             for (int i = 0; i < mask.length; i += SPECIES.length()) {
3761                 VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, i);
3762                 r[i] = vmask.allTrue();
3763             }
3764         }
3765 
3766         assertReductionBoolArraysEquals(r, mask, Long512VectorTests::allTrue);
3767     }
3768 
3769 
3770     @Test(dataProvider = "longUnaryOpProvider")
3771     static void withLong512VectorTests(IntFunction<long []> fa) {
3772         long[] a = fa.apply(SPECIES.length());
3773         long[] r = fr.apply(SPECIES.length());
3774 
3775         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3776             for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
3777                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3778                 av.withLane((j++ & (SPECIES.length()-1)), (long)(65535+i)).intoArray(r, i);
3779             }
3780         }
3781 
3782 
3783         for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
3784             assertInsertArraysEquals(r, a, (long)(65535+i), (j++ & (SPECIES.length()-1)), i , i + SPECIES.length());
3785         }
3786     }

3787     static boolean testIS_DEFAULT(long a) {
3788         return bits(a)==0;
3789     }
3790 
3791     @Test(dataProvider = "longTestOpProvider")
3792     static void IS_DEFAULTLong512VectorTests(IntFunction<long[]> fa) {
3793         long[] a = fa.apply(SPECIES.length());
3794 
3795         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3796             for (int i = 0; i < a.length; i += SPECIES.length()) {
3797                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3798                 VectorMask<Long> mv = av.test(VectorOperators.IS_DEFAULT);
3799 
3800                 // Check results as part of computation.
3801                 for (int j = 0; j < SPECIES.length(); j++) {
3802                     Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
3803                 }
3804             }
3805         }
3806     }
3807 
3808     @Test(dataProvider = "longTestOpMaskProvider")
3809     static void IS_DEFAULTMaskedLong512VectorTests(IntFunction<long[]> fa,
3810                                           IntFunction<boolean[]> fm) {
3811         long[] a = fa.apply(SPECIES.length());
3812         boolean[] mask = fm.apply(SPECIES.length());
3813         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3814 
3815         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3816             for (int i = 0; i < a.length; i += SPECIES.length()) {
3817                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3818                 VectorMask<Long> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
3819 
3820                 // Check results as part of computation.
3821                 for (int j = 0; j < SPECIES.length(); j++) {
3822                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
3823                 }
3824             }
3825         }
3826     }

3827     static boolean testIS_NEGATIVE(long a) {
3828         return bits(a)<0;
3829     }
3830 
3831     @Test(dataProvider = "longTestOpProvider")
3832     static void IS_NEGATIVELong512VectorTests(IntFunction<long[]> fa) {
3833         long[] a = fa.apply(SPECIES.length());
3834 
3835         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3836             for (int i = 0; i < a.length; i += SPECIES.length()) {
3837                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3838                 VectorMask<Long> mv = av.test(VectorOperators.IS_NEGATIVE);
3839 
3840                 // Check results as part of computation.
3841                 for (int j = 0; j < SPECIES.length(); j++) {
3842                     Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
3843                 }
3844             }
3845         }
3846     }
3847 
3848     @Test(dataProvider = "longTestOpMaskProvider")
3849     static void IS_NEGATIVEMaskedLong512VectorTests(IntFunction<long[]> fa,
3850                                           IntFunction<boolean[]> fm) {
3851         long[] a = fa.apply(SPECIES.length());
3852         boolean[] mask = fm.apply(SPECIES.length());
3853         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3854 
3855         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3856             for (int i = 0; i < a.length; i += SPECIES.length()) {
3857                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3858                 VectorMask<Long> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
3859 
3860                 // Check results as part of computation.
3861                 for (int j = 0; j < SPECIES.length(); j++) {
3862                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
3863                 }
3864             }
3865         }
3866     }
3867 
3868 
3869 
3870 
3871     @Test(dataProvider = "longCompareOpProvider")
3872     static void LTLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3873         long[] a = fa.apply(SPECIES.length());
3874         long[] b = fb.apply(SPECIES.length());
3875 
3876         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3877             for (int i = 0; i < a.length; i += SPECIES.length()) {
3878                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3879                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
3880                 VectorMask<Long> mv = av.compare(VectorOperators.LT, bv);
3881 
3882                 // Check results as part of computation.
3883                 for (int j = 0; j < SPECIES.length(); j++) {
3884                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3885                 }
3886             }
3887         }
3888     }
3889 
3890 
3891     @Test(dataProvider = "longCompareOpProvider")
3892     static void ltLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3893         long[] a = fa.apply(SPECIES.length());
3894         long[] b = fb.apply(SPECIES.length());
3895 
3896         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3897             for (int i = 0; i < a.length; i += SPECIES.length()) {
3898                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3899                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
3900                 VectorMask<Long> mv = av.lt(bv);
3901 
3902                 // Check results as part of computation.
3903                 for (int j = 0; j < SPECIES.length(); j++) {
3904                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3905                 }
3906             }
3907         }
3908     }
3909 
3910     @Test(dataProvider = "longCompareOpMaskProvider")
3911     static void LTLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
3912                                                 IntFunction<boolean[]> fm) {
3913         long[] a = fa.apply(SPECIES.length());
3914         long[] b = fb.apply(SPECIES.length());
3915         boolean[] mask = fm.apply(SPECIES.length());
3916 
3917         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
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, vmask);
3924 
3925                 // Check results as part of computation.
3926                 for (int j = 0; j < SPECIES.length(); j++) {
3927                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
3928                 }
3929             }
3930         }
3931     }
3932 
3933 
3934     @Test(dataProvider = "longCompareOpProvider")
3935     static void GTLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3936         long[] a = fa.apply(SPECIES.length());
3937         long[] b = fb.apply(SPECIES.length());
3938 
3939         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3940             for (int i = 0; i < a.length; i += SPECIES.length()) {
3941                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3942                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
3943                 VectorMask<Long> mv = av.compare(VectorOperators.GT, bv);
3944 
3945                 // Check results as part of computation.
3946                 for (int j = 0; j < SPECIES.length(); j++) {
3947                     Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
3948                 }
3949             }
3950         }
3951     }
3952 
3953     @Test(dataProvider = "longCompareOpMaskProvider")
3954     static void GTLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
3955                                                 IntFunction<boolean[]> fm) {
3956         long[] a = fa.apply(SPECIES.length());
3957         long[] b = fb.apply(SPECIES.length());
3958         boolean[] mask = fm.apply(SPECIES.length());
3959 
3960         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3961 
3962         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3963             for (int i = 0; i < a.length; i += SPECIES.length()) {
3964                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3965                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
3966                 VectorMask<Long> mv = av.compare(VectorOperators.GT, bv, vmask);
3967 
3968                 // Check results as part of computation.
3969                 for (int j = 0; j < SPECIES.length(); j++) {
3970                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
3971                 }
3972             }
3973         }
3974     }
3975 
3976 
3977     @Test(dataProvider = "longCompareOpProvider")
3978     static void EQLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3979         long[] a = fa.apply(SPECIES.length());
3980         long[] b = fb.apply(SPECIES.length());
3981 
3982         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3983             for (int i = 0; i < a.length; i += SPECIES.length()) {
3984                 LongVector av = LongVector.fromArray(SPECIES, a, i);
3985                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
3986                 VectorMask<Long> mv = av.compare(VectorOperators.EQ, bv);
3987 
3988                 // Check results as part of computation.
3989                 for (int j = 0; j < SPECIES.length(); j++) {
3990                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
3991                 }
3992             }
3993         }
3994     }
3995 
3996 
3997     @Test(dataProvider = "longCompareOpProvider")
3998     static void eqLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
3999         long[] a = fa.apply(SPECIES.length());
4000         long[] b = fb.apply(SPECIES.length());
4001 
4002         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4003             for (int i = 0; i < a.length; i += SPECIES.length()) {
4004                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4005                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4006                 VectorMask<Long> mv = av.eq(bv);
4007 
4008                 // Check results as part of computation.
4009                 for (int j = 0; j < SPECIES.length(); j++) {
4010                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
4011                 }
4012             }
4013         }
4014     }
4015 
4016     @Test(dataProvider = "longCompareOpMaskProvider")
4017     static void EQLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4018                                                 IntFunction<boolean[]> fm) {
4019         long[] a = fa.apply(SPECIES.length());
4020         long[] b = fb.apply(SPECIES.length());
4021         boolean[] mask = fm.apply(SPECIES.length());
4022 
4023         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4024 
4025         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4026             for (int i = 0; i < a.length; i += SPECIES.length()) {
4027                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4028                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4029                 VectorMask<Long> mv = av.compare(VectorOperators.EQ, bv, vmask);
4030 
4031                 // Check results as part of computation.
4032                 for (int j = 0; j < SPECIES.length(); j++) {
4033                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
4034                 }
4035             }
4036         }
4037     }
4038 
4039 
4040     @Test(dataProvider = "longCompareOpProvider")
4041     static void NELong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4042         long[] a = fa.apply(SPECIES.length());
4043         long[] b = fb.apply(SPECIES.length());
4044 
4045         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4046             for (int i = 0; i < a.length; i += SPECIES.length()) {
4047                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4048                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4049                 VectorMask<Long> mv = av.compare(VectorOperators.NE, bv);
4050 
4051                 // Check results as part of computation.
4052                 for (int j = 0; j < SPECIES.length(); j++) {
4053                     Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
4054                 }
4055             }
4056         }
4057     }
4058 
4059     @Test(dataProvider = "longCompareOpMaskProvider")
4060     static void NELong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4061                                                 IntFunction<boolean[]> fm) {
4062         long[] a = fa.apply(SPECIES.length());
4063         long[] b = fb.apply(SPECIES.length());
4064         boolean[] mask = fm.apply(SPECIES.length());
4065 
4066         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4067 
4068         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4069             for (int i = 0; i < a.length; i += SPECIES.length()) {
4070                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4071                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4072                 VectorMask<Long> mv = av.compare(VectorOperators.NE, bv, vmask);
4073 
4074                 // Check results as part of computation.
4075                 for (int j = 0; j < SPECIES.length(); j++) {
4076                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
4077                 }
4078             }
4079         }
4080     }
4081 
4082 
4083     @Test(dataProvider = "longCompareOpProvider")
4084     static void LELong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4085         long[] a = fa.apply(SPECIES.length());
4086         long[] b = fb.apply(SPECIES.length());
4087 
4088         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4089             for (int i = 0; i < a.length; i += SPECIES.length()) {
4090                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4091                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4092                 VectorMask<Long> mv = av.compare(VectorOperators.LE, bv);
4093 
4094                 // Check results as part of computation.
4095                 for (int j = 0; j < SPECIES.length(); j++) {
4096                     Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
4097                 }
4098             }
4099         }
4100     }
4101 
4102     @Test(dataProvider = "longCompareOpMaskProvider")
4103     static void LELong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4104                                                 IntFunction<boolean[]> fm) {
4105         long[] a = fa.apply(SPECIES.length());
4106         long[] b = fb.apply(SPECIES.length());
4107         boolean[] mask = fm.apply(SPECIES.length());
4108 
4109         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4110 
4111         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4112             for (int i = 0; i < a.length; i += SPECIES.length()) {
4113                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4114                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4115                 VectorMask<Long> mv = av.compare(VectorOperators.LE, bv, vmask);
4116 
4117                 // Check results as part of computation.
4118                 for (int j = 0; j < SPECIES.length(); j++) {
4119                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
4120                 }
4121             }
4122         }
4123     }
4124 
4125 
4126     @Test(dataProvider = "longCompareOpProvider")
4127     static void GELong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4128         long[] a = fa.apply(SPECIES.length());
4129         long[] b = fb.apply(SPECIES.length());
4130 
4131         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4132             for (int i = 0; i < a.length; i += SPECIES.length()) {
4133                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4134                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4135                 VectorMask<Long> mv = av.compare(VectorOperators.GE, bv);
4136 
4137                 // Check results as part of computation.
4138                 for (int j = 0; j < SPECIES.length(); j++) {
4139                     Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
4140                 }
4141             }
4142         }
4143     }
4144 
4145     @Test(dataProvider = "longCompareOpMaskProvider")
4146     static void GELong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4147                                                 IntFunction<boolean[]> fm) {
4148         long[] a = fa.apply(SPECIES.length());
4149         long[] b = fb.apply(SPECIES.length());
4150         boolean[] mask = fm.apply(SPECIES.length());
4151 
4152         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4153 
4154         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4155             for (int i = 0; i < a.length; i += SPECIES.length()) {
4156                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4157                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4158                 VectorMask<Long> mv = av.compare(VectorOperators.GE, bv, vmask);
4159 
4160                 // Check results as part of computation.
4161                 for (int j = 0; j < SPECIES.length(); j++) {
4162                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
4163                 }
4164             }
4165         }
4166     }
4167 
4168 
4169 
4170     @Test(dataProvider = "longCompareOpProvider")
4171     static void UNSIGNED_LTLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4172         long[] a = fa.apply(SPECIES.length());
4173         long[] b = fb.apply(SPECIES.length());
4174 
4175         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4176             for (int i = 0; i < a.length; i += SPECIES.length()) {
4177                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4178                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4179                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_LT, bv);
4180 
4181                 // Check results as part of computation.
4182                 for (int j = 0; j < SPECIES.length(); j++) {
4183                     Assert.assertEquals(mv.laneIsSet(j), ult(a[i + j], b[i + j]));
4184                 }
4185             }
4186         }
4187     }
4188 
4189 
4190 
4191     @Test(dataProvider = "longCompareOpMaskProvider")
4192     static void UNSIGNED_LTLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4193                                                 IntFunction<boolean[]> fm) {
4194         long[] a = fa.apply(SPECIES.length());
4195         long[] b = fb.apply(SPECIES.length());
4196         boolean[] mask = fm.apply(SPECIES.length());
4197 
4198         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4199 
4200         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4201             for (int i = 0; i < a.length; i += SPECIES.length()) {
4202                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4203                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4204                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_LT, bv, vmask);
4205 
4206                 // Check results as part of computation.
4207                 for (int j = 0; j < SPECIES.length(); j++) {
4208                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ult(a[i + j], b[i + j]));
4209                 }
4210             }
4211         }
4212     }
4213 
4214 
4215 
4216 
4217     @Test(dataProvider = "longCompareOpProvider")
4218     static void UNSIGNED_GTLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4219         long[] a = fa.apply(SPECIES.length());
4220         long[] b = fb.apply(SPECIES.length());
4221 
4222         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4223             for (int i = 0; i < a.length; i += SPECIES.length()) {
4224                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4225                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4226                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_GT, bv);
4227 
4228                 // Check results as part of computation.
4229                 for (int j = 0; j < SPECIES.length(); j++) {
4230                     Assert.assertEquals(mv.laneIsSet(j), ugt(a[i + j], b[i + j]));
4231                 }
4232             }
4233         }
4234     }
4235 
4236 
4237 
4238     @Test(dataProvider = "longCompareOpMaskProvider")
4239     static void UNSIGNED_GTLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4240                                                 IntFunction<boolean[]> fm) {
4241         long[] a = fa.apply(SPECIES.length());
4242         long[] b = fb.apply(SPECIES.length());
4243         boolean[] mask = fm.apply(SPECIES.length());
4244 
4245         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4246 
4247         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4248             for (int i = 0; i < a.length; i += SPECIES.length()) {
4249                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4250                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4251                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_GT, bv, vmask);
4252 
4253                 // Check results as part of computation.
4254                 for (int j = 0; j < SPECIES.length(); j++) {
4255                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ugt(a[i + j], b[i + j]));
4256                 }
4257             }
4258         }
4259     }
4260 
4261 
4262 
4263 
4264     @Test(dataProvider = "longCompareOpProvider")
4265     static void UNSIGNED_LELong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4266         long[] a = fa.apply(SPECIES.length());
4267         long[] b = fb.apply(SPECIES.length());
4268 
4269         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4270             for (int i = 0; i < a.length; i += SPECIES.length()) {
4271                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4272                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4273                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_LE, bv);
4274 
4275                 // Check results as part of computation.
4276                 for (int j = 0; j < SPECIES.length(); j++) {
4277                     Assert.assertEquals(mv.laneIsSet(j), ule(a[i + j], b[i + j]));
4278                 }
4279             }
4280         }
4281     }
4282 
4283 
4284 
4285     @Test(dataProvider = "longCompareOpMaskProvider")
4286     static void UNSIGNED_LELong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4287                                                 IntFunction<boolean[]> fm) {
4288         long[] a = fa.apply(SPECIES.length());
4289         long[] b = fb.apply(SPECIES.length());
4290         boolean[] mask = fm.apply(SPECIES.length());
4291 
4292         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4293 
4294         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4295             for (int i = 0; i < a.length; i += SPECIES.length()) {
4296                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4297                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4298                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_LE, bv, vmask);
4299 
4300                 // Check results as part of computation.
4301                 for (int j = 0; j < SPECIES.length(); j++) {
4302                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ule(a[i + j], b[i + j]));
4303                 }
4304             }
4305         }
4306     }
4307 
4308 
4309 
4310 
4311     @Test(dataProvider = "longCompareOpProvider")
4312     static void UNSIGNED_GELong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4313         long[] a = fa.apply(SPECIES.length());
4314         long[] b = fb.apply(SPECIES.length());
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_GE, bv);
4321 
4322                 // Check results as part of computation.
4323                 for (int j = 0; j < SPECIES.length(); j++) {
4324                     Assert.assertEquals(mv.laneIsSet(j), uge(a[i + j], b[i + j]));
4325                 }
4326             }
4327         }
4328     }
4329 
4330 
4331 
4332     @Test(dataProvider = "longCompareOpMaskProvider")
4333     static void UNSIGNED_GELong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4334                                                 IntFunction<boolean[]> fm) {
4335         long[] a = fa.apply(SPECIES.length());
4336         long[] b = fb.apply(SPECIES.length());
4337         boolean[] mask = fm.apply(SPECIES.length());
4338 
4339         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4340 
4341         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4342             for (int i = 0; i < a.length; i += SPECIES.length()) {
4343                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4344                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4345                 VectorMask<Long> mv = av.compare(VectorOperators.UNSIGNED_GE, bv, vmask);
4346 
4347                 // Check results as part of computation.
4348                 for (int j = 0; j < SPECIES.length(); j++) {
4349                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && uge(a[i + j], b[i + j]));
4350                 }
4351             }
4352         }
4353     }
4354 
4355 
4356 
4357     @Test(dataProvider = "longCompareOpProvider")
4358     static void LTLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4359         long[] a = fa.apply(SPECIES.length());
4360         long[] b = fb.apply(SPECIES.length());
4361 
4362         for (int i = 0; i < a.length; i += SPECIES.length()) {
4363             LongVector av = LongVector.fromArray(SPECIES, a, i);
4364             VectorMask<Long> mv = av.compare(VectorOperators.LT, b[i]);
4365 
4366             // Check results as part of computation.
4367             for (int j = 0; j < SPECIES.length(); j++) {
4368                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
4369             }
4370         }
4371     }
4372 
4373 
4374     @Test(dataProvider = "longCompareOpMaskProvider")
4375     static void LTLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa,
4376                                 IntFunction<long[]> fb, IntFunction<boolean[]> fm) {
4377         long[] a = fa.apply(SPECIES.length());
4378         long[] b = fb.apply(SPECIES.length());
4379         boolean[] mask = fm.apply(SPECIES.length());
4380 
4381         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4382 
4383         for (int i = 0; i < a.length; i += SPECIES.length()) {
4384             LongVector av = LongVector.fromArray(SPECIES, a, i);
4385             VectorMask<Long> mv = av.compare(VectorOperators.LT, b[i], vmask);
4386 
4387             // Check results as part of computation.
4388             for (int j = 0; j < SPECIES.length(); j++) {
4389                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
4390             }
4391         }
4392     }
4393 
4394 
4395     @Test(dataProvider = "longCompareOpProvider")
4396     static void EQLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4397         long[] a = fa.apply(SPECIES.length());
4398         long[] b = fb.apply(SPECIES.length());
4399 
4400         for (int i = 0; i < a.length; i += SPECIES.length()) {
4401             LongVector av = LongVector.fromArray(SPECIES, a, i);
4402             VectorMask<Long> mv = av.compare(VectorOperators.EQ, b[i]);
4403 
4404             // Check results as part of computation.
4405             for (int j = 0; j < SPECIES.length(); j++) {
4406                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
4407             }
4408         }
4409     }
4410 
4411 
4412     @Test(dataProvider = "longCompareOpMaskProvider")
4413     static void EQLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa,
4414                                 IntFunction<long[]> fb, IntFunction<boolean[]> fm) {
4415         long[] a = fa.apply(SPECIES.length());
4416         long[] b = fb.apply(SPECIES.length());
4417         boolean[] mask = fm.apply(SPECIES.length());
4418 
4419         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4420 
4421         for (int i = 0; i < a.length; i += SPECIES.length()) {
4422             LongVector av = LongVector.fromArray(SPECIES, a, i);
4423             VectorMask<Long> mv = av.compare(VectorOperators.EQ, b[i], vmask);
4424 
4425             // Check results as part of computation.
4426             for (int j = 0; j < SPECIES.length(); j++) {
4427                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
4428             }
4429         }
4430     }
4431 
4432 
4433     static long blend(long a, long b, boolean mask) {
4434         return mask ? b : a;
4435     }
4436 
4437     @Test(dataProvider = "longBinaryOpMaskProvider")
4438     static void blendLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb,
4439                                           IntFunction<boolean[]> fm) {
4440         long[] a = fa.apply(SPECIES.length());
4441         long[] b = fb.apply(SPECIES.length());
4442         long[] r = fr.apply(SPECIES.length());
4443         boolean[] mask = fm.apply(SPECIES.length());
4444         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4445 
4446         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4447             for (int i = 0; i < a.length; i += SPECIES.length()) {
4448                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4449                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4450                 av.blend(bv, vmask).intoArray(r, i);
4451             }
4452         }
4453 
4454         assertArraysEquals(r, a, b, mask, Long512VectorTests::blend);
4455     }
4456 
4457     @Test(dataProvider = "longUnaryOpShuffleProvider")
4458     static void RearrangeLong512VectorTests(IntFunction<long[]> fa,
4459                                            BiFunction<Integer,Integer,int[]> fs) {
4460         long[] a = fa.apply(SPECIES.length());
4461         int[] order = fs.apply(a.length, SPECIES.length());
4462         long[] r = fr.apply(SPECIES.length());
4463 
4464         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4465             for (int i = 0; i < a.length; i += SPECIES.length()) {
4466                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4467                 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
4468             }
4469         }
4470 
4471         assertRearrangeArraysEquals(r, a, order, SPECIES.length());
4472     }
4473 
4474     @Test(dataProvider = "longUnaryOpShuffleMaskProvider")
4475     static void RearrangeLong512VectorTestsMaskedSmokeTest(IntFunction<long[]> fa,
4476                                                           BiFunction<Integer,Integer,int[]> fs,
4477                                                           IntFunction<boolean[]> fm) {
4478         long[] a = fa.apply(SPECIES.length());
4479         int[] order = fs.apply(a.length, SPECIES.length());
4480         long[] r = fr.apply(SPECIES.length());
4481         boolean[] mask = fm.apply(SPECIES.length());
4482         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4483 
4484         for (int i = 0; i < a.length; i += SPECIES.length()) {
4485             LongVector av = LongVector.fromArray(SPECIES, a, i);
4486             av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
4487         }
4488 
4489         assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
4490     }





































4491     @Test(dataProvider = "longUnaryOpProvider")
4492     static void getLong512VectorTests(IntFunction<long[]> fa) {
4493         long[] a = fa.apply(SPECIES.length());
4494         long[] r = fr.apply(SPECIES.length());
4495 
4496         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4497             for (int i = 0; i < a.length; i += SPECIES.length()) {
4498                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4499                 int num_lanes = SPECIES.length();
4500                 // Manually unroll because full unroll happens after intrinsification.
4501                 // Unroll is needed because get intrinsic requires for index to be a known constant.
4502                 if (num_lanes == 1) {
4503                     r[i]=av.lane(0);
4504                 } else if (num_lanes == 2) {
4505                     r[i]=av.lane(0);
4506                     r[i+1]=av.lane(1);
4507                 } else if (num_lanes == 4) {
4508                     r[i]=av.lane(0);
4509                     r[i+1]=av.lane(1);
4510                     r[i+2]=av.lane(2);
4511                     r[i+3]=av.lane(3);
4512                 } else if (num_lanes == 8) {
4513                     r[i]=av.lane(0);
4514                     r[i+1]=av.lane(1);
4515                     r[i+2]=av.lane(2);
4516                     r[i+3]=av.lane(3);
4517                     r[i+4]=av.lane(4);
4518                     r[i+5]=av.lane(5);
4519                     r[i+6]=av.lane(6);
4520                     r[i+7]=av.lane(7);
4521                 } else if (num_lanes == 16) {
4522                     r[i]=av.lane(0);
4523                     r[i+1]=av.lane(1);
4524                     r[i+2]=av.lane(2);
4525                     r[i+3]=av.lane(3);
4526                     r[i+4]=av.lane(4);
4527                     r[i+5]=av.lane(5);
4528                     r[i+6]=av.lane(6);
4529                     r[i+7]=av.lane(7);
4530                     r[i+8]=av.lane(8);
4531                     r[i+9]=av.lane(9);
4532                     r[i+10]=av.lane(10);
4533                     r[i+11]=av.lane(11);
4534                     r[i+12]=av.lane(12);
4535                     r[i+13]=av.lane(13);
4536                     r[i+14]=av.lane(14);
4537                     r[i+15]=av.lane(15);
4538                 } else if (num_lanes == 32) {
4539                     r[i]=av.lane(0);
4540                     r[i+1]=av.lane(1);
4541                     r[i+2]=av.lane(2);
4542                     r[i+3]=av.lane(3);
4543                     r[i+4]=av.lane(4);
4544                     r[i+5]=av.lane(5);
4545                     r[i+6]=av.lane(6);
4546                     r[i+7]=av.lane(7);
4547                     r[i+8]=av.lane(8);
4548                     r[i+9]=av.lane(9);
4549                     r[i+10]=av.lane(10);
4550                     r[i+11]=av.lane(11);
4551                     r[i+12]=av.lane(12);
4552                     r[i+13]=av.lane(13);
4553                     r[i+14]=av.lane(14);
4554                     r[i+15]=av.lane(15);
4555                     r[i+16]=av.lane(16);
4556                     r[i+17]=av.lane(17);
4557                     r[i+18]=av.lane(18);
4558                     r[i+19]=av.lane(19);
4559                     r[i+20]=av.lane(20);
4560                     r[i+21]=av.lane(21);
4561                     r[i+22]=av.lane(22);
4562                     r[i+23]=av.lane(23);
4563                     r[i+24]=av.lane(24);
4564                     r[i+25]=av.lane(25);
4565                     r[i+26]=av.lane(26);
4566                     r[i+27]=av.lane(27);
4567                     r[i+28]=av.lane(28);
4568                     r[i+29]=av.lane(29);
4569                     r[i+30]=av.lane(30);
4570                     r[i+31]=av.lane(31);
4571                 } else if (num_lanes == 64) {
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                     r[i+16]=av.lane(16);
4589                     r[i+17]=av.lane(17);
4590                     r[i+18]=av.lane(18);
4591                     r[i+19]=av.lane(19);
4592                     r[i+20]=av.lane(20);
4593                     r[i+21]=av.lane(21);
4594                     r[i+22]=av.lane(22);
4595                     r[i+23]=av.lane(23);
4596                     r[i+24]=av.lane(24);
4597                     r[i+25]=av.lane(25);
4598                     r[i+26]=av.lane(26);
4599                     r[i+27]=av.lane(27);
4600                     r[i+28]=av.lane(28);
4601                     r[i+29]=av.lane(29);
4602                     r[i+30]=av.lane(30);
4603                     r[i+31]=av.lane(31);
4604                     r[i+32]=av.lane(32);
4605                     r[i+33]=av.lane(33);
4606                     r[i+34]=av.lane(34);
4607                     r[i+35]=av.lane(35);
4608                     r[i+36]=av.lane(36);
4609                     r[i+37]=av.lane(37);
4610                     r[i+38]=av.lane(38);
4611                     r[i+39]=av.lane(39);
4612                     r[i+40]=av.lane(40);
4613                     r[i+41]=av.lane(41);
4614                     r[i+42]=av.lane(42);
4615                     r[i+43]=av.lane(43);
4616                     r[i+44]=av.lane(44);
4617                     r[i+45]=av.lane(45);
4618                     r[i+46]=av.lane(46);
4619                     r[i+47]=av.lane(47);
4620                     r[i+48]=av.lane(48);
4621                     r[i+49]=av.lane(49);
4622                     r[i+50]=av.lane(50);
4623                     r[i+51]=av.lane(51);
4624                     r[i+52]=av.lane(52);
4625                     r[i+53]=av.lane(53);
4626                     r[i+54]=av.lane(54);
4627                     r[i+55]=av.lane(55);
4628                     r[i+56]=av.lane(56);
4629                     r[i+57]=av.lane(57);
4630                     r[i+58]=av.lane(58);
4631                     r[i+59]=av.lane(59);
4632                     r[i+60]=av.lane(60);
4633                     r[i+61]=av.lane(61);
4634                     r[i+62]=av.lane(62);
4635                     r[i+63]=av.lane(63);
4636                 } else {
4637                     for (int j = 0; j < SPECIES.length(); j++) {
4638                         r[i+j]=av.lane(j);
4639                     }
4640                 }
4641             }
4642         }
4643 
4644         assertArraysEquals(r, a, Long512VectorTests::get);
4645     }
4646 
4647     @Test(dataProvider = "longUnaryOpProvider")
4648     static void BroadcastLong512VectorTests(IntFunction<long[]> fa) {
4649         long[] a = fa.apply(SPECIES.length());
4650         long[] r = new long[a.length];
4651 
4652         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4653             for (int i = 0; i < a.length; i += SPECIES.length()) {
4654                 LongVector.broadcast(SPECIES, a[i]).intoArray(r, i);
4655             }
4656         }
4657 
4658         assertBroadcastArraysEquals(r, a);
4659     }
4660 
4661 
4662 
4663 
4664 
4665     @Test(dataProvider = "longUnaryOpProvider")
4666     static void ZeroLong512VectorTests(IntFunction<long[]> fa) {
4667         long[] a = fa.apply(SPECIES.length());
4668         long[] r = new long[a.length];
4669 
4670         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4671             for (int i = 0; i < a.length; i += SPECIES.length()) {
4672                 LongVector.zero(SPECIES).intoArray(a, i);
4673             }
4674         }
4675 
4676         Assert.assertEquals(a, r);
4677     }
4678 
4679 
4680 
4681 
4682     static long[] sliceUnary(long[] a, int origin, int idx) {
4683         long[] res = new long[SPECIES.length()];
4684         for (int i = 0; i < SPECIES.length(); i++){
4685             if(i+origin < SPECIES.length())
4686                 res[i] = a[idx+i+origin];
4687             else
4688                 res[i] = (long)0;
4689         }
4690         return res;
4691     }
4692 
4693     @Test(dataProvider = "longUnaryOpProvider")
4694     static void sliceUnaryLong512VectorTests(IntFunction<long[]> fa) {
4695         long[] a = fa.apply(SPECIES.length());
4696         long[] r = new long[a.length];
4697         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4698         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4699             for (int i = 0; i < a.length; i += SPECIES.length()) {
4700                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4701                 av.slice(origin).intoArray(r, i);
4702             }
4703         }
4704 
4705         assertArraysEquals(r, a, origin, Long512VectorTests::sliceUnary);
4706     }

4707     static long[] sliceBinary(long[] a, long[] b, int origin, int idx) {
4708         long[] res = new long[SPECIES.length()];
4709         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4710             if(i+origin < SPECIES.length())
4711                 res[i] = a[idx+i+origin];
4712             else {
4713                 res[i] = b[idx+j];
4714                 j++;
4715             }
4716         }
4717         return res;
4718     }
4719 
4720     @Test(dataProvider = "longBinaryOpProvider")
4721     static void sliceBinaryLong512VectorTestsBinary(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4722         long[] a = fa.apply(SPECIES.length());
4723         long[] b = fb.apply(SPECIES.length());
4724         long[] r = new long[a.length];
4725         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4726         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4727             for (int i = 0; i < a.length; i += SPECIES.length()) {
4728                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4729                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4730                 av.slice(origin, bv).intoArray(r, i);
4731             }
4732         }
4733 
4734         assertArraysEquals(r, a, b, origin, Long512VectorTests::sliceBinary);
4735     }

4736     static long[] slice(long[] a, long[] b, int origin, boolean[] mask, int idx) {
4737         long[] res = new long[SPECIES.length()];
4738         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4739             if(i+origin < SPECIES.length())
4740                 res[i] = mask[i] ? a[idx+i+origin] : (long)0;
4741             else {
4742                 res[i] = mask[i] ? b[idx+j] : (long)0;
4743                 j++;
4744             }
4745         }
4746         return res;
4747     }
4748 
4749     @Test(dataProvider = "longBinaryOpMaskProvider")
4750     static void sliceLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4751     IntFunction<boolean[]> fm) {
4752         long[] a = fa.apply(SPECIES.length());
4753         long[] b = fb.apply(SPECIES.length());
4754         boolean[] mask = fm.apply(SPECIES.length());
4755         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4756 
4757         long[] r = new long[a.length];
4758         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4759         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4760             for (int i = 0; i < a.length; i += SPECIES.length()) {
4761                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4762                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4763                 av.slice(origin, bv, vmask).intoArray(r, i);
4764             }
4765         }
4766 
4767         assertArraysEquals(r, a, b, origin, mask, Long512VectorTests::slice);
4768     }

4769     static long[] unsliceUnary(long[] a, int origin, int idx) {
4770         long[] res = new long[SPECIES.length()];
4771         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4772             if(i < origin)
4773                 res[i] = (long)0;
4774             else {
4775                 res[i] = a[idx+j];
4776                 j++;
4777             }
4778         }
4779         return res;
4780     }
4781 
4782     @Test(dataProvider = "longUnaryOpProvider")
4783     static void unsliceUnaryLong512VectorTests(IntFunction<long[]> fa) {
4784         long[] a = fa.apply(SPECIES.length());
4785         long[] r = new long[a.length];
4786         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4787         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4788             for (int i = 0; i < a.length; i += SPECIES.length()) {
4789                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4790                 av.unslice(origin).intoArray(r, i);
4791             }
4792         }
4793 
4794         assertArraysEquals(r, a, origin, Long512VectorTests::unsliceUnary);
4795     }

4796     static long[] unsliceBinary(long[] a, long[] b, int origin, int part, int idx) {
4797         long[] res = new long[SPECIES.length()];
4798         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4799             if (part == 0) {
4800                 if (i < origin)
4801                     res[i] = b[idx+i];
4802                 else {
4803                     res[i] = a[idx+j];
4804                     j++;
4805                 }
4806             } else if (part == 1) {
4807                 if (i < origin)
4808                     res[i] = a[idx+SPECIES.length()-origin+i];
4809                 else {
4810                     res[i] = b[idx+origin+j];
4811                     j++;
4812                 }
4813             }
4814         }
4815         return res;
4816     }
4817 
4818     @Test(dataProvider = "longBinaryOpProvider")
4819     static void unsliceBinaryLong512VectorTestsBinary(IntFunction<long[]> fa, IntFunction<long[]> fb) {
4820         long[] a = fa.apply(SPECIES.length());
4821         long[] b = fb.apply(SPECIES.length());
4822         long[] r = new long[a.length];
4823         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4824         int part = (new java.util.Random()).nextInt(2);
4825         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4826             for (int i = 0; i < a.length; i += SPECIES.length()) {
4827                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4828                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4829                 av.unslice(origin, bv, part).intoArray(r, i);
4830             }
4831         }
4832 
4833         assertArraysEquals(r, a, b, origin, part, Long512VectorTests::unsliceBinary);
4834     }

4835     static long[] unslice(long[] a, long[] b, int origin, int part, boolean[] mask, int idx) {
4836         long[] res = new long[SPECIES.length()];
4837         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4838             if(i+origin < SPECIES.length())
4839                 res[i] = b[idx+i+origin];
4840             else {
4841                 res[i] = b[idx+j];
4842                 j++;
4843             }
4844         }
4845         for (int i = 0; i < SPECIES.length(); i++){
4846             res[i] = mask[i] ? a[idx+i] : res[i];
4847         }
4848         long[] res1 = new long[SPECIES.length()];
4849         if (part == 0) {
4850             for (int i = 0, j = 0; i < SPECIES.length(); i++){
4851                 if (i < origin)
4852                     res1[i] = b[idx+i];
4853                 else {
4854                    res1[i] = res[j];
4855                    j++;
4856                 }
4857             }
4858         } else if (part == 1) {
4859             for (int i = 0, j = 0; i < SPECIES.length(); i++){
4860                 if (i < origin)
4861                     res1[i] = res[SPECIES.length()-origin+i];
4862                 else {
4863                     res1[i] = b[idx+origin+j];
4864                     j++;
4865                 }
4866             }
4867         }
4868         return res1;
4869     }
4870 
4871     @Test(dataProvider = "longBinaryOpMaskProvider")
4872     static void unsliceLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4873     IntFunction<boolean[]> fm) {
4874         long[] a = fa.apply(SPECIES.length());
4875         long[] b = fb.apply(SPECIES.length());
4876         boolean[] mask = fm.apply(SPECIES.length());
4877         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4878         long[] r = new long[a.length];
4879         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4880         int part = (new java.util.Random()).nextInt(2);
4881         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4882             for (int i = 0; i < a.length; i += SPECIES.length()) {
4883                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4884                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4885                 av.unslice(origin, bv, part, vmask).intoArray(r, i);
4886             }
4887         }
4888 
4889         assertArraysEquals(r, a, b, origin, part, mask, Long512VectorTests::unslice);
4890     }
4891 
4892 
4893 
4894 
4895 
4896 
4897 
4898 
4899 
4900 
4901 
4902 
4903 
4904 
4905 
4906 
4907 
4908 
4909 
4910 
4911 
4912 
4913 
4914     static long BITWISE_BLEND(long a, long b, long c) {
4915         return (long)((a&~(c))|(b&c));
4916     }

4917     static long bitwiseBlend(long a, long b, long c) {
4918         return (long)((a&~(c))|(b&c));
4919     }
4920 
4921 
4922     @Test(dataProvider = "longTernaryOpProvider")
4923     static void BITWISE_BLENDLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
4924         long[] a = fa.apply(SPECIES.length());
4925         long[] b = fb.apply(SPECIES.length());
4926         long[] c = fc.apply(SPECIES.length());
4927         long[] r = fr.apply(SPECIES.length());
4928 
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                 LongVector cv = LongVector.fromArray(SPECIES, c, i);
4934                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
4935             }
4936         }
4937 
4938         assertArraysEquals(r, a, b, c, Long512VectorTests::BITWISE_BLEND);
4939     }

4940     @Test(dataProvider = "longTernaryOpProvider")
4941     static void bitwiseBlendLong512VectorTests(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
4942         long[] a = fa.apply(SPECIES.length());
4943         long[] b = fb.apply(SPECIES.length());
4944         long[] c = fc.apply(SPECIES.length());
4945         long[] r = fr.apply(SPECIES.length());
4946 
4947         for (int i = 0; i < a.length; i += SPECIES.length()) {
4948             LongVector av = LongVector.fromArray(SPECIES, a, i);
4949             LongVector bv = LongVector.fromArray(SPECIES, b, i);
4950             LongVector cv = LongVector.fromArray(SPECIES, c, i);
4951             av.bitwiseBlend(bv, cv).intoArray(r, i);
4952         }
4953 
4954         assertArraysEquals(r, a, b, c, Long512VectorTests::bitwiseBlend);
4955     }
4956 
4957 
4958     @Test(dataProvider = "longTernaryOpMaskProvider")
4959     static void BITWISE_BLENDLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<long[]> fb,
4960                                           IntFunction<long[]> fc, IntFunction<boolean[]> fm) {
4961         long[] a = fa.apply(SPECIES.length());
4962         long[] b = fb.apply(SPECIES.length());
4963         long[] c = fc.apply(SPECIES.length());
4964         long[] r = fr.apply(SPECIES.length());
4965         boolean[] mask = fm.apply(SPECIES.length());
4966         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4967 
4968         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4969             for (int i = 0; i < a.length; i += SPECIES.length()) {
4970                 LongVector av = LongVector.fromArray(SPECIES, a, i);
4971                 LongVector bv = LongVector.fromArray(SPECIES, b, i);
4972                 LongVector cv = LongVector.fromArray(SPECIES, c, i);
4973                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
4974             }
4975         }
4976 
4977         assertArraysEquals(r, a, b, c, mask, Long512VectorTests::BITWISE_BLEND);
4978     }
4979 
4980 
4981 
4982 
4983     @Test(dataProvider = "longTernaryOpProvider")
4984     static void BITWISE_BLENDLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
4985         long[] a = fa.apply(SPECIES.length());
4986         long[] b = fb.apply(SPECIES.length());
4987         long[] c = fc.apply(SPECIES.length());
4988         long[] r = fr.apply(SPECIES.length());
4989 
4990         for (int i = 0; i < a.length; i += SPECIES.length()) {
4991             LongVector av = LongVector.fromArray(SPECIES, a, i);
4992             LongVector bv = LongVector.fromArray(SPECIES, b, i);
4993             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i);
4994         }
4995         assertBroadcastArraysEquals(r, a, b, c, Long512VectorTests::BITWISE_BLEND);
4996     }
4997 
4998     @Test(dataProvider = "longTernaryOpProvider")
4999     static void BITWISE_BLENDLong512VectorTestsAltBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
5000         long[] a = fa.apply(SPECIES.length());
5001         long[] b = fb.apply(SPECIES.length());
5002         long[] c = fc.apply(SPECIES.length());
5003         long[] r = fr.apply(SPECIES.length());
5004 
5005         for (int i = 0; i < a.length; i += SPECIES.length()) {
5006             LongVector av = LongVector.fromArray(SPECIES, a, i);
5007             LongVector cv = LongVector.fromArray(SPECIES, c, i);
5008             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i);
5009         }
5010         assertAltBroadcastArraysEquals(r, a, b, c, Long512VectorTests::BITWISE_BLEND);
5011     }

5012     @Test(dataProvider = "longTernaryOpProvider")
5013     static void bitwiseBlendLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
5014         long[] a = fa.apply(SPECIES.length());
5015         long[] b = fb.apply(SPECIES.length());
5016         long[] c = fc.apply(SPECIES.length());
5017         long[] r = fr.apply(SPECIES.length());
5018 
5019         for (int i = 0; i < a.length; i += SPECIES.length()) {
5020             LongVector av = LongVector.fromArray(SPECIES, a, i);
5021             LongVector bv = LongVector.fromArray(SPECIES, b, i);
5022             av.bitwiseBlend(bv, c[i]).intoArray(r, i);
5023         }
5024         assertBroadcastArraysEquals(r, a, b, c, Long512VectorTests::bitwiseBlend);
5025     }
5026 
5027     @Test(dataProvider = "longTernaryOpProvider")
5028     static void bitwiseBlendLong512VectorTestsAltBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
5029         long[] a = fa.apply(SPECIES.length());
5030         long[] b = fb.apply(SPECIES.length());
5031         long[] c = fc.apply(SPECIES.length());
5032         long[] r = fr.apply(SPECIES.length());
5033 
5034         for (int i = 0; i < a.length; i += SPECIES.length()) {
5035             LongVector av = LongVector.fromArray(SPECIES, a, i);
5036             LongVector cv = LongVector.fromArray(SPECIES, c, i);
5037             av.bitwiseBlend(b[i], cv).intoArray(r, i);
5038         }
5039         assertAltBroadcastArraysEquals(r, a, b, c, Long512VectorTests::bitwiseBlend);
5040     }
5041 
5042 
5043     @Test(dataProvider = "longTernaryOpMaskProvider")
5044     static void BITWISE_BLENDLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
5045                                           IntFunction<long[]> fc, IntFunction<boolean[]> fm) {
5046         long[] a = fa.apply(SPECIES.length());
5047         long[] b = fb.apply(SPECIES.length());
5048         long[] c = fc.apply(SPECIES.length());
5049         long[] r = fr.apply(SPECIES.length());
5050         boolean[] mask = fm.apply(SPECIES.length());
5051         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5052 
5053         for (int i = 0; i < a.length; i += SPECIES.length()) {
5054             LongVector av = LongVector.fromArray(SPECIES, a, i);
5055             LongVector bv = LongVector.fromArray(SPECIES, b, i);
5056             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i);
5057         }
5058 
5059         assertBroadcastArraysEquals(r, a, b, c, mask, Long512VectorTests::BITWISE_BLEND);
5060     }
5061 
5062     @Test(dataProvider = "longTernaryOpMaskProvider")
5063     static void BITWISE_BLENDLong512VectorTestsAltBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
5064                                           IntFunction<long[]> fc, IntFunction<boolean[]> fm) {
5065         long[] a = fa.apply(SPECIES.length());
5066         long[] b = fb.apply(SPECIES.length());
5067         long[] c = fc.apply(SPECIES.length());
5068         long[] r = fr.apply(SPECIES.length());
5069         boolean[] mask = fm.apply(SPECIES.length());
5070         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5071 
5072         for (int i = 0; i < a.length; i += SPECIES.length()) {
5073             LongVector av = LongVector.fromArray(SPECIES, a, i);
5074             LongVector cv = LongVector.fromArray(SPECIES, c, i);
5075             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i);
5076         }
5077 
5078         assertAltBroadcastArraysEquals(r, a, b, c, mask, Long512VectorTests::BITWISE_BLEND);
5079     }
5080 
5081 
5082 
5083 
5084     @Test(dataProvider = "longTernaryOpProvider")
5085     static void BITWISE_BLENDLong512VectorTestsDoubleBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
5086         long[] a = fa.apply(SPECIES.length());
5087         long[] b = fb.apply(SPECIES.length());
5088         long[] c = fc.apply(SPECIES.length());
5089         long[] r = fr.apply(SPECIES.length());
5090 
5091         for (int i = 0; i < a.length; i += SPECIES.length()) {
5092             LongVector av = LongVector.fromArray(SPECIES, a, i);
5093             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i);
5094         }
5095 
5096         assertDoubleBroadcastArraysEquals(r, a, b, c, Long512VectorTests::BITWISE_BLEND);
5097     }

5098     @Test(dataProvider = "longTernaryOpProvider")
5099     static void bitwiseBlendLong512VectorTestsDoubleBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb, IntFunction<long[]> fc) {
5100         long[] a = fa.apply(SPECIES.length());
5101         long[] b = fb.apply(SPECIES.length());
5102         long[] c = fc.apply(SPECIES.length());
5103         long[] r = fr.apply(SPECIES.length());
5104 
5105         for (int i = 0; i < a.length; i += SPECIES.length()) {
5106             LongVector av = LongVector.fromArray(SPECIES, a, i);
5107             av.bitwiseBlend(b[i], c[i]).intoArray(r, i);
5108         }
5109 
5110         assertDoubleBroadcastArraysEquals(r, a, b, c, Long512VectorTests::bitwiseBlend);
5111     }
5112 
5113 
5114     @Test(dataProvider = "longTernaryOpMaskProvider")
5115     static void BITWISE_BLENDLong512VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb,
5116                                           IntFunction<long[]> fc, IntFunction<boolean[]> fm) {
5117         long[] a = fa.apply(SPECIES.length());
5118         long[] b = fb.apply(SPECIES.length());
5119         long[] c = fc.apply(SPECIES.length());
5120         long[] r = fr.apply(SPECIES.length());
5121         boolean[] mask = fm.apply(SPECIES.length());
5122         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5123 
5124         for (int i = 0; i < a.length; i += SPECIES.length()) {
5125             LongVector av = LongVector.fromArray(SPECIES, a, i);
5126             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i);
5127         }
5128 
5129         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Long512VectorTests::BITWISE_BLEND);
5130     }
5131 
5132 
5133     static long NEG(long a) {
5134         return (long)(-((long)a));
5135     }
5136 
5137     static long neg(long a) {
5138         return (long)(-((long)a));
5139     }
5140 
5141     @Test(dataProvider = "longUnaryOpProvider")
5142     static void NEGLong512VectorTests(IntFunction<long[]> fa) {
5143         long[] a = fa.apply(SPECIES.length());
5144         long[] r = fr.apply(SPECIES.length());
5145 
5146         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5147             for (int i = 0; i < a.length; i += SPECIES.length()) {
5148                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5149                 av.lanewise(VectorOperators.NEG).intoArray(r, i);
5150             }
5151         }
5152 
5153         assertArraysEquals(r, a, Long512VectorTests::NEG);
5154     }
5155 
5156     @Test(dataProvider = "longUnaryOpProvider")
5157     static void negLong512VectorTests(IntFunction<long[]> fa) {
5158         long[] a = fa.apply(SPECIES.length());
5159         long[] r = fr.apply(SPECIES.length());
5160 
5161         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5162             for (int i = 0; i < a.length; i += SPECIES.length()) {
5163                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5164                 av.neg().intoArray(r, i);
5165             }
5166         }
5167 
5168         assertArraysEquals(r, a, Long512VectorTests::neg);
5169     }
5170 
5171     @Test(dataProvider = "longUnaryOpMaskProvider")
5172     static void NEGMaskedLong512VectorTests(IntFunction<long[]> fa,
5173                                                 IntFunction<boolean[]> fm) {
5174         long[] a = fa.apply(SPECIES.length());
5175         long[] r = fr.apply(SPECIES.length());
5176         boolean[] mask = fm.apply(SPECIES.length());
5177         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5178 
5179         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5180             for (int i = 0; i < a.length; i += SPECIES.length()) {
5181                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5182                 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
5183             }
5184         }
5185 
5186         assertArraysEquals(r, a, mask, Long512VectorTests::NEG);
5187     }
5188 
5189     static long ABS(long a) {
5190         return (long)(Math.abs((long)a));
5191     }
5192 
5193     static long abs(long a) {
5194         return (long)(Math.abs((long)a));
5195     }
5196 
5197     @Test(dataProvider = "longUnaryOpProvider")
5198     static void ABSLong512VectorTests(IntFunction<long[]> fa) {
5199         long[] a = fa.apply(SPECIES.length());
5200         long[] r = fr.apply(SPECIES.length());
5201 
5202         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5203             for (int i = 0; i < a.length; i += SPECIES.length()) {
5204                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5205                 av.lanewise(VectorOperators.ABS).intoArray(r, i);
5206             }
5207         }
5208 
5209         assertArraysEquals(r, a, Long512VectorTests::ABS);
5210     }
5211 
5212     @Test(dataProvider = "longUnaryOpProvider")
5213     static void absLong512VectorTests(IntFunction<long[]> fa) {
5214         long[] a = fa.apply(SPECIES.length());
5215         long[] r = fr.apply(SPECIES.length());
5216 
5217         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5218             for (int i = 0; i < a.length; i += SPECIES.length()) {
5219                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5220                 av.abs().intoArray(r, i);
5221             }
5222         }
5223 
5224         assertArraysEquals(r, a, Long512VectorTests::abs);
5225     }
5226 
5227     @Test(dataProvider = "longUnaryOpMaskProvider")
5228     static void ABSMaskedLong512VectorTests(IntFunction<long[]> fa,
5229                                                 IntFunction<boolean[]> fm) {
5230         long[] a = fa.apply(SPECIES.length());
5231         long[] r = fr.apply(SPECIES.length());
5232         boolean[] mask = fm.apply(SPECIES.length());
5233         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5234 
5235         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5236             for (int i = 0; i < a.length; i += SPECIES.length()) {
5237                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5238                 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
5239             }
5240         }
5241 
5242         assertArraysEquals(r, a, mask, Long512VectorTests::ABS);
5243     }
5244 
5245 
5246     static long NOT(long a) {
5247         return (long)(~((long)a));
5248     }
5249 
5250     static long not(long a) {
5251         return (long)(~((long)a));
5252     }
5253 
5254 
5255 
5256     @Test(dataProvider = "longUnaryOpProvider")
5257     static void NOTLong512VectorTests(IntFunction<long[]> fa) {
5258         long[] a = fa.apply(SPECIES.length());
5259         long[] r = fr.apply(SPECIES.length());
5260 
5261         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5262             for (int i = 0; i < a.length; i += SPECIES.length()) {
5263                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5264                 av.lanewise(VectorOperators.NOT).intoArray(r, i);
5265             }
5266         }
5267 
5268         assertArraysEquals(r, a, Long512VectorTests::NOT);
5269     }
5270 
5271     @Test(dataProvider = "longUnaryOpProvider")
5272     static void notLong512VectorTests(IntFunction<long[]> fa) {
5273         long[] a = fa.apply(SPECIES.length());
5274         long[] r = fr.apply(SPECIES.length());
5275 
5276         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5277             for (int i = 0; i < a.length; i += SPECIES.length()) {
5278                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5279                 av.not().intoArray(r, i);
5280             }
5281         }
5282 
5283         assertArraysEquals(r, a, Long512VectorTests::not);
5284     }
5285 
5286 
5287 
5288     @Test(dataProvider = "longUnaryOpMaskProvider")
5289     static void NOTMaskedLong512VectorTests(IntFunction<long[]> fa,
5290                                                 IntFunction<boolean[]> fm) {
5291         long[] a = fa.apply(SPECIES.length());
5292         long[] r = fr.apply(SPECIES.length());
5293         boolean[] mask = fm.apply(SPECIES.length());
5294         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5295 
5296         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5297             for (int i = 0; i < a.length; i += SPECIES.length()) {
5298                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5299                 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
5300             }
5301         }
5302 
5303         assertArraysEquals(r, a, mask, Long512VectorTests::NOT);
5304     }
5305 
5306 
5307 
5308     static long ZOMO(long a) {
5309         return (long)((a==0?0:-1));
5310     }
5311 
5312 
5313 
5314     @Test(dataProvider = "longUnaryOpProvider")
5315     static void ZOMOLong512VectorTests(IntFunction<long[]> fa) {
5316         long[] a = fa.apply(SPECIES.length());
5317         long[] r = fr.apply(SPECIES.length());
5318 
5319         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5320             for (int i = 0; i < a.length; i += SPECIES.length()) {
5321                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5322                 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
5323             }
5324         }
5325 
5326         assertArraysEquals(r, a, Long512VectorTests::ZOMO);
5327     }
5328 
5329 
5330 
5331     @Test(dataProvider = "longUnaryOpMaskProvider")
5332     static void ZOMOMaskedLong512VectorTests(IntFunction<long[]> fa,
5333                                                 IntFunction<boolean[]> fm) {
5334         long[] a = fa.apply(SPECIES.length());
5335         long[] r = fr.apply(SPECIES.length());
5336         boolean[] mask = fm.apply(SPECIES.length());
5337         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5338 
5339         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5340             for (int i = 0; i < a.length; i += SPECIES.length()) {
5341                 LongVector av = LongVector.fromArray(SPECIES, a, i);
5342                 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
5343             }
5344         }
5345 
5346         assertArraysEquals(r, a, mask, Long512VectorTests::ZOMO);
5347     }
5348 



5349 




5350 









5351 





































































































































































5352 
5353     @Test(dataProvider = "longCompareOpProvider")
5354     static void ltLong512VectorTestsBroadcastSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
5355         long[] a = fa.apply(SPECIES.length());
5356         long[] b = fb.apply(SPECIES.length());
5357 
5358         for (int i = 0; i < a.length; i += SPECIES.length()) {
5359             LongVector av = LongVector.fromArray(SPECIES, a, i);
5360             VectorMask<Long> mv = av.lt(b[i]);
5361 
5362             // Check results as part of computation.
5363             for (int j = 0; j < SPECIES.length(); j++) {
5364                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
5365             }
5366         }
5367     }
5368 
5369     @Test(dataProvider = "longCompareOpProvider")
5370     static void eqLong512VectorTestsBroadcastMaskedSmokeTest(IntFunction<long[]> fa, IntFunction<long[]> fb) {
5371         long[] a = fa.apply(SPECIES.length());
5372         long[] b = fb.apply(SPECIES.length());
5373 
5374         for (int i = 0; i < a.length; i += SPECIES.length()) {
5375             LongVector av = LongVector.fromArray(SPECIES, a, i);
5376             VectorMask<Long> mv = av.eq(b[i]);
5377 
5378             // Check results as part of computation.
5379             for (int j = 0; j < SPECIES.length(); j++) {
5380                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
5381             }
5382         }
5383     }
5384 
5385     @Test(dataProvider = "longtoIntUnaryOpProvider")
5386     static void toIntArrayLong512VectorTestsSmokeTest(IntFunction<long[]> fa) {
5387         long[] a = fa.apply(SPECIES.length());
5388 
5389         for (int i = 0; i < a.length; i += SPECIES.length()) {
5390             LongVector av = LongVector.fromArray(SPECIES, a, i);
5391             int[] r = av.toIntArray();
5392             assertArraysEquals(r, a, i);
5393         }
5394     }
5395 
5396     @Test(dataProvider = "longUnaryOpProvider")
5397     static void toLongArrayLong512VectorTestsSmokeTest(IntFunction<long[]> fa) {
5398         long[] a = fa.apply(SPECIES.length());
5399 
5400         for (int i = 0; i < a.length; i += SPECIES.length()) {
5401             LongVector av = LongVector.fromArray(SPECIES, a, i);
5402             long[] r = av.toLongArray();
5403             assertArraysEquals(r, a, i);
5404         }
5405     }
5406 
5407     @Test(dataProvider = "longUnaryOpProvider")
5408     static void toDoubleArrayLong512VectorTestsSmokeTest(IntFunction<long[]> fa) {
5409         long[] a = fa.apply(SPECIES.length());
5410 
5411         for (int i = 0; i < a.length; i += SPECIES.length()) {
5412             LongVector av = LongVector.fromArray(SPECIES, a, i);
5413             double[] r = av.toDoubleArray();
5414             assertArraysEquals(r, a, i);
5415         }
5416     }
5417 
5418     @Test(dataProvider = "longUnaryOpProvider")
5419     static void toStringLong512VectorTestsSmokeTest(IntFunction<long[]> fa) {
5420         long[] a = fa.apply(SPECIES.length());
5421 
5422         for (int i = 0; i < a.length; i += SPECIES.length()) {
5423             LongVector av = LongVector.fromArray(SPECIES, a, i);
5424             String str = av.toString();
5425 
5426             long subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5427             Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5428         }
5429     }
5430 
5431     @Test(dataProvider = "longUnaryOpProvider")
5432     static void hashCodeLong512VectorTestsSmokeTest(IntFunction<long[]> fa) {
5433         long[] a = fa.apply(SPECIES.length());
5434 
5435         for (int i = 0; i < a.length; i += SPECIES.length()) {
5436             LongVector av = LongVector.fromArray(SPECIES, a, i);
5437             int hash = av.hashCode();
5438 
5439             long subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5440             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5441             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5442         }
5443     }
5444 
5445 
5446 
5447     @Test(dataProvider = "longUnaryOpProvider")
5448     static void ADDReduceLongLong512VectorTests(IntFunction<long[]> fa) {
5449         long[] a = fa.apply(SPECIES.length());
5450         long[] r = fr.apply(SPECIES.length());
5451         long ra = 0;
5452 
5453         for (int i = 0; i < a.length; i += SPECIES.length()) {
5454             LongVector av = LongVector.fromArray(SPECIES, a, i);
5455             r[i] = av.reduceLanesToLong(VectorOperators.ADD);
5456         }
5457 
5458         ra = 0;
5459         for (int i = 0; i < a.length; i ++) {
5460             ra += r[i];
5461         }
5462 
5463         assertReductionArraysEquals(r, ra, a,
5464                 Long512VectorTests::ADDReduce, Long512VectorTests::ADDReduceAll);
5465     }
5466 
5467     @Test(dataProvider = "longUnaryOpMaskProvider")
5468     static void ADDReduceLongLong512VectorTestsMasked(IntFunction<long[]> fa, IntFunction<boolean[]> fm) {
5469         long[] a = fa.apply(SPECIES.length());
5470         long[] r = fr.apply(SPECIES.length());
5471         boolean[] mask = fm.apply(SPECIES.length());
5472         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5473         long ra = 0;
5474 
5475         for (int i = 0; i < a.length; i += SPECIES.length()) {
5476             LongVector av = LongVector.fromArray(SPECIES, a, i);
5477             r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
5478         }
5479 
5480         ra = 0;
5481         for (int i = 0; i < a.length; i ++) {
5482             ra += r[i];
5483         }
5484 
5485         assertReductionArraysEqualsMasked(r, ra, a, mask,
5486                 Long512VectorTests::ADDReduceMasked, Long512VectorTests::ADDReduceAllMasked);
5487     }
5488 
5489     @Test(dataProvider = "longUnaryOpSelectFromProvider")
5490     static void SelectFromLong512VectorTests(IntFunction<long[]> fa,
5491                                            BiFunction<Integer,Integer,long[]> fs) {
5492         long[] a = fa.apply(SPECIES.length());
5493         long[] order = fs.apply(a.length, SPECIES.length());
5494         long[] r = fr.apply(SPECIES.length());
5495 
5496         for (int i = 0; i < a.length; i += SPECIES.length()) {
5497             LongVector av = LongVector.fromArray(SPECIES, a, i);
5498             LongVector bv = LongVector.fromArray(SPECIES, order, i);
5499             bv.selectFrom(av).intoArray(r, i);
5500         }
5501 
5502         assertSelectFromArraysEquals(r, a, order, SPECIES.length());
5503     }
5504 
5505     @Test(dataProvider = "longUnaryOpSelectFromMaskProvider")
5506     static void SelectFromLong512VectorTestsMaskedSmokeTest(IntFunction<long[]> fa,
5507                                                            BiFunction<Integer,Integer,long[]> fs,
5508                                                            IntFunction<boolean[]> fm) {
5509         long[] a = fa.apply(SPECIES.length());
5510         long[] order = fs.apply(a.length, SPECIES.length());
5511         long[] r = fr.apply(SPECIES.length());
5512         boolean[] mask = fm.apply(SPECIES.length());
5513         VectorMask<Long> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5514 
5515         for (int i = 0; i < a.length; i += SPECIES.length()) {
5516             LongVector av = LongVector.fromArray(SPECIES, a, i);
5517             LongVector bv = LongVector.fromArray(SPECIES, order, i);
5518             bv.selectFrom(av, vmask).intoArray(r, i);
5519         }
5520 
5521         assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
5522     }
5523 
5524     @Test(dataProvider = "shuffleProvider")
5525     static void shuffleMiscellaneousLong512VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5526         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5527 
5528         for (int i = 0; i < a.length; i += SPECIES.length()) {
5529             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5530             int hash = shuffle.hashCode();
5531             int length = shuffle.length();
5532 
5533             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5534             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5535             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5536             Assert.assertEquals(length, SPECIES.length());
5537         }
5538     }
5539 
5540     @Test(dataProvider = "shuffleProvider")
5541     static void shuffleToStringLong512VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5542         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5543 
5544         for (int i = 0; i < a.length; i += SPECIES.length()) {
5545             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5546             String str = shuffle.toString();
5547 
5548             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5549             Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
5550                 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5551         }
5552     }
5553 
5554     @Test(dataProvider = "shuffleCompareOpProvider")
5555     static void shuffleEqualsLong512VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
5556         int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5557         int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5558 
5559         for (int i = 0; i < a.length; i += SPECIES.length()) {
5560             var av = VectorShuffle.fromArray(SPECIES, a, i);
5561             var bv = VectorShuffle.fromArray(SPECIES, b, i);
5562             boolean eq = av.equals(bv);
5563             int to = i + SPECIES.length();
5564             Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
5565         }
5566     }
5567 
5568     @Test(dataProvider = "maskCompareOpProvider")
5569     static void maskEqualsLong512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5570         boolean[] a = fa.apply(SPECIES.length());
5571         boolean[] b = fb.apply(SPECIES.length());
5572 
5573         for (int i = 0; i < a.length; i += SPECIES.length()) {
5574             var av = SPECIES.loadMask(a, i);
5575             var bv = SPECIES.loadMask(b, i);
5576             boolean equals = av.equals(bv);
5577             int to = i + SPECIES.length();
5578             Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
5579         }
5580     }
5581 
5582     static boolean beq(boolean a, boolean b) {
5583         return (a == b);
5584     }
5585 
5586     @Test(dataProvider = "maskCompareOpProvider")
5587     static void maskEqLong512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5588         boolean[] a = fa.apply(SPECIES.length());
5589         boolean[] b = fb.apply(SPECIES.length());
5590         boolean[] r = new boolean[a.length];
5591 
5592         for (int i = 0; i < a.length; i += SPECIES.length()) {
5593             var av = SPECIES.loadMask(a, i);
5594             var bv = SPECIES.loadMask(b, i);
5595             var cv = av.eq(bv);
5596             cv.intoArray(r, i);
5597         }
5598         assertArraysEquals(r, a, b, Long512VectorTests::beq);
5599     }
5600 
5601     @Test(dataProvider = "maskProvider")
5602     static void maskHashCodeLong512VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5603         boolean[] a = fa.apply(SPECIES.length());
5604 
5605         for (int i = 0; i < a.length; i += SPECIES.length()) {
5606             var vmask = SPECIES.loadMask(a, i);
5607             int hash = vmask.hashCode();
5608 
5609             boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5610             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5611             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5612         }
5613     }
5614 
5615     static int maskTrueCount(boolean[] a, int idx) {
5616         int trueCount = 0;
5617         for (int i = idx; i < idx + SPECIES.length(); i++) {
5618             trueCount += a[i] ? 1 : 0;
5619         }
5620         return trueCount;
5621     }
5622 
5623     @Test(dataProvider = "maskProvider")
5624     static void maskTrueCountLong512VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5625         boolean[] a = fa.apply(SPECIES.length());
5626         int[] r = new int[a.length];
5627 
5628         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5629             for (int i = 0; i < a.length; i += SPECIES.length()) {
5630                 var vmask = SPECIES.loadMask(a, i);
5631                 r[i] = vmask.trueCount();
5632             }
5633         }
5634 
5635         assertMaskReductionArraysEquals(r, a, Long512VectorTests::maskTrueCount);
5636     }
5637 
5638     static int maskLastTrue(boolean[] a, int idx) {
5639         int i = idx + SPECIES.length() - 1;
5640         for (; i >= idx; i--) {
5641             if (a[i]) {
5642                 break;
5643             }
5644         }
5645         return i - idx;
5646     }
5647 
5648     @Test(dataProvider = "maskProvider")
5649     static void maskLastTrueLong512VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5650         boolean[] a = fa.apply(SPECIES.length());
5651         int[] r = new int[a.length];
5652 
5653         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5654             for (int i = 0; i < a.length; i += SPECIES.length()) {
5655                 var vmask = SPECIES.loadMask(a, i);
5656                 r[i] = vmask.lastTrue();
5657             }
5658         }
5659 
5660         assertMaskReductionArraysEquals(r, a, Long512VectorTests::maskLastTrue);
5661     }
5662 
5663     static int maskFirstTrue(boolean[] a, int idx) {
5664         int i = idx;
5665         for (; i < idx + SPECIES.length(); i++) {
5666             if (a[i]) {
5667                 break;
5668             }
5669         }
5670         return i - idx;
5671     }
5672 
5673     @Test(dataProvider = "maskProvider")
5674     static void maskFirstTrueLong512VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5675         boolean[] a = fa.apply(SPECIES.length());
5676         int[] r = new int[a.length];
5677 
5678         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5679             for (int i = 0; i < a.length; i += SPECIES.length()) {
5680                 var vmask = SPECIES.loadMask(a, i);
5681                 r[i] = vmask.firstTrue();
5682             }
5683         }
5684 
5685         assertMaskReductionArraysEquals(r, a, Long512VectorTests::maskFirstTrue);
5686     }
5687 

















5688     @DataProvider
5689     public static Object[][] longMaskProvider() {
5690         return new Object[][]{
5691                 {0xFFFFFFFFFFFFFFFFL},
5692                 {0x0000000000000000L},
5693                 {0x5555555555555555L},
5694                 {0x0123456789abcdefL},
5695         };
5696     }
5697 
5698     @Test(dataProvider = "longMaskProvider")
5699     static void maskFromToLongLong512VectorTestsSmokeTest(long inputLong) {
5700         var vmask = VectorMask.fromLong(SPECIES, inputLong);
5701         long outputLong = vmask.toLong();
5702         Assert.assertEquals(outputLong, (inputLong & (((0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()))))));
5703     }
5704 
5705     @DataProvider
5706     public static Object[][] offsetProvider() {
5707         return new Object[][]{
5708                 {0},
5709                 {-1},
5710                 {+1},
5711                 {+2},
5712                 {-2},
5713         };
5714     }
5715 
5716     @Test(dataProvider = "offsetProvider")
5717     static void indexInRangeLong512VectorTestsSmokeTest(int offset) {
5718         int limit = SPECIES.length() * BUFFER_REPS;
5719         for (int i = 0; i < limit; i += SPECIES.length()) {
5720             var actualMask = SPECIES.indexInRange(i + offset, limit);
5721             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
5722             assert(actualMask.equals(expectedMask));
5723             for (int j = 0; j < SPECIES.length(); j++)  {
5724                 int index = i + j + offset;
5725                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
5726             }
5727         }
5728     }
5729 














5730     @DataProvider
5731     public static Object[][] lengthProvider() {
5732         return new Object[][]{
5733                 {0},
5734                 {1},
5735                 {32},
5736                 {37},
5737                 {1024},
5738                 {1024+1},
5739                 {1024+5},
5740         };
5741     }
5742 
5743     @Test(dataProvider = "lengthProvider")
5744     static void loopBoundLong512VectorTestsSmokeTest(int length) {
5745         int actualLoopBound = SPECIES.loopBound(length);
5746         int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
5747         Assert.assertEquals(actualLoopBound, expectedLoopBound);
5748     }
5749 








5750     @Test
5751     static void ElementSizeLong512VectorTestsSmokeTest() {
5752         LongVector av = LongVector.zero(SPECIES);
5753         int elsize = av.elementSize();
5754         Assert.assertEquals(elsize, Long.SIZE);
5755     }
5756 
5757     @Test
5758     static void VectorShapeLong512VectorTestsSmokeTest() {
5759         LongVector av = LongVector.zero(SPECIES);
5760         VectorShape vsh = av.shape();
5761         assert(vsh.equals(VectorShape.S_512_BIT));
5762     }
5763 
5764     @Test
5765     static void ShapeWithLanesLong512VectorTestsSmokeTest() {
5766         LongVector av = LongVector.zero(SPECIES);
5767         VectorShape vsh = av.shape();
5768         VectorSpecies species = vsh.withLanes(long.class);
5769         assert(species.equals(SPECIES));
5770     }
5771 
5772     @Test
5773     static void ElementTypeLong512VectorTestsSmokeTest() {
5774         LongVector av = LongVector.zero(SPECIES);
5775         assert(av.species().elementType() == long.class);
5776     }
5777 
5778     @Test
5779     static void SpeciesElementSizeLong512VectorTestsSmokeTest() {
5780         LongVector av = LongVector.zero(SPECIES);
5781         assert(av.species().elementSize() == Long.SIZE);
5782     }
5783 
5784     @Test
5785     static void VectorTypeLong512VectorTestsSmokeTest() {
5786         LongVector av = LongVector.zero(SPECIES);
5787         assert(av.species().vectorType() == av.getClass());
5788     }
5789 
5790     @Test
5791     static void WithLanesLong512VectorTestsSmokeTest() {
5792         LongVector av = LongVector.zero(SPECIES);
5793         VectorSpecies species = av.species().withLanes(long.class);
5794         assert(species.equals(SPECIES));
5795     }
5796 
5797     @Test
5798     static void WithShapeLong512VectorTestsSmokeTest() {
5799         LongVector av = LongVector.zero(SPECIES);
5800         VectorShape vsh = av.shape();
5801         VectorSpecies species = av.species().withShape(vsh);
5802         assert(species.equals(SPECIES));
5803     }
5804 
5805     @Test
5806     static void MaskAllTrueLong512VectorTestsSmokeTest() {
5807         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5808           Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
5809         }
5810     }
5811 }
5812 
--- EOF ---