branches/mty-makai/mty.c

/***********************************************************************
 *
 *      file: mty.c
 *
 *      まあ、待て屋。
 *
 *      $Id$
 *
 */

#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/timeb.h>
#include <sys/types.h>

/* MAKAI start */
#include <unistd.h>
#include <libgen.h>
/* MAKAI end */

#if defined(WIN32)

#include <windows.h>
#include <process.h>

#elif defined(__GNUC__)

#include <sys/time.h>

#endif

#include "config.h"
#include "cp932.h"
#include "crypt64.h"
#include "desconst.h"
#include "expr_parse.h"
#include "scoreboard.h"
#include "synth.h"
#include "tr64.h"
#include "translate.h"
#include "util.h"
#include "wdict.h"

#if USE_DT
#include "dt4.h"
#endif

/* MAKAI start */
#define MIN_THREAD  1
#define MAX_THREAD 32
int     nThread = 0;

#define MIN_UME 3
#define MAX_UME 6
unsigned char   umeStr[10];
int     umeLen;
/* MAKAI end */

/* CRYPT64 記述子 */
static
struct CRYPT64_DESC const *const crypt64_descs[] =
{
  &crypt64_desc,
};

/* 鍵クラス */
static
struct
{
  unsigned short map[256];
} kcls[8 + 8];

/* 拡張鍵クラス */
#define KCLS_DT0 64
#define KCLS_DT1 128
#define KCLS_K2 256

#if USE_DT
/* 鍵キメ用辞書インデクス */
struct DT *kd[8 + 8];

/* 辞書インデクス */
struct DT *dtidx[0x100 + 1];
#endif

/* 指定されたクラスと入っているキーから、classify を行う */
void
key_make_map(uint8_t *key, int n)
{
  int i, j;
  unsigned c = kcls[n].map[key[n]];

#if USE_DT
  if (3 <= n && n < 7 && kd[n - 3])
        {
          /* 辞書のケツの文字。後ろにナニヤラキャラクタが来る */
          c = kd[n - 3]->c[0];
          if ((0x81 <= c && c <= 0x9F)
                  || (0xE0 <= c && c <= 0xFC))
                c = KCLS_K2;
          else
                c = (cp932[256 * key[n]]
                         | cp932[256 * (key[n] ^ 0x80)]);
#if DEBUG>=1
          printf("*n=%d, key=%02X, cls=%04X\n",
                         n,
                         key[n],
                         c);
#endif
        }
  else if (2 <= n && n < 6 && kd[n - 2])
        {
          return;
        }
  else if (1 <= n && n < 5 && kd[n - 1])
        {
          return;
        }
  else if (1 <= n && n < 5 && !kd[n - 1]
                   //&& (c & KCLS_K2)
                   && (c & KCLS_DT1))
        {
          /* 漢字2文字を拾っていきまつ */
#if DEBUG>=1
          printf("(%d)%02X %02X(%02X:%02X:%02X:%02X)\n",
                         n, key[n - 1], key[n],
                         cp932[(256 * key[n - 1] + key[n])],
                         cp932[(256 * key[n - 1] + key[n]) ^ 0x0080],
                         cp932[(256 * key[n - 1] + key[n]) ^ 0x8000],
                         cp932[(256 * key[n - 1] + key[n]) ^ 0x8080]);
#endif
          if (n != 1 && n != 2
                  && (cp932[(256 * key[n - 1] + key[n]) ^ 0x0080] & KCLS_DT1))
                key[n] ^= 0x80;
          else if (n != 2 && n != 3
                           && (cp932[(256 * key[n - 1] + key[n]) ^ 0x8000] & KCLS_DT1))
                key[n - 1] ^= 0x80;
          else if (n > 3 && (cp932[(256 * key[n - 1] + key[n]) ^ 0x8080] & KCLS_DT1))
                key[n - 1] ^= 0x80, key[n] ^= 0x80;
          if (cp932[256 * key[n - 1] + key[n]] & KCLS_DT1)
                {
                  for (kd[n - 1] = dtidx[key[n - 1]];
                           kd[n - 1]->c[1] != key[n];
                           kd[n - 1]++)
                        assert(kd[n - 1]->c[0] == key[n - 1]);
#if DEBUG>=1
                  printf("(%02X%02X:%02X%02X)%c%c%c%c\n",
                                 kd[n - 1]->c[0],
                                 kd[n - 1]->c[1],
                                 kd[n - 1]->c[2],
                                 kd[n - 1]->c[3],
                                 kd[n - 1]->c[0],
                                 kd[n - 1]->c[1],
                                 kd[n - 1]->c[2],
                                 kd[n - 1]->c[3]);
#endif
                  return;
                }
        }
  else if (n < 4 && (c & KCLS_DT0) && kd[n] == NULL)
        {
          /* カタカナ埋め込みいきます */
          assert(kd[n] == NULL);
#if DEBUG>=1
          printf("n=%d, key=%02X\n", n, key[n]);
#endif
          kd[n] = dtidx[key[n]];
          if (!kd[n]
                  && !(n == 1 || n == 2)
                  && dtidx[key[n] ^ 0x80])
                {
                  key[n] ^= 0x80;
                  kd[n] = dtidx[key[n]];
                }
          if (kd[n])
                return;
        }
  else
        {
          kd[n] = NULL;
        }
#endif

  /* 最後の部分は class map を生成する必要ナシ */
  if (n >= 6)
        return;

  for (i = 0; i < 256; i++)
        {
          unsigned bm = 0;
#if 1
          if (c & KCLS_K1)
                {
                  if (cp932[256 * key[n] + i] & KCLS_K1)
                        bm |= KCLS_K2 | (cp932[256 * key[n] + i] & KCLS_DT1);
                  if (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_K1)
                        bm |= KCLS_K2 | (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_DT1);
#if 0
                  bm |= ((cp932[256 * key[n] + i] & KCLS_K1)
                                 || (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_K1)
                                 ? KCLS_K2 : 0);
#endif
                }
          if (c & (KCLS_AN | KCLS_KA | KCLS_K2))
                for (j = 0; j < 256; j++)
                {
                  bm |= cp932[256 * i + j] & (KCLS_AN | KCLS_KA | KCLS_K1
                                                                          | KCLS_DT0);
#if 0
                  if (j >= 127 && !(n == 0 || n == 1))
                        break;
#endif
                }
          kcls[n + 1].map[i] = bm;
#endif
          if (i >= 128 && !(n == 0 || n == 1))
                kcls[n + 1].map[i - 128] |= kcls[n + 1].map[i];
        }

  if (n < 6)
        kcls[n + 1].map[0x00] = kcls[n + 1].map[0x80] = 0;
  if (n == 6)
        kcls[7].map[0x00] |= KCLS_AN;
}

#if USE_DT
unsigned
dt_get(int kdn,
           int xn,
           int n,
           int ch)
{
  int i;
#if DEBUG>=1
  printf("*dt_get(%d)%c%c%c%c(%02X%02X:%02X%02X)->ch=%d",
                 n,
                 kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
                 kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
                 ch);
#endif
  /* まずは数える */
  for (i = 0;
           kd[kdn][i].c[xn] == kd[kdn]->c[xn];
           i++)
        ;
  assert(i > 0);
  kd[kdn] += ch % i;
#if DEBUG>=1
  printf("/%d\n dt_get:  %c%c%c%c(%02X%02X:%02X%02X)->ch=%d\n",
                 i,
                 kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
                 kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
                 ch);
#endif
  return kd[kdn]->c[n];
}
#endif

