
/* Tests in detail the core arithmetic for pcmp{e,i}str{i,m} using
   pcmpistri to drive it.  Does not check the e-vs-i or i-vs-m
   aspect. */

#include <string.h>
#include <stdio.h>
#include <assert.h>

typedef  unsigned int   UInt;
typedef  signed int     Int;
typedef  unsigned char  UChar;
typedef  unsigned short UShort;
typedef  unsigned long long int ULong;
typedef  UChar          Bool;
#define False ((Bool)0)
#define True  ((Bool)1)

//typedef  unsigned char  V128[16];
typedef
   union {
      UChar  uChar[16];
      UShort uShort[8];
      UInt   uInt[4];
      UInt   w32[4];
   }
   V128;

#define SHIFT_O   11
#define SHIFT_S   7
#define SHIFT_Z   6
#define SHIFT_A   4
#define SHIFT_C   0
#define SHIFT_P   2

#define MASK_O    (1ULL << SHIFT_O)
#define MASK_S    (1ULL << SHIFT_S)
#define MASK_Z    (1ULL << SHIFT_Z)
#define MASK_A    (1ULL << SHIFT_A)
#define MASK_C    (1ULL << SHIFT_C)
#define MASK_P    (1ULL << SHIFT_P)


UInt clz32 ( UInt x )
{
   Int y, m, n;
   y = -(x >> 16);
   m = (y >> 16) & 16;
   n = 16 - m;
   x = x >> m;
   y = x - 0x100;
   m = (y >> 16) & 8;
   n = n + m;
   x = x << m;
   y = x - 0x1000;
   m = (y >> 16) & 4;
   n = n + m;
   x = x << m;
   y = x - 0x4000;
   m = (y >> 16) & 2;
   n = n + m;
   x = x << m;
   y = x >> 14;
   m = y & ~(y >> 1);
   return n + 2 - m;
}

UInt ctz32 ( UInt x )
{
   return 32 - clz32((~x) & (x-1));
}

void expand ( V128* dst, char* summary )
{
   Int i;
   assert( strlen(summary) == 16 );
   for (i = 0; i < 16; i++) {
      UChar xx = 0;
      UChar x = summary[15-i];
      if      (x >= '0' && x <= '9') { xx = x - '0'; }
      else if (x >= 'A' && x <= 'F') { xx = x - 'A' + 10; }
      else if (x >= 'a' && x <= 'f') { xx = x - 'a' + 10; }
      else assert(0);

      assert(xx < 16);
      xx = (xx << 4) | xx;
      assert(xx < 256);
      dst->uChar[i] = xx;
   }
}

void try_istri ( char* which,
                 UInt(*h_fn)(V128*,V128*),
                 UInt(*s_fn)(V128*,V128*),
                 char* summL, char* summR )
{
   assert(strlen(which) == 2);
   V128 argL, argR;
   expand(&argL, summL);
   expand(&argR, summR);
   UInt h_res = h_fn(&argL, &argR);
   UInt s_res = s_fn(&argL, &argR);
   printf("istri %s  %s %s -> %08x %08x %s\n",
          which, summL, summR, h_res, s_res, h_res == s_res ? "" : "!!!!");
}

UInt zmask_from_V128 ( V128* arg )
{
   UInt i, res = 0;
   for (i = 0; i < 8; i++) {
      res |=  ((arg->uShort[i] == 0) ? 1 : 0) << i;
   }
   return res;
}

//////////////////////////////////////////////////////////
//                                                      //
//                       GENERAL                        //
//                                                      //
//////////////////////////////////////////////////////////


/* Given partial results from a 16-bit pcmpXstrX operation (intRes1,
   basically), generate an I- or M-format output value, also the new
   OSZACP flags.  */
static
void PCMPxSTRx_WRK_gen_output_fmt_I_wide ( /*OUT*/V128* resV,
					   /*OUT*/UInt* resOSZACP,
					   UInt intRes1,
					   UInt zmaskL, UInt zmaskR,
					   UInt validL,
					   UInt pol, UInt idx )
{
   assert((pol >> 2) == 0);
   assert((idx >> 1) == 0);

   UInt intRes2 = 0;
   switch (pol) {
      case 0: intRes2 = intRes1;          break; // pol +
      case 1: intRes2 = ~intRes1;         break; // pol -
      case 2: intRes2 = intRes1;          break; // pol m+
      case 3: intRes2 = intRes1 ^ validL; break; // pol m-
   }
   intRes2 &= 0xFF;

   // generate I-format output (an index in ECX)
   // generate ecx value
   UInt newECX = 0;
   if (idx) {
     // index of ms-1-bit
     newECX = intRes2 == 0 ? 8 : (31 - clz32(intRes2));
   } else {
     // index of ls-1-bit
     newECX = intRes2 == 0 ? 8 : ctz32(intRes2);
   }

   resV->w32[0] = newECX;
   resV->w32[1] = 0;
   resV->w32[2] = 0;
   resV->w32[3] = 0;

   // generate new flags, common to all ISTRI and ISTRM cases
   *resOSZACP    // A, P are zero
     = ((intRes2 == 0) ? 0 : MASK_C) // C == 0 iff intRes2 == 0
     | ((zmaskL == 0)  ? 0 : MASK_Z) // Z == 1 iff any in argL is 0
     | ((zmaskR == 0)  ? 0 : MASK_S) // S == 1 iff any in argR is 0
     | ((intRes2 & 1) << SHIFT_O);   // O == IntRes2[0]
}

