#define H_PRIME   1000003
#define HASH_LEN  11

// my_m128_t mimics Intel __m128i type
typedef struct my_m128_t my_m128_t;
struct my_m128_t { short m128i_i16[8]; };

// Simulate python modulo operator. Assumes mod is positive.
static int py_mod(int j, int mod)
{
   int ret;
   if (j >= 0) {
      ret = j % mod;
   } else {
      ret = j - (j / mod) * mod;
      if (ret) ret += mod;
   }
   return ret;
}

// Apart from:
//   -1 % 1001 == 1000
//   -2 % 1002 == 1000
// both -1 and -2 can never match any of 1000, 500, ..., 1
// Thus don't worry about the Python hash conversion from -1 to -2, except for M

int inner(
   int startval, int endval,
   int m2, int d2, int c2, int l2, int x2, int v2, int i2,
   my_m128_t* ps)
{
  int m, d, c, l, x, v, i;
  int m3, m4, m5, m6, m7, m8, m9;
  int d3, d4, d5, d6, d7, d8, d9;
  int c3, c4, c5, c6, c7, c8, c9;
  int l3, l4, l5, l6, l7, l8, l9;
  int x3, x4, x5, x6, x7, x8, x9;
  int v3, v4, v5, v6, v7, v8, v9;
  int i3, i4, i5, i6, i7, i8, i9;
  int q3, q4, q5, q6, q7, q8, q9;
  int iret = 0;

  for (q3 = startval; q3 < endval; ++q3) {
    if (q3 == 10 || q3 == 13) continue;
    m3 = (m2 ^ q3) * H_PRIME;
    d3 = (d2 ^ q3) * H_PRIME;
    c3 = (c2 ^ q3) * H_PRIME;
    l3 = (l2 ^ q3) * H_PRIME;
    x3 = (x2 ^ q3) * H_PRIME;
    v3 = (v2 ^ q3) * H_PRIME;
    i3 = (i2 ^ q3) * H_PRIME;
    for (q4 = 1; q4 < 128; ++q4) {
      if (q4 == 10 || q4 == 13) continue;
      m4 = (m3 ^ q4) * H_PRIME;
      d4 = (d3 ^ q4) * H_PRIME;
      c4 = (c3 ^ q4) * H_PRIME;
      l4 = (l3 ^ q4) * H_PRIME;
      x4 = (x3 ^ q4) * H_PRIME;
      v4 = (v3 ^ q4) * H_PRIME;
      i4 = (i3 ^ q4) * H_PRIME;
      for (q5 = 1; q5 < 128; ++q5) {
        if (q5 == 10 || q5 == 13) continue;
        m5 = (m4 ^ q5) * H_PRIME;
        d5 = (d4 ^ q5) * H_PRIME;
        c5 = (c4 ^ q5) * H_PRIME;
        l5 = (l4 ^ q5) * H_PRIME;
        x5 = (x4 ^ q5) * H_PRIME;
        v5 = (v4 ^ q5) * H_PRIME;
        i5 = (i4 ^ q5) * H_PRIME;
        for (q6 = 1; q6 < 128; ++q6) {
          if (q6 == 10 || q6 == 13) continue;
          m6 = (m5 ^ q6) * H_PRIME;
          d6 = (d5 ^ q6) * H_PRIME;
          c6 = (c5 ^ q6) * H_PRIME;
          l6 = (l5 ^ q6) * H_PRIME;
          x6 = (x5 ^ q6) * H_PRIME;
          v6 = (v5 ^ q6) * H_PRIME;
          i6 = (i5 ^ q6) * H_PRIME;
          for (q7 = 1; q7 < 128; ++q7) {
            if (q7 == 10 || q7 == 13) continue;
            m7 = (m6 ^ q7) * H_PRIME;
            d7 = (d6 ^ q7) * H_PRIME;
            c7 = (c6 ^ q7) * H_PRIME;
            l7 = (l6 ^ q7) * H_PRIME;
            x7 = (x6 ^ q7) * H_PRIME;
            v7 = (v6 ^ q7) * H_PRIME;
            i7 = (i6 ^ q7) * H_PRIME;
            for (q8 = 1; q8 < 128; ++q8) {
              if (q8 == 10 || q8 == 13) continue;
              m8 = (m7 ^ q8) * H_PRIME;
              d8 = (d7 ^ q8) * H_PRIME;
              c8 = (c7 ^ q8) * H_PRIME;
              l8 = (l7 ^ q8) * H_PRIME;
              x8 = (x7 ^ q8) * H_PRIME;
              v8 = (v7 ^ q8) * H_PRIME;
              i8 = (i7 ^ q8) * H_PRIME;
              for (q9 = 1; q9 < 128; ++q9) {
                if (q9 == 10 || q9 == 13) continue;
                m9 = (m8 ^ q9) ^ HASH_LEN;
                if (m9 == -1) m9 = -2;
                m = py_mod(m9, 1001);
                if (m != 1000) continue;
                d9 = (d8 ^ q9) ^ HASH_LEN;
                d = py_mod(d9, 1001);
                if (d != 500) continue;
                c9 = (c8 ^ q9) ^ HASH_LEN;
                c = py_mod(c9, 1001);
                if (c != 100) continue;
                l9 = (l8 ^ q9) ^ HASH_LEN;
                l = py_mod(l9, 1001);
                if (l != 50) continue;
                x9 = (x8 ^ q9) ^ HASH_LEN;
                x = py_mod(x9, 1001);
                if (x != 10) continue;
                v9 = (v8 ^ q9) ^ HASH_LEN;
                v = py_mod(v9, 1001);
                if (v != 5) continue;
                i9 = (i8 ^ q9) ^ HASH_LEN;
                i = py_mod(i9, 1001);
                if (i != 1) continue;
                ps[iret].m128i_i16[0] = q3;
                ps[iret].m128i_i16[1] = q4;
                ps[iret].m128i_i16[2] = q5;
                ps[iret].m128i_i16[3] = q6;
                ps[iret].m128i_i16[4] = q7;
                ps[iret].m128i_i16[5] = q8;
                ps[iret].m128i_i16[6] = q9;
                ++iret;
              }
            }
          }
        }
      }
    }
  }
  return iret;
}