/* マップから文字を拾ってセット */
unsigned
key_set(int n, unsigned ch)
{
  int cnt = 0, i;

#if USE_DT
  if (3 <= n && n < 7 && kd[n - 3])
        {
          return dt_get(n - 3, 2, 3, ch);
          return kd[n - 3]->c[3];
        }
  else if (2 <= n && n < 6 && kd[n - 2])
        {
          return dt_get(n - 2, 1, 2, ch);
          return kd[n - 2]->c[2];
        }
  else if (1 <= n && n < 5 && kd[n - 1])
        {
          return dt_get(n - 1, 0, 1, ch);
          return kd[n - 1]->c[1];
        }
#endif

#if DEBUG>=3
  if (cnt == 0)
        {
          printf("n=%d, ch=%d, (n-1)=%02X\n", n, ch, key[n - 1]);
          int j;
          for (i = 0; i < 16; i++)
                {
                  printf("map[0x%02X] =", 16 * i);
                  for (j = 0; j < 16; j++)
                        printf(" %03X", kcls[n].map[16 * i + j]);
                  printf("\n");
                }
        }
#endif
  for (i = 0; i < 256; i++)
        {
          if (kcls[n].map[i])
                {
                  if (ch-- == 0)
                        return i;
                  cnt++;
                }
          if (n != 1 && n != 2 && i >= 127)
                break;
        }
  /* 見つからなかったのでもいっぺん */
  assert(cnt > 0);
  ch %= cnt;
  for (i = 0; i < 256; i++)
        if (kcls[n].map[i])
          {
                if (ch-- == 0)
                  return i;
          }
  assert(!"not matched");
  return 0;
}

/* bitwise key をセット */
static
void
key_set64(struct KEY *key64,
                  int n,
                  unsigned k,
                  unsigned vk,
                  unsigned sk)
{
  int i, j;
  if (!((vk | sk) & 0x7F))
        return;

  for (i = 0; i < 7; i++)
        {
          if (n == 7 && i < N_STRIDE) continue;
          if (sk & (1 << i))
                {
                  /* セット */
                  int o = tr_pc1[n][6 - i] - 1;
                  if (o < 28)
                        {
                          assert(o >= 0);
                          for (j = 0; j < N_ALU; j++)
                                key64->k[0][0][o].a[j]
                                = key64->k[0][1][o].a[j]
                                  = -!!(k & (1 << i));
                        }
                  else
                        {
                          assert(o >= 28);
                          assert(o < 56);
                          for (j = 0; j < N_ALU; j++)
                                key64->k[1][0][o - 28].a[j]
                                  = key64->k[1][1][o - 28].a[j]
                                  = -!!(k & (1 << i));
                        }
                }
          else if (vk & (1 << i))
                {
                  /* 反転 */
                  int o = tr_pc1[n][6 - i] - 1;
                  if (o < 28)
                        {
                          assert(o >= 0);
                          for (j = 0; j < N_ALU; j++)
                          key64->k[0][0][o].a[j]
                                = key64->k[0][1][o].a[j]
                                = ~key64->k[0][0][o].a[j];
                        }
                  else
                        {
                          assert(o >= 28);
                          assert(o < 56);
                          for (j = 0; j < N_ALU; j++)
                                key64->k[1][0][o - 28].a[j]
                                = key64->k[1][1][o - 28].a[j]
                                = ~key64->k[1][0][o - 28].a[j];
                        }
                }
        }
}

/* 指定されたクラスの開始値にリセット
   直前の文字のクラスに縛られる */
int
key_reset(uint8_t *key, int n)
{
/* MAKAI start */
  static char   firstCall = 1;

  if ( firstCall ) {
   firstCall = 0;
  } else {
   if ( umeStr[0] != '\0' && n == 0 ) {
     exit( 0 );
   }
  }
/* MAKAI end */

  if (n >= 8)
        return 1;
  if (n == 7)
        {
          key[7] = 0;
          return 1;
        }

/* MAKAI start */
  if (n >= umeLen)
        key[n] = key_set(n, 0);
  else {
   if ( umeStr[0] == '\0' ) {
    key[n] = key_set(n, rand());
   } else {
    key[n] = umeStr[n];
   }
  }
/* MAKAI end */

#if DEBUG>=3
  printf("key[%d]=%02X ncls=%04X\n", n, key[n], kcls[n].map[key[n]]);
#endif

  /* セットされた文字を元に、次キャラの文字クラスを決める */
  key_make_map(key, n);

  return key_reset(key, n + 1);
}

/* 指定された鍵空間の中で、キーをひとつ進める
   安全にインクリメントできた場合 true を返す */
static
int
key_inc(uint8_t *key, int n)
{
  if (n >= 8)
        return 0;
  else if (n == 7)
        {
          /* 最後のバイト */
          uint8_t o_k = (key[7] + (1 << N_STRIDE)) & 0x7F;
          if (!o_k)
                return 0;       /* インクリメントできなかったときは次へ進めず待つ */

          /* 進める */
          key[7] = o_k;
          return 1;
        }
  else if (key_inc(key, n + 1)
                   /*
                        && key_inc(n + 1)
                   && key_inc(n + 1)
                   && key_inc(n + 1)*/
                   )
        return 1;

  /* Salt はインクリメントしない約束にする */
  if (n == 1 || n == 2)
        return 1;

#if DEBUG>=3
  printf("key_inc(n=%d,ck=%02X)\n", n, key[n]);
#endif

#if USE_DT
  /* 辞書語はインクリメントしていい約束にする */
  if (3 <= n && n < 7 && kd[n - 3])
        {
          if ((key[n - 3] & 0x7F) == ((kd[n - 3] + 1)->c[0] & 0x7F)
                  && (key[n - 2] & 0x7F) == ((kd[n - 3] + 1)->c[1] & 0x7F)
                  && (key[n - 1] & 0x7F) == ((kd[n - 3] + 1)->c[2] & 0x7F))
                {
                  memcpy(&key[n - 3], &(++kd[n - 3])->c[0], 4);
#if DEBUG>=2
                  printf(">dt_get:%c%c%c%c(%02X%02X:%02X%02X)\n",
                                 kd[n - 3]->c[0], kd[n - 3]->c[1], kd[n - 3]->c[2], kd[n - 3]->c[3],
                                 kd[n - 3]->c[0], kd[n - 3]->c[1], kd[n - 3]->c[2], kd[n - 3]->c[3]);
#endif
                  return 1;
                }
          else
                {
                  return 0;
                }
        }
  else if (2 <= n && n < 6 && kd[n - 2])
        {
          if ((key[n - 2] & 0x7F) == ((kd[n - 2] + 1)->c[0] & 0x7F)
                  && (key[n - 1] & 0x7F) == ((kd[n - 2] + 1)->c[1] & 0x7F))
                {
                  memcpy(&key[n - 2], &(++kd[n - 2])->c[0], 4);
#if DEBUG>=2
                  printf(">dt_get:%c%c%c%c(%02X%02X:%02X%02X)\n",
                                 kd[n - 2]->c[0], kd[n - 2]->c[1], kd[n - 2]->c[2], kd[n - 2]->c[3],
                                 kd[n - 2]->c[0], kd[n - 2]->c[1], kd[n - 2]->c[2], kd[n - 2]->c[3]);
#endif
                  return 1;
                }
          else
                {
                  return 0;
                }
          if (kd[n - 2]->c[0] == key[n - 2])
                return 1;
          else
                return 0;
        }
  else if (1 <= n && n < 5 && kd[n - 1])
        {
          unsigned c2 = kd[n - 1]->c[0];
          if ((0x81 <= c2 && c2 <= 0x9F)
                  || (0xE0 <= c2 && c2 <= 0xFC))
                {
                  kd[n - 1] = NULL;
#if 0
                  if (!(n == 1 && n == 2))
                        key[n] &= 0x7F;
                  if (!(n == 2 && n == 3))
                        key[n - 1] &= 0x7F;
#endif
                  key_make_map(n - 1);
                }
          else if ((key[n - 1] & 0x7F) == ((kd[n - 1] + 1)->c[0] & 0x7F))
                {
                  memcpy(&key[n - 1], &(++kd[n - 1])->c[0], 4);
#if DEBUG>=2
                  printf(">dt_get:%c%c%c%c(%02X%02X:%02X%02X)\n",
                                 kd[n - 1]->c[0], kd[n - 1]->c[1], kd[n - 1]->c[2], kd[n - 1]->c[3],
                                 kd[n - 1]->c[0], kd[n - 1]->c[1], kd[n - 1]->c[2], kd[n - 1]->c[3]);
#endif
                  return 1;
                }
          else
                {
                  return 0;
                }
#if 0
          if (kd[n - 1]->c[0] == key[n - 1])
                return 1;
          else
                return 0;
#endif
        }
  else if (n < 4 && kd[n])
        {
          if (0 && kd[n]->c[0] == key[n])
                return 1;
          kd[n] = NULL;
#if 0
          if (!(n == 1 || n == 2))
                key[n] &= 0x7F;
#endif
        }
#endif

  /* 実際に増やしてみる */
  assert(n >= 3);
  for (;;)
        {
          if (n <= 3
                  && !(key[n] & 0x80)
                  && kcls[n].map[key[n] ^ 0x80] & (KCLS_DT0))
                {
                  /* 半角カタカナの1バイト目 */
                  key[n] ^= 0x80;
                }
          else
                {
                  key[n] = (key[n] & 0x7F) + 1;
                  if (key[n] >= 0x80)
                        {
                          key[n] = 0xFF;        /* 次に突入させないため */
                          return 0;
                        }
                }

          if (kcls[n].map[key[n]])
                {
                  key_make_map(key, n);
                  key_reset(key, n + 1);
                  return 1;
                }
        }
}