/* Compute result and new OSZACP flags for all PCMP{E,I}STR{I,M}
   variants on 16-bit characters.

   For xSTRI variants, the new ECX value is placed in the 32 bits
   pointed to by *resV, and the top 96 bits are zeroed.  For xSTRM
   variants, the result is a 128 bit value and is placed at *resV in
   the obvious way.

   For all variants, the new OSZACP value is placed at *resOSZACP.

   argLV and argRV are the vector args.  The caller must prepare a
   8-bit mask for each, zmaskL and zmaskR.  For ISTRx variants this
   must be 1 for each zero byte of of the respective arg.  For ESTRx
   variants this is derived from the explicit length indication, and
   must be 0 in all places except at the bit index corresponding to
   the valid length (0 .. 8).  If the valid length is 8 then the
   mask must be all zeroes.  In all cases, bits 31:8 must be zero.

   imm8 is the original immediate from the instruction.  isSTRM
   indicates whether this is a xSTRM or xSTRI variant, which controls
   how much of *res is written.

   If the given imm8 case can be handled, the return value is True.
   If not, False is returned, and neither *res not *resOSZACP are
   altered.
*/

Bool pcmpXstrX_WRK_wide ( /*OUT*/V128* resV,
			  /*OUT*/UInt* resOSZACP,
			  V128* argLV,  V128* argRV,
			  UInt zmaskL, UInt zmaskR,
			  UInt imm8,   Bool isxSTRM )
{
   assert(imm8 < 0x80);
   assert((zmaskL >> 8) == 0);
   assert((zmaskR >> 8) == 0);

   /* Explicitly reject any imm8 values that haven't been validated,
      even if they would probably work.  Life is too short to have
      unvalidated cases in the code base. */
   switch (imm8) {
      case 0x01:
      case 0x03: case 0x09: case 0x0B: case 0x0D: case 0x13:
      case 0x1B: case 0x39: case 0x3B: case 0x45: case 0x4B:
         break;
      default:
         return False;
   }

   UInt fmt = (imm8 >> 0) & 3; // imm8[1:0]  data format
   UInt agg = (imm8 >> 2) & 3; // imm8[3:2]  aggregation fn
   UInt pol = (imm8 >> 4) & 3; // imm8[5:4]  polarity
   UInt idx = (imm8 >> 6) & 1; // imm8[6]    1==msb/bytemask

   /*----------------------------------------*/
   /*-- strcmp on wide data                --*/
   /*----------------------------------------*/

   if (agg == 2/*equal each, aka strcmp*/
       && (fmt == 1/*uw*/ || fmt == 3/*sw*/)) {
      Int    i;
      UShort* argL = (UShort*)argLV;
      UShort* argR = (UShort*)argRV;
      UInt boolResII = 0;
      for (i = 7; i >= 0; i--) {
         UShort cL  = argL[i];
         UShort cR  = argR[i];
         boolResII = (boolResII << 1) | (cL == cR ? 1 : 0);
      }
      UInt validL = ~(zmaskL | -zmaskL);  // not(left(zmaskL))
      UInt validR = ~(zmaskR | -zmaskR);  // not(left(zmaskR))

      // do invalidation, common to all equal-each cases
      UInt intRes1
         = (boolResII & validL & validR)  // if both valid, use cmpres
           | (~ (validL | validR));       // if both invalid, force 1
                                          // else force 0
      intRes1 &= 0xFF;

      // generate I-format output
      PCMPxSTRx_WRK_gen_output_fmt_I_wide(
         resV, resOSZACP,
         intRes1, zmaskL, zmaskR, validL, pol, idx
      );

      return True;
   }

   /*----------------------------------------*/
   /*-- set membership on wide data        --*/
   /*----------------------------------------*/

   if (agg == 0/*equal any, aka find chars in a set*/
       && (fmt == 1/*uw*/ || fmt == 3/*sw*/)) {
      /* argL: the string,  argR: charset */
      UInt   si, ci;
      UShort* argL    = (UShort*)argLV;
      UShort* argR    = (UShort*)argRV;
      UInt   boolRes = 0;
      UInt   validL  = ~(zmaskL | -zmaskL);  // not(left(zmaskL))
      UInt   validR  = ~(zmaskR | -zmaskR);  // not(left(zmaskR))

      for (si = 0; si < 8; si++) {
         if ((validL & (1 << si)) == 0)
            // run off the end of the string.
            break;
         UInt m = 0;
         for (ci = 0; ci < 8; ci++) {
            if ((validR & (1 << ci)) == 0) break;
            if (argR[ci] == argL[si]) { m = 1; break; }
         }
         boolRes |= (m << si);
      }

      // boolRes is "pre-invalidated"
      UInt intRes1 = boolRes & 0xFF;

      // generate I-format output
      PCMPxSTRx_WRK_gen_output_fmt_I_wide(
         resV, resOSZACP,
         intRes1, zmaskL, zmaskR, validL, pol, idx
      );

      return True;
   }

   /*----------------------------------------*/
   /*-- substring search on wide data      --*/
   /*----------------------------------------*/

   if (agg == 3/*equal ordered, aka substring search*/
       && (fmt == 1/*uw*/ || fmt == 3/*sw*/)) {

      /* argL: haystack,  argR: needle */
      UInt   ni, hi;
      UShort* argL    = (UShort*)argLV;
      UShort* argR    = (UShort*)argRV;
      UInt   boolRes = 0;
      UInt   validL  = ~(zmaskL | -zmaskL);  // not(left(zmaskL))
      UInt   validR  = ~(zmaskR | -zmaskR);  // not(left(zmaskR))
      for (hi = 0; hi < 8; hi++) {
         UInt m = 1;
         for (ni = 0; ni < 8; ni++) {
            if ((validR & (1 << ni)) == 0) break;
            UInt i = ni + hi;
            if (i >= 8) break;
            if (argL[i] != argR[ni]) { m = 0; break; }
         }
         boolRes |= (m << hi);
         if ((validL & (1 << hi)) == 0)
            // run off the end of the haystack
            break;
      }

      // boolRes is "pre-invalidated"
      UInt intRes1 = boolRes & 0xFF;

      // generate I-format output
      PCMPxSTRx_WRK_gen_output_fmt_I_wide(
         resV, resOSZACP,
         intRes1, zmaskL, zmaskR, validL, pol, idx
      );

      return True;
   }

   /*----------------------------------------*/
   /*-- ranges, unsigned wide data         --*/
   /*----------------------------------------*/

   if (agg == 1/*ranges*/
       && fmt == 1/*uw*/) {

      /* argL: string,  argR: range-pairs */
      UInt   ri, si;
      UShort* argL    = (UShort*)argLV;
      UShort* argR    = (UShort*)argRV;
      UInt   boolRes = 0;
      UInt   validL  = ~(zmaskL | -zmaskL);  // not(left(zmaskL))
      UInt   validR  = ~(zmaskR | -zmaskR);  // not(left(zmaskR))
      for (si = 0; si < 8; si++) {
         if ((validL & (1 << si)) == 0)
            // run off the end of the string
            break;
         UInt m = 0;
         for (ri = 0; ri < 8; ri += 2) {
            if ((validR & (3 << ri)) != (3 << ri)) break;
            if (argR[ri] <= argL[si] && argL[si] <= argR[ri+1]) {
               m = 1; break;
            }
         }
         boolRes |= (m << si);
      }

      // boolRes is "pre-invalidated"
      UInt intRes1 = boolRes & 0xFF;

      // generate I-format output
      PCMPxSTRx_WRK_gen_output_fmt_I_wide(
         resV, resOSZACP,
         intRes1, zmaskL, zmaskR, validL, pol, idx
      );

      return True;
   }

   return False;
}

