--- a/js/src/builtin/SIMD.cpp
+++ b/js/src/builtin/SIMD.cpp
@@ -363,280 +363,16 @@ const Class SIMDObject::class_ = {
         JS_ConvertStub,
         nullptr,             /* finalize    */
         nullptr,             /* call        */
         nullptr,             /* hasInstance */
         nullptr,             /* construct   */
         nullptr
 };
 
-static JSConstIntegerSpec SHUFFLE_MASKS[] = {
-    {"XXXX", 0x0},
-    {"XXXY", 0x40},
-    {"XXXZ", 0x80},
-    {"XXXW", 0xC0},
-    {"XXYX", 0x10},
-    {"XXYY", 0x50},
-    {"XXYZ", 0x90},
-    {"XXYW", 0xD0},
-    {"XXZX", 0x20},
-    {"XXZY", 0x60},
-    {"XXZZ", 0xA0},
-    {"XXZW", 0xE0},
-    {"XXWX", 0x30},
-    {"XXWY", 0x70},
-    {"XXWZ", 0xB0},
-    {"XXWW", 0xF0},
-    {"XYXX", 0x4},
-    {"XYXY", 0x44},
-    {"XYXZ", 0x84},
-    {"XYXW", 0xC4},
-    {"XYYX", 0x14},
-    {"XYYY", 0x54},
-    {"XYYZ", 0x94},
-    {"XYYW", 0xD4},
-    {"XYZX", 0x24},
-    {"XYZY", 0x64},
-    {"XYZZ", 0xA4},
-    {"XYZW", 0xE4},
-    {"XYWX", 0x34},
-    {"XYWY", 0x74},
-    {"XYWZ", 0xB4},
-    {"XYWW", 0xF4},
-    {"XZXX", 0x8},
-    {"XZXY", 0x48},
-    {"XZXZ", 0x88},
-    {"XZXW", 0xC8},
-    {"XZYX", 0x18},
-    {"XZYY", 0x58},
-    {"XZYZ", 0x98},
-    {"XZYW", 0xD8},
-    {"XZZX", 0x28},
-    {"XZZY", 0x68},
-    {"XZZZ", 0xA8},
-    {"XZZW", 0xE8},
-    {"XZWX", 0x38},
-    {"XZWY", 0x78},
-    {"XZWZ", 0xB8},
-    {"XZWW", 0xF8},
-    {"XWXX", 0xC},
-    {"XWXY", 0x4C},
-    {"XWXZ", 0x8C},
-    {"XWXW", 0xCC},
-    {"XWYX", 0x1C},
-    {"XWYY", 0x5C},
-    {"XWYZ", 0x9C},
-    {"XWYW", 0xDC},
-    {"XWZX", 0x2C},
-    {"XWZY", 0x6C},
-    {"XWZZ", 0xAC},
-    {"XWZW", 0xEC},
-    {"XWWX", 0x3C},
-    {"XWWY", 0x7C},
-    {"XWWZ", 0xBC},
-    {"XWWW", 0xFC},
-    {"YXXX", 0x1},
-    {"YXXY", 0x41},
-    {"YXXZ", 0x81},
-    {"YXXW", 0xC1},
-    {"YXYX", 0x11},
-    {"YXYY", 0x51},
-    {"YXYZ", 0x91},
-    {"YXYW", 0xD1},
-    {"YXZX", 0x21},
-    {"YXZY", 0x61},
-    {"YXZZ", 0xA1},
-    {"YXZW", 0xE1},
-    {"YXWX", 0x31},
-    {"YXWY", 0x71},
-    {"YXWZ", 0xB1},
-    {"YXWW", 0xF1},
-    {"YYXX", 0x5},
-    {"YYXY", 0x45},
-    {"YYXZ", 0x85},
-    {"YYXW", 0xC5},
-    {"YYYX", 0x15},
-    {"YYYY", 0x55},
-    {"YYYZ", 0x95},
-    {"YYYW", 0xD5},
-    {"YYZX", 0x25},
-    {"YYZY", 0x65},
-    {"YYZZ", 0xA5},
-    {"YYZW", 0xE5},
-    {"YYWX", 0x35},
-    {"YYWY", 0x75},
-    {"YYWZ", 0xB5},
-    {"YYWW", 0xF5},
-    {"YZXX", 0x9},
-    {"YZXY", 0x49},
-    {"YZXZ", 0x89},
-    {"YZXW", 0xC9},
-    {"YZYX", 0x19},
-    {"YZYY", 0x59},
-    {"YZYZ", 0x99},
-    {"YZYW", 0xD9},
-    {"YZZX", 0x29},
-    {"YZZY", 0x69},
-    {"YZZZ", 0xA9},
-    {"YZZW", 0xE9},
-    {"YZWX", 0x39},
-    {"YZWY", 0x79},
-    {"YZWZ", 0xB9},
-    {"YZWW", 0xF9},
-    {"YWXX", 0xD},
-    {"YWXY", 0x4D},
-    {"YWXZ", 0x8D},
-    {"YWXW", 0xCD},
-    {"YWYX", 0x1D},
-    {"YWYY", 0x5D},
-    {"YWYZ", 0x9D},
-    {"YWYW", 0xDD},
-    {"YWZX", 0x2D},
-    {"YWZY", 0x6D},
-    {"YWZZ", 0xAD},
-    {"YWZW", 0xED},
-    {"YWWX", 0x3D},
-    {"YWWY", 0x7D},
-    {"YWWZ", 0xBD},
-    {"YWWW", 0xFD},
-    {"ZXXX", 0x2},
-    {"ZXXY", 0x42},
-    {"ZXXZ", 0x82},
-    {"ZXXW", 0xC2},
-    {"ZXYX", 0x12},
-    {"ZXYY", 0x52},
-    {"ZXYZ", 0x92},
-    {"ZXYW", 0xD2},
-    {"ZXZX", 0x22},
-    {"ZXZY", 0x62},
-    {"ZXZZ", 0xA2},
-    {"ZXZW", 0xE2},
-    {"ZXWX", 0x32},
-    {"ZXWY", 0x72},
-    {"ZXWZ", 0xB2},
-    {"ZXWW", 0xF2},
-    {"ZYXX", 0x6},
-    {"ZYXY", 0x46},
-    {"ZYXZ", 0x86},
-    {"ZYXW", 0xC6},
-    {"ZYYX", 0x16},
-    {"ZYYY", 0x56},
-    {"ZYYZ", 0x96},
-    {"ZYYW", 0xD6},
-    {"ZYZX", 0x26},
-    {"ZYZY", 0x66},
-    {"ZYZZ", 0xA6},
-    {"ZYZW", 0xE6},
-    {"ZYWX", 0x36},
-    {"ZYWY", 0x76},
-    {"ZYWZ", 0xB6},
-    {"ZYWW", 0xF6},
-    {"ZZXX", 0xA},
-    {"ZZXY", 0x4A},
-    {"ZZXZ", 0x8A},
-    {"ZZXW", 0xCA},
-    {"ZZYX", 0x1A},
-    {"ZZYY", 0x5A},
-    {"ZZYZ", 0x9A},
-    {"ZZYW", 0xDA},
-    {"ZZZX", 0x2A},
-    {"ZZZY", 0x6A},
-    {"ZZZZ", 0xAA},
-    {"ZZZW", 0xEA},
-    {"ZZWX", 0x3A},
-    {"ZZWY", 0x7A},
-    {"ZZWZ", 0xBA},
-    {"ZZWW", 0xFA},
-    {"ZWXX", 0xE},
-    {"ZWXY", 0x4E},
-    {"ZWXZ", 0x8E},
-    {"ZWXW", 0xCE},
-    {"ZWYX", 0x1E},
-    {"ZWYY", 0x5E},
-    {"ZWYZ", 0x9E},
-    {"ZWYW", 0xDE},
-    {"ZWZX", 0x2E},
-    {"ZWZY", 0x6E},
-    {"ZWZZ", 0xAE},
-    {"ZWZW", 0xEE},
-    {"ZWWX", 0x3E},
-    {"ZWWY", 0x7E},
-    {"ZWWZ", 0xBE},
-    {"ZWWW", 0xFE},
-    {"WXXX", 0x3},
-    {"WXXY", 0x43},
-    {"WXXZ", 0x83},
-    {"WXXW", 0xC3},
-    {"WXYX", 0x13},
-    {"WXYY", 0x53},
-    {"WXYZ", 0x93},
-    {"WXYW", 0xD3},
-    {"WXZX", 0x23},
-    {"WXZY", 0x63},
-    {"WXZZ", 0xA3},
-    {"WXZW", 0xE3},
-    {"WXWX", 0x33},
-    {"WXWY", 0x73},
-    {"WXWZ", 0xB3},
-    {"WXWW", 0xF3},
-    {"WYXX", 0x7},
-    {"WYXY", 0x47},
-    {"WYXZ", 0x87},
-    {"WYXW", 0xC7},
-    {"WYYX", 0x17},
-    {"WYYY", 0x57},
-    {"WYYZ", 0x97},
-    {"WYYW", 0xD7},
-    {"WYZX", 0x27},
-    {"WYZY", 0x67},
-    {"WYZZ", 0xA7},
-    {"WYZW", 0xE7},
-    {"WYWX", 0x37},
-    {"WYWY", 0x77},
-    {"WYWZ", 0xB7},
-    {"WYWW", 0xF7},
-    {"WZXX", 0xB},
-    {"WZXY", 0x4B},
-    {"WZXZ", 0x8B},
-    {"WZXW", 0xCB},
-    {"WZYX", 0x1B},
-    {"WZYY", 0x5B},
-    {"WZYZ", 0x9B},
-    {"WZYW", 0xDB},
-    {"WZZX", 0x2B},
-    {"WZZY", 0x6B},
-    {"WZZZ", 0xAB},
-    {"WZZW", 0xEB},
-    {"WZWX", 0x3B},
-    {"WZWY", 0x7B},
-    {"WZWZ", 0xBB},
-    {"WZWW", 0xFB},
-    {"WWXX", 0xF},
-    {"WWXY", 0x4F},
-    {"WWXZ", 0x8F},
-    {"WWXW", 0xCF},
-    {"WWYX", 0x1F},
-    {"WWYY", 0x5F},
-    {"WWYZ", 0x9F},
-    {"WWYW", 0xDF},
-    {"WWZX", 0x2F},
-    {"WWZY", 0x6F},
-    {"WWZZ", 0xAF},
-    {"WWZW", 0xEF},
-    {"WWWX", 0x3F},
-    {"WWWY", 0x7F},
-    {"WWWZ", 0xBF},
-    {"WWWW", 0xFF},
-    {"XX", 0x0},
-    {"XY", 0x2},
-    {"YX", 0x1},
-    {"YY", 0x3},
-    {0,0}
-};
-
 JSObject *
 SIMDObject::initClass(JSContext *cx, Handle<GlobalObject *> global)
 {
     // SIMD relies on having the TypedObject module initialized.
     // In particular, the self-hosted code for array() wants
     // to be able to call GetTypedObjectModule(). It is NOT necessary
     // to install the TypedObjectModule global, but at the moment
     // those two things are not separable.
@@ -647,19 +383,16 @@ SIMDObject::initClass(JSContext *cx, Han
     RootedObject objProto(cx, global->getOrCreateObjectPrototype(cx));
     if (!objProto)
         return nullptr;
     RootedObject SIMD(cx, NewObjectWithGivenProto(cx, &SIMDObject::class_, objProto,
                                                   global, SingletonObject));
     if (!SIMD)
         return nullptr;
 
-    if (!JS_DefineConstIntegers(cx, SIMD, SHUFFLE_MASKS))
-        return nullptr;
-
     // float32x4
     RootedObject float32x4Object(cx);
     float32x4Object = CreateSimdClass<Float32x4Defn>(cx, global,
                                                      cx->names().float32x4);
     if (!float32x4Object)
         return nullptr;
 
     // Define float32x4 functions and install as a property of the SIMD object.

deleted file mode 100644
--- a/js/src/tests/ecma_6/TypedObject/simd/shufflemaskconstants.js
+++ /dev/null
@@ -1,274 +0,0 @@
-// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
-var BUGNUMBER = 1050214;
-
-var summary = "SIMD shuffle mask's constants";
-
-function test() {
-  print(BUGNUMBER + ": " + summary);
-
-  assertEq(SIMD.XXXX, 0x0);
-  assertEq(SIMD.XXXY, 0x40);
-  assertEq(SIMD.XXXZ, 0x80);
-  assertEq(SIMD.XXXW, 0xC0);
-  assertEq(SIMD.XXYX, 0x10);
-  assertEq(SIMD.XXYY, 0x50);
-  assertEq(SIMD.XXYZ, 0x90);
-  assertEq(SIMD.XXYW, 0xD0);
-  assertEq(SIMD.XXZX, 0x20);
-  assertEq(SIMD.XXZY, 0x60);
-  assertEq(SIMD.XXZZ, 0xA0);
-  assertEq(SIMD.XXZW, 0xE0);
-  assertEq(SIMD.XXWX, 0x30);
-  assertEq(SIMD.XXWY, 0x70);
-  assertEq(SIMD.XXWZ, 0xB0);
-  assertEq(SIMD.XXWW, 0xF0);
-  assertEq(SIMD.XYXX, 0x4);
-  assertEq(SIMD.XYXY, 0x44);
-  assertEq(SIMD.XYXZ, 0x84);
-  assertEq(SIMD.XYXW, 0xC4);
-  assertEq(SIMD.XYYX, 0x14);
-  assertEq(SIMD.XYYY, 0x54);
-  assertEq(SIMD.XYYZ, 0x94);
-  assertEq(SIMD.XYYW, 0xD4);
-  assertEq(SIMD.XYZX, 0x24);
-  assertEq(SIMD.XYZY, 0x64);
-  assertEq(SIMD.XYZZ, 0xA4);
-  assertEq(SIMD.XYZW, 0xE4);
-  assertEq(SIMD.XYWX, 0x34);
-  assertEq(SIMD.XYWY, 0x74);
-  assertEq(SIMD.XYWZ, 0xB4);
-  assertEq(SIMD.XYWW, 0xF4);
-  assertEq(SIMD.XZXX, 0x8);
-  assertEq(SIMD.XZXY, 0x48);
-  assertEq(SIMD.XZXZ, 0x88);
-  assertEq(SIMD.XZXW, 0xC8);
-  assertEq(SIMD.XZYX, 0x18);
-  assertEq(SIMD.XZYY, 0x58);
-  assertEq(SIMD.XZYZ, 0x98);
-  assertEq(SIMD.XZYW, 0xD8);
-  assertEq(SIMD.XZZX, 0x28);
-  assertEq(SIMD.XZZY, 0x68);
-  assertEq(SIMD.XZZZ, 0xA8);
-  assertEq(SIMD.XZZW, 0xE8);
-  assertEq(SIMD.XZWX, 0x38);
-  assertEq(SIMD.XZWY, 0x78);
-  assertEq(SIMD.XZWZ, 0xB8);
-  assertEq(SIMD.XZWW, 0xF8);
-  assertEq(SIMD.XWXX, 0xC);
-  assertEq(SIMD.XWXY, 0x4C);
-  assertEq(SIMD.XWXZ, 0x8C);
-  assertEq(SIMD.XWXW, 0xCC);
-  assertEq(SIMD.XWYX, 0x1C);
-  assertEq(SIMD.XWYY, 0x5C);
-  assertEq(SIMD.XWYZ, 0x9C);
-  assertEq(SIMD.XWYW, 0xDC);
-  assertEq(SIMD.XWZX, 0x2C);
-  assertEq(SIMD.XWZY, 0x6C);
-  assertEq(SIMD.XWZZ, 0xAC);
-  assertEq(SIMD.XWZW, 0xEC);
-  assertEq(SIMD.XWWX, 0x3C);
-  assertEq(SIMD.XWWY, 0x7C);
-  assertEq(SIMD.XWWZ, 0xBC);
-  assertEq(SIMD.XWWW, 0xFC);
-  assertEq(SIMD.YXXX, 0x1);
-  assertEq(SIMD.YXXY, 0x41);
-  assertEq(SIMD.YXXZ, 0x81);
-  assertEq(SIMD.YXXW, 0xC1);
-  assertEq(SIMD.YXYX, 0x11);
-  assertEq(SIMD.YXYY, 0x51);
-  assertEq(SIMD.YXYZ, 0x91);
-  assertEq(SIMD.YXYW, 0xD1);
-  assertEq(SIMD.YXZX, 0x21);
-  assertEq(SIMD.YXZY, 0x61);
-  assertEq(SIMD.YXZZ, 0xA1);
-  assertEq(SIMD.YXZW, 0xE1);
-  assertEq(SIMD.YXWX, 0x31);
-  assertEq(SIMD.YXWY, 0x71);
-  assertEq(SIMD.YXWZ, 0xB1);
-  assertEq(SIMD.YXWW, 0xF1);
-  assertEq(SIMD.YYXX, 0x5);
-  assertEq(SIMD.YYXY, 0x45);
-  assertEq(SIMD.YYXZ, 0x85);
-  assertEq(SIMD.YYXW, 0xC5);
-  assertEq(SIMD.YYYX, 0x15);
-  assertEq(SIMD.YYYY, 0x55);
-  assertEq(SIMD.YYYZ, 0x95);
-  assertEq(SIMD.YYYW, 0xD5);
-  assertEq(SIMD.YYZX, 0x25);
-  assertEq(SIMD.YYZY, 0x65);
-  assertEq(SIMD.YYZZ, 0xA5);
-  assertEq(SIMD.YYZW, 0xE5);
-  assertEq(SIMD.YYWX, 0x35);
-  assertEq(SIMD.YYWY, 0x75);
-  assertEq(SIMD.YYWZ, 0xB5);
-  assertEq(SIMD.YYWW, 0xF5);
-  assertEq(SIMD.YZXX, 0x9);
-  assertEq(SIMD.YZXY, 0x49);
-  assertEq(SIMD.YZXZ, 0x89);
-  assertEq(SIMD.YZXW, 0xC9);
-  assertEq(SIMD.YZYX, 0x19);
-  assertEq(SIMD.YZYY, 0x59);
-  assertEq(SIMD.YZYZ, 0x99);
-  assertEq(SIMD.YZYW, 0xD9);
-  assertEq(SIMD.YZZX, 0x29);
-  assertEq(SIMD.YZZY, 0x69);
-  assertEq(SIMD.YZZZ, 0xA9);
-  assertEq(SIMD.YZZW, 0xE9);
-  assertEq(SIMD.YZWX, 0x39);
-  assertEq(SIMD.YZWY, 0x79);
-  assertEq(SIMD.YZWZ, 0xB9);
-  assertEq(SIMD.YZWW, 0xF9);
-  assertEq(SIMD.YWXX, 0xD);
-  assertEq(SIMD.YWXY, 0x4D);
-  assertEq(SIMD.YWXZ, 0x8D);
-  assertEq(SIMD.YWXW, 0xCD);
-  assertEq(SIMD.YWYX, 0x1D);
-  assertEq(SIMD.YWYY, 0x5D);
-  assertEq(SIMD.YWYZ, 0x9D);
-  assertEq(SIMD.YWYW, 0xDD);
-  assertEq(SIMD.YWZX, 0x2D);
-  assertEq(SIMD.YWZY, 0x6D);
-  assertEq(SIMD.YWZZ, 0xAD);
-  assertEq(SIMD.YWZW, 0xED);
-  assertEq(SIMD.YWWX, 0x3D);
-  assertEq(SIMD.YWWY, 0x7D);
-  assertEq(SIMD.YWWZ, 0xBD);
-  assertEq(SIMD.YWWW, 0xFD);
-  assertEq(SIMD.ZXXX, 0x2);
-  assertEq(SIMD.ZXXY, 0x42);
-  assertEq(SIMD.ZXXZ, 0x82);
-  assertEq(SIMD.ZXXW, 0xC2);
-  assertEq(SIMD.ZXYX, 0x12);
-  assertEq(SIMD.ZXYY, 0x52);
-  assertEq(SIMD.ZXYZ, 0x92);
-  assertEq(SIMD.ZXYW, 0xD2);
-  assertEq(SIMD.ZXZX, 0x22);
-  assertEq(SIMD.ZXZY, 0x62);
-  assertEq(SIMD.ZXZZ, 0xA2);
-  assertEq(SIMD.ZXZW, 0xE2);
-  assertEq(SIMD.ZXWX, 0x32);
-  assertEq(SIMD.ZXWY, 0x72);
-  assertEq(SIMD.ZXWZ, 0xB2);
-  assertEq(SIMD.ZXWW, 0xF2);
-  assertEq(SIMD.ZYXX, 0x6);
-  assertEq(SIMD.ZYXY, 0x46);
-  assertEq(SIMD.ZYXZ, 0x86);
-  assertEq(SIMD.ZYXW, 0xC6);
-  assertEq(SIMD.ZYYX, 0x16);
-  assertEq(SIMD.ZYYY, 0x56);
-  assertEq(SIMD.ZYYZ, 0x96);
-  assertEq(SIMD.ZYYW, 0xD6);
-  assertEq(SIMD.ZYZX, 0x26);
-  assertEq(SIMD.ZYZY, 0x66);
-  assertEq(SIMD.ZYZZ, 0xA6);
-  assertEq(SIMD.ZYZW, 0xE6);
-  assertEq(SIMD.ZYWX, 0x36);
-  assertEq(SIMD.ZYWY, 0x76);
-  assertEq(SIMD.ZYWZ, 0xB6);
-  assertEq(SIMD.ZYWW, 0xF6);
-  assertEq(SIMD.ZZXX, 0xA);
-  assertEq(SIMD.ZZXY, 0x4A);
-  assertEq(SIMD.ZZXZ, 0x8A);
-  assertEq(SIMD.ZZXW, 0xCA);
-  assertEq(SIMD.ZZYX, 0x1A);
-  assertEq(SIMD.ZZYY, 0x5A);
-  assertEq(SIMD.ZZYZ, 0x9A);
-  assertEq(SIMD.ZZYW, 0xDA);
-  assertEq(SIMD.ZZZX, 0x2A);
-  assertEq(SIMD.ZZZY, 0x6A);
-  assertEq(SIMD.ZZZZ, 0xAA);
-  assertEq(SIMD.ZZZW, 0xEA);
-  assertEq(SIMD.ZZWX, 0x3A);
-  assertEq(SIMD.ZZWY, 0x7A);
-  assertEq(SIMD.ZZWZ, 0xBA);
-  assertEq(SIMD.ZZWW, 0xFA);
-  assertEq(SIMD.ZWXX, 0xE);
-  assertEq(SIMD.ZWXY, 0x4E);
-  assertEq(SIMD.ZWXZ, 0x8E);
-  assertEq(SIMD.ZWXW, 0xCE);
-  assertEq(SIMD.ZWYX, 0x1E);
-  assertEq(SIMD.ZWYY, 0x5E);
-  assertEq(SIMD.ZWYZ, 0x9E);
-  assertEq(SIMD.ZWYW, 0xDE);
-  assertEq(SIMD.ZWZX, 0x2E);
-  assertEq(SIMD.ZWZY, 0x6E);
-  assertEq(SIMD.ZWZZ, 0xAE);
-  assertEq(SIMD.ZWZW, 0xEE);
-  assertEq(SIMD.ZWWX, 0x3E);
-  assertEq(SIMD.ZWWY, 0x7E);
-  assertEq(SIMD.ZWWZ, 0xBE);
-  assertEq(SIMD.ZWWW, 0xFE);
-  assertEq(SIMD.WXXX, 0x3);
-  assertEq(SIMD.WXXY, 0x43);
-  assertEq(SIMD.WXXZ, 0x83);
-  assertEq(SIMD.WXXW, 0xC3);
-  assertEq(SIMD.WXYX, 0x13);
-  assertEq(SIMD.WXYY, 0x53);
-  assertEq(SIMD.WXYZ, 0x93);
-  assertEq(SIMD.WXYW, 0xD3);
-  assertEq(SIMD.WXZX, 0x23);
-  assertEq(SIMD.WXZY, 0x63);
-  assertEq(SIMD.WXZZ, 0xA3);
-  assertEq(SIMD.WXZW, 0xE3);
-  assertEq(SIMD.WXWX, 0x33);
-  assertEq(SIMD.WXWY, 0x73);
-  assertEq(SIMD.WXWZ, 0xB3);
-  assertEq(SIMD.WXWW, 0xF3);
-  assertEq(SIMD.WYXX, 0x7);
-  assertEq(SIMD.WYXY, 0x47);
-  assertEq(SIMD.WYXZ, 0x87);
-  assertEq(SIMD.WYXW, 0xC7);
-  assertEq(SIMD.WYYX, 0x17);
-  assertEq(SIMD.WYYY, 0x57);
-  assertEq(SIMD.WYYZ, 0x97);
-  assertEq(SIMD.WYYW, 0xD7);
-  assertEq(SIMD.WYZX, 0x27);
-  assertEq(SIMD.WYZY, 0x67);
-  assertEq(SIMD.WYZZ, 0xA7);
-  assertEq(SIMD.WYZW, 0xE7);
-  assertEq(SIMD.WYWX, 0x37);
-  assertEq(SIMD.WYWY, 0x77);
-  assertEq(SIMD.WYWZ, 0xB7);
-  assertEq(SIMD.WYWW, 0xF7);
-  assertEq(SIMD.WZXX, 0xB);
-  assertEq(SIMD.WZXY, 0x4B);
-  assertEq(SIMD.WZXZ, 0x8B);
-  assertEq(SIMD.WZXW, 0xCB);
-  assertEq(SIMD.WZYX, 0x1B);
-  assertEq(SIMD.WZYY, 0x5B);
-  assertEq(SIMD.WZYZ, 0x9B);
-  assertEq(SIMD.WZYW, 0xDB);
-  assertEq(SIMD.WZZX, 0x2B);
-  assertEq(SIMD.WZZY, 0x6B);
-  assertEq(SIMD.WZZZ, 0xAB);
-  assertEq(SIMD.WZZW, 0xEB);
-  assertEq(SIMD.WZWX, 0x3B);
-  assertEq(SIMD.WZWY, 0x7B);
-  assertEq(SIMD.WZWZ, 0xBB);
-  assertEq(SIMD.WZWW, 0xFB);
-  assertEq(SIMD.WWXX, 0xF);
-  assertEq(SIMD.WWXY, 0x4F);
-  assertEq(SIMD.WWXZ, 0x8F);
-  assertEq(SIMD.WWXW, 0xCF);
-  assertEq(SIMD.WWYX, 0x1F);
-  assertEq(SIMD.WWYY, 0x5F);
-  assertEq(SIMD.WWYZ, 0x9F);
-  assertEq(SIMD.WWYW, 0xDF);
-  assertEq(SIMD.WWZX, 0x2F);
-  assertEq(SIMD.WWZY, 0x6F);
-  assertEq(SIMD.WWZZ, 0xAF);
-  assertEq(SIMD.WWZW, 0xEF);
-  assertEq(SIMD.WWWX, 0x3F);
-  assertEq(SIMD.WWWY, 0x7F);
-  assertEq(SIMD.WWWZ, 0xBF);
-  assertEq(SIMD.WWWW, 0xFF);
-  assertEq(SIMD.XX, 0x0);
-  assertEq(SIMD.XY, 0x2);
-  assertEq(SIMD.YX, 0x1);
-  assertEq(SIMD.YY, 0x3);
-
-  if (typeof reportCompare === "function")
-    reportCompare(true, true);
-}
-
-test();