/* 鍵を完全にリセットする
   Saltもセットし直す */
static
void
key_init(uint8_t *key)
{
  int i, j;

#if USE_DT
  /* 辞書を、インデクスを作りながらマップにはめこんで逝く
         辞書はコード順昇順に並んでるものとする */
  for (i = 0; i < dtcnt; i++)
        {
          unsigned c = dt[i].c[0];

          assert(dt[i].c[0]
                         && dt[i].c[1]
                         && dt[i].c[2]
                         && dt[i].c[3]);

          /* BSD 鯖でしにそうな文字は残念ながら除外 */
          assert((dt[i].c[0] & 0x7F)
                         && (dt[i].c[1] & 0x7F)
                         && (dt[i].c[2] & 0x7F)
                         && (dt[i].c[3] & 0x7F));

          /* インデクス */
          if (!dtidx[c])
                dtidx[c] = &dt[i];

          if ((0x81 <= c && c <= 0x9F)
                  || (0xE0 <= c && c <= 0xFC))
                {
                  /* 全角なので、2バイトきまった時点で立てる */
                  cp932[256 * c + dt[i].c[1]] |= KCLS_DT1;
                }
          else if (0xA1 <= c && c <= 0xDF)
                {
                  /* 半角カナ */
                  for (j = 0; j < 256; j++)
                        cp932[256 * c + j] |= KCLS_DT0;
                }
        }
  /* ケツ、ちうか番人 */
  dtidx[0x100] = &dt[i];
#endif

  key[8] = 0;

  /* 初期マップを組む */
  for (i = 0; i < 256; i++)
        {
          unsigned bm = 0;
          kcls[0].map[i] = 0;
          for (j = 0; j < 256; j++)
                bm |= cp932[256 * i + j];
          kcls[0].map[i] = bm & (KCLS_AN | KCLS_KA | KCLS_K1
                                                         | KCLS_DT0
                                                         );
          if (i >= 128)
                kcls[0].map[i - 128] |= kcls[0].map[i];
        }

  key_reset(key, 0);
}

/***************************************************************
 *
 *      固定キーの生成
 *
 *      一見 Big Endian に非対応のように見えるだろうが
 *      随所でに散らばっている kludge により
 *      ALU_T が 64 ビットである限り、これで問題なく動く。
 *
 */

static
void
key_init_sk(struct KEY *key)
{
  int i, j;
  int o;
  uint64_t m;

  for (i = 5, m = 0xFFFFFFFF00000000ULL;
           i >= 0;
           m ^= (m >> (1 << --i)))
        {
          o = tr_pc1[7][6 - i] - 1;
#if DEBUG>=2
          printf("%d:%d->%2d: %08X%08X\n",
                         N_Q, i, o,
                         (unsigned)(m >> 32),
                         (unsigned)m);
#endif
          for (j = 0; j < N_Q; j++)
                if (o < 28)
                  key->k[0][0][o     ].q[j] = key->k[0][1][o     ].q[j] = m;
                else
                  key->k[1][0][o - 28].q[j] = key->k[1][1][o - 28].q[j] = m;
        }
#if N_STRIDE==7
  /* bit 6 は Little Endian として扱う */
  o = 0;
  assert(tr_pc1[7][0] - 1 == o);
  assert(N_Q == 2);
  key->k[0][0][o].q[0] = key->k[0][1][o].q[0] = 0x0000000000000000ULL;
  key->k[0][0][o].q[1] = key->k[0][1][o].q[1] = 0xFFFFFFFFFFFFFFFFULL;
#endif
}

/***************************************************************
 *
 *      Salt のセット
 *      オペランドのオフセットを書き換えて回ってるので注意
 *
 */

void
set_salt(CODE_T *code,
                 struct CRYPT64_DESC const *desc,
                 uint8_t const *k)
{
  int i, j;

  for (i = 0; i < 2; i++)
        {
          unsigned s = k[1 + i] & 255;
          if (s > 'z')
                s = 0;
          else if (s >= 'a')
                s = s - 'a' + 2 + 10 + 26;
          else if (s >= 'A')
                s = s - 'A' + 2 + 10;
          else if (s >= '.')
                s = s - '.';
          else
                s = 0;

#if DEBUG>=1
          printf("Salt %d:%3o\n", i, s & 63);
#endif
          for (j = 0; j < 6; j++)
                {
#if DEBUG>=2
                  //printf("Salt %d:%d %+3d:%+3d",
                  printf("Salt %d:%d %08lX:%08lX",
                                 i, j,
                                 LSALT(desc, code, 0, i, j,  0),
                                 LSALT(desc, code, 0, i, j, 24));
#endif
                if (s & (1 << j))
                  {
                        LSALT(desc, code, 0, i, j,  0) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);
                        LSALT(desc, code, 0, i, j, 24) = sizeof(WS_T) * (((4 * i + j -  1) & 31) - 16);
                  }
                else
                  {
                        LSALT(desc, code, 0, i, j,  0) = sizeof(WS_T) * (((4 * i + j -  1) & 31) - 16);
                        LSALT(desc, code, 0, i, j, 24) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);
                  }
                LSALT(desc, code, 0, i, j, 12) = sizeof(WS_T) * (((4 * i + j +  7) & 31) - 16);
                LSALT(desc, code, 0, i, j, 36) = sizeof(WS_T) * (((4 * i + j + 23) & 31) - 16);
#if DEBUG>=2
                //printf(" => %+3d:%+3d\n",
                  printf(" => %08lX:%08lX\n",
                                 LSALT(desc, code, 0, i, j,  0),
                                 LSALT(desc, code, 0, i, j, 24));
#endif
                }
        }
}