//////////////////////////////////////////////////////////
//                                                      //
//                       ISTRI_4B                       //
//                                                      //
//////////////////////////////////////////////////////////

UInt h_pcmpistri_4B ( V128* argL, V128* argR )
{
   V128 block[2];
   memcpy(&block[0], argL, sizeof(V128));
   memcpy(&block[1], argR, sizeof(V128));
   ULong res, flags;
   __asm__ __volatile__(
      "subq      $1024,  %%rsp"             "\n\t"
      "movdqu    0(%2),  %%xmm2"            "\n\t"
      "movdqu    16(%2), %%xmm11"           "\n\t"
      "pcmpistri $0x4B,  %%xmm2, %%xmm11"   "\n\t"
      "pushfq"                              "\n\t"
      "popq      %%rdx"                     "\n\t"
      "movq      %%rcx,  %0"                "\n\t"
      "movq      %%rdx,  %1"                "\n\t"
      "addq      $1024,  %%rsp"             "\n\t"
      : /*out*/ "=r"(res), "=r"(flags) : "r"/*in*/(&block[0])
      : "rcx","rdx","xmm0","xmm2","xmm11","cc","memory"
   );
   return ((flags & 0x8D5) << 16) | (res & 0xFFFF);
}

UInt s_pcmpistri_4B ( V128* argLU, V128* argRU )
{
   V128 resV;
   UInt resOSZACP, resECX;
   Bool ok
      = pcmpXstrX_WRK_wide( &resV, &resOSZACP, argLU, argRU,
			    zmask_from_V128(argLU),
			    zmask_from_V128(argRU),
			    0x4B, False/*!isSTRM*/
        );
   assert(ok);
   resECX = resV.uInt[0];
   return (resOSZACP << 16) | resECX;
}

void istri_4B ( void )
{
   char* wot = "4B";
   UInt(*h)(V128*,V128*) = h_pcmpistri_4B;
   UInt(*s)(V128*,V128*) = s_pcmpistri_4B;

   try_istri(wot,h,s, "0000000000000000", "0000000000000000");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaa2aaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaa2aaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaa2aa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaa2aaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaa2aaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaa2a");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "baaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9aaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaa7aaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaa2aaa4aaa");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaa00aa");
   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaa00aa");

   try_istri(wot,h,s, "aaaaaaaa00aaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaa00aa");
   try_istri(wot,h,s, "aaaaaaaa00aaaaaa", "aaaaaaaaaaaa00aa");

   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaa00aaaaaa");

   try_istri(wot,h,s, "0000000000000000", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "8000000000000000", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "0000000000000001", "aaaaaaaa00aaaaaa");

   try_istri(wot,h,s, "0000000000000000", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "0000000000000000");
}

//////////////////////////////////////////////////////////
//                                                      //
//                       ISTRI_3B                       //
//                                                      //
//////////////////////////////////////////////////////////

UInt h_pcmpistri_3B ( V128* argL, V128* argR )
{
   V128 block[2];
   memcpy(&block[0], argL, sizeof(V128));
   memcpy(&block[1], argR, sizeof(V128));
   ULong res, flags;
   __asm__ __volatile__(
      "subq      $1024,  %%rsp"             "\n\t"
      "movdqu    0(%2),  %%xmm2"            "\n\t"
      "movdqu    16(%2), %%xmm11"           "\n\t"
      "pcmpistri $0x3B,  %%xmm2, %%xmm11"   "\n\t"
      "pushfq"                              "\n\t"
      "popq      %%rdx"                     "\n\t"
      "movq      %%rcx,  %0"                "\n\t"
      "movq      %%rdx,  %1"                "\n\t"
      "addq      $1024,  %%rsp"             "\n\t"
      : /*out*/ "=r"(res), "=r"(flags) : "r"/*in*/(&block[0])
      : "rcx","rdx","xmm0","xmm2","xmm11","cc","memory"
   );
   return ((flags & 0x8D5) << 16) | (res & 0xFFFF);
}

UInt s_pcmpistri_3B ( V128* argLU, V128* argRU )
{
   V128 resV;
   UInt resOSZACP, resECX;
   Bool ok
      = pcmpXstrX_WRK_wide( &resV, &resOSZACP, argLU, argRU,
			    zmask_from_V128(argLU),
			    zmask_from_V128(argRU),
			    0x3B, False/*!isSTRM*/
        );
   assert(ok);
   resECX = resV.uInt[0];
   return (resOSZACP << 16) | resECX;
}