#define USEC_SEC 1000   /* 1秒 */

static
uint64_t
usec(void)
{
  uint32_t sec, msec;

#if !defined(WIN32)
  struct timeval tv;
  gettimeofday(&tv, NULL);
  sec = tv.tv_sec;
  msec = tv.tv_usec / (1000000 / USEC_SEC);
#else
  struct timeb tm;
  ftime(&tm);
  sec = tm.time;
  msec = tm.millitm / (1000 / USEC_SEC);
#endif

  return (uint64_t)USEC_SEC * sec + msec;
}

static
int
log_printf(FILE *ofp, char const *fmt, ...)
{
  int r;
  va_list ap;
  va_start(ap, fmt);
  vfprintf(stdout, fmt, ap);
  r = vfprintf(ofp, fmt, ap);
  va_end(ap);
  if (r > 0)
        return r;
  perror("log_printf");
  exit(errno);
}

/***************************************************************
 *
 *      CPU capabilities を取得
 *      [XXX] あまりにも古いプロセッサのことは考えない。
 *
 *      a[4] = {EAX,EBX,ECX,EDX}
 *
 */

#if defined(__GNUC__)

#define cpuid(n,a,b,c,d)        \
        asm("cpuid"             \
                : "=a"(a), "=b"(b), "=c"(c), "=d"(d)    \
                : "a"(n))

#elif defined(WIN32)

#define cpuid(n,a,b,c,d)        \
        do {int r[4]; __cpuid(r,n);     \
        (a) = r[0]; (b) = r[1]; (c) = r[2]; (d) = r[3];} while (0)

#endif

static
unsigned
cpuid_getfflags(void)
{
  unsigned a, b, c, d;
  cpuid(1, a, b, c, d);
  return d;
}

static
int
cpuid_issupported(void)
{
  unsigned m = REQUIRED_CAPS;
  return !((cpuid_getfflags() ^ m) & m);
}

/***************************************************************
 *
 *      バッチ処理用パケット
 *
 */

static
struct PACKET_CRYPT64 *
packet_create(int n,    /* パケット数 */
                          int tn,       /* 末尾要素にて必要なワーク数 */
                          uint8_t const *ini_key)
{
  int i;
  int siz;
  void *p;
  intptr_t a = 128;
  struct PACKET_CRYPT64 *pkts;
  assert(IS_POWER2(sizeof(struct PACKET_CRYPT64)));
  assert(n >= 1);

  siz = (a - 1
                 + (n - 1) * sizeof(struct PACKET_CRYPT64)
                 + offsetof(struct PACKET_CRYPT64, param64.hit[tn]));
  p = calloc(siz, 1);
  /* バンダリあわせ */
  pkts = (struct PACKET_CRYPT64 *)(((intptr_t)p
                                                                        + a - 1)
                                                                   & -a);
#if DEBUG>=1
  fprintf(stderr,
                  "packet(n=%d,tn=%d) %d allocated; %p aligned to %p\n",
                  n, tn,
                  siz, p, pkts);
#endif

  /* 内部の初期化
         コピーして回るのは、厳密には
         最終要素のケツを破ってしまうことになるので
         どうせ速度も要求されないしベタコード */
  for (i = 0; i < n; i++)
        {
          int j, k;

          /* t[16] は、内部演算で使用する、all 1 が入っている */
          memset(&pkts[i].param64.t[T_INV], -1, sizeof(SLICE));

          /* 固定キーの生成 */
          key_init_sk(&pkts[i].key64);

          /* キースケジュールをここに押し込めておく
                 従来は crypt64.S 内で完結するように引いていた */
          for (j = 0; j < 28; j++)
                for (k = 0; k < N_ALU; k++)
                  pkts[i].key64.ks[j].a[k] = sizeof(WS_T) * ks_ls[j];

          /* 念のため、鍵をここで落ち着けておく(不要?) */
          for (j = 0; j < 8; j++)
                key_set64(&pkts[i].key64, j, pkts[i].uk.key[j] = ini_key[j], 0, 0x7F);
        }

  return pkts;
}

/***************************************************************
 *
 *      thread
 *
 */

#define NQ_CRYPT        64
#define NQ_CMP          32

#if defined(__GNUC__)

typedef int32_t ATOMWORD_T;

#define LOCK_INC(p)     \
asm volatile ("lock incl %0"    \
                          : "=m"(*(p))  \
                          : /*nil*/             \
                          : "memory")

#define LOCK_DEC(p)     \
asm volatile ("lock decl %0"    \
                          : "=m"(*(p))  \
                          : /*nil*/             \
                          : "memory")

#define LOCK_CAS(pd,s,r)        \
({      ATOMWORD_T a;                                                   \
        asm volatile ("lock cmpxchg %2,%1"              \
                                  : "=a"(a)                                     \
                                  : "m"(*(pd)), "r"(s), "0"(r)  \
                                  : "memory");a;})

#define LOCK_CASP(pd,s,r)       \
({      void *a;                                                                \
        asm volatile ("lock cmpxchg %2,%1"              \
                                  : "=a"(a)                                     \
                                  : "m"(*(pd)), "r"(s), "0"(r)  \
                                  : "memory");a;})

#elif defined(WIN32)

typedef LONG ATOMWORD_T;

#define LOCK_INC(p) InterlockedIncrement((LONG *)(p))
#define LOCK_DEC(p) InterlockedDecrement((LONG *)(p))
#define LOCK_CAS(pd,s,r) InterlockedCompareExchange((LONG *)(pd), s, r)
#define LOCK_CASP(pd,s,r) InterlockedCompareExchangePointer((PVOID *)(pd), (PVOID)(s), (PVOID)r)

#else
#error "configuration not implemented"
#endif

#if defined(WIN32)

typedef DWORD THREAD_TIMEOUT_T;

#define THREAD_INFINITE INFINITE

typedef HANDLE THREAD_TH_T;
typedef HANDLE THREAD_EV_T;

#define thread_sleep(n) Sleep(n)
#define thread_create(th, proc, arg) {(th) = (HANDLE)_beginthread(proc, 8192, arg);}
#define thread_create_event(ev, f) {(ev) = CreateEvent(NULL, TRUE, f, NULL);}
#define thread_signal_event(ev) SetEvent(ev)
#define thread_clear_event(ev) ResetEvent(ev)
#define thread_get_tid()        GetCurrentThread()
#define thread_set_priority(tid,n)      SetThreadPriority(tid, n)
#define thread_set_affinity(tid,m)      SetThreadAffinityMask(tid, (DWORD_PTR)1 << (m))

static
int
thread_wait_event(THREAD_EV_T ev, DWORD tmo)
{
  DWORD r = WaitForSingleObject(ev, tmo);
  return (r < 0
                  ? r
                  : (r == WAIT_TIMEOUT
                         ? -1
                         : r));
}

#elif defined(_POSIX_SOURCE)

#include <pthread.h>
#include <unistd.h>

typedef int THREAD_TIMEOUT_T;

#define THREAD_INFINITE INT_MAX

#if defined(THREAD_PRIORITY_BELOW_NOROMAL) || defined(THREAD_PRIORITY_IDLE)
#error "unsupported implementation"
#endif

#define THREAD_PRIORITY_NORMAL  14
#define THREAD_PRIORITY_BELOW_NORMAL    15
#define THREAD_PRIORITY_IDLE    16

typedef pthread_t THREAD_TH_T;
typedef struct
{
  pthread_mutex_t       m;
  pthread_cond_t        c;
  int volatile          f;
} THREAD_EV_T;

#define thread_sleep(n) (usleep(1000 * (n)) != EINVAL || sleep((n) / 1000))
#define thread_create(th, proc, arg) thread_create_p(&(th), proc, arg)
#define thread_create_event(ev, f) thread_create_event_p(&(ev), f)
#define thread_signal_event(ev) thread_set_event_p(&(ev), 1)
#define thread_clear_event(ev) thread_set_event_p(&(ev), 0)
#define thread_wait_event(ev,tmo) thread_wait_event_p(&(ev), tmo)

static
void
thread_create_p(pthread_t *th, NORETURN (*proc)(void *), void *param)
{
  pthread_create(th, NULL, (void *(*)(void *))proc, param);
}

static
void
thread_create_event_p(THREAD_EV_T *ev, int f)
{
  ev->f = f;
  pthread_cond_init(&ev->c, NULL);
  pthread_mutex_init(&ev->m, NULL);
}

static
void
thread_set_event_p(THREAD_EV_T *ev, int f)
{
  pthread_mutex_lock(&ev->m);
  if (ev->f != f)
        {
          ev->f = f;
          pthread_cond_broadcast(&ev->c);
        }
  pthread_mutex_unlock(&ev->m);
}

static
int
thread_wait_event_p(THREAD_EV_T *ev, int a_tmo)
{
  int timeout = a_tmo;
  struct timeval now;
  struct timespec tmo;
  int r;

  pthread_mutex_lock(&ev->m);

  /* 現在時刻からタイムアウト時刻を求める
         めんどくせー */
  gettimeofday(&now, NULL);
  tmo.tv_sec = now.tv_sec + (timeout / 1000);
  timeout %= 1000;
  timeout *= 1000;
  if (now.tv_usec >= 1000000 - timeout)
        {
          timeout -= 1000000;
          tmo.tv_sec++;
        }
  tmo.tv_nsec = 1000 * (now.tv_usec + timeout);
  r = 0;
  while (!ev->f)
        {
          r = pthread_cond_timedwait(&ev->c, &ev->m, &tmo);
          if (r == ETIMEDOUT
                  && a_tmo < THREAD_INFINITE)
                break;
        }

  pthread_mutex_unlock(&ev->m);

  return (r == ETIMEDOUT
                  ? (ETIMEDOUT < 0 ? ETIMEDOUT : -1)
                  : 0);
}

#if defined(__linux__)

/* デフォルトスケジューリングポリシーでは
   優先度設定したりアイドルスレッド起こしても
   おもしろくないので、そのへんは今後の研究課題。 */

#include <linux/unistd.h>
_syscall0(pid_t,gettid)

#define thread_get_tid() gettid()

static
int thread_set_affinity(pid_t tid, int i)
{
  cpu_set_t m;
  CPU_ZERO(&m);
  CPU_SET(i, &m);
  return sched_setaffinity(tid, sizeof(m), &m);
}

#else

/* POSIX では、スレッド単位のスケジューリングに介入できない。 */

#endif

#else
#error "configuration not supported"
#endif

struct THREAD_PARAM
{
  /* 以下は共通情報のコピー */
  CODE_T *code;
  THREAD_EV_T *p_ev_ks_activated;
  ATOMWORD_T volatile *p_nidle;         /* 待ちに入ったら増加 */

  /* 以下はスレッド固有 */
#ifdef thread_set_priority
  THREAD_TH_T th;
  int pri;
#endif
};

static
volatile ATOMWORD_T wp_crypt, rp_crypt;
static
struct PACKET_CRYPT64 *volatile q_crypt[NQ_CRYPT];

static
volatile ATOMWORD_T wp_cmp, rp_cmp;
static
struct PACKET_CRYPT64 *volatile q_cmp[NQ_CMP];

static
uint64_t
thread_avail(void)
{
#if !USE_MT

  return 0x1U;

#elif defined(WIN32)    /* Win32 API */
  DWORD_PTR mask, mask_s;
  if (!GetProcessAffinityMask(GetCurrentProcess(),
                                                          &mask,
                                                          &mask_s)
          || !mask
          || !mask_s)
        return 0x1U;
#if DEBUG>=1
  fprintf(stderr,
                  "m=%08X s=%08X\n",
                 (unsigned)mask,
                 (unsigned)mask_s);
#endif
  if (popcnt64(mask_s) == 1)
        /* 何も言うまい */;
  else if (mask == mask_s)
        fprintf(stderr,
                        "通常の%d倍とはよく言ったものです。\n",
                        popcnt64(mask));
  else
        fprintf(stderr,
                        "最高速力の%g倍の力でてきとうにがんばるよ。\n",
                        (double)popcnt64(mask) / popcnt64(mask_s));
  return mask;

#elif defined(__linux__)        /* sched.h 拡張 */

  int i;
  uint64_t m = 0;
  cpu_set_t am;
  if (sched_getaffinity(getpid(), sizeof(am), &am) < 0)
        return 0x1U;

  for (i = 0; i < 64 && i < CPU_SETSIZE; i++)
        if (CPU_ISSET(i, &am))
          m |= 1ULL << i;

  return m;
#else

  /* XXX プロセッサ数を調べ上げてください */
  return 0x01U;

#endif
}

static
NORETURN
thread_crypt64(void *a_param)
{
  struct THREAD_PARAM *param = a_param;
  CODE_T *code = param->code;
  struct PACKET_CRYPT64 *pkt;
#ifdef thread_set_priority
  THREAD_TH_T th = thread_get_tid();
  thread_set_priority(th, param->pri);
#endif

  for(;;)
        {
          ATOMWORD_T rp;
          ATOMWORD_T wp;

          /* キューから要求を取り出す */
          for (;;)
                {
                  while ((rp = rp_crypt,
                                  WRAP(wp_crypt, NQ_CRYPT) == WRAP(rp, NQ_CRYPT)
                                  /*|| q_crypt[WRAP(rp, NQ_CRYPT)] == NULL*/))
                        {
                          THREAD_TIMEOUT_T tmo = (WRAP(wp_crypt, NQ_CRYPT) == WRAP(rp, NQ_CRYPT)
                                                                          ? THREAD_INFINITE
                                                                          : 1);
                          int r;

                          /* 寝た */
                          if (tmo == THREAD_INFINITE)
                                {
                                  LOCK_INC(param->p_nidle);
                                }

                          /* 要求待ち */
                          r = thread_wait_event(*param->p_ev_ks_activated, tmo);

                          if (tmo == THREAD_INFINITE)
                                {
                                  /* 起こされた */
                                  LOCK_DEC(param->p_nidle);
                                }
                          else if (r >= 0)
                                {
                                  /* もうちょっと寝てみる */
                                  thread_sleep(tmo);
                                }

                          /* 自らの優先度を戻す
                                 (外からブーストされてるかも) */
#ifdef thread_set_priority
                          if (r >= 0)
                                thread_set_priority(th, param->pri);
#endif
                        }

                  if (LOCK_CAS(&rp_crypt, rp + 1, rp) != rp)
                        continue;
                  rp = WRAP(rp, NQ_CRYPT);
                  break;
                }

          pkt = q_crypt[rp];
          assert(pkt != NULL);
          pkt = LOCK_CASP(&q_crypt[rp], NULL, pkt);
          assert(pkt != NULL);

          /* 実行してみる */
          CALL_CRYPT64(code, &pkt->key64, &pkt->param64);

          /* 結果をキューにたたき込む */
          for (;;)
                {
                  while ((wp = wp_cmp,
                                  WRAP(rp_cmp - 1, NQ_CMP) == WRAP(wp, NQ_CMP))
                                 || q_cmp[WRAP(wp, NQ_CMP)] != NULL)
                        {
#if DEBUG>=1
                          fprintf(stderr,
                                          "q_cmp stalled(%d,%d) %p\n",
                                          (unsigned)WRAP(wp, NQ_CMP),
                                          (unsigned)WRAP(rp_cmp - 1, NQ_CMP),
                                          q_cmp[WRAP(wp, NQ_CMP)]);
#endif
                          thread_sleep(1);
                        }

                  if (LOCK_CAS(&wp_cmp, wp + 1, wp) != wp)
                        continue;
                  wp = WRAP(wp, NQ_CMP);
                  break;
                }

          pkt = LOCK_CASP(&q_cmp[wp], pkt, NULL);
          assert(pkt == NULL);
        }
}