void istri_3B ( void )
{
   char* wot = "3B";
   UInt(*h)(V128*,V128*) = h_pcmpistri_3B;
   UInt(*s)(V128*,V128*) = s_pcmpistri_3B;

   try_istri(wot,h,s, "0000000000000000", "0000000000000000");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaa2aaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaa2aaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaa2aa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaa2aaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaa2aaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaa2a");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "baaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9aaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaa7aaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaa2aaa4aaa");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaa00aa");
   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaa00aa");

   try_istri(wot,h,s, "aaaaaaaa00aaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaa00aa");
   try_istri(wot,h,s, "aaaaaaaa00aaaaaa", "aaaaaaaaaaaa00aa");

   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaa00aaaaaa");

   try_istri(wot,h,s, "0000000000000000", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "8000000000000000", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "0000000000000001", "aaaaaaaa00aaaaaa");

   try_istri(wot,h,s, "0000000000000000", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "0000000000000000");
}


//////////////////////////////////////////////////////////
//                                                      //
//                       ISTRI_0D                       //
//                                                      //
//////////////////////////////////////////////////////////

__attribute__((noinline))
UInt h_pcmpistri_0D ( V128* argL, V128* argR )
{
   V128 block[2];
   memcpy(&block[0], argL, sizeof(V128));
   memcpy(&block[1], argR, sizeof(V128));
   ULong res = 0, flags = 0;
   __asm__ __volatile__(
      "movdqu    0(%2),  %%xmm2"            "\n\t"
      "movdqu    16(%2), %%xmm11"           "\n\t"
      "pcmpistri $0x0D,  %%xmm2, %%xmm11"   "\n\t"
      //"pcmpistrm $0x0D,  %%xmm2, %%xmm11"   "\n\t"
      //"movd %%xmm0, %%ecx" "\n\t"
      "pushfq"                              "\n\t"
      "popq      %%rdx"                     "\n\t"
      "movq      %%rcx,  %0"                "\n\t"
      "movq      %%rdx,  %1"                "\n\t"
      : /*out*/ "=r"(res), "=r"(flags) : "r"/*in*/(&block[0])
      : "rcx","rdx","xmm0","xmm2","xmm11","cc","memory"
   );
   return ((flags & 0x8D5) << 16) | (res & 0xFFFF);
}

UInt s_pcmpistri_0D ( V128* argLU, V128* argRU )
{
   V128 resV;
   UInt resOSZACP, resECX;
   Bool ok
      = pcmpXstrX_WRK_wide( &resV, &resOSZACP, argLU, argRU,
			    zmask_from_V128(argLU),
			    zmask_from_V128(argRU),
			    0x0D, False/*!isSTRM*/
        );
   assert(ok);
   resECX = resV.uInt[0];
   return (resOSZACP << 16) | resECX;
}

void istri_0D ( void )
{
   char* wot = "0D";
   UInt(*h)(V128*,V128*) = h_pcmpistri_0D;
   UInt(*s)(V128*,V128*) = s_pcmpistri_0D;

   try_istri(wot,h,s, "11111111abcdef11", "0000000000abcdef");

   try_istri(wot,h,s, "11111111abcdef11", "00abcdef00abcdef");

   try_istri(wot,h,s, "11111111abcdef11", "0000000000abcdef");
   try_istri(wot,h,s, "1111111111abcdef", "0000000000abcdef");
   try_istri(wot,h,s, "111111111111abcd", "0000000000abcdef");

   try_istri(wot,h,s, "1111abcd11abcd11", "000000000000abcd");

   try_istri(wot,h,s, "11abcd1111abcd11", "000000000000abcd");
   try_istri(wot,h,s, "abcd111111abcd11", "000000000000abcd");
   try_istri(wot,h,s, "cd11111111abcd11", "000000000000abcd");

   try_istri(wot,h,s, "01abcd11abcd1111", "000000000000abcd");
   try_istri(wot,h,s, "00abcd11abcd1111", "000000000000abcd");
   try_istri(wot,h,s, "0000cd11abcd1111", "000000000000abcd");

   try_istri(wot,h,s, "00abcd1100abcd11", "000000000000abcd");
   try_istri(wot,h,s, "00abcd110000cd11", "000000000000abcd");

   try_istri(wot,h,s, "1111111111111234", "0000000000000000");
   try_istri(wot,h,s, "1111111111111234", "0000000000000011");
   try_istri(wot,h,s, "1111111111111234", "0000000000001111");

   try_istri(wot,h,s, "1111111111111234", "1111111111111234");
   try_istri(wot,h,s, "0a11111111111111", "000000000000000a");
   try_istri(wot,h,s, "0b11111111111111", "000000000000000a");

   try_istri(wot,h,s, "b111111111111111", "0000000000000000");
   try_istri(wot,h,s, "0000000000000000", "0000000000000000");
   try_istri(wot,h,s, "123456789abcdef1", "0000000000000000");
   try_istri(wot,h,s, "0000000000000000", "123456789abcdef1");
}


//////////////////////////////////////////////////////////
//                                                      //
//                       ISTRI_09                       //
//                                                      //
//////////////////////////////////////////////////////////