/* MAKAI start */
void
usage( path )
char    *path;
{
  char  *myName, *chPtr;

  myName = basename( path );
  for ( chPtr = myName; *chPtr != '\0'; chPtr++ ) {
   if ( *chPtr == '.' ) {
    *chPtr = '\0';
    break;
   }
  }
  printf( "%s [-t num] [\"str\"]\n", myName );
  printf( " -t num : 検索スレッド数 ( %d ≦ num ≦ %d )\n",
           MIN_THREAD, MAX_THREAD );
  printf( " str : 先頭に埋め込む文字列 ( %d ≦ str のバイト数 ≦ %d )\n",
           MIN_UME, MAX_UME );
}
/* MAKAI end */

/***************************************************************
 *
 *      メインループとか
 *
 */

int
main(int argc, char *argv[])
{
  int i;
  int mincnt;
  int nblk_hit, nblk_total;
  int nap_hit, nap_total;
  CODE_T *code = NULL;
  off_t code_cmp;
  FILE *ofp;
  FILE *sfp;    /* scoreboard */
  struct ITREE *root_expr;
  uint64_t proc_mask;
  int ks_activated;
  static THREAD_EV_T event_ks_activated;
  static ATOMWORD_T volatile nidle;
  struct THREAD_PARAM *threads = NULL;
  int nthreads;
  int npkts;
  struct PACKET_CRYPT64 *pkts, *pkt_hit;
  uint64_t pkts_vacant;
  int tn;
  int cr;

  /* 鍵文字列 */
  uint8_t key[8 + 8];

  int xhash_loaded;

#define UPDATE_INTERVAL 8       /* 速度表示の間隔 秒 */
  struct status {
    uint64_t startTime; /* 開始時刻 ミリ秒 */
    uint64_t lastTime;  /* 最後に表示した時刻 ミリ秒 */
    uint64_t loop;              /* 総検索個数 */
    uint64_t lastloop;  /* 最後に表示した時の loop */
  } status;
  uint64_t curTime;
  uint32_t upd_int = 0;

/* MAKAI start */
/* 実際の処理とあっていないコメントを削除 */

#if defined(WIN32)
  SetPriorityClass( GetCurrentProcess(), IDLE_PRIORITY_CLASS );
#endif

{
  int   optChar;
  extern char   *optarg;
  extern int    optind;

  nThread = 0;
  while ( (optChar = getopt(argc, argv, "t:h")) != EOF ) {
   switch ( optChar ) {
    case 't':
     nThread = atoi( optarg );
     if ( nThread < MIN_THREAD || nThread > MAX_THREAD ) {
      usage( argv[0] );
      exit( 1 );
     }
     break;
    case 'h':
     usage( argv[0] );
     exit( 0 );
     break;
   }
  }

  switch ( argc - optind ) {
   case 0:
    umeStr[0] = '\0';
    umeLen = KEY_SHUFFLE_POS;
    break;
   case 1:
    strcpy( umeStr, argv[optind] );
    umeLen = strlen( umeStr );
    if ( umeLen < MIN_UME || umeLen > MAX_UME ) {
     usage( argv[0] );
     exit( 1 );
    }
    break;
   default:
    usage( argv[0] );
    exit( 1 );
  }
}
/* MAKAI end */

  if (!cpuid_issupported())
        {
          fprintf(stderr, "この環境で走らせることが想定されていません。\n");
          exit(1);
        }

  assert((1 << N_STRIDE) == N_ALU * ALU_BITS);

  /* タゲ読み込み */
  root_expr = expr_parse("target.txt");

  /* コードを生成・展開
         起動予定スレッド数に応じて
         生成するコードを変える */
  sfp = scoreboard_open();
  fwrite(crypt64_descs[0]->pro, 1, crypt64_descs[0]->cmp_pro - crypt64_descs[0]->pro, sfp);     /* prologue & コアループ */

/* MAKAI start */
  if ( nThread == 0 ) {
   proc_mask = thread_avail();
  } else {
   int  i;
   proc_mask = 0U;
   for ( i = 0; i < nThread; i++ ) {
    proc_mask |= 1U;
    proc_mask <<= 1;
   }
  }
/* MAKAI end */

  if (proc_mask == 1U)
        {
          /* single */
          npkts = 1;
          pkts_vacant = 1;
          code_cmp = 0;
        }
  else
        {
          /* multi */
          fwrite(crypt64_descs[0]->ep, 1, crypt64_descs[0]->ep_end - crypt64_descs[0]->ep, sfp);        /* epilogue */

          /* 比較器のみを生成(前半) */
          code_cmp = ftell(sfp);
          fseek(sfp, (-code_cmp) & 63, SEEK_CUR);
          code_cmp = ftell(sfp);
          fwrite(crypt64_descs[0]->pro, 1, crypt64_descs[0]->crypt - crypt64_descs[0]->pro, sfp);       /* prologue */
          npkts = 64;
          pkts_vacant = (uint64_t)-1;   /* (1 << 64) - 1 を計算したくない */
        }

  /* 比較部を生成 */
  fwrite(crypt64_descs[0]->cmp_pro, 1, crypt64_descs[0]->cmp_ep - crypt64_descs[0]->cmp_pro, sfp);      /* 比較器準備 */
  tn = synth_synthesize(sfp, root_expr);
  fwrite(crypt64_descs[0]->cmp_ep, 1, crypt64_descs[0]->ep_end - crypt64_descs[0]->cmp_ep, sfp);        /* epilogue */

  /* コードをメモリに貼り付ける */
  code = scoreboard_map(sfp);

  /* キーの初期化 */
  srand(time(NULL));
  key_init(key);
  set_salt(code, crypt64_descs[0], key);

  /* 演算パケットを作成 */
  pkts = packet_create(npkts, tn, key);
  pkt_hit = &pkts[npkts - 1];

  /* 働くおじさんを量産 */
  thread_create_event(event_ks_activated, 1);
  ks_activated = 1;
  nthreads = 0;
  if (code_cmp)
        {
          THREAD_TH_T h;
          int ots = -1;
          threads = calloc(2 * popcnt64(proc_mask), sizeof(*threads));
          for (i = 0; proc_mask; i++, proc_mask >>= 1)
                if (proc_mask & 1)
                  {
                        if (ots < 0)
                          {
                                /* 自分自身のスケジューリング
                                   こーゆー系のアプリは低めに設定するのが吉(かも) */
#ifdef WIN32
                                h = GetCurrentProcess();
                                SetPriorityClass(h, BELOW_NORMAL_PRIORITY_CLASS);
#endif
#if defined(thread_set_priority)
                                /* 心の隙間お埋めします */
                                threads[nthreads].code = code;
                                threads[nthreads].p_ev_ks_activated = &event_ks_activated;
                                threads[nthreads].p_nidle = &nidle;
                                threads[nthreads].pri = THREAD_PRIORITY_IDLE;
                                thread_create(h, thread_crypt64, &threads[nthreads]);
                                threads[nthreads].th = h;
                                nthreads++;
#endif
                                if (!code_cmp)
                                  break;

                                /* 自分自身の残りの設定を、あとでやる */
                                ots = i;
                          }
                        else
                          {
                                /* 他スレッドは、やや低めの優先度で。 */
                                threads[nthreads].code = code;
                                threads[nthreads].p_ev_ks_activated = &event_ks_activated;
                                threads[nthreads].p_nidle = &nidle;
#ifdef thread_set_priority
                                threads[nthreads].pri = THREAD_PRIORITY_BELOW_NORMAL;
#endif
                                thread_create(h, thread_crypt64, &threads[nthreads]);
#ifdef thread_set_priority
                                threads[nthreads].th = h;
#endif
#ifdef thread_get_tid
                                thread_set_affinity(h, i);
#endif
                                nthreads++;
                          }
                  }
#ifdef thread_get_tid
          if (ots)
                thread_set_affinity(thread_get_tid(), ots);
#endif
        }

  if ((ofp = fopen("log.txt", "at")) == NULL)
        {
          perror("log.txt");
          return errno;
        }

  setvbuf(ofp, NULL, _IONBF, BUFSIZ);   /* XXX MSVCRT では _IOLBF が期待通りに動作しない */

  mincnt = 0x7FFFFFFF;
  nblk_hit = nblk_total = 0;
  nap_hit = nap_total = 0;
  cr = 0;
  memset( &status, 0, sizeof( struct status ) );
  status.startTime = status.lastTime = usec();
  /* 探索ループだぞっと */
  for (;;)
        {
          struct PACKET_CRYPT64 *pkt_c;
          uint64_t cnt;
          int cnt1, cnt2;
          int k, kk;

          /* 比較器候補(may be NULL)
                 先にキューから取り出す */
          pkt_c = q_cmp[WRAP(rp_cmp, NQ_CMP)];
          if (pkt_c != NULL && WRAP(rp_cmp, NQ_CMP) != WRAP(wp_cmp, NQ_CMP))
                {
                  pkt_c = LOCK_CASP(&q_cmp[WRAP(rp_cmp, NQ_CMP)], NULL, pkt_c);
                  assert(pkt_c != NULL);
                  LOCK_INC(&rp_cmp);

                  /* パケットを vacant に回しておく */
                  pkts_vacant |= 1ULL << (pkt_c - pkts);
                }

          /* Saltチェンジ待ち */
          if (!ks_activated)
                {
                  ATOMWORD_T rp;

                  if (pkt_c == NULL)
                        {
                          if ((rp = rp_crypt,
                                   WRAP(rp, NQ_CRYPT) != WRAP(wp_crypt, NQ_CRYPT))
                                  && LOCK_CAS(&rp_crypt, rp + 1, rp) == rp)
                                {
                                  /* !ks_activate 状態では、自らも要求キューをやっつけにいく */
                                  rp = WRAP(rp, NQ_CRYPT);
                                  pkt_c = q_crypt[rp];
                                  assert(pkt_c != NULL);
                                  pkt_c = LOCK_CASP(&q_crypt[rp], NULL, pkt_c);
                                  assert(pkt_c != NULL);
                                  assert(pkt_c != pkt_hit);
                                  CALL_CRYPT64(code,
                                                           &pkt_c->key64,
                                                           &pkt_c->param64);

                                  /* パケットを vacant に回しておく */
                                  pkts_vacant |= 1ULL << (pkt_c - pkts);
                                }
                          else
                                {
                                  /* やはりすることがないのでまったりと過ごす */
                                  if (nidle != nthreads)
                                        thread_sleep(1);
                                }
                        }

                  if (nidle == nthreads)
                        {
                          assert(WRAP(rp_crypt, NQ_CRYPT) == WRAP(wp_crypt, NQ_CRYPT));
                          /* Salt チェンジが可能 */
                          set_salt(code, crypt64_descs[0], key);
                          if (nthreads)
                                thread_signal_event(event_ks_activated);
                          ks_activated = 1;
                        }
                }

          /* 鍵をキューにたたき込みまくる */
          if (!ks_activated)
                {
                  /* 鍵を登録しない */
                  ;
                }
          else for (i = npkts - 1; i >= 0; i--)
                if (pkts_vacant & (1ULL << i))
                  {
                        int j;

                        if (i == npkts - 1)
                          {
                                /* 前段で、働くおじさんから
                                   結果をもらっていたら、何もしない */
                                if (pkt_c != NULL)
                                  continue;
                          }
                        else
                          {
                                /* 前段で取り出したばかりの
                                   働くおじさんは、尊重する */
                                if (&pkts[i] == pkt_c)
                                  continue;

                                /* queue full の場合は見送る */
                                if (WRAP(wp_crypt, NQ_CRYPT) == WRAP(rp_crypt - 16, NQ_CRYPT)   /* XXX 16 はてきとう */
                                        || q_crypt[WRAP(wp_crypt, NQ_CRYPT)] != NULL)
                                  break;
                          }

                        /* 鍵のセット */
                        for (j = 0; j < 8; j++)
                          {
                                key_set64(&pkts[i].key64, j, key[j], key[j] ^ pkts[i].uk.key[j], 0);
                                pkts[i].uk.key[j] = key[j];
                          }

                        if (i == npkts - 1)
                          {
                                /* 次段で CRYPT64->CMP */
                                assert(pkt_c == NULL);
                                pkt_c = &pkts[i];
                                assert(pkt_c == pkt_hit);
                          }
                        else
                          {
                                /* キューにたたき込む */
                                while (LOCK_CASP(&q_crypt[WRAP(wp_crypt, NQ_CRYPT)], &pkts[i], NULL) != NULL)
                                  {
                                        /* 設計上はここに来ない */
#if DEBUG>=1
                                        fprintf(stderr,
                                                        "[XXX] q_crypt を汚してるのは誰だ? (rp=%3d, wp=%3d, v=%08X%08X)\n",
                                                        (unsigned)WRAP(rp_crypt, NQ_CRYPT),
                                                        (unsigned)WRAP(wp_crypt, NQ_CRYPT),
                                                        (unsigned)(pkts_vacant >> 32),
                                                        (unsigned)pkts_vacant);
                                        thread_sleep(1000);
#endif
                                        thread_sleep(1);
                                  }
                                LOCK_INC(&wp_crypt);
                                pkts_vacant ^= 1ULL << i;
                                assert(!(pkts_vacant & (1ULL << i)));   /* 削れ */
                          }

                        /* 鍵増加はこんなところに移動! */
                        assert(ks_activated);
/* MAKAI start */
                        if (!key_inc(key, 6) && !key_inc(key, umeLen))
/* MAKAI end */
                          {
                                /* 鍵のシャッフル
                                   q_crypt が捌けるまで、set_salt() はできない */
#if DEBUG>=1
                                fprintf(stderr, "********************************SHUFFLE!\n");
#endif
                                if (nthreads)
                                  thread_clear_event(event_ks_activated);
                                key_reset(key, 0);

                                /* キューの鍵が捌けるまでアイドル状態に */
                                ks_activated = 0;

                                /* スレッドをブーストして回る */
#ifdef thread_set_priority
                                for (j = 0; j < nthreads; j++)
                                  {
                                        assert(threads != NULL);
                                        thread_set_priority(threads[j].th, THREAD_PRIORITY_NORMAL);
                                  }
#endif

                                /* ループ続行はもはや不要 */
                                break;
                          }
                  }

          /* することがなくなっている場合 */
          if (pkt_c == NULL)
                {
                  assert(!ks_activated);
                  continue;
                }

          /* 呼ぶ!
                 LR 初期化は、サブモジュール内で行うべし
                 FASTCALL に準じた呼び出しのため、
                 ホントはいろいろレジスタが破壊されるハズ…なんだが。 */
          if (pkt_c != pkt_hit)
                {
                  assert(code_cmp != 0);
                  cnt = CALL_CMP64(code + code_cmp,
                                                   pkt_hit->param64.hit,
                                                   pkt_c->param64.lr);
                }
          else
                {
                  /* ようやく自スレッドで回せる */
                  cnt = CALL_CRYPT64(code,
                                                         &pkt_c->key64,
                                                         &pkt_c->param64);
                  if (code_cmp)
                        cnt = CALL_CMP64(code + code_cmp,
                                                         pkt_c->param64.hit,
                                                         pkt_c->param64.lr);
                }

#if DEBUG>=1
          cnt2 = (int32_t)(cnt >> 32);
          cnt1 = (int32_t)cnt;
          if (mincnt > cnt1 && cnt1 > 0)
                {
                  mincnt = cnt1;
                  if (cr)
                        fprintf(stderr, "\n");
                  cr = 0;
                  fprintf(stderr, "cycle=%6d/%6d\n", cnt1, cnt2);
                }
#endif

          /* ヒットしたときの処理
                 key および lr は pkt_c に
                 合致判定は pkt_hit に入っているハズ */
          xhash_loaded = 0;
          for (kk = 0; kk < N_ALU; kk++)
                {
                  ALU_T t;
                  if (!(kk & (N_ALU / N_Q - 1)))
                        nblk_total++, xhash_loaded = 0;

                  t = pkt_hit->param64.hit[HIT_ANY].a[kk];
                  if (!t)
                        continue;

                  nap_total += ALU_BITS;

                  for (k = 0; k < ALU_BITS; k++)
                        {
                          static uint64_t xhash[64];
                          char hash[16];
                          uint8_t buf[32];
                          struct timeb tb;
                          struct tm *plt;
/* MAKAI start */
  int   hitLen;
/* MAKAI end */

                          if (!(t & ((ALU_T)1 << k)))
                                continue;

                          nap_hit++;

                          /* 転置 */
                          if (!xhash_loaded)
                                {
                                  nblk_hit++;
                                  CALL_TR64(&pkt_c->param64.lr[0][0].q[kk / (N_ALU / N_Q)], xhash);
                                  xhash_loaded = 1;
                                }

                          /* 辞書を調べる */
/* MAKAI hitLen 追加 */
                          if (!((pkt_hit->param64.hit[HIT_BOOL].a[kk] & ((ALU_T)1 << k))
                                        || (hitLen = wdict_ishit(pkt_hit->param64.hit,
                                                                   kk, k,
                                                                   xhash[(ALU_BITS * kk + k) & 0x3F]))))
                                continue;

                          /* ヒット時刻; 魔改造とちょっと違う */
                          ftime(&tb);
                          plt = localtime(&tb.time);

                          for (i = 1; i < 11; i++)
                                {
                                  unsigned c = 0;
                                  c = (xhash[(ALU_BITS * kk + k) & 63] >> (6 * (i - 1))) & 0x3F;        /* XXX */
                                  hash[i - 1] = C64[c];
                                }
                          hash[10] = 0;

                          memcpy(buf, pkt_c->uk.key, 8);
                          buf[8] = buf[9] = 0;
                          buf[7] = (buf[7] & -(1 << N_STRIDE) & 0x7F) + ALU_BITS * kk + k;
                          if (translate(buf, 0, 1))
                                {
                                  if (cr)
                                        fprintf(stderr, "\n");
                                  cr = 0;
#if DEBUG>=1
                                  fprintf(stderr, "%3d:", pkt_c - pkts);
#endif
                                  log_printf(ofp,
                                                         "◆%s #%s"
                                                         "\t%04d/%02d/%02d %02d:%02d:%02d.%03d"
/* MAKAI start */
                                                         "\t(%02X %02X %02X %02X %02X %02X %02X %02X/%02X) %02d\n",
/* MAKAI end */
                                                         hash,
                                                         buf,
                                                         plt->tm_year + 1900,
                                                         plt->tm_mon + 1,
                                                         plt->tm_mday,
                                                         plt->tm_hour,
                                                         plt->tm_min,
                                                         plt->tm_sec,
                                                         tb.millitm,
                                                         buf[0], buf[1], buf[2], buf[3],
                                                         buf[4], buf[5], buf[6], buf[7],
/* MAKAI start */
                                                         buf[8], hitLen);
/* MAKAI end */
                                }
                          else
                                {
/* MAKAI start */
  log_printf( ofp, "◆%s 残念でした"
                   "\t%04d/%02d/%02d %02d:%02d:%02d.%03d"
                   "\t(%02X %02X %02X %02X %02X %02X %02X %02X/%02X) %02d\n",
                   hash,
                   plt->tm_year + 1900, plt->tm_mon + 1, plt->tm_mday,
                   plt->tm_hour, plt->tm_min, plt->tm_sec, tb.millitm,
                   buf[0], buf[1], buf[2], buf[3],
                   buf[4], buf[5], buf[6], buf[7], buf[8], hitLen );
/* MAKAI end */

#if DEBUG>=1
                                  if (cr)
                                        fprintf(stderr, "\n");
                                  cr = 0;
                                  fprintf(stderr, "%3d:", pkt_c - pkts);
                                  log_printf(ofp,
                                                         "◆%s            (%02X %02X %02X %02X %02X %02X %02X %02X   )\n",
                                                         hash,
                                                         buf[0], buf[1], buf[2], buf[3],
                                                         buf[4], buf[5], buf[6], buf[7]);
#endif
                                }
                        }
                }

          /* 速度計測 */
          status.loop += N_ALU * ALU_BITS;
          if (status.loop>= status.lastloop + upd_int
                  && (curTime = usec()) != status.lastTime)
                {
                  uint64_t diffTime;
                  int a, b, c;

                  /* 通算(単位 ktrips/sec) */
                  diffTime = curTime - status.startTime;
                  a = status.loop / ((1000 / USEC_SEC) * diffTime);

                  /* 区間(単位 trips/sec) */
                  diffTime = curTime - status.lastTime;
                  b = USEC_SEC * (status.loop - status.lastloop) / diffTime;

                  /* 予測 */
                  c = UPDATE_INTERVAL * b;

                  /* 立ち上がりなど、誤差があり upd_int が小さすぎたときは
                         いきなり全補正せず 1 秒(==b)づつ収斂させる。 */
                  upd_int = (upd_int + b < c
                                         ? upd_int + b
                                         : c);

                  status.lastTime = curTime;
                  status.lastloop = status.loop;
#if DEBUG>=1
                  fprintf(stderr,
                          "%5d/%5d(%3d%%)",
                          nblk_hit, nblk_total, 100 * nblk_hit / nblk_total);
                  nblk_hit = nblk_total = 0;
                  if (nap_total)
                        fprintf(stderr,
                                "  %5d/%5d(%3d%%)",
                                nap_hit, nap_total, 100 * nap_hit / nap_total);
                  else
                        fprintf(stderr,
                                        "  -----/-----(---%%)");
                  nap_hit = nap_total = 0;
#endif
                  fprintf( stderr,
                        "%6dktrips/s [%6d.%03dktrips/s]\r",
                        a, b / 1000, b % 1000 );
                  cr++;
                }
        }

  return 0;
}

/*
 *      Local Variables:
 *              tab-width:      4
 *      End:
 *
 * EOF */