UInt h_pcmpistri_09 ( V128* argL, V128* argR )
{
   V128 block[2];
   memcpy(&block[0], argL, sizeof(V128));
   memcpy(&block[1], argR, sizeof(V128));
   ULong res, flags;
   __asm__ __volatile__(
      "subq      $1024,  %%rsp"             "\n\t"
      "movdqu    0(%2),  %%xmm2"            "\n\t"
      "movdqu    16(%2), %%xmm11"           "\n\t"
      "pcmpistri $0x09,  %%xmm2, %%xmm11"   "\n\t"
      "pushfq"                              "\n\t"
      "popq      %%rdx"                     "\n\t"
      "movq      %%rcx,  %0"                "\n\t"
      "movq      %%rdx,  %1"                "\n\t"
      "addq      $1024,  %%rsp"             "\n\t"
      : /*out*/ "=r"(res), "=r"(flags) : "r"/*in*/(&block[0])
      : "rcx","rdx","xmm0","xmm2","xmm11","cc","memory"
   );
   return ((flags & 0x8D5) << 16) | (res & 0xFFFF);
}

UInt s_pcmpistri_09 ( V128* argLU, V128* argRU )
{
   V128 resV;
   UInt resOSZACP, resECX;
   Bool ok
      = pcmpXstrX_WRK_wide( &resV, &resOSZACP, argLU, argRU,
			    zmask_from_V128(argLU),
			    zmask_from_V128(argRU),
			    0x09, False/*!isSTRM*/
        );
   assert(ok);
   resECX = resV.uInt[0];
   return (resOSZACP << 16) | resECX;
}

void istri_09 ( void )
{
   char* wot = "09";
   UInt(*h)(V128*,V128*) = h_pcmpistri_09;
   UInt(*s)(V128*,V128*) = s_pcmpistri_09;

   try_istri(wot,h,s, "0000000000000000", "0000000000000000");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaa2aaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaa2aaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaa2aa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaa2aaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaa2aaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaa2a");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "baaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9aaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaa7aaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaa2aaa4aaa");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaa00aa");
   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaa00aa");

   try_istri(wot,h,s, "aaaaaaaa00aaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaa00aa");
   try_istri(wot,h,s, "aaaaaaaa00aaaaaa", "aaaaaaaaaaaa00aa");

   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaa00aaaaaa");

   try_istri(wot,h,s, "0000000000000000", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "8000000000000000", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "0000000000000001", "aaaaaaaa00aaaaaa");

   try_istri(wot,h,s, "0000000000000000", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "0000000000000000");
}


//////////////////////////////////////////////////////////
//                                                      //
//                       ISTRI_1B                       //
//                                                      //
//////////////////////////////////////////////////////////

UInt h_pcmpistri_1B ( V128* argL, V128* argR )
{
   V128 block[2];
   memcpy(&block[0], argL, sizeof(V128));
   memcpy(&block[1], argR, sizeof(V128));
   ULong res, flags;
   __asm__ __volatile__(
      "subq      $1024,  %%rsp"             "\n\t"
      "movdqu    0(%2),  %%xmm2"            "\n\t"
      "movdqu    16(%2), %%xmm11"           "\n\t"
      "pcmpistri $0x1B,  %%xmm2, %%xmm11"   "\n\t"
      "pushfq"                              "\n\t"
      "popq      %%rdx"                     "\n\t"
      "movq      %%rcx,  %0"                "\n\t"
      "movq      %%rdx,  %1"                "\n\t"
      "addq      $1024,  %%rsp"             "\n\t"
      : /*out*/ "=r"(res), "=r"(flags) : "r"/*in*/(&block[0])
      : "rcx","rdx","xmm0","xmm2","xmm11","cc","memory"
   );
   return ((flags & 0x8D5) << 16) | (res & 0xFFFF);
}

UInt s_pcmpistri_1B ( V128* argLU, V128* argRU )
{
   V128 resV;
   UInt resOSZACP, resECX;
   Bool ok
      = pcmpXstrX_WRK_wide( &resV, &resOSZACP, argLU, argRU,
			    zmask_from_V128(argLU),
			    zmask_from_V128(argRU),
			    0x1B, False/*!isSTRM*/
        );
   assert(ok);
   resECX = resV.uInt[0];
   return (resOSZACP << 16) | resECX;
}

void istri_1B ( void )
{
   char* wot = "1B";
   UInt(*h)(V128*,V128*) = h_pcmpistri_1B;
   UInt(*s)(V128*,V128*) = s_pcmpistri_1B;

   try_istri(wot,h,s, "0000000000000000", "0000000000000000");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaa2aaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaa2aaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaa2aa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaa2aaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaa2aaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaa2a");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "baaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9aaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaa7aaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaa2aaa4aaa");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaa00aa");
   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaa00aa");

   try_istri(wot,h,s, "aaaaaaaa00aaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaa00aa");
   try_istri(wot,h,s, "aaaaaaaa00aaaaaa", "aaaaaaaaaaaa00aa");

   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaa00aaaaaa");

   try_istri(wot,h,s, "0000000000000000", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "8000000000000000", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "0000000000000001", "aaaaaaaa00aaaaaa");

   try_istri(wot,h,s, "0000000000000000", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "0000000000000000");
}


//////////////////////////////////////////////////////////
//                                                      //
//                       ISTRI_03                       //
//                                                      //
//////////////////////////////////////////////////////////

UInt h_pcmpistri_03 ( V128* argL, V128* argR )
{
   V128 block[2];
   memcpy(&block[0], argL, sizeof(V128));
   memcpy(&block[1], argR, sizeof(V128));
   ULong res, flags;
   __asm__ __volatile__(
      "subq      $1024,  %%rsp"             "\n\t"
      "movdqu    0(%2),  %%xmm2"            "\n\t"
      "movdqu    16(%2), %%xmm11"           "\n\t"
      "pcmpistri $0x03,  %%xmm2, %%xmm11"   "\n\t"
//"pcmpistrm $0x03, %%xmm2, %%xmm11"   "\n\t"
//"movd %%xmm0, %%ecx" "\n\t"
      "pushfq"                              "\n\t"
      "popq      %%rdx"                     "\n\t"
      "movq      %%rcx,  %0"                "\n\t"
      "movq      %%rdx,  %1"                "\n\t"
      "addq      $1024,  %%rsp"             "\n\t"
      : /*out*/ "=r"(res), "=r"(flags) : "r"/*in*/(&block[0])
      : "rcx","rdx","xmm0","xmm2","xmm11","cc","memory"
   );
   return ((flags & 0x8D5) << 16) | (res & 0xFFFF);
}

UInt s_pcmpistri_03 ( V128* argLU, V128* argRU )
{
   V128 resV;
   UInt resOSZACP, resECX;
   Bool ok
      = pcmpXstrX_WRK_wide( &resV, &resOSZACP, argLU, argRU,
			    zmask_from_V128(argLU),
			    zmask_from_V128(argRU),
			    0x03, False/*!isSTRM*/
        );
   assert(ok);
   resECX = resV.uInt[0];
   return (resOSZACP << 16) | resECX;
}

void istri_03 ( void )
{
   char* wot = "03";
   UInt(*h)(V128*,V128*) = h_pcmpistri_03;
   UInt(*s)(V128*,V128*) = s_pcmpistri_03;

   try_istri(wot,h,s, "aacdacbdaacdaacd", "00000000000000aa");
   try_istri(wot,h,s, "aabbaabbaabbaabb", "00000000000000bb");
   try_istri(wot,h,s, "aabbccddaabbccdd", "000000000000aabb");
   try_istri(wot,h,s, "abcdabc0abcdabcd", "000000000000abcd");

   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aabbccdd");
   try_istri(wot,h,s, "00bbccddaabbccdd", "00000000aabbccdd");
   try_istri(wot,h,s, "aabbccddaa00ccdd", "00000000aabbccdd");
   try_istri(wot,h,s, "aabbccddaabb00dd", "00000000aabbccdd");
   try_istri(wot,h,s, "aabbccddaabbcc00", "00000000aabbccdd");

   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aabbccdd");
   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aa00ccdd");
   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aabb00dd");
   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aabbcc00");

   try_istri(wot,h,s, "0000000000000000", "0000000000000000");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "0000abcdabcdabcd", "000000000000abcd");
   try_istri(wot,h,s, "0000abcdabcdabcd", "000000000000dcba");
   try_istri(wot,h,s, "0000aabbaabbaabb", "000000000000bbbb");
   try_istri(wot,h,s, "0000ccddaabbccdd", "00000000bbaabbaa");

   try_istri(wot,h,s, "0000ccddaabbccdd", "000000bbaabbaa00");

   try_istri(wot,h,s, "0ddc0ffeebadf00d", "00000000cafebabe");
   try_istri(wot,h,s, "0ddc0ffeebadfeed", "00000000cafebabe");
}


//////////////////////////////////////////////////////////
//                                                      //
//                       ISTRI_13                       //
//                                                      //
//////////////////////////////////////////////////////////

UInt h_pcmpistri_13 ( V128* argL, V128* argR )
{
   V128 block[2];
   memcpy(&block[0], argL, sizeof(V128));
   memcpy(&block[1], argR, sizeof(V128));
   ULong res, flags;
   __asm__ __volatile__(
      "subq      $1024,  %%rsp"             "\n\t"
      "movdqu    0(%2),  %%xmm2"            "\n\t"
      "movdqu    16(%2), %%xmm11"           "\n\t"
      "pcmpistri $0x13,  %%xmm2, %%xmm11"   "\n\t"
//"pcmpistrm $0x13, %%xmm2, %%xmm11"   "\n\t"
//"movd %%xmm0, %%ecx" "\n\t"
      "pushfq"                              "\n\t"
      "popq      %%rdx"                     "\n\t"
      "movq      %%rcx,  %0"                "\n\t"
      "movq      %%rdx,  %1"                "\n\t"
      "addq      $1024,  %%rsp"             "\n\t"
      : /*out*/ "=r"(res), "=r"(flags) : "r"/*in*/(&block[0])
      : "rcx","rdx","xmm0","xmm2","xmm11","cc","memory"
   );
   return ((flags & 0x8D5) << 16) | (res & 0xFFFF);
}

UInt s_pcmpistri_13 ( V128* argLU, V128* argRU )
{
   V128 resV;
   UInt resOSZACP, resECX;
   Bool ok
      = pcmpXstrX_WRK_wide( &resV, &resOSZACP, argLU, argRU,
			    zmask_from_V128(argLU),
			    zmask_from_V128(argRU),
			    0x13, False/*!isSTRM*/
        );
   assert(ok);
   resECX = resV.uInt[0];
   return (resOSZACP << 16) | resECX;
}

void istri_13 ( void )
{
   char* wot = "13";
   UInt(*h)(V128*,V128*) = h_pcmpistri_13;
   UInt(*s)(V128*,V128*) = s_pcmpistri_13;

   try_istri(wot,h,s, "aacdacbdaacdaacd", "00000000000000aa");
   try_istri(wot,h,s, "aabbaabbaabbaabb", "00000000000000bb");
   try_istri(wot,h,s, "aabbccddaabbccdd", "000000000000aabb");
   try_istri(wot,h,s, "abcdabc0abcdabcd", "000000000000abcd");

   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aabbccdd");
   try_istri(wot,h,s, "00bbccddaabbccdd", "00000000aabbccdd");
   try_istri(wot,h,s, "aabbccddaa00ccdd", "00000000aabbccdd");
   try_istri(wot,h,s, "aabbccddaabb00dd", "00000000aabbccdd");
   try_istri(wot,h,s, "aabbccddaabbcc00", "00000000aabbccdd");

   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aabbccdd");
   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aa00ccdd");
   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aabb00dd");
   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aabbcc00");

   try_istri(wot,h,s, "0000000000000000", "0000000000000000");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "0000abcdabcdabcd", "000000000000abcd");
   try_istri(wot,h,s, "0000abcdabcdabcd", "000000000000dcba");
   try_istri(wot,h,s, "0000aabbaabbaabb", "000000000000bbbb");
   try_istri(wot,h,s, "0000ccddaabbccdd", "00000000bbaabbaa");

   try_istri(wot,h,s, "0000ccddaabbccdd", "000000bbaabbaa00");

   try_istri(wot,h,s, "0ddc0ffeebadf00d", "00000000cafebabe");
   try_istri(wot,h,s, "0ddc0ffeebadfeed", "00000000cafebabe");
}


//////////////////////////////////////////////////////////
//                                                      //
//                       ISTRI_45                       //
//                                                      //
//////////////////////////////////////////////////////////

UInt h_pcmpistri_45 ( V128* argL, V128* argR )
{
   V128 block[2];
   memcpy(&block[0], argL, sizeof(V128));
   memcpy(&block[1], argR, sizeof(V128));
   ULong res, flags;
   __asm__ __volatile__(
      "subq      $1024,  %%rsp"             "\n\t"
      "movdqu    0(%2),  %%xmm2"            "\n\t"
      "movdqu    16(%2), %%xmm11"           "\n\t"
      "pcmpistri $0x45,  %%xmm2, %%xmm11"   "\n\t"
//"pcmpistrm $0x04, %%xmm2, %%xmm11"   "\n\t"
//"movd %%xmm0, %%ecx" "\n\t"
      "pushfq"                              "\n\t"
      "popq      %%rdx"                     "\n\t"
      "movq      %%rcx,  %0"                "\n\t"
      "movq      %%rdx,  %1"                "\n\t"
      "addq      $1024,  %%rsp"             "\n\t"
      : /*out*/ "=r"(res), "=r"(flags) : "r"/*in*/(&block[0])
      : "rcx","rdx","xmm0","xmm2","xmm11","cc","memory"
   );
   return ((flags & 0x8D5) << 16) | (res & 0xFFFF);
}

UInt s_pcmpistri_45 ( V128* argLU, V128* argRU )
{
   V128 resV;
   UInt resOSZACP, resECX;
   Bool ok
      = pcmpXstrX_WRK_wide( &resV, &resOSZACP, argLU, argRU,
			    zmask_from_V128(argLU),
			    zmask_from_V128(argRU),
			    0x45, False/*!isSTRM*/
        );
   assert(ok);
   resECX = resV.uInt[0];
   return (resOSZACP << 16) | resECX;
}

void istri_45 ( void )
{
   char* wot = "45";
   UInt(*h)(V128*,V128*) = h_pcmpistri_45;
   UInt(*s)(V128*,V128*) = s_pcmpistri_45;

   try_istri(wot,h,s, "aaaabbbbccccdddd", "000000000000bbcc");
   try_istri(wot,h,s, "aaaabbbbccccdddd", "000000000000ccbb");
   try_istri(wot,h,s, "baaabbbbccccdddd", "000000000000ccbb");
   try_istri(wot,h,s, "baaabbbbccccdddc", "000000000000ccbb");

   try_istri(wot,h,s, "bbbbbbbbbbbbbbbb", "000000000000ccbb");
   try_istri(wot,h,s, "bbbbbbbb00bbbbbb", "000000000000ccbb");
   try_istri(wot,h,s, "bbbbbbbbbbbb00bb", "000000000000ccbb");
   try_istri(wot,h,s, "bbbbbbbbbbbbbb00", "000000000000ccbb");
   try_istri(wot,h,s, "0000000000000000", "000000000000ccbb");

   try_istri(wot,h,s, "0000000000000000", "0000000000000000");

   try_istri(wot,h,s, "bbbbbbbbbbbbbbbb", "000000000000ccbb");
   try_istri(wot,h,s, "bbbbbbbbbbbbbbbb", "00000000000000bb");
   try_istri(wot,h,s, "bb44bb44bb44bb44", "000000006622ccbb");

   try_istri(wot,h,s, "bb44bb44bb44bb44", "000000000022ccbb");
   try_istri(wot,h,s, "bb44bb44bb44bb44", "000000000000ccbb");
   try_istri(wot,h,s, "bb44bb44bb44bb44", "00000000000000bb");

   try_istri(wot,h,s, "0011223344556677", "0000997755442211");
   try_istri(wot,h,s, "1122334455667711", "0000997755442211");

   try_istri(wot,h,s, "0011223344556677", "0000aa8866553322");
   try_istri(wot,h,s, "1122334455667711", "0000aa8866553322");
}


//////////////////////////////////////////////////////////
//                                                      //
//                       ISTRI_01                       //
//                                                      //
//////////////////////////////////////////////////////////

UInt h_pcmpistri_01 ( V128* argL, V128* argR )
{
   V128 block[2];
   memcpy(&block[0], argL, sizeof(V128));
   memcpy(&block[1], argR, sizeof(V128));
   ULong res, flags;
   __asm__ __volatile__(
      "subq      $1024,  %%rsp"             "\n\t"
      "movdqu    0(%2),  %%xmm2"            "\n\t"
      "movdqu    16(%2), %%xmm11"           "\n\t"
      "pcmpistri $0x01,  %%xmm2, %%xmm11"   "\n\t"
//"pcmpistrm $0x01, %%xmm2, %%xmm11"   "\n\t"
//"movd %%xmm0, %%ecx" "\n\t"
      "pushfq"                              "\n\t"
      "popq      %%rdx"                     "\n\t"
      "movq      %%rcx,  %0"                "\n\t"
      "movq      %%rdx,  %1"                "\n\t"
      "addq      $1024,  %%rsp"             "\n\t"
      : /*out*/ "=r"(res), "=r"(flags) : "r"/*in*/(&block[0])
      : "rcx","rdx","xmm0","xmm2","xmm11","cc","memory"
   );
   return ((flags & 0x8D5) << 16) | (res & 0xFFFF);
}

UInt s_pcmpistri_01 ( V128* argLU, V128* argRU )
{
   V128 resV;
   UInt resOSZACP, resECX;
   Bool ok
      = pcmpXstrX_WRK_wide( &resV, &resOSZACP, argLU, argRU,
			    zmask_from_V128(argLU),
			    zmask_from_V128(argRU),
			    0x01, False/*!isSTRM*/
        );
   assert(ok);
   resECX = resV.uInt[0];
   return (resOSZACP << 16) | resECX;
}

void istri_01 ( void )
{
   char* wot = "01";
   UInt(*h)(V128*,V128*) = h_pcmpistri_01;
   UInt(*s)(V128*,V128*) = s_pcmpistri_01;

   try_istri(wot,h,s, "aacdacbdaacdaacd", "00000000000000aa");
   try_istri(wot,h,s, "aabbaabbaabbaabb", "00000000000000bb");
   try_istri(wot,h,s, "aabbccddaabbccdd", "000000000000aabb");
   try_istri(wot,h,s, "abcdabc0abcdabcd", "000000000000abcd");

   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aabbccdd");
   try_istri(wot,h,s, "00bbccddaabbccdd", "00000000aabbccdd");
   try_istri(wot,h,s, "aabbccddaa00ccdd", "00000000aabbccdd");
   try_istri(wot,h,s, "aabbccddaabb00dd", "00000000aabbccdd");
   try_istri(wot,h,s, "aabbccddaabbcc00", "00000000aabbccdd");

   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aabbccdd");
   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aa00ccdd");
   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aabb00dd");
   try_istri(wot,h,s, "aabbccddaabbccdd", "00000000aabbcc00");

   try_istri(wot,h,s, "0000000000000000", "0000000000000000");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "0000abcdabcdabcd", "000000000000abcd");
   try_istri(wot,h,s, "0000abcdabcdabcd", "000000000000dcba");
   try_istri(wot,h,s, "0000aabbaabbaabb", "000000000000bbbb");
   try_istri(wot,h,s, "0000ccddaabbccdd", "00000000bbaabbaa");

   try_istri(wot,h,s, "0000ccddaabbccdd", "000000bbaabbaa00");

   try_istri(wot,h,s, "0ddc0ffeebadf00d", "00000000cafebabe");
   try_istri(wot,h,s, "0ddc0ffeebadfeed", "00000000cafebabe");
}


//////////////////////////////////////////////////////////
//                                                      //
//                       ISTRI_39                       //
//                                                      //
//////////////////////////////////////////////////////////

UInt h_pcmpistri_39 ( V128* argL, V128* argR )
{
   V128 block[2];
   memcpy(&block[0], argL, sizeof(V128));
   memcpy(&block[1], argR, sizeof(V128));
   ULong res, flags;
   __asm__ __volatile__(
      "subq      $1024,  %%rsp"             "\n\t"
      "movdqu    0(%2),  %%xmm2"            "\n\t"
      "movdqu    16(%2), %%xmm11"           "\n\t"
      "pcmpistri $0x39,  %%xmm2, %%xmm11"   "\n\t"
      "pushfq"                              "\n\t"
      "popq      %%rdx"                     "\n\t"
      "movq      %%rcx,  %0"                "\n\t"
      "movq      %%rdx,  %1"                "\n\t"
      "addq      $1024,  %%rsp"             "\n\t"
      : /*out*/ "=r"(res), "=r"(flags) : "r"/*in*/(&block[0])
      : "rcx","rdx","xmm0","xmm2","xmm11","cc","memory"
   );
   return ((flags & 0x8D5) << 16) | (res & 0xFFFF);
}

UInt s_pcmpistri_39 ( V128* argLU, V128* argRU )
{
   V128 resV;
   UInt resOSZACP, resECX;
   Bool ok
      = pcmpXstrX_WRK_wide( &resV, &resOSZACP, argLU, argRU,
			    zmask_from_V128(argLU),
			    zmask_from_V128(argRU),
			    0x39, False/*!isSTRM*/
        );
   assert(ok);
   resECX = resV.uInt[0];
   return (resOSZACP << 16) | resECX;
}

void istri_39 ( void )
{
   char* wot = "39";
   UInt(*h)(V128*,V128*) = h_pcmpistri_39;
   UInt(*s)(V128*,V128*) = s_pcmpistri_39;

   try_istri(wot,h,s, "0000000000000000", "0000000000000000");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaa2aaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaa2aaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaa2aa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaa2aaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaa2aaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaa2a");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "baaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9aaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaaaaaa7aaa");
   try_istri(wot,h,s, "b9baaaaaaaaaaaaa", "aaaaaaaa2aaa4aaa");

   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaa");

   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaa00aa");
   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaa00aa");

   try_istri(wot,h,s, "aaaaaaaa00aaaaaa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaa00aa");
   try_istri(wot,h,s, "aaaaaaaa00aaaaaa", "aaaaaaaaaaaa00aa");

   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaa00aa", "aaaaaaaa00aaaaaa");

   try_istri(wot,h,s, "0000000000000000", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "8000000000000000", "aaaaaaaa00aaaaaa");
   try_istri(wot,h,s, "0000000000000001", "aaaaaaaa00aaaaaa");

   try_istri(wot,h,s, "0000000000000000", "aaaaaaaaaaaaaaaa");
   try_istri(wot,h,s, "aaaaaaaaaaaaaaaa", "0000000000000000");
}


//////////////////////////////////////////////////////////
//                                                      //
//                         main                         //
//                                                      //
//////////////////////////////////////////////////////////

int main ( void )
{
   istri_4B();
   istri_3B();
   istri_09();
   istri_1B();
   istri_03();
   istri_0D();
   istri_13();
   istri_45();
   istri_01();
   istri_39();
   return 0;
}